文思创新笔试题.docx

资源描述

文思创新笔试题.docx

《文思创新笔试题.docx》由会员分享，可在线阅读，更多相关《文思创新笔试题.docx（14页珍藏版）》请在冰豆网上搜索。

文思创新笔试题.docx

文思创新笔试题

SECTION I （选择题）

1、操作系统分配资源时的一个重要考虑是避免死锁的发生．若系统中有同类资源 16 个，由四个进程 P1、P2、P3 和 P4 共享该资源。

已知 P1、P2、P3、P4 所需的资源总数分别为 8、5、9、6。

各进程请求资源的次序如下表，若系统采用银行家算法为它们分配资源，那么_

（1）__依次申请分配会使系统进入不安全状态。

进程申请资源的情况

序号进程申请量

1 P1 6

2 P2 4

3 P3 5

4 P4 1

5 P1 1

6 P2 1

A．3、4 B．3、5 C．4、5 D．5、6

2、结构化分析方法（SA）是一种预先严格定义需求的方法，强调分析对象的__

（2）__，其指导思想是__（3）__。

（2） A．程序流 B．指令流 C．控制流 D．数据流

（3） A．自顶向下逐层分解 B．自底向上逐层分解 C．面向对象 D．面向过程

3、UML是一种面向对象的统一建模语言。

它包含十种图，其中，用例图展示了外部actor与系统所提供的用例之间的连接，UML中的外部actor是指__（4）__，用例可以用__（5）__图来描述。

状态图指明了对象所有可能的状态以及状态间的迁移（transition）。

如果一个并发的状态由n个并发的子状态图组成，那么，该并发状态在某时刻的状态由__（6）__个子状态图中各取一个状态组合而成。

（4） A．人员 B．单位 C．人员或单位 D．人员或外部系统

（5） A．类 B．状态 C．活动 D．协作

（6） A．每一 B．任意一 C．任意二 D．任意m（m≤n）

4、在数据库的并发控制中，事务 T 若要更新记录 Q，必须先执行操作__（7）__。

在封锁技术方面，SQL2 提供如下四种“事务的一致性级别”：

可读未提交数据、读提交数据、可重复读、可串行化。

其中__（8）__允许事务读“脏”数据。

（7） A．Lock_S（Q） B．Lock_X（Q） C．READ（Q） D．WRITE（Q）

（8） A．可读未提交数据 B．读提交数据 C．可重复读 D．可串行化

5、对下面的个人所得税程序中满足语句覆盖测试用例的是__（9）__，满足判定覆盖测试的用例是__（10）__。

if （income<800） tarrate=0;

else if （income<=1500） taxrate=0.05;

else if （income<2000） taxrate=0.08;

else taxrate=0.1;

（9） A．income=（800，1500，2000，2001） B．income=（800，801，1999，2000）

C．income=（799，1499，2000，2001） D．income=（799，1500，1999，2000）

（10） A．income=（799，1500，1999，2001） B．income=（799，1501，2000，2001）

C．income=（800，1500，2000，2001） D．income=（800，1499，2000，2001）

SECTION II（编程题）

1、用你最熟悉的语言编写程序来实现：

比较两个字符串，相等返回TRUE，不相等返回FALSE；

2、请使用一种你熟悉的面向对象语言实现一个名为Singleton的类，要求该类只能被实例化一次。

3、使用SQL语句找出表名为Table1中的处在ID字段中1-200条记录中Name字段包含w的所有记录，并对找到的结果按年龄age 升序排序。

SECTION III （推理题）

甲：

"我的弹子比你的多。

乙：

"我不信，你自己来数数看。

甲：

"好吧，你的弹子是比我的多。

但玩弹子我可比你玩得好。

我只要赢你三个弹子，我的弹子就会

比你的多一倍。

乙：

"那你就试试吧。

甲：

"好，这是你说的!

乙：

"你不是说你玩得比我好吗?

可这次我赢了！

甲：

"你只赢了两个。

乙：

"看吧，我的弹子现在比你多两倍了。

甲：

"再来一次。

乙：

"好。

甲 "唉，好运气都让你碰上了。

乙：

"你现在全输光了，而我有……"

问：

乙现在有多少弹子?

答：

15个日本鬼子和15个美国鬼子站成一圈，数到9就从圈里面踢出一个来，要求写个程序把日本鬼子都给踢出来，美国鬼子都不被踢出来，输出美国鬼子应该站在哪些位置。

publicstaticvoidmain（String[]args）{

LinkedListll=newLinkedList（）;

for（inti=1;i<=30;i++）{

ll.add（i）;

}

for（inti=1;i<=15;i++）{

pos=i*9;

if（pos>30）

pos-=30;

System.out.println（pos）;

ll.remove（pos）;

}

Iteratorit=ll.iterator（）;

while（it.hasNext（））{

System.out.print（it.next（）+""）;

}

1.写一个程序：

实现字符串翻转。

例如：

原字符串“iamastudent”转换后“studentaami”。

要求：

不能使用库函数。

publicclassTest2{

publicstaticvoidmain（String[]args）{

Stringstr="Iamastudent";

StringstrNew="";

str=reverse（str）;

String[]str2=str.split（""）;

for（inti=0;i

str2=reverse（str2）;

strNew+=str2;

if（i!

=str2.length-1）

strNew+="";

}

System.out.println（strNew）;

}

publicstaticStringreverse（Stringstr）

{

char[]ch=str.toCharArray（）;

char[]ch2=newchar[ch.length];

for（inti=0;i

ch2[ch.length-1-i]=ch;

}

returnnewString（ch2）;

}

1、建立一个父类Person

2、建立American,JapaneseextendsPerson

3、newLinkList（）

4、new15个A和J国人

5、插入LinkList（）;

6、初始化len=30,count=0

7、while（len>15）{ //但愿最后只剩下美国佬

for（pos=0;pos

count++;

if（count==9）{

count=0;

if（personinstanceofA）say:

"I'mA"+pos,donothing;

if（personinstanceofJ）{

say:

"I'mJ",dotickBLinkList.remove（pos）;

pos--;位置向前移一位

len--;队伍长度减一

}

endfor

endwhile

1. 构造函数与析构函数是否可以被重载，为什么？

2. 指针和引用的区别。

3. malloc和new的区别。

4. 字符串反转。

用两种方法，第二种方法只用一个数串，直接互换。

5. 一个time类，包含minute和sec两个数据成员。

模拟秒表，每次走一秒，满60秒进一分钟，此时秒又从0开始。

ClassTime

{

public:

Time（）{minute=0;sec=0;}

Time（intm,ints）:

minute（m）,sec（s）{}

Timeoperator++（）;

Timeoperator++（int）;

Private:

Intminute;

Intsec;

};

（1） Time:

operator++（）和Time:

operator++（int）的区别；

（2）实现这两个重载函数。

6. 带镖头的单链表倒序。

7. 二叉树的前序和中序遍历如下：

前序：

ABCDEF 中序：

CBDAEF

画出该树。

8. 画出8，9，11，17，28，30，40在二叉搜索树中的位置。

9. 写一个冒泡排序的算法。

10. 栈和队列的相同和不同。

6个数排序

importjava.util.Random;

publicclassTest{

privateInteger[]arrayInteger;

publicTest（）{

arrayInteger=newInteger[49];

for（inti=0;i<49;i++）

arrayInteger[i]=i+1;

}

publicTest（Integer[]array）{

this.arrayInteger=array;

}

publicInteger[]shuffle（）{

Randomrand=newRandom（System.currentTimeMillis（））;

Integer[]array=arrayInteger;

for（inti=0;i

array=swap（array,i,rand.nextInt（array.length））;

returnarray;

}

privateInteger[]swap（Integer[]array,intindex,intend）{

Integertemp=array[index];

array[index]=array[end];

array[end]=temp;

returnarray;

}

publicstaticvoidmain（String[]args）{

for（inti=0;i<6;i++）

System.out.println（newTest（）.shuffle（）[i]）;

}

B3作业

注意:

前两题笔试题,交过程和答案;

后两题交源程序,程序名分别为t3.pas,t4.pas.

1,已知一棵度为m的树中有n1个度为1的结点,n2个度为2的结点,……,nm个

为m的结点,问树中有多少个叶子结点

答:

在树仅有一根结点的时候,树有1个叶子结点.设该叶子结点是nm个度为m的结点之一,则此时共有1-1+m*1=m个叶子结点.在m个叶子结点中再设它们为剩余

m个度为m个结点,使他们成为nm个度为m的结点,若不够则在这些结点的孩子或者孩子的孩子之中再设他们为度为m的结点,直到所有nm个度为m的结点都被包含在树中,则此时共有1+m*nm-nm个叶子结点.然后设nm-1个度为m-1的结点为叶结点,使他们成为nm-1个度为m-1的结点,如果叶结点不够用,则在该结点的孩子中设.此时共有1+m*nm-nm+（m-1）*（nm-1）-nm-1个叶子结点.依次类推,则树中共有1+（m*nm-nm）+（（m-1）*（nm-1）-nm-1）+…+（n2*2-n2）+（n1*1-n1）个叶子结点.

2,由四个结点a,b,c,d组成二叉树,共有多少种不同的结构请分别画出形态.

答:

//分割线

由上面8形态可以知道树深度为4的时候,树根为A时数全部形态,层次遍历A,B,C,D.

//分割线

由上面6形态可以知道树根是A,深度为3时全部形态,层次遍历为A,B,C,D.

而层次遍历有4!

种,所以整个由四个结点a,b,c,d组成二叉树,共有4!

*（8+6）=336种不同的结构.

3,已知一棵具有n个结点（每个结点的数据域为一个字符串,长度不超过5）的完全二叉树被顺序地存储于一维数组A中,试编写一个算法（程序）,打印出编号为m的结点的双亲和所有孩子.

输入:

文件名t3.in,格式如下:

A[1]~A[n]{每个字符串之间用1个空格隔开}

输出:

文件名t3.out,格式如下:

m的父结点（数据域）

m的所有孩子结点（数据域）,按照编号从小到大的顺序,每个之间用1个空格隔开.

样例输入:

OkYesNoHelloThank

样例输出:

HelloThank

答:

源程序是:

programex_tree1（input,output）;

var

array[1..100000]ofstring[5];

i,j,l:

longint;

n,m,ma:

longint;

ch:

char;

functiontwo（a:

longint）:

integer;

var

integer;

begin

=0;

ma:

=0;

while（adiv2）>0do

begin

=s+1;

ma:

=ma+（amod2）;

=adiv2;

end;

two:

=s;

end;

procedurerd;

var

integer;

begin

=0;

whilech=''doread（ch）;

repeat

ifnot（eoln）then

begin

t[i]:

=t[i]+ch;

=k+1;

read（ch）;

end;

until（ch=''）or（k=5）or（eoln）;

end;

functiontwot（a:

longint）:

longint;

var

integer;

longint;

begin

=1;

fori:

=1toado

begin

=s*2;

end;

twot:

=s;

end;

begin

assign（input,'t3.in'）;

reset（input）;

readln（n）;

ifn>100000then

begin

writeln（'Nistoobig!

N>100000'）;

=100000;

end;

read（ch）;

fori:

=1tondord;

t[n]:

=t[n]+ch;

read（m）;

close（input）;

assign（output,'t3.out'）;

rewrite（output）;

ifm=1

then

writeln（'Err'）

else

writeln（t[two（m）]）;

ifm*2>n

then

write（'Err'）

else

begin

write（t[twot（two（m）+1）+2*ma]）;

ifnot（（twot（two（m）+1）+2*ma+1）>n）

then

write（'',t[twot（two（m）+1）+2*ma+1]）;

end;

writeln;

close（output）;

end.

4,写出对二叉树进行中序遍历的非递归算法（程序）.

输入:

文件名t4.in,格式如下:

n{结点数,每个结点的编号分别为1~n}

data[1]~data[n]{数据域,data[i]均为一个大写字母}

lchild[1]~lchild[n]{n个结点的左孩子编号,没有则为0}

rchild[1]~rchild[n]{n个结点的右孩子编号,没有则为0}

输出:

文件名t4.out,格式如下:

这棵二叉树的中序遍历结果.

样例输入:

ABC

200

300

样例输出:

BAC

答:

源程序是:

programex_tree2（input,output）;

type

treetype=record

data:

char;

left:

longint;

right:

longint;

father:

longint;

written:

boolean;

end;

var

array[1..100000]oftreetype;

s,n,temp:

longint;

i,j,k:

longint;

ch:

char;

begin

assign（input,'t4.in'）;

reset（input）;

readln（n）;

fori:

=1ton-1do

begin

read（ch）;

t[i].data:

=ch;

read（ch）;

t[i].written:

=false;

end;

readln（ch）;

t[n].data:

=ch;

fori:

=1tondo

begin

read（temp）;

t[i].left:

=temp;

t[temp].father:

=i;

end;

readln;

fori:

=1tondo

begin

read（temp）;

t[i].right:

=temp;

t[temp].father:

=i;

end;

=n;

close（input）;

assign（output,'t4.out'）;

rewrite（output）;

=1;

while（t[i].left0）or（t[i].right0）doi:

=t[i].left;

whiles>0do

begin

if（t[i].left0）and（t[t[i].left].written=false）then

begin

write（t[t[i].left].data）;

ifs>1thenwrite（''）;

=s-1;

t[t[i].left].written:

=true;

end;

ift[i].written=falsethen

begin

write（t[i].data）;

ifs>1thenwrite（''）;

=s-1;

t[i].written:

=true;

end;

if（t[t[i].left].written=false）and（t[i].left0）then

=t[i].left

else

if（t[t[i].right].written=false）and（t[i].right0）then

=t[i].right

elsei:

=t[i].father;

end;

close（output）;

end.

展开阅读全文