Currently browsing category

技术

工业技术 专业选择

我爸一个同事的女儿在选本科的专业,他拜托我帮忙,给了我一个列表里面有专业名让我帮忙推荐一下.于是我就写了这个文档,顺便也放在这里供大家参考.

工业设计

Computer Science and Technology

传统计算机专业,简称CS. 从几年前开始就是非常火的专业, 一直都发展的很不错, 无论就业和继续学习下去前途都很好, 起薪很高,待遇优厚但是工作相对比较忙一些.最近一年来国内因为行业出现一些泡沫所以最近发展放缓,几大国内公司招聘暂停或大规模减少, 不过在国外是非常稳定的行业,工作是这些里最好找的. 出路很好, 但是需要喜欢计算机/逻辑/编程 这些才能有兴趣的学习下去不然会觉得很费力. 如果有兴趣的话推荐. 职位:软件工程师

Digital Media Technology

数字媒体, 也是个很广泛的专业, 数字媒体的种类很多 ,比如网站的开发,设计(和艺术也许有点关系). 图像,视频的处理, 医学图像处理等等. 此专业也需要学一些计算机基础但是根据内容有所不同比如如果是网站方面就会需要一些简单的网页设计和交互的语言, 如果学习医疗图像处理就是比较难以写的和数学和算法有关的编程知识, 出路不错但是也需要兴趣才容易坚持下去. 但是就业应该也挺容易的(但是比不过CS因为学CS的这些多少都学过)

Electrical Engineering

经常被叫做Triple E, Electronic and electrical engineering. 和电子, 包括数字电路和模拟电路有关, 有些类似高中物理里的电学的..复杂版本 是一个比较有难度的学科,因为是属于很上游的学科,研究所/大学/公司研究部门比较多, 电子工程师. 不推荐女生

Electronic Science and Technology

看名字和前者类似吧, 应该更技术一些, 如果喜欢研究这条路可以考虑. 典型的研究所/大学/公司研究部门职位

Industrial Design

工业设计, 比较火的职位, 简单地说就是设计产品的外观/使用方式等等, 艺术和技术相结合. 比如设计手机,汽车,电视等等的. 注意这里说的主要是外观和使用交互

Information and Computing Science

信息科学, 比CS还要上游的专业, 理论知识特别是离散数学的知识更多一些,简单的说如果想就业就选CS,想继续深究那么可以考虑这个.

Telecommunications Engineering

通信工程. 10年前开始很火的专业但是随着行业发展的放缓已经没有那么有价值了,但是由于历史原因在大学里专业入学分数还是挺高的.不是很推荐和我一起来留学的其他通信工程的专业都转计算机了(因为通信工程找不到工作 J)

 

总之, 如果比较喜欢逻辑/编程/计算机打交道 那么推荐的是

计算机>数字媒体>信息科学

如果不是很喜欢计算机, 那么推荐

工业设计>数字媒体>计算机

 

可以去比如bing搜索这些专业的名称,可以找到这些专业的课程大纲, 大致就可以了解以后学的都是什么科目了.然后有几点要注意的:

1计算机是薪水很高的(不考虑最近几个月的国内形势)但是升职空间有限因为机会很多人更多. 其他几个专业的对口职位起薪会差一些但是是属于需要积累经验然后若干年后收入可能很高(项目提成)等等. 这是基于经济方面的考虑.

2 计算机相关行业相比电子相关行业来说, 各有优劣, 计算机行业创新更多一些 EEE和通信更稳定一些.

3 越上游的行业,越接近研究, 适合喜欢在研究室或者继续读书的人, 越接近下游的行业, 越接近应用,适合喜欢早点去行业里积累经验的人.

4 没有绝对分开的职业, 计算机专业出来也有很多人做了运营/项目经理/产品经理/用户体验师等等. 通信工程比如, 很多人也因为行业的区别而选择了进入计算机行业做码农. 有的人喜欢在自己的时间里学东西有的人喜欢在课堂上学东西.

5 计算机专业里也会需要设计的知识(前端,网站,用户界面,用户交互), 其他的所有专业里也都要学习编程, 比如EEE的学生可能会去参加机器人比赛,而所有的程序都是需要自己写的…工业设计可能是这里唯一不需要编程的专业,取而代之的是电脑绘图.

6 在做选择的时候,兴趣的重要性比就业/行业前景要重要的多. 没有人愿意做一辈子不喜欢的事情,预期以后再换不如最开始就考虑好. 任何行业里都有机会,那么选一个喜欢的专业自然更有动力也就会花更多的时间和精力,更容易取得成绩. 身边太多选择了不喜欢的东西纠结了几年最后草草混过毕业然后做了和所学专业无关的例子 J

 

以上内容,均属于个人理解,个人经验,参考为主,负责任的选择永远是自己思考后作出的.

技术面试注意事项

今天在整理电脑里的文档, 整理的时候发现了这个, 是当时我面试Google之前找给我内推的学长给我模拟面试以后记录下来的注意事项, 留着也没用删掉又可惜, 不如放在这里吧. 有些东西只适用于我不过大家可以凑合看看.

-五人小组,自己负责的主要部分
-个人简介,主要讲个人项目

-写题目时先讲个人思路和可能遇到的难点
-讲解时紧张怎么办
-提出疑问,说明考虑问题全面
-当你发现你前面的思路从根本上错了怎么办

TZ哥建议
-将简单思路写在commentaire里面,不要只说思路
-将test case写在里面(可以在)
-写之前将细节问题问清楚并简单记一下,不要一上来就直接编代码
-不需要上来就写一个特别完美的答案,将初步架构写出来,再优化
-和面试官的交流很重要
-写代码之前和面试官前确认一下变量的具体类型
-没有问s的大小和i的大小,设法确认一个更具体的描述
-可以写很简单的伪代码
-细节不是很重要,假设有一个可以直接调用的交换函数,重点在自己用的算法上
-时间控制上,时间略长
-一题和多题都有可能
-技术问题还行,但是和面试官的交流上多讲究点技巧
-用户输入错误怎么办
-错误代码不一定要删
-用笔记本写代码练习一下

原来面试的时候并不是一定要实现最fancy的算法,他们考察的很有可能是你在处理一些简单问题时思维是否严谨。
写程序的时候会别写边想测试用例,尤其是边界情况。
无论你有多激动,都一定要和面试官确认好题意,以及数据范围,然后再秒杀。

面试的时候最重要的就是要有自信,不一定要霸气外露,但是绝不能自己支支吾吾地不确定。

例如我在微软第4轮面试的时候,面试官问我可以写程序实现一下吗,我充满自信地说:”Sure. Of course!” 然后他就很happy地说:“I love that ‘Of course'”。所以有时后装B并不是什么坏事,关键是你要装得像。

另外一点,随时告诉面试官你的想法。不要只顾着想一直沉默,要让面试官知道你在想什么,让他了解你的思考过程以及你思维的敏捷程度,同时当你想偏了的时候他也好引导你给你帮助。

最后一点就是,秒杀不是必须的,关键是思考过程。万一你一开头没有想到很好的算法,先不要慌乱,面试官会引导你一步一步地改进,只要最后能搞出来,你就胜利了。

TopCoder SRM 208 TallPeople

Problem Statement

Link to original problem statement

A group of people stand before you arranged in rows and columns. Looking from above, they form an R by C rectangle of people. You will be given a String[] people containing the height of each person. Elements of people correspond to rows in the rectangle. Each element contains a space-delimited list of integers representing the heights of the people in that row. Your job is to return 2 specific heights in a int[]. The first is computed by finding the shortest person in each row, and then finding the tallest person among them (the “tallest-of-the-shortest”). The second is computed by finding the tallest person in each column, and then finding the shortest person among them (the “shortest-of-the-tallest”).

Definition
Class: TallPeople
Method: getPeople
Parameters: String[]
Returns: int[]
Method signature: int[] getPeople(String[] people)

Constraints
– people will contain between 2 and 50 elements inclusive.
– Each element of people will contain between 3 and 50 characters inclusive.
– Each element of people will be a single space-delimited list of positive integers such that:
1) Each positive integer is between 1 and 1000 inclusive with no extra leading zeros.
2) Each element contains the same number of integers.
3) Each element contains at least 2 positive integers.
4) Each element does not contain leading or trailing whitespace.

Examples
0)
{“9 2 3”,
“4 8 7”}
Returns: { 4, 7 }
The heights 2 and 4 are the shortest from the rows, so 4 is the taller of the two. The heights 9, 8, and 7 are the tallest from the columns, so 7 is the shortest of the 3.

1)
{“1 2”,
“4 5”,
“3 6”}
Returns: { 4, 4 }

2)
{“1 1”,
“1 1”}
Returns: { 1, 1 }

Analysis

还是个很简单的问题。。木有任何技术含量,先建立二维数组,把int从string里弄出来,然后去找每一排的最大最小值之类的。

My code

package tc.srm.srm208;

public class TallPeople {
	public static int[] getPeople(String[] people){
		// x = row size, y = column size
		int x = people.length, y = 1;
		// Use people0 to find the column size
		char [] people0 = people[0].toCharArray();
		for (int i = 0; i < people0.length; i++) {
			if (people0[i] == ' ') {
				y++;
			}
		}
		int [][] matrix = new int [x][y];
		// Fill the matrix with parsed int
		for (int i = 0; i < x; i++) {
			int current = 0;
			int nextSpace;
			for (int j = 0; j < y; j++) {
				nextSpace = people[i].indexOf(' ', current);
				if (nextSpace == -1) {
					nextSpace = people[i].length();
				}
				matrix[i][j] = Integer.parseInt(people[i].substring
                                               (current, nextSpace));
				current = nextSpace + 1;
			}
		}
		// Find tall in short
		int shortt, tallInShort = 0;
		for (int i = 0; i < x; i++) {
			shortt = 1001;
			for (int j = 0; j < y; j++) {
				if (matrix[i][j] < shortt) {
					shortt = matrix[i][j];
				}
			}
			if (shortt > tallInShort) {
				tallInShort = shortt;
			}
		}
		// Find short in short
		int tall, shortInTall = 1001;
		for (int j = 0; j < y; j++) {
			tall = 0;
			for (int i = 0; i < x; i++) {
				if (matrix[i][j] > tall) {
					tall = matrix[i][j];
				}
			}
			if (tall < shortInTall) {
				shortInTall = tall;
			}
		}
		int [] rtn = {tallInShort, shortInTall};
		return rtn;
	}

	public static void main(String[] args) {
		String [] people;
		people = new String [] {"9 2 3", "4 8 7"};
		System.out.println(getPeople(people)[0] + "  " + getPeople(people)[1]);
		people = new String [] {"1 2", "4 5", "3 6"};
		System.out.println(getPeople(people)[0] + "  " + getPeople(people)[1]);
		people = new String [] {"1 1", "1 1"};
		System.out.println(getPeople(people)[0] + "  " + getPeople(people)[1]);
	}
}

Complexity

空间复杂度是O(mn),m,n代表行数和列数。因为想要按行或者按列遍历,最方便的方法就是弄个二维数组了,直接通过下标读取了。 如果想做的更好当然也可以,但是要牺牲不少时间,考虑到这里数字都不大,所以无所谓了。

时间复杂度也是O(mn), 确切的说O(n + mn + mn + nm + c),因为填充数组,和先按行在按列,先按列在按行各对整个数组遍历了一次。这个应该没有特别能提升的空间了吧,起码不会比O(mn)更小我觉得,不过就我这水平肯定也弄不出来更小的。。。

TopCoder SRM 236 BusinessTasks

最近在看TopCoder网站上的算法的教程,从最简单的看起,发现不练不行,所以找到教程中提到的最简单的例子开始做,练练手。

Link to original Problem Statement

Problem Statement

A busy businessman has a number of equally important tasks which he must accomplish. To decide which of the tasks to perform first, he performs the following operation.

He writes down all his tasks in the form of a circular list, so the first task is adjacent to the last task. He then thinks of a positive number. This number is the random seed, which he calls n. Starting with the first task, he moves clockwise (from element 1 in the list to element 2 in the list and so on), counting from 1 to n. When his count reaches n, he removes that task from the list and starts counting from the next available task. He repeats this procedure until one task remains. It is this last task that he chooses to execute.

Given a String[] list representing the tasks and an int n, return the task which the businessman chooses to execute.

Definition
Class: BusinessTasks
Method: getTask
Parameters: String[], int
Returns: String
Method signature: String getTask(String[] list, int n)

Constraints
– list will contain between 2 and 50 elements inclusive.
– Each element in list will contain between 1 and 50 characters inclusive.
– Each element in list will contain only characters ‘a’-‘z’.
– n will be between 1 and 10000000 inclusive.

Examples

0)
{“a”,”b”,”c”,”d”}
2
Returns: “a”
We start counting from a. So a is 1, b is 2. We remove b, so list is now {a,c,d}. We continue from c. So c is 1, d is 2. We remove d, so list is now {a,c}. We continue from a. So a is 1, c is 2. We remove c, and now we are left with the last task a.

1)
{“a”,”b”,”c”,”d”,”e”}
3
Returns: “d”
We start counting from a. So a is 1, b is 2, c is 3. We remove c, now list = {a,b,d,e}. We continue from d. So d is 1, e is 2, a is 3. We remove a, now list = {b,d,e}. We continue from b. So b is 1, d is 2, e is 3. We remove e, now list = {b,d}. We continue from b. So b is 1, d is 2 and finally b is 3. We remove b, and now we are left with just one task d.

2)
{“alpha”,”beta”,”gamma”,”delta”,”epsilon”}
1
Returns: “epsilon”

3)
{“a”,”b”}
1000
Returns: “a”

4)
{“a”,”b”,”c”,”d”,”e”,”f”,”g”,”h”,”i”,”j”,”k”,”l”,”m”,”n”,”o”,”p”,”q”,”r”,”s”,”t”,”u”,”v”,”w”,”x”,”y”,”z”}
17
Returns: “n”

5)
{“zlqamum”,”yjsrpybmq”,”tjllfea”,”fxjqzznvg”,”nvhekxr”,”am”,”skmazcey”,”piklp”,”olcqvhg”,”dnpo”,”bhcfc”,
“y”,”h”,”fj”,”bjeoaxglt”,”oafduixsz”,”kmtbaxu”,”qgcxjbfx”,”my”,”mlhy”,”bt”,”bo”,”q”}
9000000
Returns: “fxjqzznvg”

Analysis

问题我就不翻译了。 算是个很简单的问题,简单暴力解决。

My code

package tc.srm.srm236;

import java.util.ArrayList;

public class BusinessTasks {

	public static String getTask(String[] list, int n){
		// Use the arraylist to quickly locate and delete n-th element
		ArrayList<Integer> listArray = new ArrayList<Integer>();
		// Fill it with int instead of original string to save space
		for (int i = 0; i < list.length; i++) {
			listArray.add(i);
		}
		int len = listArray.size();
		int current = 0;
		while (len != 1) {
			// Add n - 1 to the target place and modulo len to get the position
			current = (current + n - 1) % len;
			listArray.remove(current);
			len = listArray.size();
		}
		return list[listArray.get(0)];
	}

	public static void main(String[] args) {
		String [] list;
		list = new String [] {"a","b","c","d"};
		System.out.println(getTask(list, 2));
		list = new String []{"a","b","c","d","e"};
		System.out.println(getTask(list, 3));
		list = new String [] {"alpha","beta","gamma","delta","epsilon"};
		System.out.println(getTask(list, 1));
		list = new String [] {"a","b"};
		System.out.println(getTask(list, 1000));
		list = new String [] {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t",
			"u","v","w","x","y","z"};
		System.out.println(getTask(list, 17));
		list = new String [] {"zlqamum","yjsrpybmq","tjllfea","fxjqzznvg","nvhekxr","am","skmazcey","piklp",
			"olcqvhg","dnpo","bhcfc","y","h","fj","bjeoaxglt","oafduixsz","kmtbaxu",
			"qgcxjbfx","my","mlhy","bt","bo","q"};
		System.out.println(getTask(list, 9000000));
	}
}

Complexity

空间复杂度是O(n),和输入list的长度有关,有没有可能更小呢?应该很难,因为想想,总是需要记录哪些元素没有被删除,而记录这个一定需要跟删除元素数量呈线性的空间,所以应该不容易在减小了。这里使用了ArrayList来储存这个数组因为String []是没法删除某个固定位置的,也就是说一次删除需要O(n)的操作,那么如果直接在上面处理,复杂度就变成O(n2)了。所以用了可以快速删除的ArrayList,好像就相当于C++的Vector。

时间复杂度也是O(n),一共n个元素,一次删除一个,自然需要n步搞定。

推荐一个有关Maven的网站

Maven是一个项目管理软件。这类软件比Eclipse好的地方是, 在使用Eclipse做项目开发时,所有的依赖包都是通过项目的属性来设置的,保存在项目目录下的某个隐藏文件里。问题是当你转移到其他的机子上运行或者编辑的时候, 会因为系统环境不同,环境变量不同,依赖包版本不同等等造成很多麻烦。

Maven就是一个简单的项目管理软件,其实我也只是在这学期的项目里用了一点点功能但是的确很方便。官网在这:http://maven.apache.org/ 简单的说,这就是一个代替javac的命令, 但是需要在项目根目录下放一个xml文件,里面按照特定顺序写上各类信息,我用到的主要是依赖包:

		<dependency>
			<groupId>org.nuiton.thirdparty</groupId>
			<artifactId>JRI</artifactId>
			<version>0.8-4</version>
		</dependency>

但是这里遇到一个问题,不知道groupId,version从哪找,,,翻了半天,终于遇到这么一个神奇的网站。。http://mvnrepository.com/ 只要输入你想要找的包,你就可以下载各种软件的JAR包(下载以后就可以不用Maven直接放在Eclipse里再导入到项目的build path里),也可以直接从下面复制自动生成的代码。