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

1993年度程序员级下午试卷

试题 2

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

子程序 UPDATE 每隔一秒被调用一次，届时对存贮单元 HOUR( 时 )，MINUTE( 分 )以及SECOND( 秒 )的当前值予以更新处理。

SECOND 与 MINUTE 均为六十进制, HOUR 为廿四进制。HOUR，MINUTE 和 SECOND 的递加与复零均由公用子程序 ADDONE 进行。

[程序]

	标号	操作码	操作数
	UPDATE	START
		PUSH	0，GR1
		PUSH	0，GR2
		PUSH	0，GR3
		LEA	GR2， ①
		LEA	GR3， ②
		CALL	ADDONE
		③
		④
		CALL	ADDONE
		⑤
		LEA	GR2， ⑥
		LEA	GR3， ⑦
		CALL	ADDONE
	UPTOK	POP	GR3
		POP	GR2
		POP	GR1
		RET
	HOUR	DC	0
	MINUTE	DC	0
	SECOND	DC	0
	ADDONE	⑧
		CPA	GR2，0，GR3
		JZE	ADDOK
		LD	GR1，0，GR3
		LEA	GR1，1，GR1
	ADDOK	ST	GR1，0，GR3
		RET
		END

　

试题 3

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

数列 A＝{ 1，1，3，7，17，4l，……} 有以下性质：

a₀=a₁=1

a_i=a_i-2+2a_i-l ( i≥2 )

对于给定的 n，数列 X 有 n 个元素，各元素的值为

xi=ai／ai+1 ( i＝0，1，……，n-1 )

·且按升序排列，其中 X 的各元素值以分数形式表示。

函数 makex()首先在枚举数列 A 的元素时，生成 X 的元素，然后对 X 的元素进行排序，最后顺序输出排序后的 X 的各元素。

例：当 n=5 时，X＝{ 1／3，7／17，17／41.3／7.1／1 }。
[程序]

#include<stdio．h>

structfact{

1ong m ；

long n ；

}；

int test_1ist[]＝{ 4，5，8 } ；

main()

{ int i ；

for ( i；0；i<3；i++ )

makex( test_list[i] )

}

makex( int n )

{ int i；long a，b，c；struct fact * x，* y；

x＝( struct fact * )malloc ( sizeof( struct fact ) *n )；

x→m = 1L；K→n = 1L；

a = 1L； b = 1L；

for ( i＝2；i<=n；i++ )

{ c＝a+2L，*b ；a=b ；b=c ；

__①__=a ；__②__ =b ；

}

sort(n，x)；

printf( "％d＝{％1d／％1d"，n，x→m，x→n )；

for( __③__ ；y++)

printf( "％ld／％1d"，y→m，y→n )；

printf( "}＼n")；free(x) ；

}

sort( int n，struct fact * p)

{ int b；1ong s，t，u，v；struct fact * q，* end ；

end = __④__ ；b=1；

while (b)

 { b＝0 ；

for ( q＝p ；q<end ；q++ )

{ s＝q→m； t＝q→n ；

u=(q+1)→m ； V＝(q+1)→n ；

if ( s*v > t*u )

{(q+1)→m=s； (q+1)→n=t ；

q→m = u ； q→n = v ；

__⑤__ ；

}

}

__⑥__ ；

}

}

　

试题 7

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

子程序 ENCRPT 用来对给定字符串进行加密处理。

子程序使用密钥字符串与待加密字符串按顺序逐个字符进行异或操作以实现加密处理。在加密过程中如已经使用了密钥字符串的最后一个字符，则再从密钥字符串的第一个字符起重复取用，待加密字符串的全部字符处理完毕后，子程序返回其调用程序。

子程序所需的全部参数( 待加密字符串长度及字符串首址，密钥字符串长度及字符串首址 )均通过栈来传递。以下是一个调用实例：

其中标号为 CHRL 的存贮单元内是待加密字符串的长度，从标号为 CHRS 的存贮单元起顺序存放待加密字符；标号为 KEYL 的存贮单元内是密钥字符串的长度，从标号为 KEYS 的存贮单元起顺序存放密钥字符串的字符。
[程序]

	标号	操作码	操作数
	ENCRPT	START
		PUSH	0，GR1
		PUSH	0，GR2
		PUSH	0，GR3
		LEA	GR0，0
		CPA	GR0，5，GR4
		JPZ	ENDENC
		CPA	GR0，7，GR4
		JPZ	ENDENC
		__①__
	RESET	LD	GRl， __②__
		LD	GR2， __③__
	IFEND	LD	GR0，7，GR4
		SUB	GR0，NUMl
		JMI	ENDENC
		ST	__④__
	GOON	LD	GR0，0，GR3
		EOR	GR0，0，GR1
		ST	GR0，0，GR3
		LEA	GRl，1，GR1
		__⑤__
		LEA	GR2，-1，GR2
		__⑥__
		JMP	RESET
	ENDENC	POP	GR3
		POP	GR2
		POP	GR1
		RET
	NUMl	DC	1
		END

试题 8

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

这里给出的程序从指定数据文件中读入职工的工号和他完成产品个数的数据信息，对同一职工多次完成的产品个数进行累计，最后按以下格式输出：职工完成产品数量的名次，该名次每位职工完成的产品数量，同一名次的职工人数和他们的职工号( 同一名次的职工号以从小到大的顺序输出 )。

程序采用链表结构存贮有关信息，链表中的每个表元对应一位职工。在数据输入同时，形成一个有序链表(按完成的产品数量和工号排序)。当一个职工有新的数据输入，在累计他的完成数量时会改变原来链表的有序性，为此应对链表进行删除、查找和插入等处理。
[程序}

#include<stdio．h>

typedef struct ele {

int no，q ；

struct ele * next ；

} elem ；

main( int argc, char * * argv)

{ FILE *fp; elem *h, *u, *proc() ；

if ( argc == 2 && ( fp = fopen( argv[1],"r" )) !=NULL )

{ h = proc(fp) ；

fclose (fp) ；

output(h)

while (h I=NULL) { u=h→*next ；free(h) ； h=u ；)

}

}

elem * proc( FILE *fp )

{ intn, m; elem *u, *v, *p, *base ；

base = NULL ；

fscanf( fp, "%d', &m ) ；

while ( ! feof(fp) )

{ fscanf( fp, '%d', &m ) ；

for ( v = base ；v !=NULL && v→no != n ；u = v, v = v→next ) ；

if (__①__)

if (__②__) base=v→next ；

else u→next = v - next ；

v→q + - m ；

else v = ( elem * ) malloc( sizeof( elem )) ；

v→no = n ；

v→q = m ；p = base ；

while ( p != NULL )

if (__③__ )break ；

else { u = p ；p = p→next ；}

if ( __④__ ) base = v ；else u→next = v ；

__⑤__ ；

fscanf( fp, "%d",&n ) ；

}

return base ；

}

output( elem * head )

{ int count，order；elem *u， *v ；

printf( "ORDER QUANTITY COUNT NUMBER＼n" ) ；

u = head；order = 1 ；

while ( u != NULL )

{ for ( count ＝ 1，v = u→next；__⑥__ ；count++ ，v=v→next )；

printf( "％4d％9d％6d"，order，u→q，count )；

order +＝ count；

for(； __⑦__ ；printf( "％4d"，u→no)，u=u→next)； ·

printf( "＼n")；

}

}

　

试题 12

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

子程序NPUT将正整数N嵌入一存贮字WORD的第P位起的W位中，并使其余各位保持不变。

主程序在GRI中给出存放子程序所需参数的起始地址。参数的存放形式，如下图所示。

例：

调用子程序 NPUT 后 WORD 变成

子程序返回时，若 GR0 的值为 0，则表示子程序已经正常执行。若 GR0 的值为 1，则表示参数不合理，子程序异常退出。进入子程序时，已确保 P≥0，W>0 。程序中工作单元 MASKEP 和 MASKCP 分别有如下形式的数值：

[程序]

	标号	操作码	操作数
	NPUT	START
		PUSH	0，GRl
		PUSH	0，GR2
		PUSH	0，GR3
		LD	GR2，2，GR1
		LD	GR0，FULLB
		__①__
		ST	GR0，MASKEP
		EOR	GR0，FULLB
		LEA	GR3，16
		SUB	GR3，2，GRl
		__②__
		JMI	ERROR
		SLL	GR0，0，GR3
		__③__
		ST	GR0，MASKCP
		LD	GR0，3，GR1
		__④__
		JNZ	ERROR
		LD	GR2，0，GR1
		__⑤__
		AND	GR0，MASKCP
		LD	GR1，3，GR1
		SLL	GR1， __⑥__
		ST	GR1，TEMP
		OR	__⑦__
		ST	GR0，0，GR2
		LEA	GR0，0
	FIN	POP	GR3
		POP	GR2
		POP	GR1
		RET
	ERROR	LEA	GR0，1
		JMP	FIN
	LB	DC	#FFFF
	MASKEP	DS	1
	MASKCP	DS	1
	TEMP	DS	1
		END

 

试题13

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

程序中的函数 divisor() 设有四个参数：正整数 n，m，正整数数表 d 和正整数 dn。其作用是将 n分解成不多于 m(≤10)个数字的数字和。其中数字选自数表 d( d 中数字可重复选用)；数表 d 共有 dn 个数字，并限定数表 d 中数字互不相同，且按递减顺序存放。

函数 divisor() 采用试探法找解，其中工作数组 b 用于存放试探过程中暂时确定的数字在数表 d 中的下标，p 为存于 b 中的下标个数，t 为那些暂时确定的数字的和。
[程序]

#define MAXN 10

divisor( int ，n ，int m ，int d[] ，int dh )

{ int s，p，t，b[MAXN]；

for ( s=0；s<dn && d[s]>n ，s++ )；

p=0；b[0]＝s；t=d[b[p]]；

while ( t !＝ n && p2 >= 0 )

{ if  __①__ 

{ for ( s=b[p] )； __②__ ；s++ )；

if ( s <= dn-1 && t+d[s] <= n )

{ b[ __③__ ]＝s；

t += d[s]；

__④__ ；

}

}

t -= d[b[p]]；

while ( p >=0 && __⑤__ )

t -= d[ __⑥__ ]

if ( p >= 0 )

t +＝ d[ __⑦__ ]

}

if ( t＝＝n )

{ printf( "％4d＝％3d"，n，d[b[0]] )；

for ( s ＝ 1；3 <＝ p；s++ )

printf( "+％3d"，d[b[s]] )；

printf( "＼n" )；

}

else printf( "No solution.＼n" )；

{

main()

{ static int list[]＝{ 100，81，64，49，36，25，16，9，4，1 }；

int i；

  for ( i；50；i<300；i++ ) ；

divisor( i，4，list，sizeof list／sizeof(int) )；

}