这类面试只要掌握好技巧，应该其实比较好过。首先要理解：这种面试形式考查的目的是什么？实际上，这类面试考查的无法就是一点：你的团队合作能力。理解了这一点，剩下的问题就好办了。个人感觉，参加这类面试，一定要注意以下方面：

1、不要过分表现自己，表现最多的那个人一定首先被淘汰。道理很简单：既然考查的是团队合作能力，那么，集体利益显然是最重要的，如果你总是抢着表现自己，那只能说明，你把自身利益放到了集体利益之前，集体观念淡薄，肯定会被第一个淘汰。当然，也有例外，但那绝对是极少数。大家可以仔细回味一下。

2、说话不要太多，但也不能太少，太少了就不会给考官留下深刻印象。要注意掌握小组的发展动向，在最关键的时刻，说出最有分量的话，简言之，要么不说，要说就要选在最该你说的时候说。例如：当小组意见分歧严重，时间所剩不多时，你可以试着提出一个缓解矛盾的折衷方案；或者当大家讨论的问题偏离主题的时候，你可以及时提醒大家；或者当你发现其他人的意见忽略了某些重要方面时，可以及时提出来。具体的请参考后面的成功案例。

3、要多与你旁边的人交流，多交换意见。团队合作离不开交流，多跟他们交流，交换意见，会对你个人有很大启发，也会对小组达到统一意见起到重要作用。当然，这一切考官都看在眼里：）

4、考虑问题和说话时，要把集体利益放到第一位，一切都要服从集体目标。要多说"我们小组..."，少说"我..."，要多向你旁边的人或团队核心成员提意见，让他代你说。

5、总结时，要首先肯定、强调其他每个成员在团队的这次任务中的作用，向他们表示感谢，再说自己为团队作出的贡献，并要看到自己的不足。

以下以具体的安全来说明面试细节。首先是成功案例。

1、  华为

华为的一面采用的就是这种形式，据说这个环节淘汰率是相当高的。

题目：12个人，分成2组，给出14种职业，给每个组20分钟时间讨论，要求达到统一意见，对这14种职业，按照其重要程度排序；然后每个组选出一位代表，陈述小组讨论结果及理由；接下来进入自由辩论阶段，两组互相PK；最后，每个人选出一个自己认为刚才表现最出色的人，并说明理由。

1）  小组讨论

在这个环节里，有一个南大学生表现得很冒尖，当时就知道他肯定挂了（后来得到了印证）。经过20分钟，大家达成了统一意见。

2）  陈述

他们选我来陈述小组意见，当时想倒霉了，结果后来面试官指定另一个人作陈述（心中窃喜）。后来他也挂了。

3）  辩论

对方开始对我们的排序结果进行质疑。主要质疑的是，为什么我们把水产养殖人员和印章刻字人员排那么靠钱。我想到质疑他们把娱乐场所健身人员排到保育人员前面，

告诉那个比较冒尖的人，让他说（心想，他反正那么想表现，就让他说吧）。

在整个辩论过程中，基本都是南大那个人在抢着说，跟对方辩论，我们组其他人都没插上话，后来是面试官指定我们组其他人说，结果，对方的质疑他们都顶不住了。最后，面试官看我从头到尾都没说话，让我说，我就举出北京当时吃海鲜吃死人的例子和刻假章的例子，对他们进行了反驳，瞬间扭转局势。语气略带调侃，面试官也跟着乐了。

4）  总结

最后，让每个人选出刚才表现最出色的人。很多人都选我，但最后我没有选自己，而是选了我旁边那个人，原因是"他沟通做的比较好"。

相信我最后一句话给面试官留下了深刻的印象，因为他又笑着重复了一遍。当时面完，我就知道：我肯定进下一轮，南大那个肯定被淘汰（结果果然不出所料）

2、  阳光财险

采用的是无领导小组讨论形势，即：给定一个话题，小组成员在30分钟内进行自由讨论，最后选出一个人来作总结，期间面试官不给任何提示，不作任何干预。

我们的题目是：假设你们是北京市政府工人人员，08年奥运将至，对于北京的一些外来务工人员及流动人员，应该如何安置？是否应把他们遣散回家？

小组一共12个人，一半天大一半南大的。整个讨论过程比较乏味，因为大部分人都在抢着说话，希望多赢得表现机会。我只说了两段话，一个是在开头，一个是在结尾。开头时，我只说了几句：面对这个问题，我觉得大家应该考虑xx、xx...方面，请大家提出补充意见。结尾时，我也只说了几句：大家讨论了这么久，都忽略了一个很重要的方面...最后的总结不是我做的，整个过程我只说了这几句话，但后来我还是进入了下一轮。另外，我们组作总结的那个人过了，还有我的朋友，他最后对总结的那个人作了点补充。

3、  国家外汇储备管理局中央外汇业务中心

一面采用的是这种形式，小组5个人，给定一个题目，10分钟时间看，1分钟时间陈述自己观点，20分钟时间讨论，最后选一个人用3分钟对小组讨论结果进行描述，其他人用2分钟对自己刚才的表现作总结。我们的题目是：假设唐僧四人再次西天取经，但因为资金不足，必须淘汰一人，请问应该淘汰谁？并说出理由。

我们组的意见完全一致：淘汰猪八戒。所以，讨论环节变得很轻松，大家的任务变成了，找出为什么淘汰八戒而保留其他人的理由。具体过程不多说了。我最突出的表现是在最后。

最后，每个人轮流对自己刚才的表现作总结，前四个人都说了自己刚才对整体起到什么作用，最后到我说时，我的原话是：

"刚才通过我们小组的努力，最后出色的完成了任务，在这个过程中，其他几位同学都起到了重要作用，例如：1号同学...3号...4号...5号...。另外我想说的是，我们在讨论的题目跟我们刚才做的说明了同一个道理，就是：在一个团队中，一定要明确自己的定位，找到自身的角色，否则就会像猪八戒那样因为定位不明确而被淘汰。我刚才在团队中的角色主要是沟通和串联的作用。表现不足的地方就是，很抱歉，刚才忘了帮大家掐时间。"

下面是失败案例。

联想：给小组一个鸡蛋，一些吸管和胶带，请小组在20分钟时间内想出一个办法，利用这些资源，让鸡蛋从2米的高空掉下来，而不碎。最后选出一个人作演示和总结，并请每一个人对自己刚才的表现作总结。

我们组最后成功的完成了任务，并由我来作演示。可惜最后，我们的方案被HR批评了，说我们用光了所有的胶带和吸管，不懂得节约手上的资源。

最后的结果：我们组被整组淘汰。

教训总结：个人利益和集体利益是息息相关的，如果整体的方案失败了，那么个人的成功也无从谈起。

下一篇请关注面试之非技术面试篇。

http://blog.sina.com.cn/s/blog_5dde893c0100fjap.html
1. 1-20的两个数把和告诉A,积告诉B，A说不知道是多少，

B也说不知道，这时A说我知道了，B接着说我也知道了，问这两个数是多少？
答案：2和3

注（本人分析）：看了几篇类似的分析，首先我觉得拿出的两个数是不应该重复的，比如不能拿2，2，然而别人分析中没有这么认为。A说不知道，说明由和分解的结果不唯一，而B说不知道也是因为由分解的数不唯一，这时候A说他知道了，我觉得他是把分解的情况做了一个分析，假如分解的情况为x1，x2；y1，y2（如果分解的情况多了的话，我个人认为他不会很快判断出是那个数的），应该有一种情况是x1*x2或者y1*y2的值积分解唯一，而另一个积分解不唯一，因为B说不知道，可以知道答案应该是积分解不唯一的那个，所以A知道了。B在反过来推测，也该得到结论。

在1到20个数中寻找，可以发现2和3满足要求，自我感觉分析有漏洞，智商如此，请高手指点了。

4 如何输出源文件的标题和目前执行行的行数？

答案： printf("The file name: %d\n", __FILE__);

printf("The current line No:%d\n", __LINE__);

ANSI C标准预定义宏:

__LINE__

__FILE__

__DATE__

__TIME__

__STDC__ 当要求程序严格遵循ANSI C标准时该标识符被赋值为1

__cplusplus__ 当编写C++程序时该标识符被定义

7. 希尔 冒泡 快速 插入 哪个平均速度最快？

答案：快速排序nlog2n
快速排序、归并排序和基数排序在不同情况下都是最快最有用的。
8. enum的声明方式

答案：enum 枚举类型名 {

枚举常量1，

枚举常量2，

...

枚举常量n

};

For example:

enum weekday { sunday, monday, tuesday, wednesday, thursday, friday, saturda
y};

enum weekday week_day;//week_day 就是一个枚举类型变量

11. 顺序查找的平均时间

答案：(1+2+3+...+n)/n = (n+1)/2

14.不使用其他变量，交换两个整型a，b的值

答案：x = x+y; y = x-y; x = x-y

还有x=x^y;y=x^y;x=x^y这个更好一些

15. 写出float x 与“零值”比较的if语句。

if(x>=0.000001 && x<=-0.000001)（x不为0的比较）

float: 6位精度

double: 16位精度

2. Internet采用哪种网络协议？该协议的主要层次结构？

答案：TCP/IP协议。应用层、传输层、网络层、数据链路层和物理层。

3. Internet物理地址和IP地址转换采用什么协议？

答案：地址解析协议ARP address resolution protocol

4. IP地址的编码分为哪俩部分？

答案：网络号和主机号。不过是要和“子网掩码”按位与上之后才能区分哪些是网络位
哪些是主机位。

大题：

1 把字符串转换为小写，不成功返回NULL,成功返回新串

char* toLower(char* sSrcStr)
{
char* sDest= NULL;
if( __1___)
{
int j;
sLen = strlen(sSrcStr);
sDest = new [_______2_____];
if(*sDest == NULL)
return NULL;
sDest[sLen] = '\0';
while(_____3____)
sDest[sLen] = toLowerChar(sSrcStr[sLen]);
}
return sDest;
}

2 把字符串转换为整数 例如："-123" -> -123

main()
{
.....
if( *string == '-' )
n = ____1______;
else
n = num(string);
.....
}

int num(char* string)
{
for(;!(*string==0);string++)
{
int k;
k = __2_____;
j = --sLen;
while( __3__)
k = k * 10;
num = num + k;
}
return num;
}

附加题：

1 linux下调试core的命令，察看堆栈状态命令
2 写出socks套接字 服务端 客户端通讯程序
3 填空补全程序，按照我的理解是添入：win32调入dll的函数名
查找函数入口的函数名 找到函数的调用形式
把formView加到singledoc的声明 将singledoc加到app的声明

#define Max(a,b) ( a/b)?a:b

写一个病毒
while (1)
       {
              int *p = new int[10000000];
       }

不使用额外空间,将 A,B两链表的元素交叉归并
将树序列化 转存在数组或 链表中
struct st{
int i;
short s;
char c;
};
sizeof(struct st);
答案：8
    char * p1;
    void * p2;
    int *p3;
    char p4[10];
    sizeof(p1...p4) =?
答案：4，4，4，10

二分查找
快速排序
双向链表的删除结点
有12个小球,外形相同,其中一个小球的质量与其他11个不同
给一个天平,问如何用3次把这个小球找出来
并且求出这个小球是比其他的轻还是重
解答:
哈哈，据说这是微软前几年的一个面试题。很经典滴啊！三次一定能求出来，而且能确定是重还是轻。
数据结构的知识还没怎么学透，不过这个题我到是自己研究过，可以分析下。
将12个球分别编号为a1,a2,a3.......a10,a11,a12.
第一步：将12球分开3拨，每拨4个，a1~a4第一拨，记为b1， a5~a6第2拨，记为b2，其余第3拨，记为b3；
第二步：将b1和b2放到天平两盘上，记左盘为c1，右为c2；这时候分两中情况：

1.c1和c2平衡，此时可以确定从a1到a8都是常球；然后把c2拿空，并从c1上拿下a4，从a9到a12四球里随便取三球，假设为a9到a11，放到c2上。此时c1上是a1到a3，c2上是a9到a11。从这里又分三种情况：
      A：天平平衡，很简单，说明没有放上去的a12就是异球，而到此步一共称了两次，所以将a12随便跟11个常球再称一次，也就是第三次，马上就可以确定a12是重还是轻；
      B：若c1上升，则这次称说明异球为a9到a11三球中的一个，而且是比常球重。取下c1所有的球，并将a8放到c1上，将a9取下，比较a8和a11（第三次称），如果平衡则说明从c2上取下的a9是偏重异球，如果不平衡，则偏向哪盘则哪盘里放的就是偏重异球；
      C：若c1下降，说明a9到a11里有一个是偏轻异球。次种情况和B类似，所以接下来的步骤照搬B就是；

2.c1和c2不平衡，这时候又分两种情况，c1上升和c1下降，但是不管哪种情况都能说明a9到a12是常球。这步是解题的关键。也是这个题最妙的地方。
      A：c1上升，此时不能判断异球在哪盘也不能判断是轻还是重。取下c1中的a2到a4三球放一边，将c2中的a5和a6放到c1上，然后将常球a9放到c2上。至此，c1上是a1，a5和a6，c2上是a7，a8和a9。此时又分三中情况：
          1）如果平衡，说明天平上所有的球都是常球，异球在从c1上取下a2到a4中。而且可以断定异球轻重。因为a5到a8都是常球，而第2次称的时候c1是上升的，所以a2到a4里必然有一个轻球。那么第三次称就用来从a2到a4中找到轻球。这很简单，随便拿两球放到c1和c2，平衡则剩余的为要找球，不平衡则哪边低则哪个为要找球；
          2）c1仍然保持上升，则说明要么a1是要找的轻球，要么a7和a8两球中有一个是重球（这步懂吧？好好想想，很简单的。因为a9是常球，而取下的a2到a4肯定也是常球，还可以推出换盘放置的a5和a6也是常球。所以要么a1轻，要么a7或a8重）。至此，还剩一次称的机会。只需把a7和a8放上两盘，平衡则说明a1是要找的偏轻异球，如果不平衡，则哪边高说明哪个是偏重异球；
          3）如果换球称第2次后天平平衡打破，并且c1降低了，这说明异球肯定在换过来的a5和a6两求中，并且异球偏重，否则天平要么平衡要么保持c1上升。确定要找球是偏重之后，将a5和a6放到两盘上称第3次根据哪边高可以判定a5和a6哪个是重球；
      B：第1次称后c1是下降的，此时可以将c1看成c2，其实以后的步骤都同A，所以就不必要再重复叙述了。至此，不管情况如何，用且只用三次就能称出12个外观手感一模一样的小球中有质量不同于其他11球的偏常的球。而且在称的过程中可以判定其是偏轻还是偏重。

给一个奇数阶N幻方，填入数字1，2，3...N*N,使得横竖斜方向上的和都相同
答案:
#include<iostream>
#include<iomanip>
#include<cmath>
usingnamespace std;
int main()
{
 int n;
 cin>>n;
 int i;
 int **Matr=newint*[n];//动态分配二维数组
 for(i=0;i<n;++i)
      Matr[ i ]=newint[n];//动态分配二维数组
 //j=n/2代表首行中间数作为起点，即1所在位置
 int j=n/2,num=1;//初始值
 i=0;
 while(num!=n*n+1)
 {
//往右上角延升，若超出则用%转移到左下角
      Matr[(i%n+n)%n][(j%n+n)%n]=num;
    //斜行的长度和n是相等的，超出则转至下一斜行
    if(num%n==0)
          i++;
   else
      {
          i--;
          j++;
     }
      num++;
 }
 for(i=0;i<n;i++)
 {
      for(j=0;j<n;++j)
         cout<<setw((int)log10(n*n)+4)<<Matr[ i][ j ];//格式控制
      cout<<endl<<endl;//格式控制
 }
for(i=0;i<n;++i)
      delete [ ]Matr[ i ];
return1;
}
腾讯的一道面试题:(与百度相似,可惜昨天百度死在这方面了)////
在一个文件中有 10G 个整数，乱序排列，要求找出中位数。内存限制为 2G。只写出思路即可。
答案:
1， 把整数分成256M段，每段可以用64位整数保存该段数据个数，256M*8 = 2G内存，先清0
2，读10G整数，把整数映射到256M段中，增加相应段的记数
3，扫描256M段的记数，找到中位数的段和中位数的段前面所有段的记数，可以把其他段的内存释放
4，因中位数段的可能整数取值已经比较小（如果是32bit整数，当然如果是64bit整数的话，可以再次分段），对每个整数做一个记数，再读一次10G整数，只读取中位数段对应的整数，并设置记数。
5，对新的记数扫描一次，即可找到中位数。
如果是32bit整数，读10G整数2次，扫描256M记数一次，后一次记数因数量很小，可以忽略不记
(设是32bit整数，按无符号整数处理
整数分成256M段？ 整数范围是0 - 2^32 - 1 一共有4G种取值，4G/256M = 16，每16个数算一段 0-15是1段，16-31是一段，...
整数映射到256M段中？如果整数是0-15，则增加第一段记数，如果整数是16-31，则增加第二段记数，...

其实可以不用分256M段，可以分的段数少一写，这样在扫描记数段时会快一些，还能节省一些内存)

腾讯题二:
一个文件中有40亿个整数，每个整数为四个字节，内存为1GB，写出一个算法：求出这个文件里的整数里不包含的一个整数
答:
方法一: 4个字节表示的整数，总共只有2^32约等于4G个可能。
为了简单起见，可以假设都是无符号整数。
分配500MB内存，每一bit代表一个整数，刚好可以表示完4个字节的整数，初始值为0。基本思想每读入一个数，就把它对应的bit位置为１，处理完40G个数后，对500M的内存遍历，找出一个bit为0的位，输出对应的整数就是未出现的。
算法流程：
１）分配５００ＭＢ内存buf，初始化为０
２）unsigned int x=0x1;
    for each int j in file
    buf=buf ¦x < <j;
    end
(3) for(unsigned int i=0; i <= 0xffffffff; i++)
        if (!(buf & x < <i))
        {
            output(i);
            break;
        }
以上只是针对无符号的，有符号的整数可以依此类推。
方法二:
文件可以分段读啊，这个是O（2n）算法，应该是很快的了，而且空间也允许的。
不过还可以构造更快的方法的，更快的方法主要是针对定位输出的整数优化算法。
思路大概是这样的，把值空间等分成若干个值段，比如值为无符号数，则
00000000H-00000FFFH
00001000H-00001FFFH
......
0000F000H-0000FFFFH
.....
FFFFF000H-FFFFFFFFH
这样可以订立一个规则，在一个值段范围内的数第一次出现时，对应值段指示值Xn=Xn+1，如果该值段的所有整数都出现过，则Xn=1000H，这样后面输出定位时就可以直接跳过这个值段了，因为题目仅仅要求输出一个，这样可以大大减少后面对标志数值的遍历步骤。
理论上值段的划分有一定的算法可以快速的实现，比如利用位运算直接定位值段对应值进行计算。

     答案：#define Max(a,b)  (a/b)?a:b

相关：

（1）在C语言源程序中允许用一个标识符来表示一个字符串，称为“宏”。被定义为“宏”的标识符称为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。

（2）宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。

（3）在C语言中，“宏”分为有参数和无参数两种。

（4）无参数宏定义

          一般形式：   #define  标识符 字符串

          其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。比如说符号常量的定义就是一种无参宏定义。此外，常对程序中反复使用的表达式进行宏定义。例如：# define M   （y*y+3*y），定义M为表达式（y*y+3*y），在编写源程序时，所有的（y*y+3*y）都可由M代替，而对源程序做编译时，将先有预处理程序进行宏代换，即用（y*y+3*y）表达式去置换所有的宏名M，然后再进行编译。

            例子：

                             #   define M （y*y+3*y）

                             main(){

                                  int s,y;

                                  printf ("input a number:")

                                  scanf("%d",&y);

                                  s=3*M+4*M+5*M;

                                  printf("s=%d\n",s);

                             }

             注意：上例程序中。宏定义表达式（y*y+3*y）两边的括号不能少，否则会发生错误。当做以下定义后：# define M y*y+3*y在宏展开时将得到下述语句：

s=3*y*y+3*y+4*y*y+3*y+5*y*y+3*y，显然与题意不符。因此，在作宏定义时必须十分注意，应保证在宏代换之后不发生错误。

（5）带参数宏定义

        C语言允许宏带有参数。在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。

        一般定义形式：    # define  宏名 （形参表） 字符串 

        在字符串中含有各个形参。

        一般调用形式：     宏名（实参表）

        例如：  

                          #   define  MAX(a,b)      (a>b)?a:b

                          main () {

                                int x,y,max;

                                printf("input two numbers:");

                                scanf("%d%d",&x,&y);

                                max=MAX(x,y);

                                printf("max=%d\n",max);

                          }

（6） 对于宏定义语句，预处理程序对它不作任何检查，如果有错误，只能在编译已被宏展开后的源程序时发现。

（7）宏定义在行末不必加分号，如加上分号则连分号也一起置换。

（8）宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用#underf命令。

                        例如：

                                  #  define  PI 3.14159

                                  main()

                                  {

                                  ......

                                  }

                                  # underf  PI

                                  f1()    

             在这段程序中，PI只在main函数中有效，在f1()中无效。

（9）宏名在源程序中若用引号括起来，则预处理程序不对其做宏代换。

                          例如：

                                #   define   Ok  100

                                main()

                                {

                                      printf("OK");

                                      printf("\n");

                                 }

               在这段程序中，宏名OK表示100，但在printf语句中OK被引号括起来，因此不做宏代换，把“OK”当字符串处理。程序的运行结果为：OK

 （10）宏定义允许嵌套，在宏定义的字符串中可以使用已经定义的宏名。在宏展开时由预处理程序层层代换。

                           例如：

                                 #define   PI   3.14159

                                 #define   S     PI*y*y

（11）习惯上宏名用大写字母表示，以便与变量区别。但也允许用小写字母。

（12）可用宏定义表示数据类型，使书写方便。

                           例如：

                                 # define  STU  struct stu

                       这样一来，可以在程序中使用STU做变量说明，例如：

                                 STU  body[5],*p;

（14）对“输出格式”做宏定义，可以减少书写麻烦。

                            例如：

                                  # define  P printf

                                  #define   D "%d\n"

                                  #define  F "%f\n"

                                  main(){

                                  int a=5, c=8, e=11;

                                  float b=3.8,  d=9.7,   f=21.08;

                                  P(D F,a,b);

                                  P(D F,c,d);

                                  P(D F,e,f);

                                  }

（15）带参宏定义中，宏名和形参表之间不能有空格出现。

                         例如：  #define  MAX(a,b)  (a>b)?a:b

                  不能写成     #define  MAX  (a,b)  (a>b)?a:b  这样一来，宏调用语句：

max=MAX(x,y)  将变为：  max=MAX(a,b)(a>b)?a:b(x,y)   ，这显然是错误的。

（16）再带参宏定义中，形式参数不分配内存单元，因此不必做类型定义。而宏调用中的实参有具体值。要用他们去代换形参，因此必须做类型说明。这是与函数中的情况不同的。在函数中，形参和实参是两个不同的量，各有自己的作用域，调用时要把实参值赋予形参，进行“值传递”。而在带参宏中，只是符号代换，不存在值传递的问题。

（17）在宏定义中的形参是标识符，而宏调用中的实参可以是表达式。

                        例如：

                                #define SQ(y)  (y)*(y)

                                main(){

                                int a,sq;

                                printf("input a number:");

                                scanf("%d",&a);

                                sq=SQ(a+1);

                                printf("sq=%d\n",sq);

                                } 

（18）在宏定义中，字符串内的形参通常要用括号括起来以避免出错，例如把上面的例子改成：

                                #define SQ(y)  y*y

                                main(){

                                int a,sq;

                                printf("input a number:")

                                scanf("%d",&a);

                                sq=SQ(a+1)

                                }

              当给a赋值为3时运行的结果是sq=7。

（19）为避免错误，对于宏定义不仅应在参数两侧加括号，也应在整个字符串外加括号。

（20）宏定义也可以用来定义多个语句，在宏调用时，把这些语句又代换到源程序内。

                      例如：

                                  #define SSSV(s1,s2,s3,v)    s1=l*w;s2=l*h,s3=w*h,v=w*l*h;

                                  main(){

                                         int l=3,w=4,h=5,sa,sb,sc,vv;

                                         SSSV(sa,sb,sc,vv);

                                         printf("sa=%d\nsb=%d\nsc=%d\nvv=%d\n",sa,sb,sc,vv);

                                  }

                 上述程序第一行为宏定义，用宏名SSSV表示4个赋值语句，4个形参分别为4个赋值符左边的变量。在宏调用时，把4个语句展开并用实参代替形参。使计算结果送入实参中。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/omaigaode/archive/2008/12/04/3441834.aspx

发信站: 北邮人论坛 (Tue Oct 20 16:52:13 2009), 站内

     先简单介绍一下本人，本人小硕，信通院通信与信息系统，无线方向，投的百度无线新技术研发，技术岗。虽然在实验室做过一些项目，但也都是无线通信的底层开发，和互联网没有任何关系。。。
   今早尚未睡醒，突然一阵手机铃声传来，一个陌生的手机号码，见其不是响一声电话，遂接之，在不算清楚的状态下被通知下午一点普天大厦百度面试，突如其来的通知搞的我有点措手不及。本来觉得18号笔试完直接被鄙视了，这从天而降的机会还是迫使我需要在短时间内做好必要的准备，所谓的准备也就是从网上查查面经，复习复习笔试题目，总之还是抱着学习的态度去的，没抱太大希望。
   下午12点40到达普天大厦，签到后稍微等了一会儿，接待我的jj将我指到一个小型的广场，阳光很好，有很多小圆桌，我的面试官已经坐在其中一个小圆桌上等我了，是一对一的面试，坐下后简单打了个招呼，面试就开始了，先是按照我的简历问我关于最近一个项目的相关内容，包括项目组的职责，做过什么，贡献在哪，碰到过什么难题等等，因为面试官gg估计也不太懂我做过的东西，我就blabla一顿介绍，然后又问我学的课程中认为哪个比较困难，困难在哪，有没有具体例子，总之问的比较细。我觉得在这个环节最重要的就是让面试官觉得项目是你做的，有的可讲，对于自己的贡献的部分讲的越细越好，对方听没听懂没有关系，关键在于能够有条理的回答对方问的问题（当然，如果对方对自己做过的项目非常了解，回答问题的时候就应该尽量谨慎，不要扯淡，以免露怯。。。）
   之后的环节是算法，数据结构，编程题，由面试官现场出题，他先出了两个比较简单的题目，一个是 char str ="hello";sizeof(str)和strlen(str)为多少，还有一个是floata；将其和0做比较的if语句如何编写。然后出了一个数据结构算法实现题：给定二叉树，写出计算该二叉树的高度的函数，这题我没想出来。。。他又出了一个：给定二叉树，写出拷贝该二叉树的函数，返回拷贝后根节点值，这道题我只说出了大概的思路，看面试官的表情，不是很满意。。。随后又问了关于二叉树深度优先和广度优先的算法问题，和堆排序的算法问题，无奈专业背景相差过大，这些我都没答上来，对于学计算机的学生，我觉得这些问题应该都不难。。。最后又给我出了道关于字符串的问题：给定字符串，内容为a-z的字符，其中有一个字符出现为奇数次，其他均为偶数次，找出出现奇数次的字符，我简单给出了一个算法，但是时间复杂度过高，于是面试官gg问我能不能对算法进行优化，这个又难住我了，虽然面试官gg人很好，在我想的过程中一直给予提示，无奈我水平不够。。。想出来的答案都相去甚远。。。我觉得这个环节本身考察的问题其实并不难，都是基础，换一个学计算机的学生，这些东西不过是平时的功课罢了，只要算法，数据结构的基础知识过硬，回答这些问题应该都不会很困难
   距离面试结束还有几分钟的时候，和面试官gg简单聊了聊，获知对方是南开计算机毕业的，告诉我互联网行业技术岗主要要求的素质包括算法和数据结构，网络的基本知识，编程能力等等，期间还说了一些我没太明白的专有名词，总之，他觉得以我现在的知识储备和项目经历，目前还不太适合这个职位。。。
    一个小时后，面试结束，本来我也是抱着学习的心态过来试试，对于这样的结果我还是预想的到的，这一趟面试也算没有白来，能够学到一些东西我就知足了。希望大家都能找到好工作，共勉！
转载请注明出自应届生求职招聘论坛 http://bbs.yingjiesheng.com/,本贴地址:http://bbs.yingjiesheng.com/thread-253544-1-1.html

1.Stuct Foo{
Foo(){}
Foo(int){}
Void fun(){}
};

int main (){
Foo a(10);
(1)
a.fun();
(2)
Foo b();
(3)
b.fun();
(4)
}
上面的程序中哪个语句是错误的；

2.struct 和 class 的区别；

3.const char*p1=”hello”;

Char *const p2=”world”;
下面哪些操作是合法的：（1）p1++;
(2)*p1=”w”;
(3)p2++;
(4)*p2=”h”;

4.n进制下。567*456=150216成立，则n的值是多少？

5.C++中不能重载的运算符是？

6.排序方法中元素比较次数与初始化排序无关的是哪种排序方法。

7. int x[4]={0}; int y[4]={1};则x,y的值是多少？

8.二分查找的理论

9.采取FIFO页面淘汰算法，如何计算缺页。

10.顺序栈的容量如何计算

11．文件索引结构

12.搜索所用的数据结构的内存，以及速度的问题

13.堆中的数据的存储机制

14.页式存储系统，如何计算分块的大小

15.std::vector::iterator
可重载的运算符是哪些： ++，>>, *(前置), ==

16.判断单向链表是否存在环的最佳方案是什么？

17.100张多米诺骨牌1，2，3 ……100，第一次先把所有的基数位置的牌拿掉，第二次把剩下的基数位置的牌拿掉，依此类推，最后剩下的牌是哪个：(A)32，(B)64，(C)88，(D)96

18.在C++中不能重载下面的哪个运算符：（A）*
(B) ?:
(C) ::
(D) delete

19.就是指针的一大堆问题啦，什么函数指针啊，数组指针之类的

20. sizeof() 计算问题

21. public,protected在派生或者继承之后的访问权的问题
转载请注明出自应届生求职招聘论坛 http://bbs.yingjiesheng.com/,本贴地址:http://bbs.yingjiesheng.com/thread-239002-1-1.html

C/C++ code

#include <iostream>
using namespace std;
int bit_cnt(int n)
{
int result = 0;
for (; n; n &= n-1, ++result);
return result;
}
int main()
{
int F[6], B[6];
int ans = 0;
for (int state = 0; state < (1 << 12); ++state) if (bit_cnt(state) == 6)
{
int i = 0, j = 0;
for (int k = 0; k < 12; ++k) if (state&(1<<k)) F[i++] = k; else B[j++] = k;
int ok = 1;
for (int k = 0; k < 6; ++k) if (B[k] < F[k]) {ok = 0; break;}
ans += ok;
}
cout << ans << endl;
return 0;
}

1. 匹配"[10]:dddddd"和"[9]:abcdegf"但不匹配"[a]:xfdf"的正则表达式。

2. int a[5]={1,2,3,4,5};

    printf("%d\n", *((int*)(&a+1)-2);

    输出是什么。

    答：4.    分析：(int*)(&a+1)=a+5=&a[5]

编程题：

1. 给定一个int型数组array[n]，写一个函数sort(int array[], int n)，n为数组长度。使得数组中不大于零的元素在前，大于零的元素在后，要求时间复杂度O(n)。

2. 有1001个球。甲乙两人交替取球，每次可取1、2、4个球，谁拿到最后一个球就算输。如果甲先拿，问他有没有必胜的把握？为什么？

   答：有。

          第一次甲拿1个球，以后每次：

          i. 乙拿1个，甲拿2个；

         ii. 乙拿2个，甲拿1个或4个；

         iii. 乙拿4个，甲拿2个。

         最后肯定剩一个，并轮到乙拿。

3. 实现atoi()和itoa()

4. 给定一个int型数n，写一个尽可能简单的函数判断n是否为2的幂，不能用循环。

   答：bool foo(int n)

          {

                int a=n;

               if(n<=0) return false;

               a=((a&0xAAAAAAAA)>>1)+(a&0x55555555);

               a=((a&0xCCCCCCCC)>>2)+(a&0x33333333);

               a=((a&0xF0F0F0F0)>>4)+(a&0x0F0F0F0F);

               a=((a&0xFF00FF00)>>8)+(a&0x00FF00FF);

               a=((a&0xFFFF0000)>>16)+(a&0x0000FFFF);

               if(a==1) return true;

               else return false;

           }

简答题：

1. 哪些方法可以避免或减少锁的使用？

2. release版本的可执行程序为什么非常大？

3. 使用C++赋值运算符应注意什么地方？

4. strcpy()为什么会造成缓冲区溢出？可用哪个函数替代？

5. 阻塞模式的recv在没受到数据的情况下如何返回？（不能将socket修改为非阻塞）

8. 有红、绿、蓝三色球分别3,2,1个。取任意两个不同颜色的球都会使它们变成第三种颜色的两个球。问最少取多少次，可使这些球都变成同一种颜色？

   答：无论多少次，都不可以使这些球变成同一种颜色，分析：

         一、对于(R,R,R,G,G,B)即（3,2,1），有：

                i.   (R,G) ---> (B,B,B,R,R,G)即(3,2,1)

                ii. (R,B)   ---> (G,G,G,G,R,R)即(4,2)

                iii. (G,B) ---> (R,R,R,R,R,G)即(5,1)

          二、对于(G,G,G,G,R,R)即(4,2)，有 ：

                i. (R,G) ---> (G,G,G,B,B,R)即(3,2,1)

          三、对于(R,R,R,R,R,G)即(5,1)有 ：

                i. (R,G) ---> (R,R,R,R,B,B)即(4,2)

          因此，只有三种状态(3,2,1), (4,2)和(5,1)，不可能出现(6,0)这种情况。   

9. 哪些方法可让一个进程仅有一个实例运行？

10. exit()和_exit() 的区别。

11. 红黑树比AVL树的优势在哪？

12. 软件开发过程包含哪些阶段？各阶段质量保证措施是什么？

1.拼七巧板，还是比较有意思的（10分）

2.判断下列图案中哪一个与其他三个不同。（10）

       A                           B                            C                          D

3.有一个队列长一百米，有一个人从尾走到头，再从头走到尾，期间他的速度和队列的速度都不变，队列正好行进了100米，问这个人走了多少距离。（10）

4.推理题。关于白帽、黑帽的，可以网上搜搜类似的。（10）

5.一个文章系统，用户登陆后输出欢迎信息：（20）

1.用户注册时间不足一个月，输出信息A：欢迎新用户，您还没有发表文章，可以先熟悉一下系统，查看帮助信息。

2.用户注册时间不足一个月，输出信息B：欢迎新用户，您已经发表了文章，不过在最初一个月发表3篇或3篇以上文章会对以后很有帮助。

3.用户注册时间小于三个月，输出信息C：用户您好，在最初一个月后您没有发表文章，请多多努力。

4.用户注册大于三个月，输出信息D：用户您好，最近3个月您都未发表文章，如果长时间不发表文章，您的帐号将被冻结。

5.其他情况输出E：欢迎您的登陆。

1）画出流程图

2）写出实现代码，不需要定义变量类型

相关函数

GetRegisterTime(username)
 获得用户username的注册时间
 
GetNowTime()
 获得现在时间
 
TimeDiff(time1,time2)
 获得time1到time2的天数
 
AddDay(time1,day_num)
 在time1上加上天数，可以为负，得到新时间
 
GetArticleCount(username,time1,time2)
 获得用户在time1和time2之间发表的文章数量
 
Print(A)
 输出信息A，可以将A换成B、C等等
 

如有其他函数请自己定义并说明用途。

6.计算概率，具体不记得了。（10）

7.英文题目Next Number。（20）

大意就是要根据输入数字，输出一个新数，要求输出数字各个位的和加起来与原数相等。输出的数字是大于原数的第一个数。

如Input:113，output:122，Input 0050，output: 0104。

输入的N位数字k（0<=k<=101000,0<=N<2000）。

设计完成函数，用伪码实现。

游戏研发工程师必做题

1.一个游戏，角色属性有：生命、攻击、速度、防御、魔法，试设计一个角色的数据结构，用代码实现。

2.若该游戏发布了资料篇，资料篇中角色属性添加了两个：魔防、敏捷。现改进原设计，怎么区分老版游戏和资料篇玩家，并正确读取。

3.在网络游戏中GM通常有一定特权可以对角色属性进行修改，现有GM1，可以对角色的攻击属性修改，而不能对其他属性修改，试设计系统（所有属性都是可读的）。GM的指令通常为以下模式：//moveto x,y；移动到x，y；//kick 用户，踢出某一用户。

2.最优打怪路线

玩家从东往西进行，打怪只能打南北的怪，消耗的能量与怪物离玩家的距离有关，试找出一个最好的打怪路线。

注：玩家只能水平移动，怪物均是静止的，不移动。

1）证明该路线是最佳路线

2）代码实现

3.用户支付

1）某一网络游戏用户分为3种类型：计时用户、包月用户、合作用户，合作用户是与别的厂家合作，可能在某一段时间免费或计费与别的不同，试设计一个支付系统，支付部分代码实现。

2）后来又添加了一种用户：道具收费用户，即玩家游戏时间免费，而是通过购买游戏中道具需要钱，4种用户运行于同一台服务器，试改进系统。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/qiluofei/archive/2007/10/20/1834263.aspx

第三题：
利用回溯剪枝法
空间复杂度：O(n) 栈的最大深度也就是n了
时间复杂度：接近于O(2^n-1), 因为本质上程序时一个遍历树的过程，如果没有剪枝，那么树是一个满二叉树，结点共2^n-1个，也就要遍历2^n-1次。虽然剪枝，但速度估计仍是 2^n次方级别的。
试了下，调用cal_num(104),好久了结果都没有出来。。。

不知用上DP算法会不会好点，不过听说回溯法怎么弄效率都跟不上，最好用递推？
在哪听说的？
http://topic.csdn.net/u/20090922/11/ebc26b48-6581-40c3-afe0-a95ca2d700d5.html

/**//////////////////////////////////////////////////////////////////
//file divide_set.h:

#ifndef __DIVIDE_SET_H__
#define __DIVIDE_SET_H__

// 计算集合set的所有满足下列条件的子集合：子集合元素之和等于value
// 子集合的元素对应的label置1
void divide_set( int set[], int label[], int len, int i_set, int value );

// 对集合{1,2,n}划分
void cal_num( int n );

#endif


/**//////////////////////////////////////////////////////////////////
//file divide_set.cpp:

#include "stdafx.h"
#include "divide_set.h"

#include <iostream>

using namespace std;

// 查找集合set中，满足元素之和等于value的子集合，结果存于label里
void divide_set( int set[], int label[], int len, int i_set, int value )
{
 // 输出结果
 if ( value == 0 )
 {
  cout<<"{ ";
  for ( int i=0; i<len; ++i )
  {
   if ( label[i] )
   {
    cout<<set[i]<<" ";
   }
   
  }
  cout<<"} ";
  cout<<" , { ";
  for ( int i=0; i<len; ++i )
  {
   if ( 0 == label[i] )
   {
    cout<<set[i]<<" ";
   }
  }
  cout<<"} ";
  cout<<endl;
  return;
 }

 if ( i_set >= len || value <0)
 {
  return;
 }

 // 取第i_set个元素
 label[i_set] = 1;
 divide_set( set, label, len, i_set+1, value-set[i_set] );
 
 // 不取第i_set个元素
 label[i_set] = 0;
 divide_set( set, label, len, i_set+1, value );
}

void cal_num( int n )
{
 int* set = new int[n];
 int* label = new int[n];

 // initialize set and label
 int sum_value = 0;
 for ( int i=0; i<n; ++i )
 {
  set[i] = i+1;
  sum_value += set[i]; 
 }
 memset( label, 0, n*sizeof(int) );

 // 保证元素总和为偶数
 if( sum_value%2 == 0 )
  divide_set( set, label, n, 0, sum_value/2 );

 delete[] set;
 delete[] label;
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zdl1016/archive/2009/10/04/4632688.aspx

　　A hello(5)     B.hello(5,8)     C.hello(6,"#")     D.hello(0,0,"#")

　　2.下面有关重载函数的说法中正确的是:

　　A.重载函数必须具有不同的返回值类型   B.重载函数形参个数必须不同

　　C.重载函数必须有不同的形参列表       D.重载函数名可以不同

　　3.分析一下程序的运行结果:

　　#include<iostream.h>

　　class CBase

　　{

　　public:

　　CBase(){cout<<”constructing CBase class”<<endl;}

　　~CBase(){cout<<”destructing CBase class”<<endl;}

　　};

　　class CSub : public CBase

　　{

　　public:

　　CSub(){cout<<”constructing CSub class”<<endl;}

　　~CSub(){cout<<”destructing CSub class”<<endl;}

　　};

　　void main()

　　{

　　CSub obj;

　　}

　　A. constructing CSub class           B. constructing CBase class

　　constructing CBase class             constructing CSub class

　　destructing CSub class               destructing CBase class

　　destructing CBase class              destructing CSub class

　　C. constructing CBase class

　　constructing CSub class

　　destructing CSub class

　　destructing CBase class

　　D. constructing CSub class

　　constructing CBase class

　　destructing CBase class

　　destructing CSub class

　　4.在一个cpp文件里面,定义了一个static类型的全局变量,下面一个正确的描述是:

　　A.只能在该cpp所在的编译模块中使用该变量

　　B.该变量的值是不可改变的

　　C.该变量不能在类的成员函数中引用

　　D.这种变量只能是基本类型(如int,char)不能是C++类型

　　5.观察下面一段代码:

　　class ClassA

　　{

　　public:

　　virtual ~ ClassA(){};

　　virtual void FunctionA(){};

　　};

　　class ClassB

　　{

　　public:

　　virtual void FunctionB(){};

　　};

　　class ClassC : public ClassA,public ClassB

　　{

　　public:

　　};

　　ClassC aObject;

　　ClassA* pA=&aObject;

　　ClassB* pB=&aObject;

　　ClassC* pC=&aObject;

　　关于pA,pB,pC的取值,下面的描述中正确的是:

　　A.pA,pB,pC的取值相同.               B.pC=pA+pB

　　C.pA和pB不相同                      D.pC不等于pA也不等于pB

　　6.参照1.5的代码,假设定义了ClassA* pA2,下面正确的代码是:

　　A.pA2=static_cast<ClassA*>(pB);

　　B.void* pVoid=static_cast<void*>(pB);

　　pA2=static_cast<ClassA*>(pVoid);

　　C.pA2=pB;

　　D.pA2=static_cast<ClassA*>(static_cast<ClassC*>(pB));

　　7.参照1.5的代码,下面那一个语句是不安全的:

　　A.delete pA   B.delete pB   C.delete pC

　　8.下列程序的运行结果为:

　　#include<iostream.h>

　　void main()

　　{

　　int a=2;

　　int b=++a;

　　cout<<a/6<<endl;

　　}

　　A.0.5   B.0   C0.7   D.0.6666666－

　　9.有如下一段代码:

　　#define ADD(x,y) x+y

　　int m=3;

　　m+=m*ADD(m,m);

　　则m的值为:

　　A.15   B.12   C.18   D.58

　　10.如下是一个带权的图,图中结点A到结点D的关键路径的长度是:

　　A.13       B.15       C.28       D.58

　　11.下面的模板声明中,正确的是:

　　A.template<typename T1,T2>

　　B.template<class T1,T2>

　　C.template<class T1,class T2>

　　D.template<typename T1;typename T2>

　　12.在Windows编程中下面的说法正确的是:

　　A.两个窗口,他们的窗口句柄可以是相同的     B.两个窗口,他们的处理函数可以是相同的

　　C.两个窗口,他们的窗口句柄和窗口处理函数都不可以相同.

　　13.下面哪种情况下,B不能隐式转换为A?

　　A.class B:public A{}                 B.class A:public B{}
C.class B{operator A();}             D.class A{A(const B&);}

　　14.某公司使用包过滤防火墙控制进出公司局域网的数据,在不考虑使用代理服务器的情况下,下面描述错误的是”该防火墙能够(   )”.

　　A.使公司员工只能访问Internet上与其业务联系的公司的IP地址.

　　B.仅允许HTTP协议通过,不允许其他协议通过,例如TCP/UDP.

　　C.使员工不能直接访问FTP服务器端口号为21的FTP地址.

　　D.仅允许公司中具有某些特定IP地址的计算机可以访问外部网络

　　15.数字字符0的ASCII值为48,若有以下程序:

　　main()

　　{

　　char a=’1’,b=’2’;

　　printf(“%c,”,b++);

　　printf(“%d\n”,b-a);

　　}

　　程序运行之后的输出结果是:

　　A.3,2      B.50,2       C.2,2     D.2,50

　　二.  填空题(共40分)

　　本程序从正文文件text.in读入一篇英文短文,统计该短文中不同单词和它的出现次数,并按词典编辑顺序将单词及它的出现次数输出到正文文件word.out中.

　　程序用一棵有序二叉树存储这些单词及其出现的次数,一边读入一边建立.然后中序遍历该二叉树,将遍历经过的二叉树上的节点的内容输出.
程序中的外部函数

　　int getword(FILE* pFile,char* pszWordBuffer,int nBufferLen);

　　从与pFile所对应的文件中读取单词置入pszWordBuffer,并返回1;若单词遇文件尾,已无单词可读时,则返回0.

　　#include <stdio.h>

　　#include <malloc.h>

　　#include <ctype.h>

　　#include <string.h>

　　#define SOURCE_FILE "text.in"

　　#define OUTPUT_FILE "word.out"

　　#define MAX_WORD_LEN 128

　　typedef struct treenode

　　{

　　char szWord[MAX_WORD_LEN];

　　int nCount;

　　struct treenode* pLeft;

　　struct treenode* pRight;

　　}BNODE;

　　int getword(FILE* pFile,char* pasWordBuffer,int nBufferLen);

　　void binary_tree(BNODE** ppNode,char* pszWord)

　　{

　　if(ppNode != NULL && pszWord != NULL)

　　{

　　BNODE* pCurrentNode = NULL;

　　BNODE* pMemoNode = NULL;

　　int nStrCmpRes=0;

　　____(1)_____;pCurrentNode=*ppNode

　　while(pCurrentNode)

　　{

　　/*寻找插入位置*/

　　nStrCmpRes = strcmp(pszWord, ___(2)___ );pCurrentNode->nCount

　　if(!nStrCmpRes)

　　{

　　___(3)___; pCurrentNode->nCount++

　　return;

　　}

　　else

　　{

　　___(4)___; pMemoNode=pCurrentNode

　　pCurrentNode = nStrCmpRes>0? pCurrentNode->pRight : pCurrentNode->pLeft;

　　}

　　}

　　}

　　pCurrent=new BNODE;

　　if(pCurrentNode != NULL)

　　{

　　memset(pCurrentNode,0,sizeof(BNODE));

　　strncpy(pCurrentNode->szWord,pszWord,MAX_WORD_LEN-1);

　　pCurrentNode->nCount=1;

　　}

　　if(pMemoNode==NULL)

　　{

　　___(5)___; *ppNode= pCurrentNode

　　}

　　else if(nStrCmpRes>0)

　　{

　　pMemoNode->pRight=pCurrentNode;

　　}

　　else

　　{

　　pMemoNode->pLeft=pCurrentNode;

　　}

　　}

　　void midorder(FILE* pFile,BNODE* pNode)

　　{

　　if(___(6)___) return;!pNode||!pFile

　　midorder(pFile,pNode->pLeft);

　　fprintf(pFile,"%s %d\n",pNode->szWord,pNode->nCount);

　　midorder(pFile,pNode->pRight);

　　}

　　void main()

　　{

　　FILE* pFile=NULL;

　　BNODE* pRootNode=NULL;

　　char szWord[MAX_WORD_LEN]={0};

　　pFile=fopen(SOURCE_FILE,"r");

　　if(pFile==NULL)

　　{

　　printf("Can't open file %s\n",SOURCE_FILE);

　　return;

　　}

　　while(getword(pFile,szWord,MAX_WORD_LEN)==1)

　　{

　　binary_tree(___(7)___);// pRootNode,szWord

　　}

　　fclose(pFile);

　　pFile=fopen(OUTPUT_FILE,"w");

　　midorder(pFile,pRootNode);

　　fclose(pFile);

　　}

　　三.  附加题(每题30分,2题,共60分)

　　1.      从程序健壮性进行分析,下面的FillUserInfo函数和Main函数分别存在什么问题?

　　#include <iostream>

　　#include <string>

　　#define MAX_NAME_LEN 20

　　struct USERINFO

　　{

　　int nAge;

　　char szName[MAX_NAME_LEN];

　　};

　　void FillUserInfo(USERINFO* parUserInfo)

　　{

　　stu::cout<<"请输入用户的个数:";

　　int nCount=0;

　　std::cin>>nCount;

　　for(int i=0;i<nCount;i++)

　　{

　　std::cout<<"请输入年龄:";

　　std::cin>>parUserInfo[i]->nAge;

　　std::string strName;
std::cout<<"请输入姓名:";

　　std::cin>>strName;

　　strcpy(parUserInfo[i].szName,strName.c_str());

　　}

　　}

　　int main(int argc,char* argv[])

　　{

　　USERINFO arUserInfos[100]={0};

　　FillUserInfo(arUserInfos);

　　printf("The first name is:");

　　printf(arUserInfos[0].szName);

　　printf("\n");

　　return 0;

　　}

　　2.      假设你在编写一个使用多线程技术的程序,当程序中止运行时,需要怎样一个机制来安全有效的中止所有的线程?请描述其具体流程.

笔试：
　　电路，自控，机械，net,c#,结构表，英文翻译……
　　这还不算啥，最后一页才搞笑。
　　请书写无机和有机化学方程式各一个。
　　牛顿三大定律，热力学三大定律
　　……
　　面试：
　　job hunting（2）之NokiA　　Nokia一直是很牛b的，从9月开始就收简历，折腾到了12月，历时2个半月之久。
　　第一次收到电话面试，正在上班，觉得十分尴尬，跑到外面在门卫面前表现了半个小时的英语，估计他都以为我有病，话都说不明白。
　　实现一点没有准备，就被Nokia给突击了，事后我一直想，简历一定要做好，绝不能再犯类似错误，我竟然写了C＋＋项目经验比C时间还长，让面试的gg抓住了不放，非要问个一二三。
　　还是庆幸那段时间还在看friends，对英语的基本感觉还在，没有生疏，顺利通过了电话面试。接下来的技术笔试，复试，都没有悬念的通过了，nokia还是比较正式的，就是战线拉的太长了，后来因为签了其它公司，就没有参加最后一次hr面试。
　　一直以来，我在bbs上是属于潜水者一型的，接到nokia的offer也有一段时间了。忽然就很有点感触。很想写出来和大家分享一下我的面试，希望能够给下一届的同学们一点参考。前面也有一些关于nokia面试的文章，我看了一下，和我的面试情况基本相同。我就不重复说了，把我在面试中觉得应该注意的地方写一下吧。
　　1，第一面的时候主要是考你的base knowledge，笔试完三页纸的技术问题以后（我当时考的主要是基本的通讯知识和GSM的基本概念），部门的manager就会问你一些技术问题，如果你有项目经验的话，也会大概问一些，但是没有深入（这个很重要，其实他在第一面以后就会对你的个人经历有一个初步认识，以后的面试也是基本上围绕这些问题展开。）整个过程很轻松，大概面试30分钟左右，然后他会通知你回去等消息。
　　2，老实说来，我就经过两次面试就接到录用通知了，因为nokia的第二次面试安排的很紧凑，基本上是整整一天。第二次面试我是到异地去面试的，nokia之类的外企如果通知你去外地面试是一定会报销路费和三星级以上（nokia指定）酒店的住宿费的。等我到了公司以后，发现我们是安排一个group一起面试的。当时我们那个group是6个人，听说也有8个的。等大家到齐了，我们被安排到一个小房间做一个“构建动物园”的project，这个project还蛮重要的，hr，部门manager和老总（一个荷兰老外，很象圣诞老人）都来了，黑板上写好了每个人的拼音名字，所以也没有进行个人介绍，然后hr用英文介绍了一下我们下面project主要的任务，给了5分钟的时间想，然后15分钟时间group讨论和实现。在整个过程中可以用中文，这个时候会有人记录你的表现，后来我知道他们不是要你表现的最优秀，但是要有group spirit，能够接受他人的意见和提出自己的见解。
　　讨论结束以后，group推荐一个人出来做中英文综述，当时我们组是推荐了一个女生讲的，都是她一个人讲（呵呵，后来听别的组说他们是推荐一个人用英文，一个人用中文），我当时忽然很胆怯，事实上英语也没有那么牛，所以基本上没有说什么。接着hr会要求你给整个group打出一个分数，给自己打一个分数，然后说你为什么这样打分。我们那组出了一个意外，第一个站起来回答的dd居然给每个人都打了分数，我在极度惊讶之下，也飞快的给每个人打了分数。后来问到我时，我说了我的分数，我给自己打的分数比group分数高，事实上只有我一个人这样打了，hr很奇怪的问我，为什么我觉得自己的表现很好？
　　我当时特别的窘迫，想了一下我说我觉得自己能够积极主动的说出自己的想法，能够接纳他人的建议，而且给group打分和给自己打分不是基于同一个评判标准的。所以建议ddmm们以后如果要打分一定要想好为什么要给自己打这样的分数。基本上，nokia的面试官都会特别的客气，不会咄咄逼人，但是如果你自己要准确的给自己定一个位。现在想起来还是觉得当时好丢人阿。。。。。后来我们很惊讶的发现，那个表现最好的mm没有录取，很可惜，不过这也能够看出来，nokia不是要求你能够表现多出色，它要的合适的人，所以面试的时候不要有压力，如果是你的，一定会是你的。
　　3，午餐，nokia请客，好丰盛的KFC大餐，不过大家好像都没有什么胃口，大家都在相互聊天和分享公司信息。
　　4，下午的时候就发了一堆的考卷，有365题的人格测试题，好像是要划出一个曲线看看和公司要求的人才符合不符合，总之你要尽量表现得乐观就对了，他们很看重这个。那个人格测试题，特别的搞笑，还有造句题，for example，我认为女人——————————。我当时的答案是我认为女人应该独立自主。大家的答案五花八门，什么我认为女人能顶半边天。女人应该靠自己。。。。。还有50题的智力测试。（就是那种几个图形，要你选择最相近的一个之类的）。我是乱来一气，我一直以来都不知道这个到底是怎么回事，都是直觉。同步进行的是hr面试，一个一个的叫出去，大概每个40分钟左右。
　　5，终于轮到我面试了。进门前，我没有敲门，直接开门进去了，说了一声下午好，面试我的是hr和一个部门的manager，在整个面试期间我觉得最好的就是他们很尊重你，他们对你的情况特别清楚，好像就是和老朋友聊天一样。其中重点就是问了我的项目经历，因为我有专利，他们特别问了我对自己专利所有权的看法，问我为什么基本上由我完成的项目，老板做第一专利人？
　　我说其实这个构思是老板的，虽然具体实施由我个人完成，但是指导工作和申请都是老板完成的。而且由其他的师兄弟也能够完成，具体会找我来做是因为当时我自己提早学习了工具，所以老板觉得我来搞比较合适。他们开玩笑说是不是你比较聪明？我说：其实能够读到这个程度大家应该都差不多，我觉得自己属于比较勤奋。他们好像很满意，问了我对薪水的要求。我知道他们是准备要我了。
　　我问他们根据这几轮的面试他们觉得我应该拿怎么样一个薪水比较正常？他们说基本上他们会尊重个人的意愿，当然是在不会太离谱的条件下。我当时开的不高，他们给的也属于我开的范围里面。从这点可以看出，如果你个人比较牛，那么你不妨开出自己比较中意的工资。如果他们能够给，他们基本上不会太拒绝。现在想来，当时真的开的亏了。
　　面试完以后，他们告诉我2个星期之内会给你答复。后来想想这个面试很重要，基本上要人也是这个环节，其他环节都是参考。问的东西特别的细，最好不要骗人，如果你是撒谎的话，hr会一步一步的问出来的。还会问一些你和他人相处的事情，不会直接问，他会一点一点的追问，在回答每个问题之前不要太紧张开口，想想在说，说话不要太快，直视他们的眼睛有助于消除紧张并且给人一种自信的感觉。
　　大概6天以后，他们给了我答复，希望我能够加入他们公司。。。。
　　算来从第一次面试到给offer经历了大概1个月的时间。自己的求职也算是落下了帏幕，虽然还有一家公司开的待遇比nokia高，但是我希望感受一下nokia的氛围，所以还是决定把自己卖了。感谢gg在我求职期间给我的帮助和鼓励。
　　在整个求职期间，我可能本身不是特别着急，所以心态很好，大概会有一定的帮助吧。还有在求职的时候，女生化一点淡妆真的很必要，这样给人比较职业的感觉，虽然不一定要穿职业装，但是一定要穿得得体大方。
　　最后祝福大家都能够找到理想中的工作，也希望我的求职经历给大家一点帮助。
本文来自面经网-求职就业好帮手，原文地址：http://www.51mianjing.cn

a,b,c,d分别是13个元素的1维数组
函数原型 void deal( int[] a, int[] b, int[] c, int[] d );

二
实现字符串反转的c库函数 char* strrev(char* string)
注1：不可利用其他库函数，算法尽量高效、占用空间少。

三
有10亿个数，这些数的值都在0~1000万之内。实现接口 get_bigger_count( unsigned value )
输入一个值value，返回这10亿个数中比value值大的数的数目。
class order_calculate
{
public:
order_calculate();
~order_calculate();
unsinged get_bigger_count( unsigned value )
}
注1：get_bigger_count接口会被频繁的调用，实现要高效
注2：可以自己往内部任意添加变量和接口
注3：有个现成的接口 unsigned get_value_by_index( int idx ) 可以调用，该接口返回指定索引的value值
     比如 get_value_by_index( 100 )， 返回10亿个数中第100个数的值。该接口开销较大，尽量少调用。

http://topic.csdn.net/u/20090912/20/8c60e06e-321c-49a6-b2cc-59248ba9cf36.html?28642