届华为校园招聘上机考试题目及答案Java和C++两种方式实现.docx

届华为校园招聘上机考试题目及答案Java和C++两种方式实现.docx

《届华为校园招聘上机考试题目及答案Java和C++两种方式实现.docx》由会员分享，可在线阅读，更多相关《届华为校园招聘上机考试题目及答案Java和C++两种方式实现.docx（14页珍藏版）》请在冰豆网上搜索。

届华为校园招聘上机考试题目及答案Java和C++两种方式实现

2012届华为校园招聘上机考试题目（9月6日下午1点场）

     1、选秀节目打分，分为专家评委和大众评委，score[]数组里面存储每个评委打的分数，judge_type[]里存储与score[]数组对应的评委类别，judge_type[i]==1，表示专家评委，judge_type[i]==2，表示大众评委，n表示评委总数。

打分规则如下：

专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分=专家评委平均分 * 0.6+大众评委*0.4，总分取整。

如果没有大众评委，则总分=专家评委平均分，总分取整。

函数最终返回选手得分。

            函数接口  intcal_score（intscore[],intjudge_type[],intn） 

     2、给定一个数组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}

             函数接口  voidsort（intinput[],intn,intoutput[]）

     3、操作系统任务调度问题。

操作系统任务分为系统任务和用户任务两种。

其中，系统任务的优先级<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}

            函数接口   voidscheduler（inttask[],intn,intsystem_task[],intuser_task[]）

Java实现：

publicclassTest1{

publicstaticintcal_score（intscore[],intjudge_type[],intn）{

intscore_zhuanjia=0;

intscore_dazong=0;

intsum_score=0;

intnum_zhuanjia=0;

intnum_dazong=0;

for（inti=0;i

if（1==judge_type[i]）{

score_zhuanjia+=score[i];

num_zhuanjia++;

}

if（2==judge_type[i]）{

score_dazong+=score[i];

num_dazong++;

}

}

if（0==num_dazong）{

sum_score=score_zhuanjia/num_zhuanjia;

}else{

sum_score=（int）（score_zhuanjia/num_zhuanjia*0.6+score_dazong/num_dazong*0.4）;

}

returnsum_score;

}

publicstaticvoidmain（String[]args）{

intscore1[]={90,91,92,93,94,95,96,97,98,99};

intjudge_type1[]={1,1,1,2,2,1,2,1,2,1};

intsum_score1=cal_score（score1,judge_type1,10）;

System.out.println（sum_score1）;

intscore2[]={90,91,92,93,94};

intjudge_type2[]={1,1,1,1,1};

intsum_score2=cal_score（score2,judge_type2,5）;

System.out.println（sum_score2）;

}

}

publicclassTest2{

/**

*@paramargs

*/

publicstaticvoidsort（intinput[],intn,intoutput[]）{

int[]flag=newint[n];

int[]num=newint[n];

for（inti=0;i

num[i]=input[i];

}

if（0!

=n%2）{

for（inti=0;i

if（0==i%2）{

flag[i]=（n+i）/2;

}else{

flag[i]=（n-i）/2-1;

}

}

}else{

for（intj=0;j

if（0==j%2）{

flag[j]=（n+j）/2;

}else{

flag[j]=（n-j）/2;

}

}

}

for（intii=0;ii

for（intjj=ii+1;jj

if（num[jj]>num[ii]）{

inttemp=num[ii];

num[ii]=num[jj];

num[jj]=temp;

}

}

}

for（intk=0;k

output[flag[k]]=num[k];

}

}

publicstaticvoidmain（String[]args）{

//TODOAuto-generatedmethodstub

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

int[]output1=newint[5];

sort（input1,5,output1）;

for（inti=0;i<5;i++）{

System.out.println（output1[i]）;

}

System.out.println（"*********************"）;

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

int[]output2=newint[6];

sort（input2,6,output2）;

for（intj=0;j<6;j++）{

System.out.println（output2[j]）;

}

}

}

publicclassTest3{

/**

*@paramargs

*/

publicstaticvoidscheduler（inttask[],intn,intsystem_task[],intuser_task[]）{

intn_system=0;

intn_user=0;

for（inti=0;i

if（task[i]<50）{

n_system++;

}else{

if（task[i]>=50&&task[i]<=255）{

n_user++;

}

}

}

int[]num_system=newint[n_system];

int[]num_user=newint[n_user];

intj=0;

intk=0;

for（inti=0;i

if（task[i]<50）{

num_system[j]=task[i];

system_task[j]=i;

j++;

}else{

if（task[i]>=50&&task[i]<=255）{

num_user[k]=task[i];

user_task[k]=i;

k++;

}

}

}

system_task[j]=-1;

user_task[k]=-1;

for（intii=0;ii

for（intjj=ii;jj

if（num_user[ii]>num_user[jj]）{

inttemp1=num_user[ii];

num_user[ii]=num_user[jj];

num_user[jj]=temp1;

inttemp2=user_task[ii];

user_task[ii]=user_task[jj];

user_task[jj]=temp2;

}

}

}

for（intii=0;ii

for（intjj=ii;jj

if（num_system[ii]>num_system[jj]）{

inttemp1=num_system[ii];

num_system[ii]=num_system[jj];

num_system[jj]=temp1;

inttemp2=system_task[ii];

system_task[ii]=system_task[jj];

system_task[jj]=temp2;

}

}

}

}

publicstaticvoidmain（String[]args）{

//TODOAuto-generatedmethodstub

int[]task={0,30,155,1,80,300,170,40,99};

intnum_system=0;

intnum_user=0;

for（inti=0;i

if（task[i]<50）{

num_system++;

}else{

if（task[i]>=50&&task[i]<=255）{

num_user++;

}

}

}

int[]system_task=newint[num_system+1];

int[]user_task=newint[num_user+1];

scheduler（task,task.length,system_task,user_task）;

for（inti=0;i

System.out.println（system_task[i]）;

}

System.out.println（"********************"）;

for（intj=0;j

System.out.println（user_task[j]）;

}

}

}

C++实现：

题一：

#include

usingnamespacestd;

intcal_score（intscore[],intjudge_type[],intn）;

voidmain（）{

intscore1[10]={90,91,92,93,94,95,96,97,98,99};

intjudge_type1[10]={1,1,1,2,2,1,2,1,2,1};

intsum_score1=cal_score（score1,judge_type1,10）;

cout<

intscore2[5]={90,91,92,93,94};

intjudge_type2[5]={1,1,1,1,1};

intsum_score2=cal_score（score2,judge_type2,5）;

cout<

}

intcal_score（intscore[],intjudge_type[],intn）{

intscore_zhuanjia=0;

intscore_dazong=0;

intsum_score=0;

intnum_zhuanjia=0;

intnum_dazong=0;

for（inti=0;i

if（1==judge_type[i]）{

score_zhuanjia+=score[i];

num_zhuanjia++;

}

if（2==judge_type[i]）{

score_dazong+=score[i];

num_dazong++;

}

}

if（0==num_dazong）{

sum_score=score_zhuanjia/num_zhuanjia;

}else{

sum_score=（int）（score_zhuanjia/num_zhuanjia*0.6+score_dazong/num_dazong*0.4）;

}

returnsum_score;

}

题二：

#include

usingnamespacestd;

voidsort（intinput[],intn,intoutput[]）;

voidmain（）{

intinput1[5]={3,6,1,9,7};

intoutput1[5];

sort（input1,5,output1）;

for（inti=0;i<5;i++）{

cout<

}

cout<<"**************************"<

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

intoutput2[6];

sort（input2,6,output2）;

for（intj=0;j<6;j++）{

cout<

}

}

voidsort（intinput[],intn,intoutput[]）{

int*flag=newint[n];

int*num=newint[n];

for（inti=0;i

num[i]=input[i];

}

if（0!

=n%2）{

for（inti=0;i

if（0==i%2）{

flag[i]=（n+i）/2;

}else{

flag[i]=（n-i）/2-1;

}

}

}else{

for（intj=0;j

if（0==j%2）{

flag[j]=（n+j）/2;

}else{

flag[j]=（n-j）/2;

}

}

}

for（intii=0;ii

for（intjj=ii+1;jj

if（num[jj]>num[ii]）{

inttemp=num[ii];

num[ii]=num[jj];

num[jj]=temp;

}

}

}

for（intk=0;k

output[flag[k]]=num[k];

}

}

题三：

#include

usingnamespacestd;

voidscheduler（inttask[],intn,intsystem_task[],intuser_task[]）;

voidmain（）{

inttask[]={0,30,155,1,80,300,170,40,99};

intnum_system=0;

intnum_user=0;

for（inti=0;i<9;i++）{

if（task[i]<50）{

num_system++;

}else{

if（task[i]>=50&&task[i]<=255）{

num_user++;

}

}

}

int*system_task=newint[num_system+1];

int*user_task=newint[num_user+1];

scheduler（task,9,system_task,user_task）;

for（intk=0;k

cout<

}

cout<<"*******************************"<

for（intj=0;j

cout<

}

}

voidscheduler（inttask[],intn,intsystem_task[],intuser_task[]）{

intn_system=0;

intn_user=0;

for（inti=0;i

if（task[i]<50）{

n_system++;

}else{

if（task[i]>=50&&task[i]<=255）{

n_user++;

}

}

}

int*num_system=newint[n_system];

int*num_user=newint[n_user];

intj=0;

intk=0;

for（intij=0;ij

if（task[ij]<50）{

num_system[j]=task[ij];

system_task[j]=ij;

j++;

}else{

if（task[ij]>=50&&task[ij]<=255）{

num_user[k]=task[ij];

user_task[k]=ij;

k++;

}

}

}

system_task[j]=-1;

user_task[k]=-1;

for（intii=0;ii

for（intjj=ii;jj

if（num_user[ii]>num_user[jj]）{

inttemp1=num_user[ii];

num_user[ii]=num_user[jj];

num_user[jj]=temp1;

inttemp2=user_task[ii];

user_task[ii]=user_task[jj];

user_task[jj]=temp2;

}

}

}

for（intiii=0;iii

for（intjj=iii;jj

if（num_system[iii]>num_system[jj]）{

inttemp1=num_system[iii];

num_system[iii]=num_system[jj];

num_system[jj]=temp1;

inttemp2=system_task[iii];

system_task[iii]=system_task[jj];

system_task[jj]=temp2;

}

}

}

}