#3725. 普及组 CSP-J 第 2 套初赛模拟试题

普及组 CSP-J 第 2 套初赛模拟试题

一、单项选择题（共 15 题，每题 2 分，共计 30 分；每题有且仅有一个正确选项）

1. 以下不是属于国家级域名的是（ ）{{ select(1-1) }}

  • .au
  • .cn
  • .com
  • .jp

2. 2 个 10 进制数 1111 和 1010 的异或运算结果的 10 进制表示是（ ）{{ select(1-2) }}

  • 101
  • 3
  • 1957
  • 5

3. 8 位二进制数中去掉符号位，最大能表示多少字符（ ）{{ select(1-3) }}

  • 127
  • 128
  • 255
  • 256

4. 在写递归函数时，哪些定义一般不写在递归函数中？（ ）{{ select(1-4) }}

  • int
  • float
  • double
  • 数组

5. 一棵完全二叉树，共有 1234 个节点，其叶子结点的个数为（ ）{{ select(1-5) }}

  • 615
  • 616
  • 617
  • 210

6. 某公司派赵钱孙李周五人出国学习，选派条件是：
a. 若赵去，钱也去；
b. 李、周两人必有一人去；
c. 若周去，则赵、钱也同去；
d. 孙、李二人同去或同不去；
如何选他们出国？（ ）{{ select(1-6) }}

  • 孙赵周去
  • 赵钱周去
  • 李周孙去
  • 钱孙去

7. 已知一棵二叉树前序遍历为 ABCDEFGI，后序遍历为 CEDBIGFA，则其中序遍历可能为（ ）{{ select(1-7) }}

  • ABCDEFGI
  • CBEDAFIG
  • CBDEAGFI
  • CBEDAIFG

8. 8 颗子弹，编号为 1,2,3,4,5,6,7,8，从编号 1 开始按序嵌入弹夹，以下不是正常的打出子弹的次序的是（ ）{{ select(1-8) }}

  • 12345678
  • 87654321
  • 32154876
  • 32164587

9. 已知循环队列空间为 30，队头位置编号为 12，队尾元素下一个空位置编号为 5，则队伍中元素个数为（ ）{{ select(1-9) }}

  • 22
  • 23
  • 7
  • 8

10. 甲箱中有 200 个螺杆，其中有 160 个 A 型螺杆；乙箱中有 240 个螺母，其中有 180 个 A 型的。现从甲乙两箱中各任取一个，则能配成 A 型螺栓的概率为多少？（ ）{{ select(1-10) }}

  • 1/20
  • 19/20
  • 3/5
  • 15/16

11. 今年信息学进复赛的同学有 6 人，老师将他们排成一圈分发奖品，一共有（ ）种排法。（ ）{{ select(1-11) }}

  • 60
  • 120
  • 180
  • 240

12. 设二维数组 A 的行下标为 0 至 5，列下标为 1 至 5，F 的每个数据元素均占 2 个字节。在按行存贮的情况下，已知数据元素 A[3][3] 的第一个字节是 2019，则 A[4][4] 的第一个字节的地址为（ ）{{ select(1-12) }}

  • 2029
  • 2025
  • 2027
  • 2031

13. 在下图中，有（ ）个顶点出发存在一条路径可以遍历图中的每条边，而且仅遍历一次。

第 13 题图

符合要求的顶点个数为（ ）{{ select(1-13) }}

  • 6
  • 2
  • 3
  • 4

14. 有 A,B,C,D,E,F 六个绝顶聪明又势均力敌的盗墓贼，他们都排着队，他们每个人都想独吞财宝，最前面的 A 如果拿了财宝，那么体力下降，则其后面的 B 会杀掉 A，拿了财宝，当然 B 拿了财宝，体力也会下降，一样会被 C 杀掉，如果 B 不拿财宝，则 C 无法杀 B，若每个人杀人必拿财宝，且优先保命，请问 A、C、E 的最终想法是（ ）{{ select(1-14) }}

  • A 不拿 C 不拿 E 拿
  • A 拿 C 拿 E 不拿
  • A 不拿 C 不拿 E 不拿
  • A 不拿 C 拿 E 拿

15. 以下不属于应用层的是（ ）{{ select(1-15) }}

  • HTTP
  • FTP
  • TELNET
  • UDP

二、阅读程序（程序输入不超过数组或字符串定义的范围；除特殊说明外，判断题每题 1.5 分，选择题每题 3 分，共计 40 分）

（一）

#include<bits/stdc++.h>
using namespace std;
int main(){
    string s;
    char s1[100];
    int len,j=0;
    cin>>s;
    len=s.size();
    memset(s1,0,sizeof(s1));
    for(int i=0;i<len;i++){
        if(i%2==0)
            if((s[i]>='A'&&s[i]<'Z')||(s[i]>='a'&&s[i]<'z')){
                s1[j]=s[i]+1;
                ++j;
            }
    }
    cout<<s1<<endl;
    return 0;
}

判断题

16. 输出的字符串只能是字母组成。（ ）{{ dropdown(2-1)[√, ×] }}

17. 若将 12 行的“<”改为“<=”，则输出结果有可能包含数字。（ ）{{ dropdown(2-2)[√, ×] }}

18. 将第 9 行删除，程序运行结果不会改变。（ ）{{ dropdown(2-3)[√, ×] }}

19. 若将 11 行删除，则输出字符的长度和输入字符的长度一致。（ ）{{ dropdown(2-4)[√, ×] }}

选择题

20. 若输入的字符串长度为 10，则输出的字符串长度最长可能为（ ）{{ select(2-5) }}

  • 4
  • 5
  • 6
  • 10

21. 若输入的字符串都是字母，则输出中可能出现（ ）{{ select(2-6) }}（4 分）

  • A
  • Z
  • a
  • 以上都不对

（二）

#include<bits/stdc++.h>
using namespace std;
int main() {
    int a[1001],i,j,t,n;
    for(i=0;i<=1000;i++)
        a[i]=0;
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        scanf("%d",&t);
        a[t]++;
    }
    for(i=1000;i>=0;i--)
        for(j=1;j<=a[i];j++)
            printf("%d ",i);
    return 0;
}

判断题

22. 输入 10 个数字，输出结果是从小到大。（ ）{{ dropdown(2-7)[√, ×] }}

23. 若输入的数字中有两个 1，则输出时出来第一个 1 是第一个输入的。（ ）{{ dropdown(2-8)[√, ×] }}

24. 若将第 13 行的“<=”改为“<”，且输入数据为 10 2 12 33 34 1 2 87 22 9 0，则输出 2。（ ）{{ dropdown(2-9)[√, ×] }}（2 分）

25. 若将第 12 行改为 for(i=0;i<=1000;i++)，则程序运行结果不变。（ ）{{ dropdown(2-10)[√, ×] }}（2 分）

选择题

26. 若将第 12 行改为 for(i=1000;i>1;i--)；第 13 行改为 for(j=a[i];j>1;j--)，输入数据为 5 2 12 33 34 44，则运行结果（ ）{{ select(2-11) }}

  • 不变
  • 输出 2 12 33 34 44
  • 无输出
  • 输出 44 34 33 12 2

27. 若将第 10 行改为 ++a[t] 或 a[t++]，则输入 5 1 2 3 4 5，输出结果为（ ）{{ select(2-12) }}（4 分）

  • 1 2 3 4 5 或 5 4 3 2 1
  • 1 2 3 4 5 或无输出
  • 5 4 3 2 1 或 5 4 3 2 1
  • 5 4 3 2 1 或无输出

（三）

#include<bits/stdc++.h>
using namespace std;
const int maxn=500000,INF=0x3f3f3f3f;
int L[maxn/2+2],R[maxn/2+2];
void unknown(int a[],int n,int left,int mid,int right) {
    int n1=mid-left,n2=right-mid;
    for(int i=0;i<n1;i++)
        L[i]=a[left+i];
    for(int i=0;i<n2;i++)
        R[i]=a[mid+i];
    L[n1]=R[n2]=INF;
    int i=0,j=0;
    for(int k=left;k<right;k++) {
        if(L[i]<=R[j])
            a[k]=L[i++];
        else
            a[k]=R[j++];
    }
}
void unknownsort(int a[],int n,int left,int right){
    if(left+1<right){
        int mid=(left+right)/2;
        unknownsort(a,n,left,mid);
        unknownsort(a,n,mid,right);
        unknown(a,n,left,mid,right);
    }
}
int main(){
    int a[maxn],n;
    cin>>n;
    for(int i=0;i<n;i++)  cin>>a[i];
    unknownsort(a,n,0,n);
    for(int i=0;i<n;i++){
        if(i)  cout<<" ";
        cout<<a[i];
    }
    cout<<endl;
    return 0;
}

判断题

28. 将第 13 行的“<”改为“<=”不会改变运行结果。（ ）{{ dropdown(2-13)[√, ×] }}

29. 将第 21 行的“<”改为“<=”不会改变运行结果。（ ）{{ dropdown(2-14)[√, ×] }}

30. 此类排序方法是高效的，但是不稳定。（ ）{{ dropdown(2-15)[√, ×] }}

31. 将第 4 行的 2 个“+2”都去掉不会改变运行结果。（ ）{{ dropdown(2-16)[√, ×] }}

选择题

32. 此题是哪种排序？（ ）{{ select(2-17) }}

  • 选择排序
  • 桶排序
  • 归并排序
  • 堆排序

33. 此题用到了（ ）思想。（ ）{{ select(2-18) }}（4 分）

  • 动态规划
  • 分治
  • 冒泡
  • 贪心

三、完善程序（单选题，每题 3 分，共计 30 分）

（一）（田忌赛马）

田忌赛马，田忌每赢一次齐王的马就得 200 金币，当然输了就扣 200 金币，平局则金币数不变。

#include<bits/stdc++.h>
using namespace std;
int main(){
    int n;
    while(cin>>n&&n!=0){
        int tj[1001],king[1001],count=0;
        int tj_min=0,tj_max=n-1;
        int king_min=0,king_max=n-1;
        for(int i=0; i<n; i++)  cin>>tj[i];
        for(int i=0; i<n; i++)  cin>>king[i];
        sort(tj,tj+n);
        sort(king,king+n);
        while(n--){
            if(tj[ ① ]>king[ ② ]) {
                count++;
                tj_max--;
                king_max--;
            }
            else if(tj[ ③ ]<king[ ④ ]){
                count--;
                tj_min++;
                king_max--;
            }
            else
            {
                if(tj[tj_min]>king[king_min]) {
                    count++;
                    ⑤;
                    ⑥;
                }
                else{
                    if( ⑦ )
                        count--;
                    tj_min++;
                    ⑧;
                }
            }
        }
        cout<<count*200<<endl;
    }
    return 0;
}

34. ① 处和 ② 处填（ ）{{ select(3-1) }}

  • tj_max 和 king_max
  • tj_min 和 king_max
  • tj_min 和 king_max
  • tj_max 和 king_min

35. ③ 处和 ④ 处填（ ）{{ select(3-2) }}

  • tj_min 和 king_max
  • tj_min 和 king_min
  • tj_max 和 king_max
  • tj_max 和 king_min

36. ⑤ 处和 ⑥ 处填（ ）{{ select(3-3) }}

  • tj_min-- 和 king_min++
  • tj_max++ 和 king_min++
  • tj_min++ 和 king_min++
  • tj_max++ 和 king_min--

37. ⑦ 处填（ ）{{ select(3-4) }}

  • tj[tj_min]<king[king_max]
  • tj[tj_min]>king[king_max]
  • tj[tj_max]<king[king_max]
  • tj[tj_min]>king[king_min]

38. ⑧ 处填（ ）{{ select(3-5) }}

  • king_max--
  • king_max++
  • king_min--
  • king_min++

（二）（寻路）

寻路问题：N * N 矩阵，其中 0 是表示可以走的，1 表示无法走，矩阵由二维数组表示，左上角是入口，右下角是出口，只能横着走和竖着走，要求找出最短路径。

#include<bits/stdc++.h>
using namespace std;
int mymax=10000;
int f[4][2]= {{-1,0},{1,0},{0,-1},{0,1}};
int a[20][20],v[20][20],v1[20][20];
int l=1;
int n;//矩阵的规模
bool check(int x1,int y1) {
    if(x1<0||x1>=n|| ① )return false;
    if(a[x1][y1]==1|| ② )return false;
    return true;
}
void dfs(int x,int y)  {
    if(x==n-1&&y==n-1){
        if(l<mymax){
            mymax=l;
            memcpy(v1,v,sizeof(v1));
        }
        return;
    }
    for(int k=0; k<4; k++){
        int x1,y1;
        x1=x+ ③ ;
        y1=y+ ④ ;
        if(check(x1,y1))  {
            ⑤;
            ⑥;
            dfs(x1,y1);
            ⑦;
            v[x1][y1]=0;
        }
    }
}
int main(){
    cin>>n;
    for(int i=0; i<n; i++){
        for(int j=0; j<n; j++)
            cin>>a[i][j];
    }
    dfs(0,0);
    int d=v1[n-1][n-1];
    int x=n-1,y=n-1;
    int k;
    int qn[400][2];
    qn[0][0]=n-1;
    qn[0][1]=n-1;
    for(k=1;; k++){
        x=x-f[d][0];
        y=y-f[d][1];
        qn[k][0]=x;
        qn[k][1]=y;
        d=v1[x][y];
        if(x==0&&y==0)break;
    }
    for(int i=k; i>=0; i--)
        cout<< ⑧ <<", "<< ⑨ <<endl;
    return 0;
}

39. ① 处和 ② 处填（ ）{{ select(3-6) }}

  • y1<=0||y1>n 和 v[x1][y1]>0
  • y1<0||y1>=n 和 v[x1][y1]>0
  • y1>0&&y1<=n 和 v[x1][y1]>0
  • y1>0&&y1<n 和 v[x1][y1]>0

40. ③ 和 ④ 处填（ ）{{ select(3-7) }}

  • f[k][0] 和 f[k][1]
  • f[k][1] 和 f[k][0]
  • f[0][k] 和 f[1][k]
  • f[1][k] 和 f[0][k]

41. ⑤ 处填（ ）{{ select(3-8) }}

  • v[x1][y1]=k+1;
  • v[x1][y1]=k;
  • v[x][y]=k;
  • v[x][y]=k+1;

42. ⑥ 处和 ⑦ 处填（ ）{{ select(3-9) }}

  • l++ 和 l--
  • k++ 和 k--
  • x1++ 和 x1--
  • y1++ 和 y1--

43. ⑧ 处和 ⑨ 处填（ ）{{ select(3-10) }}

  • qn[i][1] 和 qn[i][2]
  • qn[i][0] 和 qn[i][1]
  • qn[1][i] 和 qn[2][i]
  • qn[0][i] 和 qn[1][i]
难度 未评定
通过率 2.8%
尝试 36
通过 1
ID
3725
类型
客观题
上传者
标签
  1. Language
  2. 兼容模式
  3. 主题
  2. AC Pro · 南昌信奥程老师 — 从 C++ 基础到 CSP-S 的闯关式信奥学习平台
  3. Worker 0, 39ms
  4. Powered by Hydro v5.0.4 Community