CSP - J 初赛阅读程序专题

原创 已于 2025-07-02 19:57:37 修改 · 1k 阅读 · 16 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
CSP初赛

当前文章被收录于：

CSP初赛
1 篇文章 1 人学习

初赛专题及模拟题

订阅专栏 查看详情
于 2025-06-03 11:30:40 首次发布

CSP - 初赛阅读程序专题

程序设计一共有3大题，共40分，是CSP-X/J/S考试中的一大拉分点。
该题首先让考生阅读程序，然后利用判断题和选择题考查考生对程序的理解深度。
本题所考查的知识点非常多，主要包括计算机语言、多重循环的嵌套、数组的操作等。对于阅读程序题，考生一定要细心，程序从主函数main开始顺序执行，要注意循环的判断条件以及程序的输入输出细节。

一、常用解题方法:

  1.模拟法:利用人脑模拟程序的执行过程，只要题目不是很复杂，这种方法就比较奏效。但在模拟过程中，要特别注意各个变量变化时书写的认真和整洁，因为一个变量的计算错误就会引起整个程序结果的错误。
当程序涉及数组、循环、双重循环、递归调用等稍微复杂的语句时，这些过程模拟往往涉及较多的变量变化，稍不留神就可能会导致整个程序的错误。为了让整个过程整洁有序，从而快速发现程序的运行规律，设计表格以进一步模拟时非常有必要的。

  2.先猜测、后验证:模拟法虽然奏效,但如果考生对整个程序要完成的功能不理解,则会造成求解的速度很慢。如果考生知道了程序的功能,那么对阅读程序的效率的提高很大。所以,在阅读程序中,考生可以借助以前阅读程序的功底以及程序中变量和函数一些常用的写法提示,大胆地猜测程序的功能,然后再进行验证,这就要求学员在平时学习时一方面要及时总结经典或者常用的功能代码段,另一方面要按照程序设计的经典写法进行书写,以提升自己程序的可读性。
    1)变量的常用含义
搞懂或者猜出变量的含义对于程序的理解至关重要。在变量的定义上,程序员喜欢使用英语单词或者英语单词的缩写、简写等方式表达变量含义,从而逐渐形成了一些固定的使用习惯,例如:sum表示累加求和的结果，count表示累加计数等。以下列举了一些常用
的变量使用习惯和含义。

序号变量名英文单词全拼/含义序号变量名英文单词全拼/含义
1ansanswer/计算答案17index索引，多用于数组下标
2retreturn/返回值18first第一，多用于比较
3resresult/计算结果19second第二，多用于比较
4flag标识，多用于记录状态20last最后，多用于比较
5done完成21begin开始，多用于指针位置
6error错误，多用于记录错误信息22end结束，多用于指针位置
7found找到，多用于bool变量23start开始，多用于指针位置
8success成功24node节点，多用于链表
9ok完成25op操作符，多用于链表
10numnumber/数字26min最小值，多用于比较
11value值27max最大值，多用于比较
12cntcount/统计28avg平均值，多用于计算
13target目标29total总和，多用于统计
14record记录30preNode上一个节点，用于链表
15foo确实存在东西的普遍替代语31curNode当前节点，用于链表
16tmp/temp临时变量32nextNode下一个节点，用于链表

    2)算法的结构:很多常用算法都有一些基本的结构，了解并掌握这些结构不仅能在阅读程序上快速地判断出程序的功能，而且在今后编写程序上也能根据算法结构快速地写出程序。以下列举几个。

while (l <= r){
	mid = (l + r) / 2;
	...
	if(...) l = mid + 1;
	else r = mid - 1;
}
这里的l代表left，r代表right，mid代表middle

if (...){
	t = a[i];
	a[i] = a[j];
	a[j] = t;
当满足某一条件时，交换数组中a[i]和a[j]的位置

num = 0;
c = cin.get();
while(c >= '0' && c <= '9'){
	num = num * 10 + c - '0';
	c = cin.get();
}
将连续数字字符转换成整数

while(b != 0){
	temp = b;
	b = a % b;
	a = temp;
}
return a;

返回值a就是数值a和b的最大公约数

二. 入门篇

1、NOIP1998

#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int s,maxx;
int a[11];
int main(){
	for(int i = 1; i <= 10; ++i) cin >> a[i];
	maxx = a[1]; s = a[1];
	for(int i = 2; i <= 10; ++i){
		if(s < 0) s = 0;
		s = s + a[i];
		if(s > maxx) maxx = s;
	}
	printf("%d",maxx);
	return 0;
}

●判断题
(1)将03行删除，程序也能得到正确的结果。( )
(2)将13行“<”改为“<=”程序也能得到正确的结果。( )
●选择题
(3)输入为“8 9 -1 24 6 5 11 15 -28 9”时，输出为( )。
A.78
B.24
C.77
D.50
(4)将13行删除，(3)的输入会输出( )。
A.78
B.24
C.50
D.77

正确，正确，C，D

2、NOIP1998

#include<iostream>
#include<cstdio>
using namespace std;
const int n = 10;
int s;
int co(int i1){
    int j1, s1;
    s1 = n;
    for (int j1 = n - 1; j1 >= n - i1 + 1; --j1)
        s1 = (s1 * j1) / (n - j1 + 1);
    return s1;
}
int main(){
	s = n + 1;
    for (int i = 2; i <= n; ++i) s = s + co(i);
    printf("S=%d", s);
}

●判断题
(1)将15行i=2改为i=1，程序运行结果不会发生变化。( )
(2)将07行“j1”去掉，程序运行结果不会发生变化。( )
●选择题
(3)输出为( )。
A.S=512
B.S=1024
C.S=256
D.S=2048
(4)该程序的时间复杂度为( )。
A. O ( n ) O(n) O(n)
B. O ( n l o g n ) O(nlogn) O(nlogn)
C. O ( n 2 O(n^2 O(n2)
D. O ( n n ) O(n\sqrt{n}) O(nn ​)

错误，正确，B，C

3、NOIP2001

#include<cstdio>
using namespace std;
inline int fun(int x){
    if (x == 0 || x == 1) return 3;
    else return x - fun(x - 2);
}
int main(){
	printf("%d", fun(9));
    putchar('\n');
    return 0;
}

●判断题
(1)将04行改为if (x <= 1) return (7 & 3)；程序输出结果不变。( )
(2)将03行inline去掉，程序可以正常运行。( )
●选择题
(3)输出为( )。
A.5
B.6
C.7
D.8
(4)8行的fun(9)改为fun(10)，输出为( )。
A.3
B.2
C.4
D.7

正确，正确，C，A

4、NOIP2001

#include<cstdio>
using namespace std;
int ack(int m, int n){
    if (m == 0) return n + 1;
    else if (n == 0) return ack(m - 1, 1);
    else return ack(m - 1, ack(m, n - 1));
}
int main(){
	printf("%d\n", ack(3, 4));
    putchar('\n');
    return 0;
}

●判断题
(1)09行的a ck(3, 4)改为ack(-1, -1)，程序能正常输出结果。( )
(2)ack函数增长很慢。( )
●选择题
(3)输出为( )。
A.125
B.250
C.114
D.514
(4)将09行的ack(3, 4)改为ack(2, 5)，输出为( )。
A.125
B.13
C.130
D.26

错误，错误，A，B. (阿克曼函数)

5、NOIP2001

#include<cstdio>
using namespace std;
int i, j, h, m, n, k, b[11];
int main(){
	scanf("%d", &n);
    for (i = 1; i <= 10; i++){
        m = n; j = 11;
        while(m > 0){
            j = j - 1; b[j] = m % 10; m = m / 10;}
        for (h = 1; h <= 10; h++) n = n + b[h];
    }
    printf("%d", n);
    return 0;
}

输入的n为正整数, 且保证所有数都不会超出int范围。
●判断题
(1)08行修改为while(m){，输出结果不变。( )
(2)时间复杂度为O(n)。( )
●选择题
(3)当输入为"1234"时，输出为( )。
A.1345
B.1348
C.1248
D.1145
(4)当输入为"1145"时，输出为( )。
A.1265
B.1145
C.1255
D.1919

正确，错误，B，A

6、NOIP2003

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int a, x, y, ok1, ok2;
int main(){
    a = 100;
    x = 20;
    y = 20;
    ok1 = 5;
    ok2 = 0;
    if ((x > y) || ((y != 20) && (ok1 == 0)) && (ok2 != 0))
        a = 1;
    else if ((ok1 != 0) && (ok2 == 0))
        a = -1;
    else a = 0;
    cout << a << endl;
    return 0;
}

●判断题
(1)把02、03行删除，程序可以正常运行。( )
(2)将11行删除，输出结果与原来相同。( )
●选择题
(3)输出为( )。
A.-1
B.-2
C.0
D.1
(4)将08行修改为"x = 114;"，输出为( )。
A.1
B.2
C.0
D.-1

正确，正确，A，A

7、NOIP2003

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
using namespace std;
string a, t;
int i, j;
int main(){
    a = "morning";
    j = 1;
    for (i = 2; i <= 7; i++)
        if (a[j] < a[i])
            j = i;
    j = j - 1;
    for (i = 0; i <= j; i++)
        printf("%c", a[i]);
    return 0;
}

●判断题
(1)该程序可以正常运行。( )
(2)将第13行的a[j]<a[i]改成a[j]<=a[i]，输出结果不变。( )
●选择题
(3)该程序的输出结果为( )。
A.mo
B.om
C.morning
D.gninrom
(4)该程序的时间复杂度级别为( )。
A.常数级别
B.线性级别
C.平方级别
D.对数级别

正确，正确，A，A

8、NOIP2004

#include <stdio.h>
int main(){
    int i, j;
    char str1[] = "pig-is-stupid";
    char str2[] = "clever";
    str1[0] = 'd';
    str1[1] = 'o';
    for (i = 7, j = 0; i < 6; i++, j++) str1[i] = str2[j];
    printf("%s\n", str1);
    return 0;
}

●判断题
(1)该程序可以正常运行。( )
(2)该程序输出结果为整数。( )
●选择题
(3)该程序的输出结果为( )。
A.dog-is-clever
B.dog_is_clever
C.dog-is-stupid
D.dog_is-stupid
(4)该程序的时间复杂度级别为( )。
A.常数级别
B.线性级别
C.平方级别
D.对数级别

正确，错误，A，A

9、NOIP2003

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int a, b, c, d, sum;
int main(){
    cin >> a >> b >> c >> d;
    a = a % 23;
    b = b % 28;
    c = c % 33;
    sum = a * 5544 + b * 14421 + c * 1288 - d;
    sum += 21252;
    sum %= 21252;
    if (sum == 0) sum = 21252;
    cout << sum << endl;
    return 0;
}

●判断题
(1)该程序可以正常运行。( )
(2)将#define int long long加到05行下面，程序可以正常运行。( )
●选择题
(3)输入283 102 23 320，该程序的输出结果为( )。
A.8910
B.21252
C.327690
D.348942
(4)该程序的时间复杂度级别为( )。
A.常数级别
B.线性级别
C.平方级别
D.对数级别

正确，错误，A，A

10、NOIP2005

#include <cstdio>
int main(){
    int a, b;
    scanf("%d", &a);
    b = (a * (a * a)) + 1;
    if (b % 3 == 0) b = b / 3;
    if (b % 5 == 0) b = b / 5;
    if (b % 7 == 0) b = b / 7;
    if (b % 9 == 0) b = b / 9;
    if (b % 11 == 0) b = b / 11;
    if (b % 13 == 0) b = b / 13;
    if (b % 15 == 0) b = b / 15;
    printf("%d\n", (100 * a - b) / 2);
    return 0;
}

●判断题
(1)答案可能为负。( )
(2)将cstdio替换为iostream，程序会编译错误。( )
●选择题
(3)输入5，该程序的输出结果为( )。
A.246
B.247
C.248
D.249
(4)输入10，该程序的输出结果为( )。
A.499
B.500
C.501
D.502

正确(-1)，正确，B，A

11、NOIP2005

#include <cstdio>
int main(){
    char str[20] = "Today-is-terrible!";
    int i;
    for (i = 6; i <= 10; i++) if (str[i] == '-') str[i - 1] = 'x';
    for (i = 12; i >= 0; i--) if (str[i] == 't') str[i + 1] = 'e';
    printf("%s\n", str);
    return 0;
}

●判断题
(1)程序输出一行一个字符串。( )
(2)将第04行去掉，程序会编译错误。( )
●选择题
(3)该程序的输出结果为( )。
A.Today-is-terrible!
B.Todax-ix-terrible!
C.Today-ix-terrible!
D.Todax-iy-terrible!
(4)若将第05行的"i=6"替换为"i=5"，该程序的输出结果为( )。
A.Today-is-terrible!
B.Todax-ix-terrible!
C.Today-ix-terrible!
D.Todax-iy-terrible!

正确，正确，C，B

12、NOIP2006

#include <iostream>
#define N 7
using namespace std;
int fun(char s[], char a, int n){
    int j;
    j = n;
    while (a < s[j] && j > 0) j--;
    return j;
}
int main(){
    char s[N + 1];
    int k;
    for (k = 1; k <= N; k++)
        s[k] = 'A' + 2 * k + 1;
    cout << fun(s, 'M', N) << endl;
}

●判断题
(1)将第02行替换为"int N = 7;"，程序正常运行。( )
(2)将第12行去掉，程序编译错误。( )
●选择题
(3)该程序的输出结果为( )。
A.4
B.5
C.6
D.7
(4)在运行到第14行时，串s等于( )。
A.PNLJHFD
B.DFHJLNP
C.DFMJLNP
D.DDFJLNP

正确，正确，B，B

三. 普及篇

1、NOIP1998

#include<iostream>
#include<cstdio>
using namespace std;
const int n = 4;
int i, j, i1, j2, k, s, t, s1, l, swapp;
char temp,a[n * 2 + 1];
int main(){
    for(int i = 1; i <= 2 * n; ++i) a[i] = getchar();
    s = 0; t = 0;
    for(int i = 1; i <= n * 2; ++i)
        if(a[i] == '1') s++;
        else if(a[i] == '0') t++;
    if(s != n || t != n) printf("error");
    else{
        s1 = 0;
        for(int i = 1; i <= 2 * n - 1; ++i)
            if(a[i] != a[i + 1]) s1++;
        printf("jamp=%d\n", s1);
        swapp = 0;
        for(int i = 1; i <= 2 * n - 1; ++i)
            for(int j = i; j <= 2 * n; ++j)
                if(a[i] != a[j]){
                    temp = a[i]; a[i] = a[j]; a[j] = temp;
                    s = 0;
                    for(int l = 1; l <= 2 * n - 1; ++l){
                        if(a[l] != a[l + 1]) s++;
                    }
                    if(s > swapp){
                        swapp = s; i1 = i; j2 = j;
                    }
                    temp = a[i]; a[i] = a[j]; a[j] = temp;
                }
        if(swapp > 0) printf("maxswap=%d i=%d j=%d", swapp - s1, i1, j2);
    }
    return 0;
}

●判断题
(1)第23行语句的作用是交换temp和i的值。( )
(2)输入11111111，输出error。( )
(3)(int)a[i]的值为0或1。（ ）
●选择题
(4)输入10101101，输出结果为( )。
A.jamp=5 maxswap=2 i=6 j=7
B.jamp=5 maxswap=1 i=6 j=7
C.error
D.jamp=5 maxswap=2 i=7 j=8

错误，正确，错误，A

2、NOIP1999

#include<iostream>
using namespace std;
int a[21];
int main(){
    int x, y, y1, jk, j1, g, e;
    x = 3465; y = 264; jk = 20;
    for(j1 = 1; j1 <= 20; ++j1) a[j1] = 0;
    while(y != 0){
        y1 = y % 10;
        y = y / 10;
        while(y1 != 0){
            g = x;
            for(e = jk; e >= 1; --e){
                g = g + a[e];
                a[e] = g % 10;
                g = g / 10;
            }
            y1 = y1 - 1;
        }
        jk = jk - 1;
    }
    j1 = 1;
    while(a[j1] == 0) j1 = j1 + 1;
    for (jk = j1; jk <= 20; ++jk) cout << " " << a[jk]; 
    return 0;
}

●判断题
(1)第14行的g=g+a[e]改为g+=a[e]，程序输出结果不变。( )
(2)将第6行的jk=20改为jk=2，程序输出结果不变。( )
(3)将第6行的x=3465;y=264改为x=y=0，则程序输出结果为0。（ ）
●选择题
(4)输出结果为( )。
A.1 1 4 5 1 4
B.9 1 4 7 6 0
C.1 9 1 9 8 1 0
D.1

正确，错误，错误，B

3、NOIP1999

#include<iostream>
using namespace std;
int i, j, k, a[101];
int main(){
    for (int i = 0; i <= 100; ++i) a[i] = i;
    for (k = 5; k >= 2; --k){
        for (i = 1; i <= 100; ++i) if (i % k == 0) a[i] = 0;
        for (i = 1; i <= 99; ++i) 
            for (j = 1; j <= 100 - i; ++j)
                if (a[j] > a[j + 1]){
                    a[j] = a[j] + a[j + 1];
                    a[j + 1] = a[j] - a[j + 1];
                    a[j] = a[j] - a[j + 1];
                }
    }
    j = 1;
    while(a[j] == 0 && j < 100) j = j + 1;
    for (i = j; i <= 100; ++i) a[0] = a[0] + a[i];
    cout << a[0];
    return 0;
}

●判断题
(1)去掉第17行，程序输出结果不变。( )
(2)将第11～13行的代码的作用时交换a[j]和a[j+1]的值。( )
(3)将第7行的i=1改为i=101-k*20，，程序输出结果不变。（ ）
●选择题
(4)第8～14行的排序方式为为( )。
A.快速排序
B.选择排序
C.冒泡排序
D.基数排序
(5)输出结果为（ ）。
A.970
B.1053
C.528
D.729

正确，正确，正确，C，A

4、NOIP2000

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
int b[105], c[105];
bool p1;
int main(){
    int i, j, j1, j2, p, q;
    cin >> q >> p; j = 1; p1 = true; b[j] = q; j1 = 0;
    while(q > 0 && p1){
        j1++; c[j1] = q * 10 / p; q = q * 10 - c[j1] * p;
        if (q > 0){
            j2 = 1;
            while(b[j2] != q && j2 <= j) j2++;
            if (b[j2] == q){
                p1 = false; cout << "0.";
                for (i = 1; i <= j2 - 1; i++) cout << c[i];
                cout << '{';
                for (i = j2; i <= j1; i++) cout << c[i];
                cout << '}';
            }
            else{
                j++; b[j] = q;
            }
        }
        if(q == 0){
            cout << "0.";
            for (i = 1; i <= j1; i++) cout << c[i];
            cout << endl;
        }
    }
    return 0;
}

●判断题
(1)输入的q可以为任意自然数。( )
(2)输入-1 2，会输出0.5。( )
(3)输入1 2时，程序会输出0.{5}。（ ）
(4)输入的q，p为小于 1 0 4 10^4 104的自然数时，程序可能会运行错误。( )
●选择题
(5)输入5 13，输出为。( )
A.0.{384615}
B.0
C.18
D.8
(6)删除下列哪一行后，输出结果一定错误的是（ ）。
A.13
B.23
C.17
D.21

正确，错误，错误，错误，A，D

5、NOIP2001

#include<cstdio>
using namespace std;
int i, j, f, a[9], n = 8;
int main(){
    for(int i = 1; i <= n; i++){
        f = i % 2;
        if(f == 0) a[i] = 0;
        else a[i] = 1;
        for(int j = 1; j <= i; j++)
            if(f == 0) a[i] = a[i] + j;
            else a[i] = a[i] * j;
    }
    for(int i = 1; i <= n; i++)
        printf("%5d", a[i]);
    return 0;
}

●判断题
(1)输出为1  3  6 10 120 21 5040 36。( )
(2)把第06行改为f=i&1;不影响运行结果。( )
(3)删去02行，程序仍然正常运行。( )
(4)f只有0/1两种取值。( )
●选择题
(5)程序的时间复杂度为( )。
A. O ( n 2 ) O(n^2) O(n2)
B. O ( 2 n ) O(2^n) O(2n)
C. O ( n ) O(n) O(n)
D. O ( n l o g n ) O(n log n) O(nlogn)
(6)该程序可以改造成时间复杂度最少为( )的程序。
A. O ( 1 ) O(1) O(1)
B. O ( n l o g 2 n ) O(nlog^2n) O(nlog2n)
C. O ( n l o g n ) O(n log n) O(nlogn)
D. O ( n ) O(n) O(n)

错误，正确，正确，正确，A，D

6、NOIP2001

#include<cstdio>
using namespace std;
int n, k, i, a[41];
void find(int x){
    int s, i1, j1;
    bool p;
    i1 = 0;
    p=1;
    while(p){
        i1 = i1 + 1;
        s = 0;
        for(j1 = 1; j1 <= n; j1++)
            if(a[j1] > a[i1]) s = s + 1;
        if(s == x - 1){
            printf("%d\n", a[i1]);
            p=0;
        }
    }
}
int main(){
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    find(k);
    find(n - k);
    return 0;
}

●判断题
(1)程序时间最坏复杂度为0(n log n)。( )
(2)程序最好时间复杂度为0(n)。( )
(3)k可以是[1,n]范围内的任意整数。( )
(4)第23行可以改成scanf(“%d”,a+i);。()
●选择题
(5)输入
10 4
12 34 5 65 67 87 7 90 120 13,输出( )。
A.67\n34
B.65 7
C.7\n65
D.12\n13
(6)可以实现一个时间复杂度最少为( )的等效代码。
A. O ( n ) O(n) O(n)
B. O ( n l o g 2 n ) O(n log^2n) O(nlog2n)
C. O ( l o g n ) O(log n) O(logn)
D. O ( n l o g n ) O(n log n) O(nlogn)

错误，正确，错误，正确，A，A

7、NOIP2002

#include <iostream>
#include <cstdio>
using namespace std;
int a[21], i, j, k, n, l0,l1,lk;
int main()
{
    scanf("%d%d", &n, &k);
    for(i = 0; i <= n - 1; ++i) a[i] = i + 1;
    a[n] = a[n - 1];
    l0 = n - 1;
    lk = n - 1;
    for(i = 1; i <= n - 1; ++i)
    {
        l1 = l0 - k;
        if(l1 < 0) l1 = l1 + n;
        if(l1 == lk)
        {
            a[l0] = a[n];
            lk = lk - 1;
            a[n] = a[lk];
            l0 = lk;
        }
        else
        {
            a[l0]=a[l1];
            l0 = l1;
        }
    }
    a[l0] = a[n];
    for(i = 0; i <= n - 1; ++i) printf("%4d",a[i]);
    printf("\n");
    return 0;
}

●判断题
(1)将第31行的printf(“\n”);改为cout<<endl;,程序输出结果不变。( )
(2)将第30行的“%4d”改为“%d ”,程序输出结果不变。( )
(3)去掉第16行的if语句以及该if语句内的所有语句，程序输出结果不变。( )
(4)若将第12行的n-1改为n,并去掉第29行，程序输出结果不变。( )
●选择题
(5)输人10 4,输出结果为( )。
A.7 8 9 10 1 2 3 4 5 6
B.5 6 7 8 9 10 1 2 3 4
C.6 7 8 9 10 1 2 3 4 5
D.4 5 6 7 8 9 10 1 2 3
(6)第21行代码被执行的次数为( )。
A: k g c d ( n , k ) \frac{k}{gcd(n, k)} gcd(n,k)k​
B: n g c d ( n , k ) \frac{n}{gcd(n, k)} gcd(n,k)n​
C: n k g c d ( n , k ) \frac{nk}{gcd(n, k)} gcd(n,k)nk​
D: g c d ( n , k ) gcd(n, k) gcd(n,k)

正确，错误，错误，正确，A，D

8、NOIP2002

#include <iostream>
#include <cstdio>
using namespace std;
int a[11], i, j, s, sp1;
bool p;
int main(){
    sp1 = 1;
    a[1] = 2;
    j = 2;
    while(sp1 < 10){
        j = j + 1;
        p = true;
        for(i = 2; i <= j - 1; ++i)
            if(j % i == 0) p = false;
        if(p){
            sp1 = sp1 + 1;
            a[sp1] = j;
        }
    }
    j = 2;
    p = true;
    while(p){
        s = 1;
        for(i = 1; i <= j; ++i) s = s * a[i];
        s = s + 1;
        for(i = 2; i <= s - 1; ++i)
            if(s % i == 0) p = false;
        j = j + 1;
    }
    printf("%d\n\n",s);
    return 0;
}

●判断题
(1)去掉第01行，程序可以正常编译。( )
(2)把第05行的bool改为int,程序结果不变。( )
(3)程序输出由一个数字和一个空行组成。( )
(4)将11行改为j++;,程序运行结果不变。( )
●选择题
(5)程序输出的数字为( )。
A.30030
B.30031
C.30032
D.30033
(6)程序的07～19行实现了( )的功能。
A.预处理素数
B.预处理欧拉函数
C.预处理莫比乌斯函数
D.预处理约数和

正确，正确，错误，正确，B，A

9、NOIP2002

#include<iostream>
#include<cstdio>
using namespace std;
int a[21], i, j, p, n, q, s;
int main()
{
    scanf("%d%d%d", &p, &n, &q);
    j = 21;
    while(n > 0)
    {
        j = j - 1;
        a[j] = n % 10;
        n = n / 10;
    }
    s = 0;
    for(i = j; i <= 20; ++i) s = s * p + a[i];
    printf("%d\n", s);
    j = 21;
    while(s > 0)
    {
        j = j - 1;
        a[j] = s % q;
        s = s / q;
    }
    for(i = j; i <= 20; ++i) printf("%d", a[i]);
    printf("\n");
    return 0;
}

●判断题
(1)去掉第02行，程序输出结果不变。( )
(2)输入2 100110 8,输出结果为38 46。( )
(3)本题时间复杂度为O(n)。( )
(4)输人一组数据Png(p,9,n>0,且保证数组不越界，所有数都在in;范围内),我们出的答案为n’,我们再输入q n’p,那么程序输出结果一定为n。()
●选择题
(5)输入7 3051 8,输出结果为( )。
A.1066 2052
B.1065 2051
C.1067 2053
D.1064 2050
(6)读入的n相当于是一个( )。
A.二进制数
B.十进制数
C.p进制数
D.q进制数

错误，正确，错误，错误，B，C

10、NOIP2004

#include<cstdio>
int main(){
    int u[4], a, b, c, x, y, z;
    scanf("%d%d%d%d", &(u[0]), &(u[1]), &(u[2]), &(u[3]));
    a = u[0] + u[1] + u[2] + u[3] - 5;
    b = u[0] * (u[1] - u[2] / u[3] + 8);
    c = u[0] * u[1] / u[2] * u[3];
    x = (a + b + 2) * 3 - u[(c + 3) % 4];
    y =(c * 100 - 13) / a / (u[b % 3] * 5);
    if((x + y) % 2 == 0) z=(a + b + c + x + y) / 2;
    z = (a + b + c - x - y) * 2;
    printf("%d\n", x + y - z);
    return 0;
}

●判断题
(1)去掉第04行中的&,则程序可以正常运行。( )
(2)去掉第09行的第2个配对好的括号，则程序运行结果不变。( )
(3)把第04行中的%d换成%lld,则程序可以正常运行。()
(4)输人2 5 7 4 ,则输出263。()
●选择题
(5)程序的时间复杂度为( )。
A. O ( 1 ) O(1) O(1)
B. O ( n ) O(n) O(n)
C. O ( n l o g n ) O(n log n) O(nlogn)
D. O ( n 2 ) O(n^2) O(n2)
(6)当输入为3 6 5 8,程序输出为( )。
A.395
B.396
C.397
D.398

错误，错误，错误，正确，A，B

11、NOIP2004

#include<cstdio>
using namespace std;
int number, ndata, data[100], sum;
void solve(int s,int sign,int n){
    int i;
    for(i = s; i < ndata; i++){
        sum += sign * (number / n / data[i]);
        solve(i + 1, -sign, n * data[i]);
    }
}
int main(){
    int i;
    scanf("%d%d", &number, &ndata);
    sum = 0;
    for(i = 0; i < ndata; i++) scanf("%d", &(data[i]));
    solve(0,1,1);
    printf("%d\n", sum);
    return 0;
}

●判断题
(1)ndata必须小于等于100,程序不会发生运行时错误。()
(2)去掉第14行，程序可以输出正确答案。( )
(3)data[i]可以为0。( )
(4)输入1000 3 5 13 11时，输出328。( )
●选择题
(5)该程序的时间复杂度为( )。
A. O ( 1 ) O(1) O(1)
B. O ( n ) O(n) O(n)
C. O ( n l o g n ) O(n log n) O(nlogn)
D. O ( n 2 ) O(n^2) O(n2)
(6)当输入为2000 5 5 3 9 2 4时，输出( )。
A.1643
B.1644
C.1645
D.1646

正确，正确，错误，正确，B，B

12、NOIP2005

#include<cstdio>
#include<cmath>
using namespace std;
int a[50];
void work(int p,int r){
    if(p < r){
        int i = p - 1, j, temp;
        for(j = p; j < r; j++){
            if(a[j]>=a[r]){
                i++;
                temp = a[i]; a[i] = a[j]; a[j]=temp;
            }
        }
        temp = a[i + 1]; a[i + 1] = a[r]; a[r] = temp;
        work(p,i);
        work(i + 2, r);
    }
}
int main(){
    int n, i, sum = 0;
    scanf("%d", &n);
    for(i = 0; i < n; i++) scanf("%d", &(a[i]));
    work(0, n - 1);
    for(i = 0; i < n - 1; i++) sum += abs(a[i + 1] - a[i]);
    printf("%d\n", sum);
    return 0;
}

●判断题
(1)去掉第02行，程序可以正常编译。( )
(2)n必须小于等于50,否则会发生运行时错误。()
(3)第11行实现了交换的功能。( )
(4)输入10 23 435 12 345 3123 43 456 12 32 -100,输出3223。( )
●选择题
(5)程序的时间复杂度为()。
A. O ( 1 ) O(1) O(1)
B. O ( n ) O(n) O(n)
C. O ( n l o g n ) O(n log n) O(nlogn)
D. O ( 2 n ) O(2^n) O(2n)
(6)输入为8 43 12 63 54 85 47 84 34,输出为( )。
A.71
B.72
C.73
D.74

错误，正确，正确，正确，C，C

四. 提高篇

待补充…

标签
#c++ #算法 #数据结构
CSP-J 初赛模拟卷6 题解（附阅读程序及完善程序题答题方法）
Sat77GryHp_Pro的博客
08-16 5480
正解题解：1=0.01x100，把0.01当成1，1当成100，题目就变为了“在区间(0,100)上二分查找单调递增函数f(x)的零点，至少需要比较（）次可以把误差控制在±1内”，代入查找长度为n的区间至少找。注：有的题一道题有两个答案，红色为错解，绿色为正解，是我在做这套题时的错题（以前的那四套题课上也做过，只不过当时没想到可以写错题分析，这套题解算是最完整的）（4）若n=26，且输入的str依次为"ab", "bc", "cd", ..., "za"，则输出结果为"abcd...za"。
CSP2020-J1-真题解析-阅读程序
严老师编程
06-14 2550
二、阅读程序 1. 编解码 #include <cstdlib> #include <iostream> using namespace std; char encoder[26] = {'C','S','P',0}; char decoder[26]; string st; int main() { int k = 0; for (int i = 0; i < 26; ++i) if (encoder[i] != 0) ++k; for (char
CSP测试中完善程序题目的解题经验与运用
Hacket_Xu的博客
09-12 2292
根据历年CCF CSP、NOIP和洛谷CSP进行分析得出的与完善程序相关的知识，并配备详细解析。
2024年CSP-J第一轮暑假冲刺训练营(6)：程序阅读技巧
joe_g12345的博客
08-01 1028
近年非常喜欢考数学相关的程序（例如分解质因数、寻找所有因数）等等。
CSP-J1 CSP-S1 初赛 第1轮 第四章 阅读程序 第3节 枚举算法 3、NOIP2017
青少年趣味编程
08-05 298
CSP-J1 CSP-S1 初赛 第1轮 第四章 阅读程序 第3节 枚举算法 3、NOIP2017
CSP-J1 CSP-S1 第1轮 初赛 阅读程序 完善程序 解题方法
青少年趣味编程
08-31 829
CSP-J1 CSP-S1 第1轮 初赛 阅读程序 完善程序 解题方法
CSP-J1 CSP-S1 初赛 第1轮 第四章 阅读程序 第10节 数论 1、NOIP2012
青少年趣味编程
08-08 281
CSP-J1 CSP-S1 初赛 第1轮 第四章 阅读程序 第10节 数论 1、NOIP2012
CSP J1 CSP-S1 初赛 第1轮 阅读程序 第三章 入门篇 1、NOIP1998
青少年趣味编程
07-31 539
CSP J1 CSP-S1 初赛 第1轮 阅读程序 第三章 入门篇 1、NOIP1998
2020 CSP - J初赛 题解
热门推荐
studentWheat的博客
08-08 1万+
CSP 2020 入门级第一轮，题目、答案、解析
deepseek认为明天CSP-J/S初赛的重点
最新发布
初心如磐，逐梦前行||b站@一个空客迷
09-19 3257
📌 CSP-J/S初赛备考精华 高频考点： 算法与数据结构（排序、栈/队列、二叉树、动态规划）占比最高 计算机基础（冯·诺依曼结构、存储层次、进制转换）必考 C++语法（指针、递归、STL）是核心难点 数学（补码、位运算）常出计算题 题型策略： 1️⃣ 单选：善用排除法，重点抓基础概念 2️⃣ 阅读程序：逐行分析+变量追踪表 3️⃣ 完善程序：理解算法思想再填空 组别差异： J组：主攻基础语法和简单数据结构 S组：需掌握图论、DP、内存管理等进阶内容 🔥 冲刺建议：限时刷最近3年真题，重点突破薄弱环节
2024年信息学奥赛CSP-J初赛真题详细分析
邓校长的编程课堂专栏
09-25 4726
CSP-J 2024 入门组初赛第一轮初赛试题及答案解析
2022 CSP-J1 CSP-S1 初赛 第1轮 真题讲评 真题解析
青少年趣味编程
09-21 5271
2022 CSP-J1 CSP-S1 初赛 第1轮 真题讲评 真题解析
竞赛中的C++阅读程序类题目：全面解析与实战技巧
Sunnyside_______的博客
08-09 1759
本文系统解析了竞赛中C++阅读程序类题目的特点和解题技巧。文章首先强调这类题目在信息学竞赛中的重要性，指出其占分比例高且能检验代码理解能力。然后从基础知识、数据结构与算法两个维度展开，详细讲解C++语法要点、指针、递归、STL等核心概念，以及数组、链表、树等常见数据结构。针对题型特点，文章总结出判断题、选择题和完善程序题三大类，并分析其知识分布和难度梯度。最后提出有效的解题策略，包括快速理解代码结构、变量跟踪和测试用例分析等实用技巧，帮助竞赛选手提升解题能力。
csp--j、各类信息竞赛考试经验
zjx的博客
08-22 604
献给
2022CSP阅读程序真题附解析
lb201205的博客
07-09 2819
22年CSP答案加解析，作者包对的
CSP-J 2020 初赛试题解析（第二部分：阅读程序（二））
汉克老师的博客
09-01 736
CSP-J 2020 初赛试题解析（第一部分：阅读程序（二））
CSP-J1 CSP-S1第1轮 初赛 如何拿到好成绩（60分及以上）
青少年趣味编程
08-31 4992
CSP-J1 CSP-S1第1轮 初赛 如何拿到好成绩（60分及以上）
【2024CSP-J初赛】补全代码（2）试题详解
lybc2019的博客
07-15 218
【2024CSP-J初赛】补全代码（2）试题详解 汉诺塔问题
信息学奥赛初赛天天练-27-CSP-J2022阅读程序位运算、数据类型范围、进制转换攻略
ya888g
06-12 1226
运算规则，按位或的2个位其中有1个为1，结果为1，否则为0。20.当输入为"2 2"时，输出为"59" ( F )运算规则，按位与的2个位同时为1时，结果为1，否则为0。19.当输入为"2 2"时，输出为"10"（ F ）参考19题，输出结果应该是12，输出59结果是错误的。20.当输入为"2 2"时，输出为"59" ( )19.当输入为"2 2"时，输出为"10"（ ）PDF文档公众号回复关键字:20240612。21.当输入为"13 8"时，输出为( )21.当输入为"13 8"时，输出为( )
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青岛少儿编程-王老师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值