存档在 2013年1月

位操作实现加减乘除四则运算

2013年1月31日

1. 题目描述

如何使用位操作分别实现整数的加减乘除四种运算?

2. 解决方案

需要熟练掌握一些常见功能的位操作实现,具体为:

<1> 常用的等式:-n = ~(n-1) = ~n+1

<2> 获取整数n的二进制中最后一个1:n&(-n) 或者 n&~(n-1),如:n=010100,则-n=101100,n&(-n)=000100

<3> 去掉整数n的二进制中最后一个1:n&(n-1),如:n=010100,n-1=010011,n&(n-1)=010000

(1) 加法实现

可以很容易地用“异或”和“或”操作实现整数加法运算:对应位数的“异或操作”可得到该位的数值,对应位的“与操作”可得到该位产生的高位进位,如:a=010010,b=100111,计算步骤如下:

第一轮:a^b=110101,(a&b)<<1=000100, 由于进位(000100)大于0,则进入下一轮计算,a=110101,b=000100,a^b=110001,(a&b)<<1=001000,由于进位大于0,则进入下一轮计算:a=110001,b=001000,a^b=111001,(a&b)<<1=0,进位为0,终止,计算结果为:111001。

代码如下:

int add(int a, int b) {
  int carry, add;
  do {
    add = a ^ b;
    carry = (a & b) << 1;
    a = add;
    b = carry;
  } while(carry != 0);
  return add;
}

(2) 减法实现

减法可很容易地转化为加法:a – b = a + (-b) = a + (~b + 1 )

代码如下:

<code>int</code> <code>subtract(</code><code>int</code> <code>a, </code><code>int</code> <code>b) {</code>
<div><code>  </code><code>return</code> <code>add(a, add(~b, 1));</code></div>
<div><code>}</code>

(3) 乘法实现
先看一个实例:1011*1010:

1011
   * 1010
 ----------
    10110 < 左移一位,乘以0010
+ 1011000 < 左移3位,乘以1000
----------
  1101110

因而乘法可以通过系列移位和加法完成。最后一个1可通过b&~(b-1)求得,可通过b& (b-1)去掉,为了高效地得到左移的位数,可提前计算一个map,代码如下:

int multiply(int a, int b) {
  bool neg = (b < 0);
  if(b < 0)
    b = -b;
  int sum = 0;
  map<int, int> bit_map;
  for(int i = 0; i < 32; i++)
    bit_map.insert(pair<int, int>(1 << i, i));
    while(b > 0) {
      int last_bit = bit_map[b & ~(b - 1)];
      sum += (a << last_bit);
      b &= b - 1;
    }
  if(neg)
    sum = -sum;
  return sum;
}

(4) 除法实现

乘法可很容易转化为减法操作,主要思想与乘法实现类似,代码如下:

int divide(int a, int b) {
  bool neg = (a > 0) ^ (b > 0);
  if(a < 0)
    a = -a;
  if(b < 0)
    b = -b;
  if(a < b)
    return 0;
  int msb = 0;
  for(msb = 0; msb < 32; msb++) {
    if((b << msb) >= a)
      break;
  }
  int q = 0;
  for(int i = msb; i >= 0; i--) {
    if((b << i) > a)
      continue;
    q |= (1 << i);
    a -= (b << i);
  }
  if(neg)
    return -q;
  return q;
}

位操作实现加法

2013年1月31日

用位操作进行加法运算,主要思想是将加法的计算结果分解为两部分:第一是不考虑进位的运算结果,第二是进位,然后再将这两者相加,即得到结果。详细表述如下:

  • 以一位二进制数为例,不考虑进位的情况

1+1=0
1+0=1
0+1=1
0+0=0

这个过程与使用异或位运算符的效果是一样的
1^1=0
1^0=1
0^1=1
0^0=0
a^b表示不考虑进位的计算结果。

  • 以一位二进制数为例,考虑进位的情况

0+0→不进位
0+1→不进位
1+0→不进位
1+1→进位,

即相当于是10,将10加到不考虑进位的计算结果上,即可得到整个的计算结果,而可以用位运算的与操作和向左的移位操作即可模拟上述的是否进位:
0&0=0       (0&0)<<1=0
0&1=0       (0&1)<<1=0
1&0=0       (1&0)<<1=0
1&1=1       (1&1)<<1=10
如此,即将运算结果计算出来了。

  • 接下来,需要按照递归的方式将上述思想实现,主要原因是将运算结果分为不考虑进位的运算结果A和进位值B,则计算结果为A+B,但该运算可能还是会产生进位,故将A和B再次采用这种计算方法进行计算,直到进位部分为0,即表示上次加法计算没有进位,则上次加法计算的不考虑进位的运算结果,即为整个加法计算的结果。

大端模式和小端模式

2013年1月30日

在 各种计算机体系结构中,对于字节、字等的存储机制有所不同,因而引发了计算机 通信领 域中一个很重要的问题,即通信双方交流的信息单元(比特、字节、字、双字等等)应该以什么样的顺序进行传送。如果不达成一致的规则,通信双方将无法进行正 确的编/译码从而导致通信失败。目前在各种体系的计算机中通常采用的字节存储机制主要有两种:Big-Endian和Little-Endian,下面先从字节序说起。
一、什么是字节序
字节序,顾名思义字节的顺序,再多说两句就是大于一个字节类型的数据在内存中的存放顺序(一个字节的数据当然就无需谈顺序的问题了)。其实大部分人在实际的开 发中都很少会直接和字节序打交道。唯有在跨平台以及网络程序中字节序才是一个应该被考虑的问题。

在所有的介绍字节序的文章中都会提到字 节序分为两类:Big-Endian和Little-Endian,引用标准的Big-Endian和Little-Endian的定义如下:
a) Little-Endian就是低位字节排放在内存的低地址端,高位字节排放在内存的高地址端。
b) Big-Endian就是高位字节排放在内存的低地址端,低位字节排放在内存的高地址端。
c) 网络字节序:TCP/IP各层协议将字节序定义为Big-Endian,因此TCP/IP协议中使用的字节序通常称之为网络字节序。

1.1 什么是高/低地址端
首先我们要知道C程序映像中内存的空间布局情况:在《C专 家编程》中或者《Unix环境高级编程》中有关于内存空间布局情况的说明,大致如下图:
———————– 最高内存地址 0xffffffff
栈底

栈顶
———————–

NULL (空洞)
———————–

———————–
未初始 化的数据
———————– 统称数据段
初始化的数据
———————–
正 文段(代码段)
———————– 最低内存地址 0x00000000
由图可以看出,再内存分布中,栈是向下增长的,而堆是向上增长的。
以上图为例如果我们在栈 上分配一个unsigned char buf[4],那么这个数组变量在栈上是如何布局的呢?看下图:
栈底 (高地址)
———-
buf[3]
buf[2]
buf[1]
buf[0]

———-
栈顶 (低地址)
其实,我们可以自己在编译器里面创建一个数组,然后分别输出数组种每个元素的地址,来验证一下。
1.2 什么是高/低字节
现在我们弄清了高/低地址,接着考虑高/低字节。有些文章中称低位字节为最低有效位,高位字节为最高有效位。如果我们有一个32位无符号整型0x12345678,那么高位是什么,低位又是什么呢? 其实很简单。在十进制中我们都说靠左边的是高位,靠右边的是低位,在其他进制也是如此。就拿 0x12345678来说,从高位到低位的字节依次是0x12、0x34、0x56和0x78。
高/低地址端和高/低字节都弄清了。我们再来回顾 一下Big-Endian和Little-Endian的定义,并用图示说明两种字节序:
以unsigned int value = 0x12345678为例,分别看看在两种字节序下其存储情况,我们可以用unsigned char buf[4]来表示value:
Big-Endian: 低地址存放高位,如下图:
栈底 (高地址)
—————
buf[3] (0x78) — 低位
buf[2] (0x56)
buf[1] (0x34)
buf[0] (0x12) — 高位
—————
栈顶 (低地址)

Little-Endian: 低地址存放低位,如下图:
栈底 (高地址)
—————
buf[3] (0x12) — 高位
buf[2] (0x34)
buf[1] (0x56)
buf[0] (0x78) — 低位
————–
栈 顶 (低地址)

二、各种Endian
2.1 Big-Endian
计算机体系结构中一种描述多字节存储顺序的术语,在这种机制中最重要字节(MSB)存放在最低端的地址 上。采用这种机制的处理器有IBM3700系列、PDP-10、Mortolora微处理器系列和绝大多数的RISC处理器。
+———-+
| 0x34 |<– 0x00000021
+———-+
| 0x12 |<– 0x00000020
+———-+
图 1:双字节数0x1234以Big-Endian的方式存在起始地址0x00000020中

在Big-Endian中,对于bit序列 中的序号编排方式如下(以双字节数0x8B8A为例):
bit 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+—————————————–+
val | 1 0 0 0 1 0 1 1 | 1 0 0 0 1 0 1 0 |
+—————————————-+
图 2:Big-Endian的bit序列编码方式
2.2 Little-Endian
计算机体系结构中 一种描述多字节存储顺序的术语,在这种机制中最不重要字节(LSB)存放在最低端的地址上。采用这种机制的处理器有PDP-11、VAX、Intel系列微处理器和一些网络通信设备。该术语除了描述多字节存储顺序外还常常用来描述一个字节中各个比特的排放次序。

+———-+
| 0x12 |<– 0x00000021
+———-+
| 0x34 |<– 0x00000020
+———-+

图3:双字节数0x1234以Little-Endian的方式存在起始地址0x00000020中
 在 Little-Endian中,对于bit序列中的序号编排和Big-Endian刚好相反,其方式如下(以双字节数0x8B8A为例):
bit 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+—————————————–+
val | 1 0 0 0 1 0 1 1 | 1 0 0 0 1 0 1 0 |
+—————————————–+
图 4:Little-Endian的bit序列编码方式
注意:通常我们说的主机序(Host Order)就是遵循Little-Endian规则。所以当两台主机之间要通过TCP/IP协议进行通信的时候就需要调用相应的函数进行主机序 (Little-Endian)和网络序(Big-Endian)的转换。
采用 Little-endian模式的CPU对操作数的存放方式是从低字节到高字节,而Big-endian模式对操作数的存放方式是从高字节到低字节。 32bit宽的数0x12345678在Little-endian模式CPU内存中的存放方式(假设从地址0x4000开始存放)为:
                                          内存地址     0x4000     0x4001     0x4002     0x4003
                                          存放内容     0x78        0x56        0x34         0x12
而在Big- endian模式CPU内存中的存放方式则为:
                                          内存地址     0x4000     0x4001     0x4002     0x4003
                                          存放内容     0x12         0x34        0x56         0x78

具体的区别如下:


三、Big-Endian和Little-Endian优缺点
Big-Endian优点:靠首先提取高位字节,你总是可以由看看在偏移位置为0的字节来确定这个数字是 正数还是负数。你不必知道这个数值有多长,或者你也不必过一些字节来看这个数值是否含有符号位。这个数值是以它们被打印出来的顺序存放的,所以从二进制到十进制的函数特别有效。因而,对于不同要求的机器,在设计存取方式时就会不同。

Little-Endian优点:提取一个,两个,四个或者更长字节数据的汇编指令以与其他所有格式相同的方式进行:首先在偏移地址为0的地方提取最低位的字节,因为地址偏移和字节数是一对一的关系,多重精度的数学函数就相对地容易写了。

如果你增加数字的值,你可能在左边增加数字(高位非指数函数需要更多的数字)。 因此, 经常需要增加两位数字并移动存储器里所有Big-endian顺序的数字,把所有数向右移,这会增加计算机的工作量。不过,使用Little- Endian的存储器中不重要的字节可以存在它原来的位置,新的数可以存在它的右边的高位地址里。这就意味着计算机中的某些计算可以变得更加简单和快速。

任意进制转换

2013年1月29日
/*将任意进制整数转化为十进制整数,返回转化后的十进制整数,num为任意进制整数,binary为该整数的进制*/
int anyBinaryToDecimal(string num,int binary)
{
	int len=num.size();
	int decimal_num=0;
	for(int i=0;i<len;i++)
	{
		decimal_num+=charToNum(num[i])*pow(binary,len-i-1);
	}
	return decimal_num;
}

/*将十进制转化为任意进制,decimal为十进制整数,binary为需要转化的进制*/
void decimalToAnyBinary(int decimal,int binary)
{
	string result;//保存x进制数
	char temp;
	while(decimal>0)
	{
		temp=decimal%binary;
		result+=numToChar(temp);
		decimal=decimal/binary;
	}
	
	/*输出转化后的x进制整数*/
	for(int i=result.size()-1;i>=0;i--)
		cout<<result[i];
	cout<<endl;
}

百度2013年校园招聘笔试题目

2013年1月20日

一:简答题(30)
1:数据库以及线程发生死锁的原理及必要条件,如何避免死锁
答:
产生死锁的原因主要是:
(1) 因为系统资源不足。
(2) 进程运行推进的顺序不合适。
(3) 资源分配不当等。
产生死锁的四个必要条件:
(1)互斥条件:一个资源每次只能被一个进程使用。
(2)请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
(3)不剥夺条件:进程已获得的资源,在末使用完之前,不能强行剥夺。
(4)循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
避免死锁:
死锁的预防是通过破坏产生条件来阻止死锁的产生,但这种方法破坏了系统的并行性和并发性。
死锁产生的前三个条件是死锁产生的必要条件,也就是说要产生死锁必须具备的条件,而不是存在这3个条件就一定产生死锁,那么只要在逻辑上回避了第四个条件就可以避免死锁。
避免死锁采用的是允许前三个条件存在,但通过合理的资源分配算法来确保永远不会形成环形等待的封闭进程链,从而避免死锁。该方法支持多个进程的并行执行,为了避免死锁,系统动态的确定是否分配一个资源给请求的进程。
预防死锁:具体的做法是破坏产生死锁的四个必要条件之一
2:面向对象的三个基本元素,五个基本原则
答:
三个基本元素:
封装
继承
多态
五个基本原则:
单一职责原则(Single-Resposibility Principle):一个类,最好只做一件事,只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申,将职责定义为引起变化的原因,以提高内聚性来减少引起变化的原因。
开放封闭原则(Open-Closed principle):软件实体应该是可扩展的,而不可修改的。也就是,对扩展开放,对修改封闭的。
Liskov替换原则(Liskov-Substituion Principle):子类必须能够替换其基类。这一思想体现为对继承机制的约束规范,只有子类能够替换基类时,才能保证系统在运行期内识别子类,这是保证继承复用的基础。
依赖倒置原则(Dependecy-Inversion Principle):依赖于抽象。具体而言就是高层模块不依赖于底层模块,二者都同依赖于抽象;抽象不依赖于具体,具体依赖于抽象。
接口隔离原则(Interface-Segregation Principle):使用多个小的专门的接口,而不要使用一个大的总接口。
3:windows内存管理的机制以及优缺点
答:
分页存储管理基本思想:
用户程序的地址空间被划分成若干固定大小的区域,称为“页”,相应地,内存空间分成若干个物理块,页和块的大小相等。可将用户程序的任一页放在内存的任一块中,实现了离散分配。
分段存储管理基本思想:
将用户程序地址空间分成若干个大小不等的段,每段可以定义一组相对完整的逻辑信息。存储分配时,以段为单位,段与段在内存中可以不相邻接,也实现了离散分配。
段页式存储管理基本思想:
分页系统能有效地提高内存的利用率,而分段系统能反映程序的逻辑结构,便于段的共享与保护,将分页与分段两种存储方式结合起来,就形成了段页式存储管理方式。
在段页式存储管理系统中,作业的地址空间首先被分成若干个逻辑分段,每段都有自己的段号,然后再将每段分成若干个大小相等的页。对于主存空间也分成大小相等的页,主存的分配以页为单位。
段页式系统中,作业的地址结构包含三部分的内容:段号 页号 页内位移量
程序员按照分段系统的地址结构将地址分为段号与段内位移量,地址变换机构将段内位移量分解为页号和页内位移量。
为实现段页式存储管理,系统应为每个进程设置一个段表,包括每段的段号,该段的页表始址和页表长度。每个段有自己的页表,记录段中的每一页的页号和存放在主存中的物理块号。

二:程序设计题(40)

1:公司里面有1001个员工,现在要在公司里面找到最好的羽毛球选手,也就是第一名,每个人都必须参赛,问至少要比赛多少次才能够找到最好的羽毛球员工。
答:两两比赛,分成500组剩下一人,类似于归并排序的方式,比出冠军后,让冠军之间再比,主要是要想想多余的那一个选手如何处理,必然要在第一次决出冠军后加入比赛组。

2:现在有100个灯泡,每个灯泡都是关着的,第一趟把所有的灯泡灯泡打开,第二趟把偶数位的灯泡制反(也就是开了的关掉,关了的打开),第三趟让第3,6,9….的灯泡制反…….第100趟让第100个灯泡制反,问经过一百趟以后有多少灯泡亮着
答:
1.对于每盏灯,拉动的次数是奇数时,灯就是亮着的,拉动的次数是偶数时,灯就是关着的。
2.每盏灯拉动的次数与它的编号所含约数的个数有关,它的编号有几个约数,这盏灯就被拉动几次。
3.1——100这100个数中有哪几个数,约数的个数是奇数。我们知道一个数的约数都是成对出现的,只有完全平方数约数的个数才是奇数个。
所以这100盏灯中有10盏灯是亮着的。
它们的编号分别是: 1、4、9、16、25、36、49、64、81、100。
3:有20个数组,每个数组有500个元素,并且是有序排列好的,现在在这20*500个数中找出排名前500的数
答:TOP-K问题,用个数为K的最小堆来解决
4. 字符串左移,void *pszStringRotate(char *pszString, intnCharsRotate),比如ABCDEFG,移3位变DEFGABC,要求空间复杂度O(1),时间复杂度O(n)

三:系统设计题(30)

现在有一个手机,手机上的键盘上有这样的对应关系,2对应”abc”,3对应”def”…..手机里面有一个userlist用户列表,当我们输入942的时候出来拼音的对应可能是“xia”,“zha”,“xi”,“yi”等,当我们输入9264的时候出来是yang,可能是“样”,“杨”,“往”等,现在我们输入一个字符串数字,比如926等,要在电话簿userlist中查找出对应的用户名和电话号码并返回结果。
C++语言: 电话号码对应的英语单词(注意此题的非递归做法)

#include <iostream>  
#include <cstdlib>  
#define N 4 //电话号码个数  
 
using namespace std; 
 
char c[][10] = {"","","ABC","DEF","GHI","JKL","MNO","PQRS","TUV","WXYZ"};//存储各个数字所能代表的字符  
int number[N] = {2, 4 ,7, 9}; //存储电话号码  
int total[10] = {0, 0, 3, 3, 3, 3, 3, 4, 3, 4}; //各个数组所能代表的字符总数  
int answer[N]; //数字目前所代表的字符在其所能代表的字符集中的位置,初始为0  
 
void Search(int *number, int n); //非递归的办法  
void RecursiveSearch(int *number, int cur, char *ps, int n); //递归的办法 
int main() 
{ 
        //Search(number, N);  
        char ps[N+1] = {0}; 
        RecursiveSearch(number, 0, ps, N); 
        return 0; 
} 
 
 
void Search(int *number, int n) 
{ 
        int i; 
        while(1) 
        { 
                for(i=0; i<n; ++i) 
                        printf("%c", c[number[i]][answer[i]]); 
                printf("\n"); 
                int k = n-1;    //用k和while循环来解决扩展性问题,模拟了递归  
                while(k >= 0) 
                { 
                        if(answer[k] < total[number[k]]-1) 
                        { 
                                ++answer[k]; 
                                break; 
                        } 
                        else 
                        { 
                                answer[k] = 0; 
                                --k; 
                        } 
                } 
                if(k < 0) 
                        break; 
        } 
} 
 

/*递归的解法: number为存储电话号码的数组,pos为当前处理的数字在number中的下标,初始为0
*ps为一外部数组,用于存放字母,n代表电话号码的长度(个数)
* 此递归的方法好理解,比上面非递归的办法好写易懂
* */

void RecursiveSearch(int *number, int pos, char *ps, int n) 
{ 
        int i; 
        for(i=0; i<total[number[pos]]; ++i) 
        { 
                ps[pos] = c[number[pos]][i]; 
                if(pos == n-1) 
                        cout<<ps<<endl; 
                else 
                        RecursiveSearch(number, pos+1, ps, n); 
        } 
} 

Git命令

2013年1月20日

符号约定:

[]:可选  <>:必选

Git 配置

git config [–global] user.name <name>        设置用户名

git config [–global] user.email <email>         设置邮箱

git config [–global] core.editor <editor>        设置编辑器

git config [–global] github.user <user>         设置github帐号名

git config [–global] github.token <token>        设置github的token

–global是对当前系统用户的全局设置,在~/.gitconfig中。对系统所有用户进行配置,/etc/gitconfig。对当前项目,.git/config

Git 创建库

git clone <url>                   ssh/http(s)/git三种协议,ssh和https可推送

git init                        初始化Git仓库

Git 日常操作

git add <file>                 将文件加入index file

git rm [–cached]                删除,加–cached表示仅从index file中删除文件,即放弃跟踪

git mv <src> <dest>             移动/更名

git diff –cached/–staged          当前索引与上次提交(有哪些需要commit)

git diff                      当前索引与工作目录(有哪些需要add)

git diff HEAD[^]               工作目录与上次提交(当前目录与上次提交有何改变)

git commit [-a] -m <msg>          提交

git commit –amend [-m <msg>]       修复上次提交

git reset HEAD <file>             同–mixed,default option

git reset –mixed HEAD            撤销 commit 和index file,只保留 working tree 的信息

git reset –hard HEAD[^]           将 working tree 和 index file 都撤销到以前状态

git reset –soft HEAD[^]            只撤销 commit,而保留 working tree 和 index file 的信息

回复到某个状态。以git reset –soft HEAD为例,commit回退到

HEAD(相当于无变化),若是HEAD^,则commit回退到HEAD^

git gc                     用垃圾回收机制清除由于 reset 而造成的垃圾代码

git status                  显示当前工作目录状态

git log [-p]                   显示提交历史(many useful options to be learned)

git branch [branch]               显示/新建分支

git branch -d/-D               删除分支(d表示“在分支合并后删除分支”,D表示无论如何都删除分支)

git show-branch

git checkout <branch>            切换分支(分支未commit无法切换)

git merge <branch>              合并分支

git merge == git pull .

git show <branch | commit | tag | etc>        显示对应对象的信息

git grep <rep> [object]             (在指定对象(历史记录)中)搜索

git cat-file                    查看数据

git cat-file <-t | -s | -e | -p | (type)> <object>        type can be one of: blob, tree, commit, tag

git ls-files [–stage]              show information about files in the index and the working tree(实际是查看索引文件)

git watchchanged <since>..<until>       显示两个commit(当然也可以是branch)的区别

git remote [-v]                    显示远程仓库,加-v选项可显示仓库地址

git remote add <repo_name> <url>         添加远程仓库,repo_name为shortname,指代仓库地址

git remote rename <old_name> <new_name>    更名

git remote rm <repo_name>            删除远程仓库

git remote show <repo_name>          查看远程仓库信息

git remote fetch <repo_name>           从远程仓库抓取数据(并不合并)

git pull <repo_name> <branch_name>      拉去数据并合并到当前分支

git push <repo_name> <branch_name>      推送指定分支到指定仓库

git fetch <repo_name> <branch_name>[:<local_branch_name>]    拉去数据,未合并

Git 标签

git 标签相关……

Git 相关环境变量

GIT_DIR: 如果指定了那么git init将会在GIT_DIR指定的目录下创建版本库

GIT_OBJECT_DIRECTORY: 用来指示对象存储目录的路径。即原来$GIT_DIR/objects下的文件会置于该变量指定的路径下

Git 常见变量

HEAD: 表示最近一次的 commit。

MERGE_HEAD: 如果是 merge 产生的 commit,那么它表示除 HEAD 之外的另一个父母分支。

FETCH_HEAD: 使用 git-fetch 获得的 object 和 ref 的信息都存储在这里,这些信息是为日后 git-merge 准备的。

HEAD^: 表示 HEAD 父母的信息

HEAD^^: 表示 HEAD 父母的父母的信息

HEAD~4: 表示 HEAD 上溯四代的信息

HEAD^1: 表示 HEAD 的第一个父母的信息

HEAD^2: 表示 HEAD 的第二个父母的信息

COMMIT_EDITMSG: 最后一次 commit 时的提交信息。

阿里巴巴2010年校园招聘笔试题目

2013年1月20日

[print_gllr id=2329]

阿里巴巴2013年实习生招聘笔试题目

2013年1月20日

[print_gllr id=2316]