找工作主要分为准备阶段、正式应聘阶段。

（1）准备阶段：

A、基础知识准备。对于基础不扎实的，最好平时就开始学习一些基础知识。重点准备科目内容：（最好平时积累一定的基础，时间：研二下学期重点准备）

B、笔试面试知识准备。在具备一定基础的条件上，做相关笔试面试题。推荐《java面试宝典》（针对java的）或《程序员面试宝典》（针对c的），《剑指offer》或《编程之美》（两本都是c/c++的）java的最好也买一本。其中面试宝典最好过2-3遍，剑指offer可以熟悉一些容易的题目。（时间：研二下学期到暑假中期，暑假预留时间做各种网络笔试题）

C、个人简历准备。可以参考网上面经，总体差别不大。可以参考如下布局

D、自我介绍（一般准备一分钟到二分钟即可，中英文各准备一份）

  可以参考网上面经。需要注意的是！！！搞IT最需要的个人素质是责任心、耐心、细心、学习意识和学习能力强、团队合作、沟通等，所以切记往这方面靠拢，一定要结合自身特点进行选取，并准备相应特点的具体例子（面试可能会问到）。给出个人介绍模板。

（2）正式面试阶段。

包括笔试、技术面、综合面、签约。（部分公司有技术二面、终面）

A、笔试：

很多公司都是提前网申，尤其是刚开始招聘的公司（包括中兴上机笔试、华为是集体机试3个编程题）。

到中后期，很多公司直接宣讲后现场笔试。同时很多公司在网申之后要进行测评（比较耗时间，主要结合自身，并往积极方面做，个人根据网上面经经验得知，仅供参考）。

对于现场笔试，有的比较严，有的比较松，自己看着办。关键一点：最好带个本子，将笔试中遇到不会的问题摘录下来，回去后立即查找答案。（金蝶面试的时候就把笔试题拿出来问你回去查了资料没，问你会不会做了。）这样的好处是，你知道的越来越多，笔试也会更轻松。当然有的公司笔试题比较怪，自己着情况而定，对于那些难度不太大的一定要摘录。同时，到网上搜索笔试题（多做基础类的，且容易错的）

B、技术面试：

每个面试都要自我介绍，然后面试官问你问题。在自我介绍过程中要和面试官有眼神交流，不要让人感觉是硬背的。

自我介绍后，面试官问你问题，部分公司会问基础题（如果没有项目问的更多，如果没有项目有的公司直接就没有兴趣应聘你）。注意！！！一般应聘岗位不同问的问题不同，总体来说，运维、测试类简单，研发类中等，算法类难，没必要一心搞研发，根据自己实力来选取（尤其转专业的）。

基础问题：包括数据结构中链表实现、栈实现、二叉树实现及遍历等，操作系统中问进程线程通信有哪些方式、linux内核等，计算机网络会问java实现socket编程等，数据库会问索引是什么，有什么用，是不是每个表都建立索引会更好等。中兴被问过链表实现（手写代码），华为有同学问到红黑树（难度太大，可以直接忽略）、数据用的什么（mysql）、哪个公司的，css+div全称是什么等，有的同学问的写一个简单的数据库查询语句、索引的利弊。这个看个人运气，有的问的容易，有的问的难。

项目问题：项目做了哪些工作、你负责哪部分、工作流程（以登录为例等）、遇到什么问题（问的最多）以及如何解决的、存在哪些不足（安全方面、并发访问方面），你如何改进。有同学问到了struts框架流程、spring框架、hibernate框架等，这些也是必须掌握的，有个同学没有项目经验，就是熟悉这三大框架拿到了4-5个offer。另外，也会问到js等方面的知识，如你用过何种js框架，以登录为例，如何实现验证（简单写一下过程）。

C、综合面试：

首先，自我介绍。

部分公司（中兴）会有英语口语测试（topic），大概2分钟左右，有的是面试官和你交流，有的是要求自己说。问到的问题看个人运气，有问到自我介绍中提到的家乡（用英语描述一下家乡，可以讲地理位置，状况、吃等方面）、我被问到描述面试酒店的感受、有的直接英语自我介绍，有的问到用英语描述专业（这个纯属人品太差了）、有的问到兴趣爱好等。

问你做过哪些项目，最值得说的是哪个，为什么。

回答：是***项目，因为这个项目从技术选取、框架设计等都是我们自己选择的，锻炼了我们的决策能力，同时投入的时间和精力也是最多的，期间有段时间每天连续工作近16（早上八点到晚上12点）小时，具备一定的抗压能力。总而言之，完成这个项目，个人兴趣是一方面，更重要的是强烈的责任感。所以我觉得这是我最值得说的一个项目。

（剖析：将个人的优秀品质责任心抗压能力、个人能力决策、个人兴趣充分融合，立体展现了自身，也充分解释自己为什么能胜任这份工作）

为什么转专业(从机械转软件，其实我是调剂的，但面试的时候最好别说是调剂的，而说是转专业的)：

回答：很多人觉得从机械转软件有点难，或者没有什么优势。但我并不这么认为。首先，本科期间就接触过软件（如制图软件），也进行过简单的编程工作（如单片机编程），激发了我的浓厚兴趣。其次，在学习机械制图过程中培养的严谨、耐心、细心等这些优秀品质其实也是软件开发人员最需要的综合素质。因此我选择软件这个专业并自学了计算机相关课程，也参与了几个实际项目开发，积累的一定的开发经验。

（剖析：首先提出很多人的观点，然后点出自己的看法，充分展现自身多角度思考问题的优势；接着，结合自身专业特点，凸显适合从事开发工作的优秀品质，最后基础知识的学习以及项目经验充分表明能胜任这份工作。）

怎么证明你适合我们这个岗位：

回答：首先，我对***方面比较感兴趣，贵公司正好有这方面的岗位。其次，我做事认真细心，有耐心，同时具有较强的抗压能力，曾经在开发过程中连续3周每天工作近16小时。最重要的是学习意识及学习能力强，在刚读研的时候我就意识到要学好一门语言，于是开始学习java编程，同时，努力寻找机会锻炼自己，参与到实际项目开发中，积累了的一定的开发经验。因此能够很快适应这个岗位的相关工作。

（剖析：这个问题其实是一个压力面试，我回答的不是太好，中兴面试我就被问到，面试官说感觉你不适合我们公司，你用2分钟时间来说服我。个人意见：从兴趣入手，辅以个人优秀品质，实际开发经验。）

个人职业规划：

回答：1-3年的时间熟悉公司相关工作、夯实技术基础、提升自身技术方面的竞争力，3-5年则逐渐向项目经理等方面发展，5-10年培养成为管理与技术兼备的中坚力量。

（剖析：这个回答的也不是太好，可以参考网上面经，总体来说，要对自己有清晰的定位，当然不能逗比到说自己将来打算创业，直接被KO）

你有没有对象，在哪工作：

回答1：我有女朋友，现在在***工作，所以我想到贵公司***分公司工作。

回答2：我女朋友和我一届，现在在实习，我非常感谢她，因为她愿意跟随我。

回答3：目前还没有，工作后再找。

（剖析：这个问题核心在于判断你的工作稳定性，如果你是异地，最好说明不会因为异地而可能工作几年后离开公司，否则直接被刷。一般如果想留在某个地方，最好引导面试官到这个话题，这样基本会优先考虑你）

（3）技巧总结：

A、交流技巧：交流过程不要太多夸张手势（一般就行，如果要的话），不要抢面试官话，其次，以诚待人（但不是二逼到对自己工作特别不利的都实说，有个同学在问到以后打算如何时说了句先工作几年，然后自己创业，直接没戏了）。最重要的一点，和面试官交谈的时候语气温和，语速中等偏缓，让人听着舒服，也是对其的尊重。

B、笔试技巧：笔试看你自己如何去操作了，有经验的就比较有优势，没经验的也可以逐渐练习。有公司上机笔试（有摄像头）也可以操作，（如中兴的，只要将摄像头对着头就行，没必要拍到全身，你懂的。因为中兴笔试太多都不是计算机类的）

C、选择公司技巧：一般来说，it公司要求相对高，对于技术不是太好的可以考虑到传统公司应聘，尤其是在招聘高峰期，我就投过几个传统公司，一个是神龙汽车（湖北武汉）结果面试我们学校就我一个（面试官还问我为什么没人来，呵呵）当场就要了。一个是英威腾（深圳南山区），结果我们学校去的就3-5个人，笔试也挺容易，技术面试感觉有项目经验应该没问题（我说了些采用https基于RSA非对称加密，数据进行了MD5加密什么的，面试官感觉我太牛逼，直接让二面面试官给我offer（听二面面试官说的）。有时候感觉逼格还是要的，不然只能被忽悠。

D、技术技巧：对于项目，如果不是特别高大上的话，最好做点装饰工作，重点在于安全方面和并发访问方面。比如上面说到的采用https协议（自己需要实际去做，并进行较为详细的了解，说的时候也有底气）、数据库加密、并发访问采用何种方案以及实现。有了这些，技术面试基本比较完美了。

（4）招聘时间表：

A、研二开始有部分公司招聘实习（这个时候最好能进去实习，后面基本都留下来了，包括BAT、华为等）

B、（7月初-9月初）最早是内推的（包括百度、阿里，腾讯等），能内推就尽量内推，省了笔试。所以早作准备也是非常有优势的，内推的时候就能进去。

（这个阶段大牛比较多，当然也有部分实力的或运气比较好的，前提是要准备好了，问的问题比较广而泛）

C、（9初-10月初）其次，湖南大学今年（20##-9）最早来的公司是中兴，9月初，华为在后（先宣讲，后面试（大概在9月23-26）后面来了金蝶什么的（要实际开发经验）、海康（还可以）、烽火等。 （这个阶段招的人比较多，一般有实际项目经验的或运气好的）

D、（10月初-10月15）来了一些公司，很多招的比较少，要1-2个人。

E、（10月15-10月30）10中期后有不少真正要人的公司，很多都是it类的，也有很多非it类招计算机的，这个时候如果没有什么实力的可以避开，选择非it类公司。尤其在二十号左右，格力、方太、顺丰等招的人还可以，待遇也不错。其他公司有汇川（待遇不错）、英威腾、捷顺（深圳待遇貌似8K，宣讲的时候吹的老好了）还有不少金融证券公司、通信公司（如中国移动、联通、电信）等（这个阶段招的人比较多。因为第一波已经把有实力的人招过去了，所以这波对于有一定基础和一定实力的人来说命中率较高，待遇不比第一波公司差）

F、（11月）公司有，了解的也不是太多，应该还是有些不错的。貌似很多银行类的在这个阶段笔试较多。

G、春招（补漏），也有部分好的公司，没关注，仅听说。

（5）心得

基础知识和项目经验是第一位，运气和人品也占很大成分，不要因为一时找不到工作而灰心气馁，这也是一个成长的过程。始终做到不放弃、及时总结笔试面试经验、和同学沟通交流，运气总会降临。

工作学习交流：1136958892

                                                                     20##-10-30

 

第二篇：应聘华为软件的上机试题及部分答案

1，判断电话号码是否合法：

//要注意情况包含，有可能会同时出现几种不好的情况，要按照顺序输出错误。不能同时输出好几种错误，应该是这样包含：先判断长度是否符合，再判断是否以86打头，再判断有无其他字符

int fun(char num[])

{ char *p=num;

int n=strlen(num);

if(n==13){

if(*p=='8'&&*(p+1)=='6')

while(*p!='\0'){

if(*p>='0'&&*p<='9')

p++;

else

return 2;

if(*p=='\0')

return 0;

}

else return 3;

}

else

return 1;

}

int main()

{

char num[]="87139a3887671";

int k=fun(num);

cout<<k<<endl;

return 0;

}

2、 数组比较（20分）

? 问题描述：

比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果2个数组长度不等，则只比较较短长度数组个数元素。请编程实现上述比较，并返回比较中发现的不相等元素的个数

比如：数组{1,3,5}和数组{77,21,1,3,5}按题述要求比较，不相等元素个数为0 数组{1,3,5}和数组{77,21,1,3,5,7}按题述要求比较，不相等元素个数为3 ? 要求实现函数：

int array_compare(int len1, int array1[], int len2, int array2[]) ? 示例

1） 输入：int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5}，int len2 = 5 函数返回：0

2） 输入：int array1[] = {1,3,5}，int len1 = 3int array2[] = {77,21,1,3,5,7}，int len2 = 6 函数返回：３

函数如下：

using namespace std;

int f(int len1,int arry1[],int len2,int arry2[])

{ int k=0;

for(int i=len1-1,j=len2-1;i>=0&&j>=0;i--,j--)

if(arry1[i]!=arry2[j])

k++;

return k;

}

int main()

{

int num1[]={1,3,5};

int num2[]={77,21,1,3,5};

int k=f(3,num1,5,num2);

cout<<k<<endl;

return 0;

} ，

3. 约瑟夫问题

? 问题描述：

输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数值m。从数列首位置开始计数，计数到m后，将数列该位置数值替换计数值m，并将数列该位置数值出列，然后从下一位置从新开始计数，直到数列所有数值出列为止。如果计数到达数列尾段，则返回数列首位置继续计数。请编程实现上述计数过程，同时输出数值出列的顺 比如： 输入的随机数列为：3,1,2,4，初始计数值m=7，从数列首位置开始计数（数值3所在位置）

第一轮计数出列数字为2，计数值更新m=2，出列后数列为3,1,4，从数值4所在位置从新开始计数

第二轮计数出列数字为3，计数值更新m=3，出列后数列为1,4，从数值1所在位置开始计数 第三轮计数出列数字为1，计数值更新m=1，出列后数列为4，从数值4所在位置开始计数 最后一轮计数出列数字为4，计数过程完成。

输出数值出列顺序为：2,3,1,4。

? 要求实现函数：

void array_iterate(int len, int input_array[], int m, int output_array[])

【输入】 int len：输入数列的长度；

int intput_array[]：输入的初始数列

int m：初始计数值

【输出】 int output_array[]：输出的数值出列顺序

? 示例

输入：int input_array[] = {3,1,2,4}，int len = 4， m=7

输出：output_array[] = {2,3,1,4}

函数如下：

void fun(int len,int a1[],int len2,int a2[])

{ int n=0,i=-1,k=1,m=len2;

while(1){

for(int j=0;j<m;){

i=(i+1)%len; //注意这个是%，不要写成/

if(a1[i]!=0)

j++;

}

m=a1[i];

a2[n++]=a1[i];

a1[i]=0;

if(k==len)break;

k++;

}

}

4. 简单四则运算

? 问题描述：

输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值

注： 1、表达式只含 +, -, *, / 四则运算符，不含括号

2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况

3、要考虑加减乘除按通常四则运算规定的计算优先级

4、除法用整数除法，即仅保留除法运算结果的整数部分。比如8/3=2。输入表达式保证无0作为除数情况发生

5、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况

? 要求实现函数：

int calculate(int len,char *expStr)

【输入】 int len: 字符串长度；

char *expStr: 表达式字符串；

【输出】 无

【返回】 计算结果

? 示例

1） 输入：char *expStr = “1+4*5-8/3” 函数返回：19

2） 输入：char *expStr = “8/3*3” 函数返回：6

简化版的四则运算：没有括号，只有加减乘除四种运算

int fun(char a[],int len) //字符数组和字符数组的长度

{ int num[20];

char str[20];

int k1=0,k2=0;

int data=0;

for(int i=0;i<len;i++) //主要运算

{ if(a[i]>='0'&&a[i]<='9')

num[k1++]=a[i]-'0';

if(a[i]=='-'||a[i]=='+')

str[k2++]=a[i];

if(a[i]=='*')

{num[k1-1]=num[k1-1]*(a[i+1]-'0');i++;}//遇见*，就运算，结果保存在数组中

if(a[i]=='/')

{ num[k1-1]=num[k1-1]/(a[i+1]-'0');i++;}

}

int temp=num[0];

int j=0; //两个数组只剩下数组和加减运算符

while(j<k2){ //顺序运算

if(str[j]=='-')

temp=temp-num[j+1];

else if(str[j]='+')

temp=temp+num[j+1];

j++;

}

return temp;

}

int main()

{ har a[]="3*3+7+4/3";

int k=fun(a,9);

cout<<k<<endl;

return 0;

}

函数实现2：中序表达式转换为后序表达式，使用算法实现

int isp(char c)

{ int p;

switch(c){

case '*':

case '/':p=1;break;

case '+':

case '-': p=0;break;

}

return p;

}

char* transf(int len,char a[],char b[])

{ int k=0;

stack<char> s1;

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

{ if(a[i]>='0'&&a[i]<='9')b[k++]=a[i];

else

{ if(s1.empty())s1.push(a[i]);

else while(isp(a[i])<=isp(s1.top())) {b[k++]=s1.top();s1.pop();} s1.push(a[i]);

}

}

while(s1.empty()){

b[k++]=s1.top();

s1.pop();

}

b[k]='\0';

return b;

}

void fun(char c,stack s2)

{ char p1,p2;

if(!s2.empty()){

p1=s2.top();s2.pop();

else pos=false;

cout<<"kongzhan"<<endl;}

if(!s2.empty()){

p2=s2.top();s2.top();

else pos=false;

cout<<"kongzhan"<<endl;}

if(pos=true)

switch(c){

case '+':s2.push(p1+p2);break; case '-':s2.push(p2-p1);break; case '*':s2.push(p1*p2);break; case '/':s2.push(p2/p1);break; }

}

void eval(char a[])

{ stack<char> s2;

for(int i=len;i<len;i++){

switch(a[i]){

case '+':

case '-':

case '*':

case '/':fun(a[i],&s2);break; default:s2.push(a[i]-'0');break; }

}

}

int main()

{ char a[]="1+4*5-8/3";

}

int len=strlen(a); char b[20]; char *q=transf(9,a,b); cout<<q<<endl; return 0;

5、一副牌中发五张#9@k牌给你：让你判断数字的组成：有以下几种情况：

1：四条：即四张一样数值的牌（牌均不论花色） 2：三条带一对

3：三条带两张不相同数值的牌 4：两对 5：顺子 包括 10，J，Q，K，A 6：什么都不是 7：只有一对

思路：将数组排序，统计相同的数字的个数，再分情况讨论

void sort(int a[])

{ int temp;

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

for(int j=0;j<5;j++)

if(a[i]>a[j])

{temp=a[i];a[i]=a[j];a[j]=temp;}

}

void test(int a[])

{ int *b=new int[5];

int k=1;

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

{ b[i]=a[i];}

for(int j=0;j<4;j++)

if(a[j]==a[j+1])

k++;

if(k==4){

if(b[1]==b[3])

cout<<"四条"<<endl;

else

cout<<"三条带一对"<<endl;

}

if(k==3){

if(b[1]!=b[2]||b[2]!=b[3])

cout<<"三条带两个不同的牌"<<endl;

else

cout<<"两对"<<endl;

}

if(k==2)

cout<<"一对"<<endl;

if(k==1){

if(b[4]-b[0]==4&&b[4]-b[1]==3&&b[4]-b[2]==2&&b[4]-b[3]==1)

cout<<"顺子<<endl;

else

cout<<"什么都不是"<<endl;

}

}

int main()

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

test(a);

return 0;}

6、求两个数组的和差就是去掉两个数组中相同的元素然后将两个数组中的元素存放在一个新的数组中 ，按大小顺序排序 思路：将数组A和数组B分别进行排序，然后将A与B进行比较，重复的跳过去，不重复的赋给数组C，依次输出。

while(i < la && j < lb)

{ if(aa[i] < bb[j])

{

c[sub] = aa[i];

++sub;

++i;

}

else if(aa[i] > bb[j])

{ c[sub] = bb[j];

++sub;

++j;

}

else if(aa[i] == bb[j])

{ ++i;

++j;

} }

for(; i < la; ++i)

{c[sub] = aa[i];

++sub;

}

for(; j < lb; ++j)

{c[sub] = bb[j];

++sub;

}

7、逆序单链表

node *reverse(node *head)

{ node *p1,*p2,*p3;

p1=head;

p2=head->next;

while(p2){

p3=p2->next;

p2->next=p1;

p1=p2;

p2=p3;

}

head->next=NULL;

head=p1;

return head;

}

8、 将一个字符串的元音字母复制到另一个字符串，并排序（30分）

问题描述：有一字符串，里面可能包含英文字母（大写、小写）、数字、特殊字符，现在需要实现一函数，将此字符串中的元音字母挑选出来，存入另一个字符串中，并对字符串中的字母进行从小到大的排序（小写的元音字母在前，大写的元音字母在后，依次有序）。 说明：1、 元音字母是a,e,i,o,u,A,E,I,O,U。 2、 筛选出来的元音字母，不需要剔重； 最终输出的字符串，小写元音字母排在前面，大写元音字母排在后面，依次有序。 要求实现函数：void sortVowel (char* input, char* output);

using namespace std;

void fun(char a[],char s[]) //提取元音字母，放入数组

{ int i=0,n=0;

while(a[i]!='\0'){

if(a[i]=='a'||a[i]=='e'||a[i]=='i'||a[i]=='o'||a[i]=='u')

s[n++]=a[i];

else if

(a[i]=='A'||a[i]=='E'||a[i]=='I'||a[i]=='O'||a[i]=='U')

s[n++]=a[i];

i++;

}

char temp; //将数组排序

for(int i=0;i<n-1;i++)

for(int j=0;j<n-i-1;j++)

if(s[j]>s[j+1])

{temp=s[j];s[j]=s[j+1];s[j+1]=temp;}

int k=0; //定位大写字母的最后位置

while(s[k]>='A'&&s[k]<='Z'){

k++;

}

for(int j=0;j<n;j++) //输出原字符串

cout<<s[j]<<' '; cout<<endl;

char *p=new char[20]; //将字符串变换位置，输出。

char *q=p;

for(int i=k;i<n;i++)

{*p=s[i];p++;}

for(int j=0;j<k;j++)

{*p=s[j];p++;}

*p='\0';

cout<<q<<endl;

}

int main()

{ char str[]="HaJsdStOoAOeINaPQaWEiAIiO";

char s[20];

fun(str,s);

return 0;

}

9、身份证号码合法性判断

我国公民的身份证号码特点如下：

1、 长度为18位；

2、 第1～17位只能为数字；

3、 第18位可以是数字或者小写英文字母x。

4、 身份证号码的第7~14位表示持有人生日的年、月、日信息。

例如：511002 19880808 0111或511002 19880808011x。

请实现身份证号码合法性判断的函数。除满足以上要求外，需要对持有人生日的年、月、日信息进行校验。年份大于等于19xx年，小于等于2100年。需要考虑闰年、大小月的情况。所谓闰年，能被4整除且不能被100整除 或 能被400整除的年份，闰年的2月份为29天，非闰年的2月份为28天。其他情况的合法性校验，考生不用考虑。

函数返回值：

1） 如果身份证号合法，返回0；

2） 如果身份证号长度不合法，返回1；

3） 如果身份证号第1~17位含有非数字的字符，返回2；

4） 如果身份证号第18位既不是数字也不是英文小写字母x，返回3；

5） 如果身份证号的年信息非法，返回4；

6） 如果身份证号的月信息非法，返回5；

7） 如果身份证号的日信息非法，返回6（请注意闰年的情况）；

要求实现函数：

int verifyIDCard(char* input)

示例

1） 输入：”511002 111222”，函数返回值：1；

2） 输入：”511002 abc123456789”，函数返回值：2； 3） 输入：”511002 19880808123a”，函数返回值：3； 4） 输入：”511002 188808081234”，函数返回值：4； 5） 输入：”511002 198813081234”，函数返回值：5； 6） 输入：”511002 198808321234”，函数返回值：6； 7） 输入：”511002 1989 0229 1234”，函数返回值：7； 8） 输入：”511002 198808081234”，函数返回值：0；

int fun(char *str) { }

int main()

int year=0,month=0,day=0; if((strlen(str)-1)<18) //1 { for(int i=0;i<18;i++)

{ if(str[i]>='0'&&str[i]<='9') //2

;

else return 2;

if(str[17]=='x'||(str[17]>='0'&&str[17]<='9'))//3

{for(int i=6;i<10;i++) year=year*10+str[i]-'0';

if(year>1900&&year<2100)//4 { for(int i=10;i<12;i++) }

else return 4;

month=month*10+str[i]-'0';

if(month>0&&month<=12)//5 { for(int i=12;i<14;i++)

day=day*10+str[i]-'0'; if(day<=31)//6

{ if(year%4!=0&&month==2&&day<=28)

return 0; return 0; return 0;

else if(year%4==0&&month==2&&day<29) else if(year%4!=4&&month!=2&&day<31) else return 6;

}

}

else return 6;

}

else return 5;

}

else return 3;

}

else return 1;

{

} char a[]="340621198608377817"; int k=fun(a); cout<<k<<endl; return 0;

10、比较一个数组的元素 是否为回文数组

判断是否是回文数组：

bool fun(char a[])

{

int n=strlen(a);

int i=0,j=n-1;

while(i<j){

if(a[i]!=a[j])

return false;

i++;j--;

}

return true;

}

11、求两个数组的和差：就是去掉两个数组中相同的元素 然后将两个数组中的元素存放在一个新的数组中 且数组A中元素要在B数组元素之前

思路：利用循环比较，将相同的数字的标记为0，再赋给数组C

int main()

{ int a[]={1,3,5,7,9,12,13};

int s[]={1,3,5,6,7,8,9};

int len1=sizeof(a)/sizeof(int);

int len2=sizeof(s)/sizeof(int);

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

for(int j=0;j<len2;j++)

if(a[i]==s[j])

{a[i]=0;s[j]=0;}

int t[30];

int k=0,i=0,j=0;

while(i<len1){

if(a[i]!=0)

t[k++]=a[i];

i++;

}

while(j<len2){

if(s[j]!=0)

}

t[k++]=s[j]; j++; } for(int i=0;i<k;i++) cout<<t[i]<<' '; return 0;

12、字符串计算

1、选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，judge_type[] 里存储与 score[] 数组对应的评委类别，judge_type == 1，表示专家评委，judge_type == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分 = 专家评委平均分 * 0.6 + 大众评委 * 0.4，总分取整。如果没有大众评委，则 总分 = 专家评委平均分，总分取整。函数最终返回选手得分。

int cal_score(int score[], int judge_type[], int n)

{ int sum1=0,sum2=0,avg1=0,avg2=0;

int m=0,k=0;

for(int i=0;i<n;i++){

if(judge_type[i]==1)

{sum1=sum1+score[i];m++;}

if(judge_type[i]==2)

{sum2=sum2+score[i];k++;}

}

avg1=sum1/m;avg2=sum2/k;

return (int)(avg1*0.6+avg2*0.4);

}

int main()

{ int input[]={3,6,1,9,7,8};

int output[]={1,1,2,1,2,2};

int n=sizeof(input)/sizeof(int);

int p=cal_score(input,output,n);

cout<<p<<endl;

return 0;

}

13、给定一个数组input[] ，如果数组长度n为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置，如果数组长度n为偶数，则将数组中最大的元素放到 output[] 数组中间

两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。 例如：input[] = {3, 6, 1, 9, 7} output[] = {3, 7, 9, 6, 1}; input[] = {3, 6, 1, 9, 7, 8} output[] = {1, 6, 8, 9, 7, 3} 函数接口 void sort(int input[[, int n, int output[])

using namespace std;

void sort(int input[],int n,int output[])

{ int i=0,j=n-1;

int temp;

for(int i=0;i<n-1;i++)

for(int j=0;j<n-i-1;j++)

{ if(input[j]>input[j+1])

{temp=input[j];input[j]=input[j+1];input[j+1]=temp;}

}

int k=0;

i=0;j=n-1;

while(i<j){

output[i++]=input[k++];

output[j--]=input[k++];

}

cout<<output[3]<<endl;

}

int main()

{ int input[]={3,6,1,9,7,8};

int output[20];

sort(input,6,output);

return 0;

}

14、操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级 < 50，用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任务，应予以剔除。现有一任务队列task[]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。函数scheduler实现如下功能，将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[] 数组和 user_task[] 数组中（数组中元素的值是任务在task[] 数组中的下标），并且优先级高的任务排在前面，数组元素为-1表示结束。

task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99} system_task[] = {0, 3, 1, 7, -1} user_task[] = {4, 8, 2, 6, -1} 函数接口：

void scheduler(int task[], int n,int system_task[], int user_task[]) { int *p = new int[n];

int i,j,temp;

int k1=0,k2=0;

for(i = 0;i<n;i++)

{ p[i] = i;}

for(i = 0;i<n-1 ;i++)

for(j=0;j<n-i-1;j++)

{ if(*(task+p[j])>*(task+p[j+1]))

{temp = p[j];p[j] = p[j+1];p[j+1] = temp; //此处是排下标

}}

for(j=0;j<n;j++)

{if(*(task+p[j])<50)

system_task[k1++] = p[j];

if(*(task+p[j])>=50 && *(task+p[j])<=255)

user_task[k2++] = p[j];

}

system_task[k1] = -1;

user_task[k2] = -1;

}

15、地区2：单链表的操作：排序，插入，删除，逆序，创建。struct node{

int data;

struct node* next;

}; node *creat()

{ node *head,*p,*s;

head=new node[1];

p=head; //p只是定义，并没有分配空间，

int k;

while(cin>>k) { //创建单链表

s=new node[1];

s->data=k;

p->next=s;

p=s;

}

head=head->next; //开始的的时候head是表头节点，现在是第一个节点

p->next=NULL;

return head;

}

node *creat()

{

node *head,*p,*s;

head=new node[1];

p=head;

int k,cyc=1;

while(cyc)

{

cout<<"enter a data:"; cin>>k;

if(k!=0)

{

s=new node[1];

s->data=k;

p->next=s;

p=s;

}

else

{

cout<<"OK!"<<endl; cyc=0;

}

}

head=head->next;

p->next=NULL;

return head;

}

node *reverse(node *head)

{ node *p1,*p2,*p3;

p1=head;

p2=head->next;

while(p2){

p3=p2->next;

p2->next=p1;

p1=p2;

p2=p3;

}

head->next=NULL;

head=p1;

return head;

}

node *del(node *head,int num) { node *p,*s;

p=head;

while(p->data!=num&&p->next!=NULL) {s=p;p=p->next;}

if(p->data==num){

if(p==head)

{head=p->next;delete p;}

else

{s->next=p->next;delete p;}

}

else

cout<<"未找到要删除的节点"<<endl;

return head;

}

node *insert(node *head,int num)//要插入和删除的时候要考虑判断特殊位置点 { node *p,*s,*t;

p=head;

t=new node[1];

t->data=num;

while(p->data<num&&p->next!=NULL)

{s=p;p=p->next;}

if(num<=p->data){

if(p==head)

{t->next=p;head=s;}

else

{t->next=p;s->next=t;}

}

else //把插入点定位在了链尾

{p->next=t;t->next=NULL;}

return head;

} node *sort(node* head)

{ node *p; int temp;

int n=sizeof(head)/sizeof(node);

if(head==NULL&&head->next==NULL)

return head;

p=head;

for(int i=0;i<n;i++){

p=head;

for(int j=0;j<n-i;j++){

if(p->data>p->next->data)

{ temp=p->data;

p->data=p->next->data;

p->next->data=temp;

}}}

return head;

}

node *sort(node *head)

{

node *p;

int temp;

int n;

n=length(head);

if(head==NULL&&head->next==NULL) return head;

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

{

p=head;

for(int j=0;j<n;j++)

{

if(p->next!=NULL)

{

if(p->data>p->next->data) {

temp=p->data;

p->data=p->next->data; p->next->data=temp; }

p=p->next;

}

}

}

cout<<"new sort is:"<<endl; return head;

}

int main()

{

node *p1;

p1=creat();

sort(p1);

print(p1);

cout<<endl;

return 0;

}

16、栈的基本操作：

struct list{

int data;

struct node *next;

}*node;

void initstack(node &top)

{

top=NULL;

}

void push(node &top,int num) { node *p;

p=new node;

p->data=num;

p->next=top;

top=p;

}

void pop(node &top)

{ node *p=top;

int n=top->data;

top=top->next;

cout<<n<<endl;

delete p;

}

int Isempty(node &top) {

return top==NULL;

}

17、改进后的冒泡排序： oid maopao(int *s,int n) { int i=1,j,b=1;

int temp;

while(b){

b=0;

for(j=n-i-1;j>i;j--) if(s[j]<s[j-1]) {

b=1;

temp=s[j]; s[j]=s[j-1]; s[j-1]=temp; }

for(j=i;j<n-1;j++) if(s[j]>s[j+1]) { b=1;

temp=s[j]; s[j]=s[j+1]; s[j+1]=temp; }

i++;

}

}

18、扫描数组，求出最大的增量长度：

int main()

{ int a[]={7,2,3,4,5,6,8};

int n=7;

int max=1,len=1;

for(int i=1;i<n;i++)

{

if(a[i]>=a[i-1])

{ len++;

continue; //跳出本次循环，继续以下的部分

}

if(max<len)

max=len;

len=1;

}

cout<<max<<endl;

return 0;

}

19、扫描整数序列，求出最大长度子序列：

思路：定义两个游标i j分别在数组的左右，从两边收缩，计算i j之间数组的总和，然后比较，求出最大的记录，并将此时的i j 记录下来。

int main()

{ int s[]={1,20,-3,49,59,10,30,20,-41,90,-2,-30,60.-29};

int n=sizeof(s)/sizeof(int);

int i,k,j,a,b,num,max=0;

for( i=0;i<n;i++)

for( j=n-1;j>=i;j--)

{ num=0;

for( k=i;k<=j;k++)

num=num+s[k];

if(max<num)

{

max=num;

a=i; b=j;

}

}

for(int m=a;m<=b;m++)

cout<<s[m]<<' ';

return 0;

}

20、直接插入排序：

void insertsort(int a[],int n)

{ int x,j;

for(int i=1;i<n;i++){ x=a[i]; for( j=i-1;j>=0&&x>a[j];j--) a[j+1]=a[j]; a[j+1]=x; }

21、提取字符串中的数字：

在字符串"ab00cd+123fght456-253.005fgh"中提取的字符是0,123,456,253，5。 void fun( char str[], int outArray[])

{ char *p=str;

int count=0,value=0;

while(*p!='\0')

{

if(*p>='0'&&*p<='9')

{

value=0;

while(*p>='0'&&*p<='9')

{

value=value*10+(*p-'0');

p++；

}

outArray[count++]=value;

}

p++;

}

}

22、数字转换成字符串：

int main()

{ char str[20],temp[20];

int i=0,j=0;

int num=1234567;

while(num>0){

str[i]=num%10+'0';

num=num/10;

i++;

}

i--;

while(i>=0){

temp[j++]=str[i--];

}

temp[j]='\0';

cout<<temp<<endl;

return 0;

}

23、如下输入方法：第一行输入要输入字符的行数N，接下输入N行字符，统计字符中特定字符的个数。方法如下：

int main()

{ char ch;

int N,num=0;cin>>N; //定义输入的行数

getchar(); //输入的N行字符

for(int i=0;i<N;i++){

while(1){ //记住控制方法

ch=getchar(); //这是单个字符

if(ch=='a')num++;

if(ch=='\n')break;

} }

cout<<num<<endl;

return 0;

}

24、大数的运算：

void fun(char *num1,char *num2,char *result)

{ int i=strlen(num1)-1,j=strlen(num2)-1;

char *p=num1;

char *q=num2;

int n=0,k=0;

if(p[0]!='-'&&q[0]!='-'){

//两个正数相加，两个负数相加一样，就是在result[n]中再加上一个‘-’，再反序输出。 while(i>=0&&j>=0){

result[n++]=((p[i]-'0')+(q[j]-'0')+k)%10+'0';

k=((p[i]-'0')+(q[j]-'0'))/10;

i--;j--;

}

while(i>=0){

result[n++]=((p[i]-'0')+k)%10+'0';

k=((p[i]-'0')+k)/10;

i--;

}

while(j>0){

result[n++]=((q[j]-'0')+k)%10+'0';

k=((q[j]-'0')+k)/10;

i--;

}

if(k==1)

{result[n++]=1;} //如果是两个负数相加 ，加上result[n++]='-'; result[n]='\0';

}

}

25、求字符串中最大的回文长度：

void fun(char a[])

{

int len=strlen(a);

int i=0,j=len-1,len2=0; //len2是回文的一半长度

char *p,*q;

int max=0,pos1=0,pos2=0;

for(i=0;i<len;i++)

for(j=len-1;j>i;j--)

{ p=&a[i];q=&a[j];

while(p<q)

{

if(*p==*q)

{len2++;p++;q--;}

Else //上式中，如若不成立，保留下来的len的值可能很大，要将其变成 0，以便继续使用。

{ len=0,break;}

}

if(max<len2)

{max=len2;pos1=i;pos2=j;}

len2=0;

}

while(pos1<=pos2)

cout<<a[pos1++];

}

int main()

{

char a[]="ddaffafFEaabbccccbbaabsgbsbgsbg";

fun(a);

return 0;

}

26、求一串字符串中出现次数最多的单词：

void fun(char a[])

{ char str[100][100];

char temp[200];

int value[200];

int k1=0,k2=0,k3=0;

int i=0,j=0;

while(a[i]!='\0'){

if(i==0)

{ while(a[i]!=' ')

temp[k3++]=a[i++];

temp[k3]='\0'; k3=0;

strcpy(str[k1],temp);

value[k1++]=1;

}

else{

if(a[i]==' ')

i++;

while(a[i]!='\0'&&a[i]!=' ')

temp[k3++]=a[i++];

temp[k3]='\0';k3=0;

j=0;

while(j<k1){

if(strcmp(str[j],temp)==0)

{ value[j]+=1; break;}

j++;

}

if(j==k1)

{ strcpy(str[k1],temp);value[k1]=1;k1++;}

}

}

cout<<value[7]<<endl;

cout<<str[7]<<endl;

}

int main()

{ char a[]="aa aa aa aa aa aa aa aa aa aa amedede am am am jnnk adfp crpcwe crwc qa qa qa qa qa qa qa qa qa ";

fun(a);

return 0;

}

27、一个字符串“aasbbsdsskkff”，求出重复的次数，并写到数组后面，

输出为“a2s1b2s1d1s2k2f2” void fun(char *a,char *s) { int n=1,k=0;

char *p=a,*q=a;

q++; s[k++]=*p;

while(*p!='\0'){

if(*p==*q)

{ n++;p++;q++;}

else

{

s[k++]=n+'0'; s[k++]=*q; p++;

q++;

n=1;

}

}

cout<<s<<endl;

}

单链表操作：

struct node{

int data;

node *next;

};

node* creat()

{ int num;

node *head,*p,*q;

head=new node[1];

q=head;

while(cin>>num){

p=new node[1];

p->data=num;

p->next=NULL;

q->next=p;

q=p;

}

return head;

}

void reverse(node **head) {

node *p1,*p2,*p3;

p1=*head;

p2=p1->next;

while(p2){

p3=p2->next;

p2->next=p1;

p1=p2;

p2=p3;

}(*head)->next=NULL; *head=p1;

while(!(*head)->next==NULL){ cout<<(*head)->data<<'-'; *head=(*head)->next; }

}

void insert(node *head)

{

node *p=head;

while(p->data<=num)

p++;

}

int main()

{ node *head;

head=new node[1];

head=creat();

reverse(&head);

return 0;

}