1995年度程序员级试题（附答案）

1995年度程序员级下午试卷

试题 2

在 COMET 型计算机上可以使用试卷上所附的 CASL 汇编语言。阅读下列程序说明和 CASL 程序，把应填入程序中__(n)__ 处的字句，写在答卷的对应栏内。
[程序说明]

子程序 SUMIT 把整型数组 EACH(N) 的元素加到整型数组 SUM(N) 的对应元素中去（N>0）。数组元素按下标顺序连续存放在存储区中。

进入子程序时，GR1 中存放着数组元素的个数 N，GR2 中存放着数组 EACH 的起始地址；GR3 中存放着数组 SUM 的起始地址。

要求在返回主程序时，GR1、GR2 和 GR3 的内容均保持不变。
[程序]

		START
	SUMIT	PUSH	0，GR1
		PUSH	0，GR2
		PUSH	0，GR3
	LOOP	LD	GR0，0，GR2
		__(1)__
		__(2)__
		LEA	GR2，1，GR2
		__(3)__
		__(4)__
		__(5)__
		POP	GR3
		POP	GR2
		POP	GR1
		RET
		END

　

试题 3

阅读下列程序说明和 C 程序，将应填入程序中__(n)__处的字句写在答卷纸的对应栏内。
[程序说明]

有 n 个班级参加 ns 个项目的比赛。下面的程序从文件 t.in 读入 n(≤30)，ns(≤10) 和全部班级各项目的得分，计算出各班的总分，并按总分降序的次序将每个班级总分及各项目的得分输出到文件 t.out。
为了避免排序时可能要交换 score[i][k] 和 score[i][k] ( 0 <＝ k < ns)，程序另引入数组 order[]，改上述交换为 order[i] 和 order[j] 的交换。
[程序]

#include<stdio.h>

#define NUlTIber 30

#define Terms 10

#define INF ”t.in”

#define OUTF ”t.out”

　

int score[Number][Terms]；

int total[Number]，Order[Number]；

main()

{ int i，j，n，ns，t；FILE，fpt;

if ((fpt＝fopen(1NF，”r”))＝＝NULl){

printf("Can't open file %s\no",INF);exit(1)；

}

fscanf( fpt,”%d%d”,&n，&ns)；

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

{ for (j＝0;j<ns; i++)

fscanf( fpt," %d", score[i]+i );

for (t=j=0 ; j<ns ;j++ )

t+=score[i][j] ;

total[i] = t ;__(1)__ ;

}

fclose (fpt)

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

for (j= __(2)__ ;j<n ;j++)

if ( __(3)__)

{ t = order[i];

order[i-] = order[i]~ order[i-] ----- t~

}

fpt ---- fopen (OUTF, "w")

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

{ fprintf(fpt,"%4d %7d ;" ,i+l,total[__(4)__]);

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

fprintf( fpt ," %3d",__(5)__)

fprintf (fpt ,"\ n" )

}

fclose (fpt);

}

　

试题 7

在 COMET 型计算机上可以使用试卷上所附的 CASL 汇编语言，阅读下列程序说明和 CASL 程序，把应填入程序中__(n)__处的字句，写在答卷的对应栏内。
[程序说明]

本子程序用来比较两个非空字符串。设被比较的字符串 A 和字符串 B 已由输入子程序读入内存并确认均为非空。

标号为 ALNGTH 和 BLNGTH 的存储字中分别存放着字符串 A 和 B 的长度(均为不大于 80 的正整数)；标号为 ASTRNG 和 BSTRNG 开始的连续存储区中分别存放着字符串 A 和 B 的诸字符。

按下述规则，将比较结果以带符号的整数形式存于 GRO 中返回主程序。

1.从两字符串的首字符开始，依次取各字符串中相同位置的字符，按它们的 ASCII 编码逐个进行比较，直至出现相异字符或已取完其中一个字符串中的全部字符时，终止比较。

2.若因出现相异字符而终止比较，则当字符串 A 中的字符编码小于字符串 B 中的相应字符编码时返回负值，否则返回正值。

3.若因取完其中一个字符串的全部字符而终止比较，则当两字符串长度相等时，返回零值；字符串 A 的长度较长时，返回正值；字符串 B 的长度较长时，返回负值。
[程序] 

		START	CMPSTR
	ALNGTH	DS	1
	BLNGTH	DS	1
	ASTRNG	DS	80
	BSTRNG	DS	80
	CMPSTR	LEA	GRI，ALNGTH
		LD	GR0，ALNGTH
		SUB	GR0，BLNGTH
		JMI	CMPCHR
		LEA	GRI，BLNGTH
	CMPCHR	__(1)__
	NEXCHR	__(2)__
		__(3)__
		__(4)__
		LEA	GR0，0,GR3
		JMP	RETURN
	CONTIN	LEA	GR2，1，GR2
		__(5)__
		__(6)__
		RETURN	__(7)__
		END

试题 8

阅读下列程序说明和 C 程序，将应填入程序中__(n)__ 处的字句，写在答卷纸的对应栏内。
[程序说明]

从文件 t2.in 中读出整数，将其中的不同整数及其出现次数，按整数由小到大的次序输出到文件t2.out 中。程序用一个有序二叉树存储这些不同的整数及其出现次数。然后按中序遍历该二叉树，将整数及其出现次数输出到文件 t2.out 中。
[程序] 

#include <stdio.h>

#include <alloc.h>

#define INF ”t2.in”

#define OUTF ”t2.out”

typedef struct treenode

{ intval，count

struct treenode'left，'right

} Binary

binary_tree ( Binary **t，int data )

{ Binary *ptr，*p；int d ;

p = NULL ；ptr =__(1)__ ;

while(__(2)__)

if (data == ptr -> val)

{ ptr -> count++; return; }

else

{ p＝ptr ; ptr ＝__(3)__ ? __(4)__;}

ptr ＝(Binary * )malloc(sizeof(Binary));

ptr -> left = ptr -> right＝NULL;

ptr -> val = data __(5)__ ;

if ( __(6)__) __(7)__ ＝ ptr;

else if (data > p -> val ) p -> right = ptr;

else p -> left ＝ ptr;

travel tree( FILE *fpt,Binary *t)

{ if (t == NULL) return ;

travel_tree ( fpt, t -> left)

fprintf(fpt,"%d %d\ n" ,t -> val,t -> count );

travel tree (fpt, t -> right);

}

main ( )

{ FILE *fpt; Binary * root = NULL; int d;

if (( fpt = fopen (INF,'r') == NULL )

{ printf( "Canlt open file !\n") ; exit(1);

while ( fscanf ( fpt,"%d" ,&d) == 1)

binary_tree( &root,d);

fclose (fpt);

fpt = fopen(OUTF,"wt" ) ; travel_tree(fpt,root);

felose(fpt) ; travel_tree( stdout,root);

}

　

试题 12

在 COMET 型计算机上可以使用试卷上所附的 CASL 汇编语言。阅读下列程序说明和 CASL 程序，把应填入程序中__(n)__ 处的字句，写在答卷的对应栏内。
[程序说明]

本程序按以下格式输出方框内的十六进制数乘法表。乘积数据按行输出到标准输，其中每个乘积数据均占三个字符位置。

程序中调用了子程序 MULIT (略)，子程序 MULIT 计算 GR0 和 GRl 中的两个整积，结果置于 GR2 。返回时，除 GR2 外，所有寄存器的值均保持不变。

[程序]

		START	BEG
	BEG	LEA	GR3，0
		LD	GR0，SPACE
	L0	__(1)__
		__(2)__
		CPA	GR3，OUTNUM
		JMI	L0
		LEA	GR1，1
	L1	LEA	GR0，1
		LEA	GR3，OUTBUF
		LEA	GR3，1，GR3
	L2	CALL	MULIT
		ST	GR2，WORK
		__(3)__
		__(4)__
		__(5)__
		LD	GR2，WORK
		__(6)__
		JZE	L3
		__(7)__
		ST	GR2，0，GR3
	L3	__(8)__
		ADD	GR0，ONE
		ST	GR0，WORK
		CPA	GRl，WORK
		JPZ	L2
		OUT	OUTBUF，OUTNUM
		LEA	GR1，1，GR1
		CPA	GR1，N16
		JMI	L1
		EXIT
	OUTBUF	DS	45
	SPACE	DC	' '
	ONE	DC	1
	N16	DC	16
	NOTOF	DC	'0123456789ABCDEF'
	OUTNUM	DC	45
	N000F	DC	#000F
	WORK	DS	1
		END

 

试题13

阅读下列程序说明和 C 程序，将应填入程序中__(?)__处的字句，写在答卷纸的对应栏内。
[程序说明]

本程序输入 4 个整数，对这四个整数可任意作加、减、乘、除四则运算，找出一个运算结果等于 24 的表达式。

设4个数的某个排列依次为 A，B，C，D，某次选定的三个运算符分别为 x，y，z，则由它们可组成以下 5 种不同的表达式：

	(1) A z(B y(C x D))	(2) A z((Bx C)y D)
	(3) (A y(B x C))z D	(4) ((A xB)y C)z D
	(5) (A x B)z(C y D)

在以上形式的表达式中，运算符写在两个运算分量的中间(称作中缀表达式)：

左运算分量 运算符 右运算分量

别一种更便于计算机处理的表达式表示形式是将运算符写在两个运算分量的后面（称作后缀表达式）：

左运算分量 右运算分量 运算符

以上 5 种中缀表达式可分别改写成以下5种后缀表达式：

	(1)A B C D x y z	(2)A B C x D y z
	(3)A BC x y D z	(4)A B x C y Dz
	(5)A B x C D y z

程序中，函数 search( int a[]，int k) 以 a[] 中元素为运算分量，对运算分量和运算符的各种可能排列，按上述 5 种形式寻找结果等于 k 的后缀表达式，并输出其对应的中缀表达式。在函数 search()中，调用函数 calculate() 计算表达式的值。

为了便于识别对运算分量和运算符的各种可能排列，用数组 intpt[] 存放指向运算分量和运算符的指针的指针。

程序为每种后缀表达式规定一种输出相应中缀表达式的格式，相应输出元的指针的指针存储在数组 rule[][] 中。例如，对于后缀表达式 ABxCDyz （见程序中的 sample[4]），对应中缀表达式为 (AxB)z(CyD)，其输出格式为

"(%d%c%d)%c(%d%c%d)\n"（见程序中的format[4]），相应输出元的指针的指针见程序中的 rule[4]。
[程序] 

#include,< stdio.h>

int op[]＝{ '+'，'-'，'*'，'/'};

char *sample[]＝{"ABCDxyz"，"ABCxDyz"，

"ABCxyDz"，"ABxCyDz"，'ABxCDyz'}；

char *format[]＝{"%d%c(%d%c(%d%c%d))\n"，

"%d%c((%d%c%d)%c%d)\n"，

"__(1)__ "

"((%d%c%d)%c%d)%c%d\n"，

"(%d%c%d)%c(%d%c%d)\n" }；

main()

{ int a[4];

printf ('Enter four numbers ! xx nn );

scanf (' %d%d%d%d" ,&[0], &.a [,1 ] ,&[2] ,&[3]);

if (search(a,24) == 0)printf('No solution !!& n");

}

int search( int a[],int k )

{ int m;

static int *i1, *i2, *i3, *i4, *s1, *s2, *s3;

int* * intpt[7] = { &i1,&d2,&i3,&i4,&s1,&s2,&s3 };

int* *rule[][7] = {{ &i1,&s3,&i2,&s2,&i3,&s1,&i4 },

{ &i1,&s3,&i2,&s1,&i3,&s2,&i4 },

{ &i1,&s2,&i2,&s1,&i3,&s3,&i4 },

{__(2)__},

{ &i1,&s1,&i2,&s3,&i3,&s2,&i4 } };

for (i1 = a ; i1 < a4 + 4 ; i1++ )

{ for ( i2 = a ; i2 < a + 4; i2++ )

{ if ( i2 == i1 ) continue;

for ( i3 = a ;i3 < a + 4 ; i3++ )

{ if ( i3 == i1 || i3 == i2 ) continue;

i4 = a + __(3)__ ;

for ( s1 = op ; s1 < op + 4 ; s1++ )

for ( s2 = op ; s2 < op + 4 ; s2++ )

for ( s3 = op ; s3 < op + 4 ; s3++ )

for ( m = O; m < 5; m++ )

if ( calculate( intpt,sample[,m]) == k )

{ printf( format[m], ** rule[m][O], ** rule[m][1],

** rule[m][2], ** rule[m][3],

** rule[m][4], ** rule[m][5],

** rule[m][6] );

return 1;

}

}

}

}

return 0;

}

int calculate( int **ipt[],char *s)

{ int st[4],i,j,rl,r2;

for(j=i=O;i<7;i++)

{ if ( __(4)__ ) st[j++] = __(5)__;

else { ri = st[j-2]; r2 = st[j-1];

switch ( __(6)__ )

{ case '+' : st[j-2] = rl+r2; j--; break;

case '-' : if(ri<r2) return -1;

st[j-2] = rl-r2; j--; break;

case '*' : st[j-2] = r1&*r2; j--; break;

case '/' : if ( r2 == 0 || r1%r2 != O)

return - 1

st[j--2] = rl/r2; j--; break;

}

}

}

return __(7)__ ;

}