图像所 复试C语言答案.docx

图像所 复试C语言答案.docx

《图像所 复试C语言答案.docx》由会员分享，可在线阅读，更多相关《图像所 复试C语言答案.docx（15页珍藏版）》请在冰豆网上搜索。

图像所复试C语言答案

满分20分

学术一,二,三题/专业一,二,四题

要求添加足够多的注释

一,精确计算阶乘.

一个32位整型变量无法精确表示大数的阶乘,但一个整型数组却可表示.

算法思路:

当阶乘结果为不超过10的4次方的十进制正整数时,可用一个整型数组（intnFactorial[4]）来依次存放阶乘的每一位数字.比如,5!

=120可被记录为nFactorial[0]=0,nFactorial[1]=2,nFactorial[2]=1,nFactorial[3]=0.

当已计算出k的阶乘,要计算（k+1）的阶乘时,将记录k的阶乘的数组的每一位都与（k+1）相乘,乘积依然存在数组的对应位上.最后,从最低位开始,依次向高位循环处理每个位中大于9的数.若数大于9，则需要进位.将数的10的倍数进到高一位上，将数的小于10的余数存在原来的位中.一直到所有位中的数都小于10为止.

（1）（6分）按此思路,当已知阶乘结果为一个不超过10的1000次方的十进制整数时,写出计算正整数阶乘的完整C/C++代码.

输入:

键盘输入一个正整数

输出:

显示输入正整数的阶乘

（2）（2分）完善代码,实现键盘输入是否满足要求的检查功能.

（3）（2分）写出几种测试用例.

二,有一个浮点型数组记录了1000个浮点数（floatfData[1000]）.

（1）（3分）编写C/C++代码,求出这1000个数中最大的10个数.

（2）（3分）写出能实现从1000亿个数中寻找最大的10个数的算法思路.

三,已知一个指向单向链表的某个非头非尾节点的指针（node*pCurrent）.pCurrent指向的地址中仅保存2个指针,一个是指向下一个节点的Next指针（pCurrent->Next）,另一个是指向节点本身数据的Data指针（pCurrent->Data）.编写一个C/C++函数,实现以下功能:

（1）（2分）保留链表的原有顺序,在原链表中删除这个已知节点的下一个节点.

（2）（2分）保留链表的原有顺序,在原链表中删除这个已知节点.

四,异或运算的应用.

（1）（2分）列举异或运算的性质.

（2）（2分）已知一个记录了1000个整数的整数型数组.将这1000个整数打乱顺序后,只将其中的999个整数记录在另一个数组中.请利用异或运算的性质编写一个C/C++函数,找出缺少的那一个整数.

精确计算大数的阶乘

2012-4-917:

03|计算,2012,阶乘,图像所,编程

2012图像所复试编程题一,精确计算阶乘.

一个32位整型变量无法精确表示大数的阶乘,但一个整型数组却可表示.

算法思路:

当阶乘结果为不超过10的4次方的十进制正整数时,可用一个整型数组（intnFactorial[4]）来依次存放阶乘的每一位数字.比如,5!

=120可被记录为nFactorial[0]=0,nFactorial[1]=2,nFactorial[2]=1,nFactorial[3]=0.

当已计算出k的阶乘,要计算（k+1）的阶乘时,将记录k的阶乘的数组的每一位都与（k+1）相乘,乘积依然存在数组的对应位上.最后,从最低位开始,依次向高位循环处理每个位中大于9的数.若数大于9，则需要进位.将数的10的倍数进到高一位上，将数的小于10的余数存在原来的位中.一直到所有位中的数都小于10为止.

（1）（6分）按此思路,当已知阶乘结果为一个不超过10的1000次方的十进制整数时,写出计算正整数阶乘的完整C/C++代码.

输入:

键盘输入一个正整数

输出:

显示输入正整数的阶乘

（2）（2分）完善代码,实现键盘输入是否满足要求的检查功能.

（3）（2分）写出几种测试用例.

/***************************************************************************

function:

tocalculatethefactorialofapositiveintegerusingarray

IPRAI,HUST,2012,April,9

testexample:

5!

=120,0!

=1!

=1,25!

=15511210043330985984000000,499!

=...

（a,=,*,',1.3,-0,>=450）areinvalidinput,

-1,-2forending.

****************************************************************************/

#include

#include//onlyformemset（）

#include//onlyforitoa（）,atoi（）

intmain（void）

{

intData[1000];

intdigit;//numberofthevaliddecimalbitofthefactorial

inti,j;

intN;

charcN[100],cNN[100];

do

{

//inputapositiveinteger

printf（"\nEnterapositiveinteger（lessthan450）tocalculateitsfactorial（negativeintegerforending）:

"）;

scanf（"%s",&cN）;

//checkthevalidityoftheinput

N=atoi（cN）;

itoa（N,cNN,10）;

if（strcmp（cN,cNN））

{

printf（"\nThisisnotavalidnumber.Tryagain!

\n"）;

continue;

}

if（N>449）

{

printf（"\nThisnumberistoobig.Tryasmallerone（lessthan450）.\n"）;

continue;

}

//checkthestopcondition

if（N<0）

{

printf（"\nCaculatingends.\n"）;

break;

}

//initializeData=0

memset（Data,0,sizeof（Data））;

//0!

=1!

=1

Data[0]=1;

digit=1;

for（i=1;i<=N;i++）

{

for（j=0;j

{

Data[j]*=i;

}

for（j=0;j

{

if（Data[j]>9）

{

if（Data[digit-1]>9）

{

digit++;

}

Data[j+1]+=（Data[j]/10）;

Data[j]=Data[j]%10;

}//endofif（Data[j]）

}//endoffor（j）

}//endoffor（i）

//outputtheresult

printf（"%d!

=",N）;

for（j=digit-1;j>=0;j--）

printf（"%d",Data[j]）;

printf（"\n"）;

}while

（1）;

return0;

}

部分排序---寻找数组中最大的10个数

已有18次阅读2012-4-1009:

38|2012,图像所,复试,编程,最大的

2012图像所复试编程题二

（1）,有一个浮点型数组记录了1000个浮点数（floatfData[1000]）.

编写C/C++代码,求出这1000个数中最大的10个数.

/*************************************************************************

function:

tofindthefirst10biggestdatainadataarray

IPRAI,HUST,2012,April,10

****************************************************************************/

#include

#include//onlyforrand（）

#include//onlyfortime（）

#include//onlyformemset（）

/*MySort1（floatfpData[10],intnpIndex[10],floatfpSortedData[10]）

function:

tosort10datainincreasingorder

input:

floatfpData[10]---the10dataneedtobesorted

intnpIndex[10]---theindexofthedata

output:

floatfpSortedData[10]---the10sorteddataintheincreasingorder

intnpIndex[10]---theindexofthe10sorteddata

return:

void

functionsused:

memset（）,sizeof（）

*/

voidMySort1（floatfpData[10],intnpIndex[10],floatfpSortedData[10]）

{

intnRank[10][10];

inti,j;

floatfTemp;

intnLocation;

intnRecord[10];

memset（nRank,0,sizeof（nRank））;

//recordtherelevancecomparingresult

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

{

fTemp=fpData[i];

for（j=i+1;j<10;j++）

{

if（fTemp>=fpData[j]）

{

nRank[i][j]=1;

nRank[j][i]=0;

}

else

{

nRank[i][j]=0;

nRank[j][i]=1;

}

}

}

//getthelocationofdatainthesortedarray

for（i=0;i<10;i++）

{

nLocation=0;

for（j=0;j<10;j++）

{

nLocation+=nRank[i][j];

}

nRecord[nLocation]=npIndex[i];

fpSortedData[nLocation]=fpData[i];

}

for（i=0;i<10;i++）

{

npIndex[i]=nRecord[i];

}

return;

}

/*MySort2（floatfpData[10],intnpIndex[10],floatfpSortedData[10]）

function:

tosort10datainincreasingorderinwhichthelast9dataaresortedinincreasingorder

input:

floatfpData[10]---the10dataneedtobesortedandthelast9dataaresorted

intnpIndex[10]---theindexofthedata

output:

floatfpSortedData[10]---the10sorteddataintheincreasingorder

intnpIndex[10]---theindexofthe10sorteddata

return:

void

functionsused:

*/

voidMySort2（floatfpData[10],intnpIndex[10],floatfpSortedData[10]）

{

inti,j;

floatfTemp;

intnLocation;

//rank

fTemp=fpData[0];

for（i=1;i<10;i++）

{

if（fTemp>fpData[i]）

{

nLocation=npIndex[i];

npIndex[i]=npIndex[i-1];

npIndex[i-1]=nLocation;

}

else

{

break;

}

}

for（j=9;j>=i;j--）

fpSortedData[j]=fpData[j];

for（j=0;j

fpSortedData[j]=fpData[j+1];

fpSortedData[i-1]=fTemp;

return;

}

intmain（void）

{

intnSizeData=1000;//thesizeofdataarray

floatfData[1000];

intnSizeRank=10;//thesizeofthesorteddata

floatfRank[10];//the10sorteddatainincreasingorder

floatfDataTemp[10];//the10dataneedtobesorted

intnIndex[10];//theindexofthe10sorteddatainincreasingorder

inti;

//-----------inputthedataarray------------

//settheseedofrandom

srand（（unsigned）time（NULL））;

//getthedataarrayrandomly

for（i=0;i

{

fData[i]=（float）（rand（）*0.1）;

}

//showsometestdata

intnSortNum=1000;//thesizefortestdata

printf（"\nThe%ddataneedtobesortedare:

\n",nSortNum）;

for（i=0;i

{

printf（"%f",fData[i]）;

if（（i+1）%5==0）

printf（"\n"）;

}

//initializethesorteddataarray

for（i=0;i

{

fDataTemp[i]=fData[i];

nIndex[i]=i;

}

MySort1（fDataTemp,nIndex,fRank）;

//insertsort

for（i=nSizeRank;i

{

if（fData[i]>fData[nIndex[0]]）

{

fRank[0]=fData[i];

nIndex[0]=i;

MySort2（fRank,nIndex,fRank）;

}

}

printf（"\nThefirst%dbiggestdataare:

\n",nSizeRank）;

for（i=nSizeRank-1;i>=0;i--）

{

printf（"%f",fData[nIndex[i]]）;

if（i%5==0）

printf（"\n"）;

}

printf（"\nThefirst%dbiggestdatainincresingorderare:

\n",nSizeRank）;

for（i=0;i

{

printf（"%f",fRank[i]）;

if（（i+1）%5==0）

printf（"\n"）;

}

return0;

}

删链表中的当前节点

2012-4-1111:

12|2012,编程

2012图像所复试编程题三,

已知一个指向单向链表的某个非头非尾节点的指针（node*pCurrent）.pCurrent指向的地址中仅保存2个指针,一个是指向下一个节点的Next指针（pCurrent->Next）,另一个是指向节点本身数据的Data指针（pCurrent->Data）.编写一个C/C++函数,实现以下功能:

（1）（2分）保留链表的原有顺序,在原链表中删除这个已知节点的下一个节点.

（2）（2分）保留链表的原有顺序,在原链表中删除这个已知节点.

思路:

（1）传统的删节点.

（2）移花接木,释放原pCurrent节点中的原Data指针.

将pCurrent节点中保存的Data指针换为pCurrent的下一个节点中的Data指针,

将pCurrent节点的Next指针换为pCurrent的下一个节点中的Next指针,

然后删除pCurrent的下一个节点.（完成）

/********/

（1）

node*pTemp=pCurrent->Next;

pCurrent->Next=pTemp->Next;

if（pTemp->Data!

=NULL）

{

delete（pTemp->Data）;

pTemp->Data=NULL;

}

if（pTemp!

=NULL）

{

delete（pTemp）;

pTemp=NULL;

}

（2）

Data*pTemp0=pCurrent->Data;（这里题目缺少Data指针的具体类型哈...）

node*pTemp1=pCurrent->Next;

pCurrent->Next=pTemp1->Next;

pCurrent->Data=pTemp1->Data;

if（pTemp0!

=NULL）

{

deletepTemp0;

pTemp0=NULL;

}

if（pTemp1->Data!

=NULL）

{

deletepTemp1->Data;

pTemp1->Data=NULL;

}

if（pTemp1!

=NULL）

{

deletepTemp1;

pTemp1=NULL;

}

/***finished***/

异或的应用

2012图像所复试编程题四,

异或运算的应用.

（1）（2分）列举异或运算的性质.

（2）（2分）已知一个记录了1000个整数的整数型数组.将这1000个整数打乱顺序后,只将其中的999个整数记录在另一个数组中.请利用异或运算的性质编写一个C/C++函数,找出缺少的那一个整数.

/**********************/

（1）

a^0=a,a^a=0,a^b=b^a,a^（b^c）=（a^b）^c

[同数异或为0,数异或0还为该数,异或运算可交换,异或运算满足结合律]

（2）

intMyFind（intnArray0[1000],intnArray1[999]）

{

intnResult=nArray0[0];

inti;

for（i=1;i<1000;i++）

{

nResult^=nArray0[i];

}

for（i=0;i<999;i++）

{

nResult^=nArray1[i];

}

returnnResult;

}