华为上机题目总结.docx
《华为上机题目总结.docx》由会员分享，可在线阅读，更多相关《华为上机题目总结.docx（25页珍藏版）》请在冰豆网上搜索。
华为上机题目总结
试题一：
输入字符串长度len1,字符串s1，字符串长度len2，字符串s2。
从后向前比较，以最短字符串为标准，输出不同的元素的个数.
例如：
输入：
s1=”1,3，5”len1=3s2=”2,4，1,7,5”len2=5
输出:
1
publicclassTest1{
publicstaticvoidmain（String［］args）{
Stringstr1=”1，3，5”;
Stringstr2=”2,1,6，5”;
System.out.println（getDifferentNumber（str1，3，str2,4））;
｝
publicstaticintgetDifferentNumber（Stringstr1,intlen1,Stringstr2,intlen2）
{
intcount=0;
intlen=0；
len=（len1len1:
len2;
Strings1[］=str1.split（”，”）;
Strings2[］=str2。
split（”，”）;
for（inti=0;i〈len;++i）
{
if（！
（s2[len2-i-1］。
equals（s1[len1—i-1］）））
{
count++；
}
}
returncount;
}
}
试题二：
约瑟夫环问题。
输入字符串长度，字符串,计数m。
从前往后计数，当数到m个元素时，m个元素出列，然后将出列的数字赋值给m.然后从下一个数计数循环，直到所有数字都出列，给定的数全部为大于0的数字。
输出出队队列。
publicclassJosephus_Seq｛
publicstaticvoidmain（String[］args）{
Josephusjo=newJosephus（newint[］{3，1,6，2,5｝）；
jo。
ShowInfo（）;
System。
out。
println（）;
jo.doJosephus（3）；
}
｝
classNode
{
publicintnum；
publicNodenext;
publicNode（inti）
{
this.num=i;
this。
next=null;
}
}
classJosephus
｛
publicNodehead；
publicJosephus（int［]data）
{
Nodep=newNode（data[0］）;
head=p；
for（inti=1；i〈data。
length;++i）
｛
p。
next=newNode（data[i］）;
p=p.next;
｝
p.next=head;
}
publicvoiddoJosephus（ints）
｛
Nodep，q=null;
intstep=s；
p=head；
while（p。
next！
=p）
{
for（inti=1；i｛
q=p;
p=p。
next；
}
step=p。
num；
System。
out。
println（p.num）;
q.next=p.next;
p=p.next;
}
}
｝
试题三：
手机号码判断问题
publicclassPhoneNumberTest｛
publicstaticvoidmain（String［］args）{
PhoneNumberTestpt=newPhoneNumberTest（）；
intres=pt。
verifyMsisdn（"8662923042663”）；
System.out。
println（res）；
}
publicintverifyMsisdn（Stringnum）
{
intres=0；
char[］ch=num.toCharArray（）；
if（ch.length〈13）
return1;
for（inti=0；i〈ch.length；++i）
{
if（!
（'0'<=ch［i]＆&ch［i]<=’9'））
return2；
｝
if（！
（（ch［0]=='8'）&&（ch［1]==’6’）））
return3;
returnres;
｝
｝
试题四:
使用数组和链表实现数据结构-栈。
//数组实现
publicclassMyStack{
privateObject［]obj=newObject[16］；
privateintsize=0；
publicbooleanisEmpty（）
｛
returnsize==0;
}
publicvoidclear（）
｛
for（inti=0；i〈size；i++）
｛
obj［i]=null;
｝
size=0;
｝
publicintlentgh（）
｛
returnsize;
｝
privatevoidresize（）
{
Object[］temp=newObject［obj。
length*3/2+1］；
for（inti=0；i｛
temp[i]=obj[i］;
obj［i］=null;
｝
obj=temp;
}
publicbooleanpush（Objectdata）
{
if（size>=obj。
length）
｛
resize（）；
}
obj［size++］=data；
returntrue；
｝
publicObjectpop（）
{
if（size==0）
{
returnnull；
}
returnobj［——size］;
｝
｝
实例应用1：
将10进制的正整数转换为n进制
publicStringconversion（intnum,intn）
{
MyStackms=newMyStack（）；
Integerres=num；
while（true）
{
ms.push（res％n）;
res=res/n；
if（res==0）
｛
break；
｝
}
StringBuffersb=newStringBuffer（）；
while（（res=（Integer）ms.pop（））！
=null）
{
sb.append（res）；
｝
returnsb。
toString（）;
｝
实例应用2：
判断括号的匹配
publicbooleanisMatch（Stringstr）{
MyStackchar［]arr=str.toCharArray（）;
for（charc：
arr）｛
Charactertemp=myStack.pop（）;
//栈为空时只将c入栈
if（temp==null）{
myStack.push（c）;
｝
//配对时c不入栈
elseif（temp==’[’＆&c=='］’）{
｝
//配对时c不入栈
elseif（temp=='（'＆＆c=='）'）{
｝
//不配对时c入栈
else{
myStack.push（temp）；
myStack.push（c）;
}
｝
returnmyStack。
isEmpty（）；
}
//链表实现
publicclassMyLinkedStack｛
privateLinkedNodetop；
privateintsize；
publicMyLinkedStack（）
{
top=null；
size=0；
｝
publicbooleanisEmpty（）
｛
returnsize==0；
}
publicvoidclear（）
{
top=null；
size=0;
｝
publicintlength（）
｛
returnsize；
}
publicbooleanpush（Objecto）
｛
LinkedNodeln=newLinkedNode（）；
ln。
data=o;
ln.pre=top；
top=ln；
size++；
returntrue;
｝
publicObjectpop（）
{
if（top！
=null）
｛
LinkedNodeln=top;
top=top.pre;
size——；
returnln。
data；
｝
returnnull；
｝
｝
classLinkedNode
{
publicObjectdata；
publicLinkedNodepre;
}
试题五:
简单四则运算
publicclassOperate｛
publicstaticvoidmain（String［］args）｛
Stringexp="1+3*4+6/2”；
System.out。
println（calculate（exp））;
}
publicstaticintcalculate（Stringexp）
{
char[］exps=exp.toCharArray（）；
int[］num=newint[20];
int[］str=newint[20];
intk2；
intk1=k2=0;
for（inti=0；i{
if（exps[i]>='0’&＆exps[i]〈='9’）
｛
num［k1++]=exps[i]—’0'；
｝
if（exps［i］==’—'｜|exps[i］==’+’）
｛
str[k2++］=exps[i];
}
if（exps［i］=='*’）
{
num[k1-1]=num[k1-1］＊（exps［i+1］—’0'）;
i++;
}
if（exps[i］=='/'）
{
num[k1—1]=num［k1-1]/（exps[i+1］—’0'）；
i++；
｝
}
for（inti=0;i〈num。
length;i++）
{
System。
out。
print（num［i]）；
}
System。
out.println（）;
for（inti=0;ilength；i++）
{
System.out。
print（str[i]）；
｝
System.out。
println（）;
inttemp=num［0];
intj=0;
while（j〈k2）
{
if（str[j］=='—’）
temp=temp—num［j+1］;
elseif（str［j］=='+'）
temp=temp+num[j+1］;
j++;
｝
returntemp；
｝
}
试题六：
判断回文字符
publicclassHuiwenArrayTest{
publicstaticvoidmain（String[]args）｛
int[］a=newint[］{1,2,2，1};
System.out.println（HuiwenArrayTest。
judge（a））；
｝
publicstaticbooleanjudge（int［]array）
{
for（inti=0;ilength/2;i++）
｛
if（array[i]==array［array。
length—1-i]）
{
continue；
｝
else
returnfalse；
｝
returntrue;
｝
}
试题七：
求两个数组的异集（A和B的交集）
publicstaticvoidstart（Integer[］a，Integer［］b）
{
List〈Integer>list=newArrayList〈Integer>（）;
for（inti=0；ilength;++i）
｛
for（intj=0；j〈b.length;++j）
{
if（b[j］==a[i]）
｛
list。
add（a[i］）；
break；
}
｝
｝
System.out.println（list）；
}
｝
试题八：
逆序链表
非递归实现：
publicvoidreverse（）
｛
MyTestNodepre=null，post=null；
MyTestNodep=head；
while（p。
next！
=null）
｛
post=p。
next;
if（post==null）
｛
head=post;
}
p。
next=pre;
pre=p;
p=post；
｝
p。
next=pre;
head=p；
｝
试题九：
一副牌中发五张扑克牌给你：
让你判断数字的组成:
有以下几种情况：
1：
四条：
即四张一样数值的牌（牌均不论花色）2：
三条带一对
3：
三条带两张不相同数值的牌4：
两对5：
顺子 包括 10,J，Q，K，A
6：
什么都不是7:
只有一对
publicclassPuke｛
publicstaticvoidmain（String［]args）{
int［］a=newint[］{1,2，3，4,5};
start（a）；
}
publicstaticvoidstart（inta[］）
｛
for（inti=0;ilength;i++）
｛
for（intj=i+1;j〈a.length;j++）
｛
inttmp=0;
if（a［i]〉a[j］）
｛
tmp=a[i]；
a［i］=a［j］；
a［j]=tmp；
}
｝
｝
intk=0；
for（inti=0;i<4；i++）
{
if（a［i］==a［i+1]）
k++;
}
if（k==3）
{
if（a［0]==a［3］）
System.out。
println（”四条"）;
else
System。
out。
println（”三条带一对”）;
｝
if（k==2）
{
if（a［1］！
=a[2］||a［2］！
=a[3］）
System。
out.println（"三条带两个不同的"）；
else
System.out。
println（"两对”）；
｝
if（k==1）
System.out。
println（”一对”）;
if（k==0）{
if（a［4］—a[0］==4＆&a[4]—a［1]==3&＆a［4］—a[2］==2&&a[4]-a［3］==1）
System。
out.println（"顺子”）；
else
System.out。
println（"什么都不是"）；
}
}
}
试题十：
选秀节目打分，分为专家评委和大众评委，score［]数组里面存储每个评委打的分数，judge_type［]里存储与score[]数组对应的评委类别,judge_type==1，表示专家评委,judge_type==2，表示大众评委，n表示评委总数。
打分规则如下：
专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分=专家评委平均分＊0。
6+大众评委＊0。
4，总分取整。
如果没有大众评委,则总分=专家评委平均分，总分取整。
函数最终返回选手得分.
publicclassMark｛
publicstaticvoidmain（String[］args）{
int[］a=newint[］{20，10，40，50｝；
int［]b=newint[］{1，2，1，2｝;
System。
out.println（newMark（）。
doMark（a，b））；
}
publicintdoMark（int[］score,int[］s）
{
intresult=0;
intdazhong=0；
intzhuanye=0；
inttotal=0；
for（inti=0；i｛
total+=s[i］;
｝
if（total==score.length）
｛
for（inti=0;i〈score.length;i++）
｛
zhuanye+=score[i]；
｝
result=zhuanye/score.length；
}
else
｛
inttmpa=0;
inttmpb=0;
for（inti=0；ilength;i++）
{
if（s[i]==1）
｛
dazhong+=score［i];
tmpa++;
｝
elseif（s[i］==2）
{
zhuanye+=score［i];
tmpb++;
}
｝
System。
out.println（dazhong）；
System。
out。
println（zhuanye）;
result=（int）（dazhong/tmpa*0.4+zhuanye/tmpb*0。
6）;
｝
returnresult;
｝
｝
试题十一：
给定一个数组input[］，如果数组长度n为奇数，则将数组中最大的元素放到output[］数组最中间的位置，如果数组长度n为偶数，则将数组中最大的元素放到output[］数组中间两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。
publicclassArrayTest｛
publicstaticvoidmain（String[]args）｛
int［］input=newint［]{3,6，1，9，7,8｝;
int[]output=newint［]｛0，0，0,0，0,0};
arrange（input，output）;
｝
publicstaticvoidarrange（int［］input,int［]output）
｛
//首先冒泡排序
for（inti=0；i〈input。
length;++i）
｛
for（intj=i+1；j〈input.length;++j）
｛
inttmp=0;
if（input[i]{
tmp=input［i］；
input[i]=input［j］；
input［j]=tmp；
｝
｝
｝
//根据题目要求进行分配
output[output。
length/2］=input[0];
intleft=0;
intright=0；
for（inti=1;i｛
if（!
（i％2==0））
｛
left++；
System。
out.println（output。
length/2—left+":
”+input[i］）;
output［output。
length/2—left]=input［i]；
}
elseif（i%2==0）
｛
right++;
System。
out.println（output.length/2—left+”：
”+input[i]）;
output[output.length/2+right]=input［i];
｝
}
for（inti=0；i〈output.length;++i）
｛
System.out。
print（output［i]）;
｝
｝
}
试题十二：
操作系统任务调度问题.操作系统任务分为系统任务和用户任务两种。
其中，系统任务的优先级〈50，用户任务的优先级〉=50且〈=255.优先级大于255的为非法任务,应予以剔除.现有一任务队列task［］，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。
函数scheduler实现如下功能，将task［]中的任务按照系统任务、
升级会员 