第 1 题
一个 32 位整型变量占用(A
)个字节。
A. 4
B. 8
C. 32
D. 128
常识题,每个32 位整型变量占4个字节
第 2 题
二进制数 11.01 在十进制下是(A
)。
A. 3.25
B. 4.125
C. 6.25
D. 11.125
进制转换(答案很明显)
第3题
下面的故事与(B
)算法有着异曲同工之妙。 从前有座山,山里有座庙,庙里有个老和尚在给小和尚讲故事:“从前有座山,山里有座庙,庙里有个老和尚在给小和尚讲故事:‘从前有座山,山里有座庙,庙里有个老和尚给小和尚讲故事……’”
A. 枚举
B. 递归
C. 贪心
D. 分治
这句话一直在重复:从前有座山,山里有座庙,庙里有个老和尚在给小和尚讲故事。首先排除分治和贪心。其次我们发现他是一层一层地在重复着同一句话,所以不符合枚举的意思。只剩下递归。
第 4 题
逻辑表达式(C
)的值与变量 A 的真假无关。
A. (A ∨ B) ∧﹃A
B. (A ∨ B) ∧﹃B
C. (A ∧ B) ∨ (﹃ A ∧ B)
D. (A ∨ B) ∧﹃A ∧ B
常识题
第 5 题
将
{
2
,
6
,
10
,
17
}
\{2, 6, 10, 17\}
{2,6,10,17} 分别存储到某个地址区间为
0
∼
10
0\sim10
0∼10的哈希表中,如果哈希函数 h(x)= (D
),将不会产生冲突,其中
a
m
o
d
b
a \bmod b
amodb 表示 a 除以 b 的余数。
A.
x
m
o
d
11
x \bmod 11
xmod11
B.
x
2
m
o
d
11
x^2 \bmod 11
x2mod11
C.
(
2
x
)
m
o
d
11
(2x) \bmod 11
(2x)mod11
D.
⌊
x
⌋
m
o
d
11
\lfloor \sqrt{x} \rfloor \bmod 11
⌊x⌋mod11,其中
⌊
x
⌋
\lfloor \sqrt{x}\rfloor
⌊x⌋表示
x
\sqrt{x}
x下取整
A,B,C,D分别是4个哈希函数,题目的要求是输入为(2,6,10,17)时,哈希函数的输出各自不相同,所以判断就行了
第6题
在十六进制表示法中,字母
A
\texttt A
A 相当于十进制中的(B
)。
A. 9
B. 10
C. 15
D. 16
第 7 题
下图中所使用的数据结构是(B
)。
A. 哈希表
B. 栈
C. 队列
D. 二叉树
很明显,这道题是先进后出的,使用的是栈
第 8 题
在 Windows 资源管理器中,用鼠标右键单击一个文件时,会出现一个名为“复制”的操作选项,它的意思是(C
)。
A. 用剪切板中的文件替换该文件
B. 在该文件所在文件夹中,将该文件克隆一份
C. 将该文件复制到剪切板,并保留原文件
D. 将该文件复制到剪切板,并删除原文件
常识题
第 9 题
已知一棵二叉树有 10 个节点,则其中至多有(A
)个节点有 2 个子节点。
A. 4
B. 5
C. 6
D. 7
第 10 题
在一个无向图中,如果任意两点之间都存在路径相连,则称其为连通图。下图是一个有 4 个顶点、6 条边的连通图。若要使它不再是连通图,至少要删去其中的( C
)条边。
A. 1
B. 2
C. 3
D. 4
第 11 题
二叉树的(A
)第一个访问的节点是根节点。
A. 先序遍历
B. 中序遍历
C. 后序遍历
D. 以上都是
先序遍历:根左右;中序遍历:左根右;后序遍历:左右根
第 12 题
以
A
0
A_0
A0作为起点,对下面的无向图进行深度优先遍历时,遍历顺序不可能是(A
)
A.
A
0
,
A
1
,
A
2
,
A
3
A_0,A_1, A_2, A_3
A0,A1,A2,A3
B.
A
0
,
A
1
,
A
3
,
A
2
A_0,A_1,A_3,A_2
A0,A1,A3,A2
C.
A
0
,
A
2
,
A
1
,
A
3
A_0,A_2,A_1,A_3
A0,A2,A1,A3
D.
A
0
,
A
3
,
A
1
,
A
2
A_0,A_3,A_1,A_2
A0,A3,A1,A2
第 13 题
IPv4 协议使用 32 位地址,随着其不断被分配,地址资源日趋枯竭。因此,它正逐渐被使用(D
)位地址的IPv6协议所取代
A. 40
B. 48
C. 64
D. 128
第 14 题
(A
)的平均时间复杂度为
O
(
n
log
n
)
O(n \log n)
O(nlogn),其中 n 是待排序的元素个数。
A. 快速排序
B. 插入排序
C. 冒泡排序
D. 基数排序
第 15 题
下面是根据欧几里得算法编写的函数,它所计算的是 a 和 b 的(C
)。
int euclid(int a, int b)
{
if (b == 0)
return a;
else
return euclid(b, a % b);
}
A. 最大公共质因子
B. 最小公共质因子
C. 最大公约数
D. 最小公倍数
第 16 题
通常在搜索引擎中,对某个关键词加上双引号表示(C
)。
A. 排除关键词,不显示任何包含该关键词的结果
B. 将关键词分解,在搜索结果中必须包含其中的一部分
C. 精确搜索,只显示包含整个关键词的结果
D. 站内搜索,只显示关键词所指向网站的内容
第 17 题
中国的国家顶级域名是(A
)。
A. .cn
B. .ch
C. .chn
D. .china
想想NOI的网址
第 18 题
把 64 位非零浮点数强制转换成 32 位浮点数后,不可能(D
)。
A. 大于原数
B. 小于原数
C. 等于原数
D. 与原数符号相反
第 19 题
下列程序中,正确计算
1
,
2
,
…
,
100
1,2,\dots,100
1,2,…,100 这 100 个自然数之和
s
u
m
\mathrm{sum}
sum(初始值为 0)的是(A
)。
A. i = 1 do{ sum +=i; i++; }while(i<=100);
B. i = 1; do{ sum +=i; i++; }while(i > 100);
C. i = 1; while(i < 100){ sum+=i; i++; }
D. i = 1; while(i >= 100){ sum+=i; i++; }
第 20 题
CCF NOIP 复赛全国统一评测时使用的系统软件是(B
)。
A. NOI Windows
B. NOI Linux
C. NOI Mac OS
D. NOI DOS
第 21 题
7 个同学围坐一圈,要选 2 个不相邻的作为代表,有____14_____种不同的选法。
第 22 题
某系统自称使用了一种防窃听的方式验证用户密码。密码是 n 个数
s
1
,
s
2
.
.
.
s
n
s_1,s_2...s_n
s1,s2...sn,均为 0 或 1。该系统每次随机生成 n 个数
a
1
,
a
2
,
…
,
a
n
a_1, a_2, \dots , a_n
a1,a2,…,ana,均为 0 或 1,请用户回答
(
s
1
a
1
+
s
2
a
2
+
⋯
+
s
n
a
n
)
(s_1a_1 + s_2a_2 + \dots + s_na_n)
(s1a1+s2a2+⋯+snan)除以 2 的余数。如果多次的回答总是正确,即认为掌握密码。该系统认为,即使问答的过程被泄露,也无助于破解密码——因为用户并没有直接发送密码。
然而,事与愿违。例如,当 n =4 时,有人窃听了以下 5 次问答:
就破解出了密码s1 =___ ,s2 = ___,s3 =___ ,s4 =___
。
答案格式为:纯数字用,
连接
答案:0,1,1,1
第 23 题
阅读程序写结果:
#include <iostream>
using namespace std;
int main()
{
int a, b;
cin >> a >> b;
cout << a << "+" << b << "=" << a + b << endl;
}
输入: 3 5
答案:3+5=8
很简单,直接模拟
第 24 题
阅读程序写结果:
#include <iostream>
using namespace std;
int main()
{
int a, b, u, i, num;
cin>>a>>b>>u; num = 0;
for (i = a; i <= b; i++) if ((i % u) == 0)
num++;
cout<<num<<endl; return 0;
}
输入: 1 100 15
答案:6
就是求a到b中能被u整除的数的数量
第 25 题
阅读程序写结果:
#include <iostream>
using namespace std;
int main()
{
const int SIZE = 100;
int n, f, i, left, right, middle, a[SIZE];
cin>>n>>f;
for (i = 1; i <= n; i++)
cin>>a[i]; left = 1;
right = n;
do {
middle = (left + right) / 2;
if (f <= a[middle])
right = middle;
else
left = middle + 1;
} while (left < right);
cout<<left<<endl;
return 0;
}
输入:
12 17
2 4 6 9 11 15 17 18 19 20 21 25
答案:7
求f在a数组中的位置
第 26 题
阅读程序写结果:
#include <iostream>
using namespace std;
int main()
{
const int SIZE = 100;
int height[SIZE], num[SIZE], n, ans;
cin>>n;
for (int i = 0; i < n; i++)
{
cin>>height[i]; num[i] = 1;
for (int j = 0; j < i; j++)
{
if ((height[j] < height[i]) && (num[j] >= num[i]))
num[i] = num[j]+1;
}
}
ans = 0;
for (int i = 0; i < n; i++)
{
if (num[i] > ans) ans = num[i];
}
cout<<ans<<endl;
}
输入:
6
2 5 3 11 12 4
答案:4
第 27 题
完善程序: (序列重排)
全局数组变量 a 定义如下:
const int SIZE = 100;
int a[SIZE], n;
它记录着一个长度为 n 的序列
a
1
,
a
2
,
…
,
a
n
a_1, a_2,\dots,a_n
a1,a2,…,an。
现在需要一个函数,以整数
p
(
1
≤
p
≤
n
)
p(1\leq p\leq n)
p(1≤p≤n) 为参数,实现如下功能:将序列 a 的前 p 个数与后 n-p 个数对调,且不改变这 p 个数(或 n−p 个数)之间的相对位置。例如,长度为 5 的序列 1,2,3,4,5,当 p=2 时重排结果为 3, 4, 5, 1, 2 。
有一种朴素的算法可以实现这一需求,其时间复杂度为
O
(
n
)
O(n)
O(n)、空间复杂度为
O
(
n
)
O(n)
O(n):
void swap1( int p )
{
int i, j, b[SIZE];
for ( i = 1; i <= p; i++ )
b[①] = a[i]; // (3分)
for ( i = p + 1; i <= n; i++ )
b[i - p] = ②; // (3分)
for ( i = 1; i <= ③; i++ ) // (2分)
a[i] = b[i];
}
我们也可以用时间换空间,使用时间复杂度为 O ( n 2 ) O(n^2) O(n2)、空间复杂度为 O ( 1 ) O(1) O(1) 的算法:
void swap2( int p )
{
int i, j, temp;
for ( i = p + 1; i <= n; i++ )
{
temp = a[i];
for ( j = i; j >= ④; j-- ) // ( 3 分)
a[j] = a[j - 1];
⑤ = temp; // ( 3 分)
}
}
答案:
n –p + i
a[i]
n
i -p + 1
a[i-p]
第 28 题
完善程序:
(二叉查找树) 二叉查找树具有如下性质: 每个节点的值都大于其左子树上所有节点的值、小于其右子树上所有节点的值。试判断一棵树是否为二叉查找树。
输入的第一行包含一个整数 n,表示这棵树有 n 个顶点, 编号分别为
1
,
2
,
…
,
n
1, 2, \dots , n
1,2,…,n,其中编号为 1 的为根结点。之后的第 i 行有三个数
v
a
l
u
e
,
l
e
f
t
_
c
h
i
l
d
,
r
i
g
h
t
_
c
h
i
l
d
\mathrm{value},\mathrm{left\_child},\mathrm{right\_child}
value,left_child,right_child,分别表示该节点关键字的值、左子节点的编号、右子节点的编号;如果不存在左子节点或右子节点,则用 0 代替。输出 1 表示这棵树是二叉查找树,输出 0 则表示不是。
#include <iostream>
using namespace std;
const int SIZE = 100;
const int INFINITE = 1000000;
struct node
{
int left_child, right_child, value;
}; node a[SIZE];
int is_bst( int root, int lower_bound, int upper_bound )
{
int cur;
if ( root == 0 )
return(1);
cur = a[root].value;
if ( (cur > lower_bound) && ( ① ) && (is_bst( a[root].left_child, lower_bound, cur ) == 1) && (is_bst( ②, ③, ④ ) == 1) )
return(1);
return(0);
}
int main()
{
int i, n; cin >> n;
for ( i = 1; i <= n; i++ )
cin >> a[i].value >> a[i].left_child >> a[i].right_child;
cout << is_bst( ⑤, -INFINITE, INFINITE ) << endl;
return(0);
}
答案:
cur<upper_bound
a[root].right_child
cur
upper_bound
1
(最后那道题好难)