单选题

1.关于CPU下面哪个说法是正确的?

[A]CPU全称为中央控制器

[B]CPU能直接运行机器语言

[C]CPU最早是由Intel公司发明的

[D]同样主频下,32位CPU比16位快一倍

解析过程
  • [A] CPU全称为中央控制器‌：‌错误‌。CPU的全称是中央处理单元（Central Processing Unit），而不是中央控制器。中央控制器（Control Unit）是CPU的一部分，负责指令的解码和执行控制，但CPU整体包括运算器（ALU）、寄存器、缓存等组件。
  • [B] CPU能直接运行机器语言‌：‌正确‌。机器语言是CPU能直接理解和执行的二进制指令集（由0和1组成），CPU的硬件设计就是基于这些指令集运作的。高级语言（如C++、Python）编写的程序需要先编译或解释成机器语言，才能被CPU执行。
  • [C] CPU最早是由Intel公司发明的‌：‌错误‌。CPU的概念并非由Intel发明。现代CPU的架构基础源于冯·诺依曼（John von Neumann）在1945年提出的“存储程序”概念（如EDVAC设计），而早期电子计算机如ENIAC（1946年）已有类似CPU的处理单元。Intel在1971年推出了第一个商用微处理器Intel 4004，这是第一个单芯片CPU，但CPU的发明应归功于更早的计算机先驱（如Konrad Zuse、John Mauchly等）。
  • [D] 同样主频下,32位CPU比16位CPU快一倍‌：‌错误‌。这个说法过于简化，不准确。主频（时钟频率，单位Hz）表示CPU每秒的时钟周期数，但位宽（如16位或32位）指的是CPU一次能处理的数据位数（如寄存器大小或数据总线宽度）。在相同主频下：32位CPU可能在某些任务上更快，例如处理32位整数运算时，它一次即可完成，而16位CPU需要两次操作（先处理低16位，再处理高16位）。然而，性能差异并非固定“一倍”。速度受多种因素影响，包括指令集架构（ISA）、流水线设计、缓存大小、内存带宽等。对于16位数据或简单任务，两者性能可能接近；对于复杂或并行任务，32位CPU的优势可能更明显，但绝不是简单的倍数关系。

2.若二叉树的高度为n,其根节点高度为0,则其节点数一定可以为（ ）个。

[A]n

[B]n*n*n

[C]2^n

[D]n!

解析过程
  • [A] n‌n‌：最小节点数为n+1，n小于n+1，不可能。
  • [B] n∗n∗n‌n*n*n‌：例如n=2时，最小节点数3，最大节点数7，而n³=8>7，不可能。
  • [C] 2n‌2ⁿ‌：当n=1时，高度为1的二叉树，最大节点数为2(1+1)−1=32^{(1+1)}-1=3，21=22¹=2在[2,3]范围内（如根节点有一个左孩子或右孩子，共2个节点）；n=2时，最大节点数7，22=42²=4在[3,7]范围内（如根节点左子树2个节点，右子树1个节点）。因此2n2ⁿ一定可以是节点数。
  • [D] n!‌n!‌：n=3时，n!=6，高度为3的二叉树最小节点数4，最大节点数15，6在范围内；但n=4时，n!=24，最大节点数31，24在范围内，然而n=1时n!=1，最小节点数2，1不可能，因此n!不总是可行。
知识点

二叉树的高度与节点数的关系。高度为n（根节点高度为0）的二叉树，节点数的范围是[n+1, 2(n+1)2^{(n+1)}-1]。其中：

  • 最小节点数：当二叉树为单链结构（每个节点只有左孩子或只有右孩子）时，节点数为n+1（从高度0到高度n共n+1层，每层1个节点）。
  • 最大节点数：当二叉树为满二叉树时，节点数为2(n+1)−12^{(n+1)}-1（每层节点数为2h2^h，h从0到n累加）。

3.设待排序的记录为（49，38，65，97，76， 13，27 , 48, 55, 4）,每次可以交换任意两个数字，则需要交换（ ）次使得序列元素可以从小到大有序。

[A]5

[B]8

[C]9

[D]10

解析过程

......

这也只好自己模拟，但是本题实际只需8次交换(我也想到了)，但题目要求可能为"最多交换次数"指所有可能初始序列中最少交换次数的最大值（理论最坏情况），因此选C.9次。

程序题

1.

#include <cmath>
#include <cstdio>
int a1[1001];
int i, j, t, t2, n;
int main() {
    scanf("%d", &n);
    for (i = 2; i <= sqrt(n); i++) {
        if (a1[i] == 0)
        {
            t2 = n / i;
            for (j = 2; j <= t2; j++)
                a1[i * j] = 1;
        }
    }
    t = 0;
    for (i = 2; i <= n; i++)
        if (a1[i] == 0)
        {
            printf("%d", i);
            t++;
            if (t % 10 == 0)
                printf("\n");
        }
    printf("\n");
    return 0;
}
  • 若将第16行的”i=2”改为”i=1”,程序结果会发生变化()

[A]√

[B]×

若改为i=1，则外层循环从i=1开始。但1‌不是质数‌，且$1×j(j≥2)$是所有数的因数。这会导致：内层循环标记$a1[1×j]=1$（即所有a1[j]被标记为合数）。后续统计质数时，$a1[2],a1[3],…,a1[n]$均被标记为合数，无法正确统计质数。因此，程序结果‌会发生变化‌，选A。
  • 若去掉第8行的if语句及其括号（不去掉大括号内语句）,程序结果会发生变化()

[A]√

[B]×

合数的倍数已被其质因数提前标记：例如i=4 时，其倍数（如8、12）已在i=2 的迭代中被标记为合数。额外的标记操作不会改变数组状态
  • 若程序最终t的值为25,则n的输入可以有()种方案。

[A]1

[B]2

[C]3

[D]4

当n=98,99,100时，t仍为25（98,99,100均不是质数，不影响前25个质数的统计）。因此，n的输入方案有4种（97,98,99,100），选D。

2.

#include  <ctype.h>
#include  <stdio.h>
void expand(char s1[], char s2[])
{
    int i, j, a, b, c;
    j = 0;
    for (i = 0; (c = s1[i]) != '\0'; i++)
        if(c == '-')
        {
            a = s1[i - 1]; b = s1[i + 1];
            if (isalpha(a) && isalpha(b) || isdigit(a) && isdigit(b))
            {
                j--;
                do
                    s2[j++] = a++;
                while (tolower(a) < tolower(s1[i + 1]) && isalpha(a));
            }
            else s2[j++] = c;
        } else s2[j++] = c;
    s2[j] = '\0';
}
int main()
{
    char s1[100], s2[300];
    gets(s1);
    expand(s1, s2);
    printf("%s\n", s2);
}
  • 若输入的字符串不包含“－”号，则输出的字符串和输入相同。

[A]√

[B]×

代码中当字符不是'-'时，会直接将s1的字符复制到s2（else s2[j++] = c），所以没有'-'时输出与输入相同。
  • 若存在一个字符，只存在于s2字符串中而不存在于s1字符串中，则s1字符串中一 定存在“－”号。

[A]√

[B]×

代码中只有当遇到'-'时才会扩展生成新字符（do s2[j++] = a++），所以s2中出现s1没有的字符必然是因为s1中有'-'触发了扩展。代码中只有当遇到'-'时才会扩展生成新字符（do s2[j++] = a++），所以s2中出现s1没有的字符必然是因为s1中有'-'触发了扩展。

填空题

在一个2k∗2k2^k∗2^k个方格组成的棋盘中恰有一个方格与其他方格不同（如图中标记为－1的方格），称之为特殊方格。现用L形（占3个小方格）纸片覆盖棋盘上除特殊方格的所有部分，各纸片不得重叠，于是，用到的纸片数恰好是(4k−1)/3(4^k−1)/3。在下面给出的覆盖方案例子中，k=2,相同的3个数字构成一个纸片。下面给出的程序使用分治法设计的，将棋盘一分为四，依次处理左上角、右上角、左下角、右下角，递归进行。 请将程序补充完整。 例：

2 3
2 -1 1 3
4 1 5
4 5

－1为特殊方格的位置，其他数字表示L形方格放置的顺序。

题目描述

#include <bits/stdc++.h>
using namespace std;
int board[65][65], tile; /* tile为纸片编号 */
void chessboard(int tr, int tc, int dr, int dc, int size)
/* dr,dc依次为特殊方格的行、列号 */
{
    int t, s;
    if (size == 1)
        return;
    t = tile++;
    s = size / 2;
    if (①)
        chessboard(tr, tc, dr, dc, s);
    else{
        board[tr + s - 1][tc + s - 1] = t;
        ②;
    }
    if (dr < tr + s && dc >= tc + s)
        chessboard(tr, tc + s, dr, dc, s);
    else {
        board[tr + s - 1][tc + s] = t;
        ③;
    }
    if (dr >= tr + s && dc < tc + s)
        chessboard(tr + s, tc, dr, dc, s);
    else {
        board[tr + s][tc + s - 1] = t;
        ④;
    }
    if (dr >= tr + s && dc >= tc + s)
        chessboard(tr + s, tc + s, dr, dc, s);
    else {
        board[tr + s][tc + s] = t;
        ⑤; }
}
void prt1(int b[][65], int n)
{
    int i, j;
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
            cout << setw(3) << b[i][j];
        cout << endl;
    }
}
void main()
{
    int size, dr, dc;
    cout << "input size(4/8/16/64):" << endl;
    cin >> size;
    cout << "input the position of special block(x,y):" << end1;
    cin >> dr >> dc;
    board[dr][dc] = -1;
    tile++;
    chessboard(1, 1, dr, dc, size);
    prt1(board, size);
}

[①]dr < tr + s && dc < tc + s‌

原因：检查特殊方格是否在左上象限。如果是，则递归处理这个象限。

[②]chessboard(tr, tc, tr + s - 1, tc + s - 1, s)‌

原因：如果特殊方格不在左上象限，则在中心位置放置一个L型骨牌（用当前tile编号标记），并将这个位置作为新的特殊方格递归处理左上象限。

[③]chessboard(tr, tc + s, tr + s - 1, tc + s, s)‌

原因：处理右上象限，同上逻辑，在中心位置放置骨牌后递归。

[④]chessboard(tr + s, tc, tr + s, tc + s - 1, s)‌

原因：处理左下象限，同上逻辑。

[⑤]chessboard(tr + s, tc + s, tr + s, tc + s, s)‌

原因：处理右下象限，同上逻辑。
  1. Language
  2. 兼容模式
  3. 主题
  3. Worker 0, 17ms
  4. Powered by Hydro v5.0.0-beta.13 Community