计算机科学(论文1：理论)
(最高分数：70)
(允许时间：三个小时)
(候选人只能再阅读15分钟才能阅读论文。在此期间，他们不得开始写作。)
回答第一部分(必修)中的所有问题和第二部分中的六个问题，从A部分中选择两个问题，从B部分中选择两个问题，从C部分中选择两个问题。所有的工作，包括粗略的工作，都应与答案的其余部分在同一张纸上进行。问题或部分问题的预期标记在方括号[]中。
第一部分(20分)
回答所有问题。
在回答本部分中的问题时，请在任何需要的地方简要说明您的工作和推理。
1(a)陈述由以下命题表示的法律，并借助真值表进行证明：PVP = P [1]
法律：幂等法。它指出P v P =P。
P P P V P
0 0 0
1 1 1
(b)陈述对偶原则。 [1]
对偶原理指出，每个布尔方程都存在另一个方程，该方程对原始方程是对偶的。为此，将AND(。)转换为OR(+)，反之亦然，0转换为l，反之亦然，但是补码保持不变。
(c)使用De Morgan定律找到以下布尔表达式的补码：F(a，b，c)=(b’+ c)+ a [1]
的补充：F(a，b，c)=(b’+ c)+ a
=(b’+ c)’。一种’
= b”。 C’。 a’= bc’.a’
(d)绘制2输入XNOR门的逻辑图和真值表。 [1]
A B X
0 0 1
0 1 0
1 0 0
1 1 1 (e)如果(P’=> Q)，则写出：[1]
一种。逆：(P => Q)OR P’+ Q’
b。相反：(Q => P)OR Q’+ P’
2(a)什么是接口?与班级有何不同? [2]
(a)接口是非原始数据类型，具有静态和最终数据成员以及函数原型(即，函数未定义)
接口和类之间的区别：接口支持多重继承，而类不支持多重继承。
(b)将以下中缀表达式转换为后缀形式：P * Q / R +(S + T)[2]
(b) Infix to postfix :
P*Q/R+(S+T)
= P*Q/R+ ST+
= PQ* /R + ST+
= PQ*R/ + ST+
= PQ*R/ST++ (c)存储矩阵P [15] [10]，每个元素需要存储8个字节。如果P [0] [0]的基地址为1400，则当矩阵存储在Row Major Wise中时，确定P [10] [7]的地址。 [2]
(c)大行明智：P [i] [j] = BA + W [(i-lr)*栏+(j-lc]
= 1400 + 8 [(10-0)* 10 +(7-0)]
= 1400 + 856
P [10] [7] = 2256
(d)(i)以下代码段的最坏情况复杂度是多少：[2]
for (int x = 1; x <= a; x++) {
statements;
}
for (int y = 1; y <= b; y++) {
for (int z = 1; z <= c; z++) {
statements;
}
}
= O(a)+ O(bxc)
= O(a + bc)
(ii)如果所有三个循环都变为N而不是a，b和c，那么复杂度将如何变化?
= O(N)+ O(N 2 )
= O(N 2 )，采用主导项。
(e)区分构造函数和类的方法。 [2]
(e)构造函数具有与类相同的名称，而方法具有不同的名称。没有返回类型，在构造函数中甚至没有void，因为在方法中它可以返回值
3.以下函数magicfun()是某些类的一部分。当n = 7和n = 10时，magicfun()函数将返回什么?显示空运行/工作：[5]
int magicfun(int n)
{
if (n = = 0)
return 0;
else
return magicfun(n / 2) * 10 + (n % 2);
}
(i)当n = 7时
OUTPUT : magicfun(7)
magicfun(3) * 10 + 1
magicfun(1) *10 + 1
magic fun(0) *10 + 1 = 111(ii)当n = 10时
OUTPUT : magicfun(10)
magicfun(5) * 10 + 0
magicfun(2) *10 + 1
magicfun(1) *10 + 0
magicfun(0) *10 + 1 = 1010第二部分(50分)
回答六个问题，从A节中选择两个问题，从B节中选择两个，从C节中选择两个。
部分– A (回答任何两个问题)
4(a)给定布尔函数F(A，B，C，D)= R(2、3、4、5、6、7、8、10、11)。
(i)通过使用4变量卡诺图来简化上述表达式，显示各个组(即八进制，四边形和对)。 [4]
四边形1：(M2 + M3 + M10，M11)= B’C
四边形2：(M4，M5，M6，M7)= A’B
四元组3：(M8，M10)= AB’D’
因此F(A，B，C，D)= B’C + A’B + AB’D’
(ii)画出简化表达式的逻辑门图。假定变量及其补码可用作输入。 [1]
(b)给定布尔函数F(P，Q，R，S)= R(0，1，2，4，5，6，8，8，10)。
四极杆1：(M0，M1，M4，M5)= Q + S
四极杆2：(M0，M2，M4，M6)= P + S
四元组3：(M0，M2，M8，M10)= P + R
因此，F(P，Q，R，S)＝(P + R)。 (P + S)。 (Q + S)
(i)通过使用4变量卡诺图来简化上述表达式，显示各个组(即八进制，四边形和对)。 [4]
(ii)绘制简化表达式的逻辑门图。假定变量及其补码可用作输入。 [1]
5(a)学校打算根据以下标准选择校际作文比赛的候选人：
该学生参加了较早的比赛，并且很有创造力。
或者
该学生非常有创造力，并且具有出色的一般意识，但是之前没有参加过任何比赛。
或者
该学生具有出色的一般意识，并在内部竞赛中获奖。
输入是：
输入
A较早参加比赛
B很有创造力
C在一次内部竞赛中获得了大奖
D具有良好的一般意识
输出：X [1表示是，0表示否”
画出上面给出的输入和输出的真值表，并写出X(A，B，C，D)的POS表达式。 [5]
A B C D X (OUTPUT)
0 0 0 0 0
0 0 0 1 0
0 0 1 0 0
0 0 1 1 1
0 1 0 0 0
0 1 0 1 1
0 1 1 0 0
0 1 1 1 1
1 0 0 0 0
1 0 0 1 0
1 0 1 0 0
1 0 1 1 1
1 1 0 0 1
1 1 0 1 1
1 1 1 0 1
1 1 1 1 1
POS表达式：X(A，B，C，D)= R(0，1，2，4，4，6，8，9，10)
(b)说明半加法器的应用。画出真值表和半加法器的电路图。 [3]
Half Adder的应用是执行两位的部分加法。
半加器真值表：
A B Sum CARRY
0 0 0 0
0 1 1 0
1 0 1 0
1 1 0 1(c)将以下布尔表达式转换为其规范的POS形式：F(A，B，C)=(B + C’)·(A’+ B)[2]
转换为标准格式：F(A，B，C)
=(B + C’)。(A’+ B)
=(B + C’+ 0)。 (A’+ B + O)
=(B + C’+(AA’))。(A’+ B +(CC’))[xx’= 0]
=(A + B + C’)。(A’+ B + C’)。(A’+ B + C)
6(a)什么是多路复用器?与解码器有何不同?绘制8：1多路复用器的电路图。 [5]
(a)复用器是输入并行数据并输出一个串行数据的组合电路，其中，解码器是输入n行并输出2n或更少行的组合电路。
8：1多路复用器的电路图：
(b)使用布尔定律证明布尔表达式。另外，请提及在每个步骤中使用的法律。 F =(x’+ z)+ [(y’+ z)•(x’+ y)]’= 1 [3]
F =(x’+ z)+ [(y’+ z)。(x’+ y)] = 1
=(x’+ z)+(y’+ z)’+(x’+ y)’ (De Morgan Law)
= x’+ z + yz’+ xy’
=(x’+ x)(x’+ y’)+(z + z’)(z + y)= x’+ y’+ z + y(分配律)
= 1 (当y + y’= 1)(恒等律)
(c)定义最大项和最小项。在以下情况下找到最大值和最小值：P = 0，Q = 1，R = 1和S = 0 [2]
Maxterm：它是所有字面量的总和。
名词：它是所有字面量的产物。
当P = 0，Q = 1，R = 1，S = 0
最大值= P + Q’+ R’+ S
最小项= P’QR S’
B节
回答任何两个问题。每个程序的编写方式都应清楚地描述问题的逻辑。这可以通过在程序中使用助记符名称和注释来实现。 (不需要流程图和算法。)程序必须用Java编写。
7.已经定义了佩林类别，以检查正数是否是回文数。
如果原始数字及其反数相同，则数字“ N”为回文。
该班的一些成员如下：[10]
班级名称：佩林
数据成员/实例变量：
num：用于存储数字的整数
revnum：用于存储数字倒数的整数
方法/成员函数：
P alin()：用于初始化数据成员的构造函数
合法初始值
void accept()：接受数字
int reverse(int y)：反转参数化的参数“ y”，并使用递归技术将其存储在“ revnum”中
void check()：通过调用函数reverse()来检查数字是否为回文，并显示结果并显示适当的消息
指定类Palin，以提供构造函数()的详细信息，void accept()，int reverse(int)和void check()的详细信息。定义main()函数以创建对象，并相应地调用函数以启用任务。
import java.util.*;
public class Palin {
int num, revnum;
static Scanner x = new Scanner(System.in);
Palin()
num = 0;
revnum = 0;
}
void accept()
System.out.println("Enter a number");
num = x.nextlntO;
}
int reverse(int y)
{
if (y > 0)
revnum = revnum * 10 + y % 10;
return reverse(y / 10);
}
else return revnum;
}
void check()
{
int p = num;
if (num == reverse(p))
System.out.println("palindrome");
else
System.out.println("not a palindrome");
}
static void main()
{
Palin obj = new Palin();
obj.accept();
obj.check();
}
8.定义了一个加法器类来添加任何两个接受的时间。 [10]
示例：时间A – 6小时35分钟
时间B – 7小时45分钟
他们的总和是– 14小时20分钟(其中60分钟= 1小时)
该类成员的详细信息如下：
类名称：加法器
数据成员/实例变量：
a []：包含两个元素的整数数组(小时和
分钟)
成员函数/方法：
Adder()：向数组元素分配0的构造函数
void readtime()：输入数组的元素
void addtime(加法器X，加法器Y)：将两个参数化对象X和Y的时间相加，并将和存储在当前调用对象中
void disptime()：显示带有适当消息的数组元素(例如，小时=和分钟=)
指定Adder类，以提供构造函数()的详细信息，void readtime()，void addtime(Adder，Adder)和void disptime()。定义main()函数来创建对象，并相应地调用函数以启用任务。
import java.util.*;
public class Adder {
int a[] = new int[2];
static Scanner x = new Scanner(System.in);
Adder()
{
a[0] = 0;
a[1] = 0;
}
void readtime()
System.out.println("Enter hours and minutes");
a[0] = x.nextInt();
a[1] = x.nextInt();
void disptime()
{
System.out.println("Hours=" + a[0]);
System.out.println("Minutes=" + a[1]);
}
void addtime(Adder X, Adder Y)
{
a[1] = X.a[1] + Y.a[1];
a[0] = a[1] / 60;
a[1] = a[1] % 60;
a[0] += X.a[0] + Y.a[0];
}
static void main()
{
Adder a = new Adder();
Adder b = new Adder();
Adder c = new Adder();
a.readtimeO;
b.readtimeO;
c.addtime(a, b);
c.disptime();
9.已经定义了SwapSort类，以对单词输入执行与字符串相关的操作。 [10]
该类的一些成员如下：
类名称：SwapSort
数据成员/实例变量：
wrd：存储一个单词
len：整数，用于存储单词的长度
swapwrd：存储交换的单词
sortwrd：存储排序的单词
成员函数/方法：
SwapSort()：默认构造函数，用于使用合法的初始值初始化数据成员
void readword()：接受大写形式的单词
void swapchar()：交换/交换“ wrd”中单词的第一个和最后一个字符，并将新单词存储在“ swapwrd”中
void sortword()：按字母顺序对原始单词的字符进行排序，并将其存储在“ sortwrd”中
void display()：显示原始单词，交换单词和排序的单词
指定类SwapSort，提供构造函数()，无效readword()，无效swapchar()，无效sortword()和无效display()的详细信息。定义main()函数以创建对象，并相应地调用函数以启用任务。
import java.util.*;
public class SwapSort {
String wrd, swapwrd, sortwrd;
int len;
static Scanner x = new Scanner(System.in);
SwapSort()
{
swapvvrd = "";
sortwrd = "";
}
void readword()
{
System.out.println("Enter word in Upper case");
wrd = x.nextO;
len = wrd.lengthO;
}
void swapchar()
swapwrd = wrd.charAt(len - 1) + wrd.sub strin g(1, len - 1)
+ wrd.charAt(0);
}
void sortword()
{
char c;
for (int i = 65; i <= 90; i++)
for (int j = 0; j < len; j++)
c = wrd.charAt(j);
if (c == i)
sortwrd += c;
}
}
}
void display()
{
System.out.println("Original word = " + wrd);
System.out.println("Swapped word = " + swapwrd);
System.out.println(" Sorted word = " + sortwrd);
}
static void main()
SwapSort x = new SwapSort();
x.readwordO;
x.swapchar();
x.sortword();
x.display();
}
C节
回答任何两个问题。
每个程序的编写方式都应清楚地描述问题的逻辑
明智地。这可以通过在程序中使用注释以及助记符名称或算法的伪代码来实现。程序必须用Java编写，并且算法必须以通用/标准形式编写，无论需要/指定在何处。 (不需要流程图。)
10.定义了一个超类产品来存储批发商出售给零售商的产品的详细信息。定义一个子类别“销售”以计算零售商在有或没有罚款以及服务税的情况下支付的总金额。 [5]
这两个类的一些成员如下：
类别名称：产品
数据成员/实例变量：
名称：存储产品名称
code：存储产品代码的整数
金额：存储产品的总销售金额(以十进制表示)
成员函数/方法：
Product(String n，int c，double p)：参数化的构造函数，用于分配数据成员名称= n，代码= c和数量= p
show()：显示数据成员的详细信息
类别名称：销售
数据成员/实例变量：
天：商店支付销售金额所需的天数
tax：存储服务税(十进制)
totamt：存储总量(十进制)
成员函数/方法：
Sales(…)：参数化的构造函数，用于将值分配给两个类的数据成员
void compute()：仅当零售商支付给批发商的金额超过30天时，才以实际销售额的12·4％计算服务税，才算为实际销售额的2·5％的罚款。零售商支付的金额(实际销售额+服务税+罚款)
show()：显示超类的数据成员和总数
假设已经定义了超类Product。使用继承的概念，指定Sales类，以提供构造函数(…)，void compute()和show()的详细信息。
无需编写超类，主要函数和算法。
public class Sales extends Product {
int day;
double tax, totamt;
Sales(String n, int a, double b, int d)
{
super(n, a, b);
day = d;
}
void compute()
{
double f = 0.0;
tax = (12.4 / 100) * amount;
if (day > 27)
f = (2.5 / 100) * amount;
totamt = amount + tax + f;
void show()
{
super.show();
System.out.println("No of days=" + day);
System.out.println("Sales Tax=" + tax);
System.out.println("Total Amount=" + totamt);
11.队列是一个最多可容纳100个整数的实体。队列使用户可以从后面添加整数，从前面删除整数。用以下详细信息定义一个类队列：[5]
类名：队列
数据成员/实例变量：
Que []：保存整数元素的数组
size：存储数组的大小
front：指向前面的索引
后方：指向后方的索引
成员功能：
队列(int mm)构造函数来初始化数据
尺寸=毫米，正面= 0，背面= 0
void addele(int v)：如果可能，从后面添加整数
否则显示消息“溢出”
int delele()：如果存在则从前面返回元素，否则显示消息“ Underflow”并返回-9999
void display()：显示数组元素
指定Queue类，仅提供仅函数void addele(int)和int delele()的详细信息。假设已经定义了其他功能。主要函数和算法无需编写。
public class Queue {
int Quen = new int[100];
int max, f, r;
void addele(int v) if (r < max - 1)
Que[+ - Fr]
= v;
else System.out.println("Overflow");
}
int delele() if (f != r) return Que[++f];
else return -9999;
12(a)由类Node的对象形成一个链表。的类结构
节点如下：
类节点
{
整数
节点下一个；
}
编写算法或方法以对现有链接列表中仅包含奇数整数的节点进行计数并返回计数。方法声明如下：
int CountOdd(Node startPtr)[2]
(a)算法：
步骤1.开始
步骤2.设置指向第一个节点的临时指针
步骤3.重复步骤4和5，直到指针达到空值为止。返回计数步骤4.检查奇数并递增计数器。
步骤5.将指针移到下一个节点
步骤6.结束
方法：
int CountOdd(Node startPtr)
{
int c = 0;
Node temp = new Node(startPtr);
while (temp != null) {
if (temp.num % 2 != 0)
c++;
temp = temp.next;
return c;
(b)从下面给出的二叉树图中回答以下问题：
(i)编写上述树形结构的后序遍历。 [1]
妇产科
(ii)如果根为0(零)级别，则说明节点N和R的级别编号。 [1]
N = 1的水平，R = 3的水平
(iii)列出右子树的内部节点。 [1]
G和Z