完善程序题集.docx
《完善程序题集.docx》由会员分享，可在线阅读，更多相关《完善程序题集.docx（27页珍藏版）》请在冰豆网上搜索。
完善程序题集
第1题
[问题描述]
求出所有满足列条件的二位数：
将此二位数的个位数字与十位数字进行交换，可得到一个新的数，要求新数与原数之和小于100。
程序要求：
每行输出6个满足要求的数。
[算法说明]
分解每一个二位数，然后重新组成一个新数，当满足条件时，用计数器来统计个数。
[程序清单]
begin
k:
=0；
fori:
=_____①____to99do
begin
x:
=____②____;y:
=____③____;
j:
=x*10+y;
if____④____then
begin
k:
=k+1;
write（1:
4）;
____⑤____thenwriteln;
end
end
end．
第2题
[问题描述]
找出小于33的6个正整数，用这些整数进行加法运算，使得包括原来的整数在内能组成尽可能多的不同整数。
例如：
用2，3，5这3个数能组成下面的数
2，3，5
2+3=5,5已经存在
2+5=7，3+5=8，2+3+5=10
所以用2，3，5能组成6个不同的数。
程序要求：
输出所选的这6个数，以及能组成不同整数的个数。
[算法说明]
选择的这6个数，用来组成数时应该尽可能不重复，引入数组a保存找出的这6个数。
[程序清单]
begin
a[1]:
=1；t:
=0；
fori:
=2to6do
begin
____①____；
forj:
=1toi-1do
s:
=____②____；
a[i]:
=____③____；
end；
fori:
=1tO6dO
begin
t:
=____④____；
write（a[i]，''）
end；
writeln（'能组成不同整数的个数：
'，t）
end．
第3题
[问题描述]
求出2—1000之间长度最长的、成等差数列的素数（质数）。
例如：
在2-50之间的全部素数有
2，3，5，7，11，13，17，19，23，29，3l，37，4l，43，47
其中公差为1的素数数列为2，3，其长度为2
公差为2的素数数列为3，5，7，其长度为3
程序要求：
输出满足条件的素数数列。
[算法说明]
首先用筛选法求出此范围内的全部素数，存放在数组b中，然后用2个变量i，j，
逐步求出满足条件的素数数列。
[程序清单]
begin
max:
=0；num:
=1000；
fori:
=2tonumdob[i]:
=i；
fori:
=2to____①____do
if____②____then
begin
k:
=i+i；
whilek<=numdo
begin
b[k]:
=0；
k:
=k+i
end
end；
fori:
=2tonum-1do
if____③____then
begin
j:
=1；
d[j]:
=b[i]；
fori1:
=____④____do
ifb[i1]<>0then
begin
delta:
=____⑤____；
k:
=delta；
while（i+k<=num）and____⑥____do
begin
j:
=j+1；
d[j]:
=i+k；
k:
=k+delta
end；
ifj>maxthenbegin
max:
=j；
c:
=d{数组d的值赋给数组c}
end；
j:
=1
end
end；
writeln（'Themaxlengthis:
'，max）；
write（'Thestringis：
'）；
fori:
=1tomaxdowrite（c[i]，''）；
writeln
end．
第4题参考图
第4题
[问题描述]
求出二个整形数组错位相加的最大面积
1．数组面积的定义：
（限定数组头尾不为0）
设有一个数组C二（4，8，12，0，6）
则C的面积为Sc＝（4+8）、2+（8+12）/2+12/2+6/2
也就是说，Sc=各梯形面积之和（其中梯形的高约定为1，三角形作为梯形的特殊情况处理）。
又如D=（12，24，6）是，其面积的定义为
Sd=（12+24）/2+（24+6）/2
2．数组错位相加的定义
设有2个正整数的数组a，b，长度为n，当n=5时：
a=（34，26，15，44，12）b=（23，46，4，0，18）
对a、b进行错位相加，可能有下列情况
3426154412
+）23464018
342615441223464018
或：
3426154412
+）23464018
3426154435464018
或：
3426154412
+）23464018
34261567584018
或……最后有：
3426154412
+）23464018
234640183426154412
可以看到：
由于错位不同，相加的结果也不同。
程序要求：
找出一个错位相加的方案，使得输出的数组面积为最大。
[算法说明]
设a，b的长度为10，用a，b：
array[1..10]ofinteger表示，其结果用数组c，d：
array[1..30]ofinteger表示。
错位相加的过程可以从开始不重叠，然后逐步重叠，再到最后的不重叠。
梯形面积的计算公式为：
（上底+下底）*高/2，其中约定高为1，故可写为（上底十下底）／2。
[程序清单]
constn=10；
functionsea:
=real；{计算数组C面积}
begin
j1:
=1；
while____①____doj1:
=j1+1;
ifj1=3*nthensea:
=0
elsebegin
j2:
=3*n;
while___②___doj2:
=j2-1;
ifj1=j2thensea:
=0
elsebegin
j3:
=c[jl]+c[j2];
forj4:
=jl+ltoj2-1do
j3:
=j3+c[j4]*2;
sea:
=j3/2
end
end
end;
begin{主程序}
fori:
=1tondoread（a[i]）;
forj:
=1tondoread（b[j]）;
___③___;
fori:
=1to2*n+1do
begin
forj:
=1to3*ndo___④___;
forj:
=1tondoc[j+n]:
=a[j];
forj:
:
1tondo___⑤___;
p:
=sea;
ifp>sthenbegin
d:
=c;
s:
=p
end;
end;
fori:
=1to3*ndowrite（d[i],''）;
writeln;
writeln（'s=',s）
end.
第5题
[问题描述]
表的操作：
设有一个表，记为L=（a1，a2，…，an），其中：
L：
表名。
a1，a2，…，an为表中的元素。
当ai为0-9数字时，表示元素，为大写字母时表示是另一个表，但不能循环定义。
例如下列表的定义是合法的（约定L是第一个表的表名）。
L=（1，3，K，8，0，4）
K=（3，P，4，H，7）
P=（2，3）
H=（4，0，5，3）
程序要求：
当全部表给出之后，求出表中所有元素的最大元素，以及表中所有元素之和。
【算法说明】
表用记录类型定义：
设lmax为表中元素最大个数
tabtype：
record
length：
0..lmax；{长度}
element：
array[1..lmax]Ofchar；{表体}
end；
再定义队列：
qtype=record
base：
array[0..lmax]Ofchar；
front，rear：
0..lmax；
end；
为此，设计一个字符入队的过程inqueue，出队函数outqueue，表中最大元素及元素求和均采用递归计算。
[程序清单]
constlmax=38;
vart:
array['A'..'Z']oftabtype;
s:
string[lmax];
procedureinqueue（varq:
qtype;c:
char）;
begin
q.rear:
=___
（1）___;
q.base[q.rear]:
=c
end;
functionoutqueue（varq:
qtype）:
char;
begin
q.front:
=___
（2）___;
outqueue:
=q.base[q.front]
end.
functionmaxnumber（c:
char）:
char;
varmax:
char;
begin
max:
=chr（0）;
fori:
=1tot[c].lengthdo
begin
ch:
=t[c].element[i];
if___（3）___thenm:
=maxnumber（ch）
elsem:
=ch
ifmax=m
end;
___（4）___
end;
functiontotal（c:
char）:
integer
vark,i:
integer;
begin
k:
=0;
fori:
=1tot[c].lengthdo
begin
ch:
=t[e].lelment[i];
if___（5）___thenm:
=total（ch）;
elsem:
=ord（ch）-ord（'0'）;
k:
=k+m
end;
total:
=k
end;
begin
max:
=36;
fortabno:
='A'to'Z'dot[tabno].length:
=0;
q.front:
=O;q.rear:
=0;
inqueue（q,'L'）;
whileq.front<>.reardo
begin
tabno:
=outqueue（q）;
write（tabno,'='）;
readln（s）;
i:
=1;
whiles[i]<>'（'doi:
=i+1;
whiles[i]<>'）'do
begin
if（s[i]>='a'）and（s[i]<='z'）
thens[i]:
=chr（ord（s[i]）+ord（'A'）-ord（'a'））;
if（s[i]>='A'）and（s[i]<='Z'）
thenbegin
inc（t[tabno].length）;
t[tabno].element[t[tabno].length]:
=s[i];
inqueue（q,s[i]）
end
elseif（s[i]>='0'）and（s[i]<='9'）
thenbegin
inc（t[tabno].length）;
t[tabno].element[t[tabno].length]:
=s[i]
end;
inc（i）
end;
end;
writeln（'themaxnumberintableLis:
',maxnumber（'L'））;
writeln（'Totalis:
',total（'L'））
end.
第6题
[问题描述]
设有一个实数，以字符串形式存放于数组x中，用x：
array[1..n]ofchar表示。
其中x[1]若为'-'，表示负数；若为'+'，'.'，''，则表示正数。
若为数字，也认为是正数。
例如x=（''，'2'，，'0'，''，'3'，'.'，'5'，'%'）则表示203.5
x=（'-'，'1'，，'.'，''，'2'，'0'，'%'）则表示-1.2
约定：
在字符串x中，除x[1]外，其后可以包含有若干个'.'与''，但仅以第一次出现的为准，空格不起任何作用，并以字符'%'，作为结束标志。
程序要求：
将输入的字符串还原成实数（小数点后无用的0应除去），还原的结果以下列形式存放（不需要输出）
f：
数符。
正数放0，负数放1。
a：
array[1..n]ofinteger；存放数字，不放小数点。
k：
表示A中有效数字的个数。
j：
表示小数点后的位数。
例如：
数203.24，还原后结果的存放是：
f=0
a=（2，0，3，2，4）
k=5
j=2
又如：
数-33.0740，还原后结果的存放是：
f=1
a=（3，3，0，7，4）
k=5
j=3
[算法说明]
x：
array[1..10]ofchar；可放长度定为10；首先读入字符串，然后处理数的符号，在还原的过程中，需要判定正数部分与小数部分，同时去除多余的空格和小数点，并约定输入是正确的，
不用作出错检查。
[程序清单]
begin’
fori:
=1to10doa[i]:
=0；
fori:
=1to10doread（x[i]）；
j:
=0；f:
=0；k:
=0；b:
=0；
ifx[1]='-'thenbegin
___
（1）___
___
（2）___
end
elseifx[1]:
=''thenI:
=2
elseI:
=1;
while___（3）___doi:
=i+1;
while___（4）___do
begin
if（x[i]>='0'）and（x[i]<='9'）
thenbegin
k:
=k+l;
___（5）___;
ifb=1then___（6）___
end
elseif（x[I]='.'）and（b=0）thenb:
=1;
i:
=i+l
end;
ifj>0thenwhilea[k]=0dobegin
___（7）___
___（8）___
end
end.
第1题
[问题描述]
设有n个不同整数的数列：
例如n二4时，有4个不同整数的数列为17，4，16，5。
数列中的第1个数17，比它后面的三个数都大，则称数17的逆数为3。
数列中的第2个数4比它后
面的数都小，则称数4的逆数为0。
同时记数列中全部逆数的和称为数列的逆数。
上例中，数列17，4，16，5的逆数为3+0+1+0=4
程序要求：
当给出n个不同整数的数列后，求出此数列的逆数。
[算法说明]
为求得上面问题的解，设置数组a：
anay[1..n]ofinteger和逆数计数器s，然后用一个二重循环求出数列的逆数。
[程序清单]
constn=10;
vari,j,s:
integer;
a:
array[1..n]ofinteger;
begin
s:
=0;
fori:
=1tondoread（a[i]）;
fori:
=1to___
（1）___do
forj:
=___
（2）___tondo
ifa[i]>a[j]then___（3）___
writeln（'s:
',s）
end.
第2题
[问题描述]
装球：
设有n个盒子（n足够大，可装入任何数量的球），分别编号1，2，…。
同时有k个小球（k>0），今将k个小球装入到盒子中去。
装入规则如下：
（1）第一个盒子不能为空。
（2）装入必须严格按递增顺序进行。
例如，当k：
8，n；6时，装入方法有1，2，5或1，3，4。
（3）在满足上面的两个条件下，要求有球的盒子尽可能多。
（4）装完后，相邻盒子中球的个数差的绝对值之和最小（未装的盒子不计）。
如上例中
装入法1，2，5，则差的绝对值之和为2-1+5-2=4
装入法1，3，4，则差的绝对值之和为3-1+4-3=3
程序要求：
给出k（k表示小球的个数）之后，求出满足上述四个条件的装入方法。
[算法说明]
设置数组a：
anay[1..n]ofinteger；用数组元素代表盒子，然后依次装入小球。
[程序清单]
constn=20;
vari,j,k,l:
integer;
a:
array[1..n]ofinteger;
begin
readln（k）;
___
（1）___;
j:
=1;
while___
（2）___dobegin
a[j]:
=j;___（3）___;j:
=j+1
end;
l:
=j-1;
whilek>0dobegin
___（4）___;
k:
=k-1;
l:
=l-1;
end;
forI:
=1to___（5）___do
write（a[I]:
4）
end.
第3题
[问题描述]
积木游戏：
设有n个小木块排成一排，如下图：
口口口……
游戏开始时，每个小木块向下的一面涂有红、黄、蓝三种颜色之中的一种（约定：
0表示红色，1表示黄色，2表示蓝色）。
要求通过翻看与交换方式对小木块重新排列（翻看的规则为每
个小木块只能看一次），最终成为下面的形状：
口口口……口口口口……口口口口……
红蓝黄
即相同颜色的木块排列在一起，设计一个翻看与交换的方案，使得用最少的交换次数实现上面的要求。
[算法说明]
翻看小木块时，可以从两端进行。
例如，设中间状态如下：
口口口……口回口口……回口口口……回口口口……
红a未翻过b蓝c黄
此时，可以从两个方向看，即从a或b处开始：
1．若看a则有三种可能性：
为红色，则不用交换
为蓝色，交换一次，即a与b交换
为黄色，交换两次，即c与b交换一次，然后a与c再交换一次
此时，平均交换次数为1。
2．若看b，也有三种可能性：
为蓝色，则不用交换
为红色，交换一次，即b与a交换。
为黄色，交换一次，即b与c交换。
此时，平均交换次数为2/3。
由此可见，从b处翻看直到游戏结束，次数最少符合题目要求。
[程序清单]
constn=20;
vari,tem,r,b,y:
integer;
a:
array[1..n]ofO..2;
begin
fori:
=1tondoread（a[i]）;
r:
=1;___
（1）___;y:
=n;
while___
（2）___do
if___（3）___thenbegin
tem:
=a[r];a[r]:
=a[b];a[b]:
=tem;
r:
=r+1
end
elseif___（4）___thenbegin
tem:
=a[b];a[b]:
=a[y];a[y]:
=tem;
___（5）___;___（6）___;
end
elseb:
=b-1;
fori:
=1tondowrite（a[i]:
3）
end.
第4题
[问题描述]
四色问题。
设有下列形状的图形：
有8个区域，其编号为1，2，…，n。
（n=8）
图形中各区域的相邻关系用上边的邻接矩阵表示：
1——相邻，0——不相邻。
问题要求：
将上面图形的每一个部分涂上红
（1），黄
（2），蓝（3），绿（4）四种颜色之一，要求相邻的部分不同色。
[算法说明]
用数组r：
array[1..n，1..n]of0..1;表示邻接矩阵
s：
array[1..n]ofInteger;表示涂的颜色。
采用回溯的方法，首先给第一个图形涂上红色
（1），然后在下面的图形中依次涂上其他颜色，当有矛盾时回溯解决。
[程序清单]
constn=8;
varI,j,k:
integer;
r:
array[1..n,1..n]of0..1;
s:
array[1..n]ofinteger;
begin
fori:
=1tondo
begin
forj:
=1tondoread（r[i,j]）;readln
end;
___
（1）___;i:
=2;j:
=1;
whilei<=ndo
begin
while（j<=4）and（i<=n）do
begin
k:
=1;
while___
（2）___dok:
=k+1;
ifk___（4）___
i:
=i+1;j:
=1
end
end;
ifj>4thenbegini:
=i-1;___（5）___end;
end;
fori:
=1tondowriteln（i,'---',s[i]）
end.
第5题
[问题描述]
多项式加法运算：
一个仅含有x的多项式可以用下列的方式表示：
（系数，指数），（系数，指数），…，（0，0）。
其中（0，0）作为结束标志。
例如：
P（x）=4x6-3x3+2x2-1可表示为：
（4，6），（-3，3），（2，2），（-1，0），（0，0）
Q（x）=x4-x+1可表示为：
（1，4），（-1，1），（1，0），（0，0）
当用上面的方式给出2个多项式之后，程序对这两个多项式进行加法运算，结果也用上面的方式给出。
例如：
上面的P（x）和Q（x）相加的结果为：
4x6+x4-3x3+2x2-x
表示结果为：
（4，6），（1，4），（-3，3），（2，2），（-1，1），（0，0）
[算法说明]
多项式可用数组p：
array[1..n，1..2]ofinteger表示。
分别以P1表示p，p2表示q，p3表示结果。
处理的过程为将p赋值到p3，然后逐项检查q，当发现有相同的方次时，进行系数相加；当发现没有相同的方次时，插入到p3中去。
[程序清单]
varx,y,i,i1,j,j1,j2:
integer;
p1,p2,p3:
array[1..20,1..2]ofinteger;
begin
i1:
=0;
write（'InputP（x）='）;
read（x,y）;
whilex<>0dobegin
j1:
=j1+1;p1[j1,1]:
=x;p1[j1,2]:
=y;
read（x,y）
end;
j1:
=j1+1;p1[j1,1]:
=O;p1
升级会员 