记4月22日 小米招聘会 笔试

今天晚上7点在南园参加了小米公司举办的专场招聘会，由于事先没有什么准备，笔试时直接被秒杀了，好几个题都不会，随便瞎写写，以前自以为对java这门编程语言了如指掌的我才意识到自己真的是弱爆了。几乎没什么希望进二轮了，幸运的是没有空手而归，在提问环节我给老婆抢了一个米娃娃，开心。。。。

言归正传，我凭自己的记忆记录下几个印象比较深刻的题目，以供自己后面的笔试参考。

问题一：java语言中synchronized关键字的用法，具体题目记不清了，大概是这样的

package test;

public class Test {
	public synchronized void a(){
		System.out.println("a");
	}
	
	public static synchronized void b(){
		System.out.println("b");
	}
	
	public void c(){
		synchronized(this){
			System.out.println("c");
		}	
	}
	
	public synchronized void d(){
		System.out.println("d");
	}

	public static void main(String[] args){
		new Thread(new Runnable(){
			@Override
			public void run() {
				new Test().a();
			}
		}).start();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				new Test().b();
			}
		}).start();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				new Test().c();
			}
		}).start();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				new Test().d();
			}
		}).start();
	}
}

问这个程序会输出什么？

问题二：问一下程序是否能编译通过，如果能通过会输出什么，如果通不过是为什么？

A.java:

public interface A {
	
}

B.java:

public class B {

}

C.java:

public class C extends B implements A{
	
}

Test.java:

public class Test {
	public void print(A a)
	{
		System.out.print("A");
	}
	public void print(B a)
	{
		System.out.print("B");
	}
	public static void main(String[] args){
		new Test().print(new C());
	}
}

问题三：要求在一张m*n的棋盘上摆放k个棋子，要求1,不得同时有两个棋子在同一行；2，不得同时有两个棋子在同一列；3，不得同时有两个棋子在同一对角线上，问有多少种摆放方法。

问题四：给定一个个数为n的数列，现在需要取出其中的第k大的数，问时间复杂度是多少？

问题五：java/c++中的传值引用有何异同？

答案一：

synchronized问题

总结：

1、synchronized关键字的作用域有二种：
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.

程序打印出a,b,c,d

 

答案二：

编译错误，不能识别c是哪个

答案三：原创求指教

#include<stdio.h>
#include<math.h>
const int MAX_LENGTH = 1000;
int M,N,K; //这里为了方便用了全局变量，M表示棋盘的行数，N表示棋盘的列数，K表示皇后个数
int methodCount; 
int flag[MAX_LENGTH];//flag[i]表示第i行所放的皇后在第flag[i]列，flag[i]=-1表示该行未放皇后

bool judge(int rowNum,int colNum)
{
	int i;
	bool f = true;
	for(i=0;i<rowNum;i++)
		if(flag[i]==colNum|| (rowNum-i)==abs(colNum-flag[i]))
		{
			f = false;
			break;
		}
	return f;
}

void recursive(int currentRow,int queensLeft)
{
	if(queensLeft==0)
	{
		//已经找到一种复合条件的放置方式
		methodCount++;
		return;
	}
	else if((M-currentRow)<queensLeft)
		//此处表示剩下的行数已经不足以放置还未放置完的皇后个数
		return;

	int i;
	
	//对每一列试探性的放下皇后
	for(i=0;i<N;i++)
		if(judge(currentRow,i))
		{
			flag[currentRow]=i;
			recursive(currentRow+1,queensLeft-1);
		}
	
	//本列不放皇后，继续往下递归
	flag[currentRow]=-1;
	recursive(currentRow+1,queensLeft);
}

int main()
{
	scanf("%d %d %d",&M,&N,&K);
	methodCount=0;
	if(!(M<K || N<K)) 
		recursive(0,K);
	printf("%d\n",methodCount);
}

 

答案四：

http://www.cnblogs.com/zhjp11/archive/2010/02/26/1674227.html

未完....答案待续。。。