阅读以下说明和C++程序，将应填入（n)处的字句写在对应栏内。

【说明】

下面的程序按照以下规则输出给定名词的复数形式。

a．若名词以“y”结尾，则删除y并添加“ies”；

b．若名词以“s”、“ch”或“sh”结尾，则添加“es”；

c．其他所有情况，直接添加“s”。

【C程序】

include ＜stdio．h＞

include ＜string．h＞

char*plural(char *word)

{

int n；

char *pstr；

n＝strlen(word)； /*求给定单词的长度*/

pstr＝(char*)malloc(n+3)；/*申请给定单词的复数形式存储空间*/

if (!pstr||n＜2)

return NULL；

strcpy(pstr，word)； /*复制给定单词*/

if ((1))

{

pstr[n-1]＝'i'；pstr[n] ＝'e'；pstr[n+1]＝'s'；(2)；

}

else

if(pstr[n-1]＝＝'s'| |pstr[n-1]＝＝'h'&&((3)))

{

pstr[n]＝'e'；pstr[n+1]＝'s'；pstr[n+2]＝'\0'；

}

else

{ pstr[n]＝'s'；pstr[n+1]＝'\0'；)

(4)；

}

main()

{ int i； char *ps；

char wc[9][10]＝

{"chair"，"dairy"，"boss"，"circus"，"fly"，"dog"，"church"，"clue"，"dish")；

for(i ＝ 0；i＜9； i++) {

ps＝ (5) ；

printf("%s： %s\n"，wc[i]，ps)； /*输出单词及其复数形式*/

free(ps)； /*释放空间*/

}

system("pause")；

}

【说明】

下面的程序用DoleRob算法生成N阶(N为奇数)魔方阵(各行、列、对角线数字之和相等)。该算法的过程为：从1开始，按如下方法依次插入各自然数，直到N2为止。

a．在第一行的正中插入1。

b．新位置应当处于最近插入位置的右上方，若该位置已超出方阵的上边界，则新位置取应选列的最下一个位置；若超出右边界，则新位置取应选行的最左一个位置。

c．若最近插入的元素是N的整数倍，则选同列的下一行位置为新位置。

例如，3阶魔方阵如下所示：

8 1 6

3 5 7

4 9 2

【C程序】

include＜stdio.h＞

include＜stdlib.h＞

define SIZE 50

main( )

{ int row， col， n，value；

int a[SIZE+1][SIZE+1]； /*不使用下标为0的元素*/

printf("请输入要输出魔方阵的阶数n(奇数，＜%d)：n＝"，SIZE)；

scanf("%d"，&n)；

if (!(n % 2)||n ＜ 1 ||(1)) {

printf("输入数据有误!\n")； exit(0)；

}

row＝1； col ＝ (n+1)/2； value＝1；

while(value＜ ＝(2)) {

a[row][col] ＝ value；

/*计算下一位置*/

if(value%n !＝0){

row--； (3)；

if(row＜1) row＝n；

if(col＞n)(4)；

}

else row++；

value ＝(5)；

}

printf("\n%d阶魔方阵如下所示:\n\n"，n)；

for(row ＝ 1；row ＜＝ n； row++){

for(col ＝ 1； col ＜＝n； col++)

printf("%5d"，a[row][col])；

printf("\n")；

}

}

【说明】

并行计算中需要将N个作业分配给N个处理器同时去完成，每个处理器都能承担这N个作业，但耗时不同。下面的程序用回溯法计算总耗时最小的一种作业分配方案，在该方案中为每个处理器分配1个不同的作业。

程序中，N个作业从0开始依次编号，N个处理器也从0开始依次编号，主要的变量说明如下：

c[i][j]：将作业i分配给处理器j的耗时；

job[i]：值为0表示作业i未分配，值为j表示作业i分配给处理器j；

processor[k]：值为0表示处理器k未分配作业，值为1表示处理器k已分配作业；

mincost：最小总耗时。

【C程序】

include＜stdio．h＞

define N 8/*N表示作业数和处理器数*/

int c[N][N]；

unsigned int mincost=65535/*设置min的初始值，大于可能的总耗时*/

int job[N]，temp[N]，processor[N]；

void Assign(int k，unsigned int cost)

{

int i；

if (1)&& cost＜mincost){

mincost = cost

for(i=0；i＜N；i++)temp[i]=job[i]；

}

else {

for(i=0；i＜N；i++)/*分配作业k*/

if (2)&& cost+c[k][i]＜mincost){

processor[i]=1；job[k]=(3)；

Assign (4)，cost+c[k][i])；

(5)；job[k]=0；

}/ * if * /

}

}/ *Assign * /

void main()

{

int i，j；

for(i=0；i＜N；i++){/*设置每个作业由不同处理器承担时耗时及全局数组的初值*/

processor[i]=0；job[i]=0；temp[i]=0；

for(j=0；j＜N；j++)

scanf("%d"，&c[i][j])；

}

Assign(0，0)；/*从作业0开始分配*/

printf("\n最小耗时=%d\n"，mincost)；

for(i=0；i＜N；i++)

printf("Job%d is assigned to Processor%d\n"，i，temp[i])；

}/*main*/

[说明]

下面程序用来将打乱的单词还原为原来的次序，比如将rty还原为try。单词的原来次序存储于wordlist.txt文件中，原则上可用穷举法(rty对应的穷举为：rty、ryt、try、tyr、ytr、yrt)，但考虑到破译速度，采用如下方法。

注意到单词列表中不存在组成字符完全相同的单词(如Hack12与Hack21包含完全相同的字符)，因此将单词中的字符进行重组再进行比较，例如，try单词重组为rty(按ASCⅡ码顺序)，这样不管打乱的单词是什么顺序，只要是由r、t、y三个字母组成的均破译为try，大大提高破译速度。程序中借助二叉排序树以进一步提高查找效率，二叉排序树左子树(如果有)上的节点对应的值均小于根节点的值，右子树(如果有)上的节点对应的值均大于根节点的值。

函数中使用的符号定义如下：

#define NumberofWords 1275//单词总数

#define MaxLength 10//最长单词所含字符数

char WordList[NumberofWords][MaxLength]；//存储单词列表

int cmp(Node *q，Node *p)；//q与p比较。p小，返回负值；P大返回正值：相等，返回0

typedef struct Node(//二叉树节点

char *eleLetters；//重组后的字符串

int index；//对应单词表中的下标

struct Node *lChiId，*rChiid；//左右子节点

}Node；

[C代码]

void reCompose(Node *p，char *temp)

//重纰，亦即将temp字符串中的字符升序排序，存储于p节点中

//采用直接插入排序法

{

char c；

strcpy(p-＞eleLetters，temp)；//

int len=strlen(temp)；

int i，j，k；

for(i=0；i＜len－1；i++){

k=i；

for(j=i+1；j＜lan；j++){

if(p-＞eleLetters[j]＜P-＞eleLetters[k])k=J；

}

if( (1) ){

C=P-＞eleLetters[i]；

P-＞eleLetters[i]=P-＞eleLetters[k]；

P-＞eleLetters[k]=c；

}//if

}//for

}；

int find(Node &root，char *temp)

//在二叉排序树root中查找与temp匹配的单词。

//若匹配返回相应单词在WordList中下标；若查找失败，返回-1

{

Node *P，*q；

int flag；

P=(2)；//临时存储

reCompose(p，temp)；//将temp重组

q=&root；

while((flag=(3))＆＆q !=NULL){

if(flag＜0){//搜索左子树

q=q-＞lChiid；

}else(//搜索右子树

q=q-＞rChild；

}

}//while

if(flag==0){//找到匹配的，保存下标

return (4)；

}

}

if( (5) ){//查找失败

printf("cant unscramble the following word：%s"，temp)；；

return -1；

}

}；

(1)

[说明]

以下程序的功能是计算三角形、矩形和正方形的面积并输出。

程序由4个类组成：类Triangle，Rectangle和Square分别表示三角形、矩形和正方形；抽象类Figure提供了一个纯虚拟函数getArea()，作为计算上述三种图形面积的通用接口。

[C++程序]

include＜iostream.h＞

include＜math.h＞

class Figure{

public:

virtual double getArea()=0; //纯虚拟函数

};

class Rectangle: (1) {

protected:

double height;

double width;

public:

Rectangle(){};

Rectangle(double height,double width){

This-＞height=height;

This-＞width=width;

}

double getarea(){

return (2);

}

};

class Square: (3)

public:

square(double width){

(4);

}

};

class triangle: (5) {

double la;

double lb;

double lc;

public:

triangle(double la,double lb,double lc){

this-＞la=la;thiS-＞ib;this-＞lc;

}

double getArea(){

double s=(la+lb+lc)/2.0;

return sqrt(s*(s-la)**(s-lb)*(s-lc));

}

};

viod main(){

figure*figures[3]={

new triangle(2,3,3),new Rectangle(5,8),new Square(5)};

for(int i=0; i＜3;i++){

cout＜＜"figures["＜＜i＜＜"]area="＜＜(figures)-＞getarea()＜＜endl;

}

}

};

[说明]

以下程序的功能是统计学生成绩，包括输入学生的姓名和成绩，按成绩从高到低排列打印输出，对前百分之七十的学生定为合格(PASS)，而后百分之三十的学生定为不合格(FAIL)。例如，当输入4名学生的姓名和成绩“Alice 67 Mary 90 Tom 56 John 88”后，程序的执行结果如下：

姓名 成绩 合格否

Mary 90 PASS

John 88 PASS

Alice 67 FAIL

Tom 56 FAIL

[C++程序]

include ＜stdio.h＞

include ＜string.h＞

define N 10

class student

{ protected:

char name[10];

int deg;

public:

void setname(charna[]) {strcpy(name,na);}

char * getname() {return name;}

void setdeg(int d) {deg= d;}

int getdeg(){return deg;}

};

class compute

{ int ns;

student na[N];

public:

void getdata();

void sort();

void disp();

};

void compute::getdata()

{ int i,tdeg;

char tname[10];

printf("输入学生人数:");

scanf("%d",&ns);

printf("输入学生姓名和成绩:\n");

for(i=0;i＜ns;i+ +){

scanf("%s%d",tname,&tdeg);

(1);

na[i].setdeg(tdeg);

}

}

void compute::sort()

{ int i,j,pick;

(2);

for(i=0;i＜ns-1;i+ +){

pick=i;

for(j=i+1;j＜ns;j+ +)

if(na[j].getdeg()＞na[pick].getdeg()) (3);

temp=na[i];

na[i]=na[pick];

na[pick]=temp;

}

}

void compute::disp()

{ int cutoff,i;

printf("RESULT\n");

printf("姓名 成绩 合格否\n");

cutoff=ns*7/10-1;

for(i=0;i＜ns;i+ +) {

printf("%-6s%3d",(4));

if((5)) printf("\tPASS\n");

else printf("\tFAIL\n");

void main()

{ compute obj;

obj.getdata();

obj.sort();

obj.disp();

}

【程序说明】

某网络由n个端点组成，这些端点被物理地分成若干个分离的端点组。同一组内的两件端点i和j，它们或直接相连，或间接相连(端点i和端点j间接相连是指在这两件端点之间有一个端点相连序列，其中端点i和j分别与这相连序列中的某个端点直接相连)。网络的n个端点被统一编号为0，1，…，n-1。本程序输入所有直接相连的端点号对，分别求出系统各分离端点组中的端点号并输出。

程序根据输入的直接相连的两件端点号，建立n个链表，其中第i个链表的首指针为s[i]，其结点是与端点i直接相连的所有端点号。

程序依次处理各链表。在处理s[i]链表中，用top工作链表重新构造s[i]链表，使s[i]链表对应系统中的一个端点组，其中结点按端点号从小到大连接。

【程序】

inelude

define N 100

typeef struct node{

int data；

struct node *link；

}NODE；

NODE * s[N]；

int i，j，n，t；

NODE *q，*p，*x，*y，*top；

main()

{

printf(“Enter namber of components．”)；

scanf(“%d”，&n)；

for(i=0；i＜n；i++) printf(“Enter pairs．\n”)；

while(scanf(“%d%d”，&i，&j)==2)

{ /*输入相连端点对，生成相连端点结点链表*/

p=(NODE*)malloc(sizeof(NODE))；

p→data=j；p→link=s[i]；s[i]=p；

p=(NODE*)malloc(sizeof(NODE))；

p→data=i；p→link=s[j]；s[j]=p；

}

for(i=0；i＜n；i++) /*顺序处理各链表*/

for(top=s[i]， (1)；top! =NULL；)

{ /*将第i链表移入top工作链表，并顺序处理工作链表的各结点*/

q=top；

(2)；

if(s¨[j=q→data]!=NULL)

{ /将j链表也移入工作链表*/

for(p=s[j]；p→link! =NULL；p= p→link)；

p→link= top；top=s[j]；

(3)；

}

/*在重新生成的第i链表中寻找当前结点的插入点*/

for(y=s[i]； (4)；x=y，y=y→link)；

if(y!=NULL && y→data==q→data)

free(q)； /*因重新生成的第i链表已有当前结点，当前结点删除*/

else{

(5)；

if(y ==s[i])s[i]=q；

else x→link=q；

}

}

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

{/*输出结果*/

if(s[i]==NULL)continue；

for(p=s[i]；p!=NULL；){

printf(“\t%d”，p→data)；

q=p→link；free(p)；p=q；

}

printf(“\n”)；

}

}

[说明]

下面程序是为汽车市场编制的一个程序的一部分。其中automobile是基类。

[C++程序]

//Auto.h

ifndef AUTO_H

define AUTO_H

class automobile

{

(1):

int miles_per_gallon; //汽车每加仑行驶公里数

float fuel_capacity； //油箱容积

public:

void initialize(int in_mpg,int in_fuel);

int get_mpg(void);

float get_fuel(void);

float travel_distance(void);

}

endif

//Auto.cpp

include"auto.h"

void automobile::initialize(int in_mpg,float in fuel)

{

miles_per_gallon=in_mpg;

fuel_capacity=in_fuel;

)

int automobile::get_mpg() //提供一辆特定汽车每加仑公里数

{return miles per_gallon;}

float automobile::get_fuel() //提供油箱容积

{return fuel_capacity;}

float automobile::travel_distance()

{return (2) }

//car.h

ifndef CAR_H

define CAR_H

include"auto.h"

class car: (3)

{

int Total_doors;

public:

void initialize(int in_mpg,float in_fuel,int doors=4);

int doors(void);

};

endif

//car.cpp

include"car.h"

void car::initialize(int in_mpg,float in_fuel,int door)

{

Total_doors=door;

miles_per_galion=in_mpg;

fuel_capacity=in_fuel;

}

int car::doors(void)

{return Total doors;}

//Allauto.cpp

include

include"auto.h"

include"car.h"

int main()

{

car sedan;

sedan.initialize(24，20.0，4);

tout＜＜"The sedan can travel"＜＜ (4) ＜＜"miles.\n";

cout＜＜"The sedan has"＜＜ (5) ＜＜"doors.\n";

return 0;

}

[说明]

下面程序实现十进制向其它进制的转换。

[C++程序]

include"ioStream.h"

include"math.h"

include

typedef struct node {

int data;

node*next;

}Node;

Class Transform.

{

DUDlic:

void Trans(int d,int i); //d为数字;i为进制

void print();

private:

Node*top;

};

void Transform.:Trans(int d,int i)

{

int m,n=0;

Node*P;

while(d＞0)

{

(1);

d=d/i;

p=new Node;

if(!n){

p-＞data=m;

(2);

(3);

n++;

}

else{

p-＞data=m;

(4);

(5);

}

}

}

void Transform.:print()

{

Node*P;

while(top!=NULL)

{

p=top;

if(p-＞data＞9)

cout＜＜data+55;

else

cout＜＜data;

top=p-＞next;

delete p;

}

}

[说明]

下面程序输出一个矩形面积，以及矩形区域上的假想的作物产量。

[C++程序]

include ＜iostream.h＞

class crop_assessment

{

int actual_crop;

int ideal_crop;

public:

void set(int in_actual,int in_ideal)

{

actual crop=in_actual;

ideal_crop=in_ideal;

}

int get_actual_crop(void){ (1) ;}

int get_ideal_crop(void){ (2) ;)

};

Class lot_size

{

int length;

int width;

(3) crop;

public:

void set(int 1,int w,int a,int i)

{

length=1;

width=w;

crop.set(a,i);

}

int get_area(void){return length*width;}

int get_data(void){return (4) ;}

int get_data2(void)freturn (5) ;}

}

int main()

{

Los_size small，medium;

small.set(5,5,5,25);

medium.set(10,10,10,50);

cout＜＜"For a small lot of area"＜＜smallget_area()＜＜“\n”;

cout＜＜"the actual crops are$"＜＜small.get_data2()＜＜"\n";

cout＜＜"and ideal crops are$”＜＜small.get_data()＜＜"\n";

cout＜＜"For a medium Lot of area"＜＜medium.get area()＜＜:\n”;

cout＜＜"the actual crops are$"＜＜medium.get_data2()＜＜"\n";

cout＜＜"and ideal crops are$"＜＜medium.get_data()＜＜"\n";

return 0;

}