202006软件编程（C语言）真题------（1级）
202006软件编程（C语言）真题------（2级）
202006软件编程（C语言）真题------（3级）
202006软件编程（C语言）真题------（4级）
202109软件编程（C语言）真题------（1-6级）
202212软件编程（C语言）真题------（1级）
202212软件编程（C语言）真题------（2级）
202212软件编程（C语言）真题------（3级）
202212软件编程（C语言）真题------（4级）
202212软件编程（C语言）真题------（5级）
202212软件编程（C语言）真题------（6级）
202212软件编程（C语言）真题------（7级）
202212软件编程（C语言）真题------（8级）
202403C语言一级
202403C语言二级
202403C语言三级
202403C语言四级
202403C语言五级
202403C语言六级
202403C语言七级
202403C语言八级
全国青少年软件编程等级考试标准（C语言）
青少年软件编程（C语言）等级考试试卷（一级）
分数：100 题数：5
| 总体情况 |
|------|------|------|--------|----|-----|------|------|---|---|
| 姓名 | 开始时间 | 结束时间 | 用时(分钟) | 得分 | 得分率 | 是否通过 | 考试状态 | | |
一、编程题(共5题，共100分)
| 1. |
鸡尾酒疗法 |
|
|
|
|
|
试题编号：20200621-105 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：20 |
|
是否评分：已评分 |
|
评价描述： |
| 2. |
判断是否存在重复的数 |
|
|
|
|
|
试题编号：20200621-103 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：20 |
|
是否评分：已评分 |
|
评价描述： |
| 3. |
日期输出 |
|
|
|
|
|
试题编号：20200621-101 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：20 |
|
是否评分：已评分 |
|
评价描述： |
| 4. |
计算表达式的值 |
|
|
|
|
|
试题编号：20200621-102 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：20 |
|
是否评分：已评分 |
|
评价描述： |
| 5. |
与指定数字相同的数的个数 |
|
|
|
|
|
试题编号：20200621-104 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：20 |
|
是否评分：已评分 |
|
评价描述： |
鸡尾酒疗法
鸡尾酒疗法，原指"高效抗逆转录病毒治疗"（HAART），由美籍华裔科学家何大一于1996年提出，是通过三种或三种以上的抗病毒药物联合使用来治疗艾 滋病。该疗法的应用可以减少单一用药产生的抗药性，最大限度地抑制病毒的复制，使被破坏的机体免疫功能部分甚至全部恢复，从而延缓病程进展，延长患者生 命，提高生活质量。人们在鸡尾酒疗法的基础上又提出了很多种改进的疗法。为了验证这些治疗方法是否在疗效上比鸡尾酒疗法更好，可用通过临床对照实验的方式 进行。假设鸡尾酒疗法的有效率为x，新疗法的有效率为y，如果y-x大于5%，则效果更好，如果x-y大于5%，则效果更差，否则称为效果差不多。下面给 出n组临床对照实验，其中第一组采用鸡尾酒疗法，其他n-1组为各种不同的改进疗法。请写程序判定各种改进疗法效果如何。
时间限制：10000
内存限制：65536
输入
第一行为整数n（ 1 < n <= 20）； 其余n行每行两个整数，第一个整数是临床实验的总病例数(小于等于10000)，第二个疗效有效的病例数。 这n行数据中，第一行为鸡尾酒疗法的数据，其余各行为各种改进疗法的数据。
输出
有n-1行输出，分别表示对应改进疗法的效果： 如果效果更好，输出better；如果效果更差，输出worse；否则输出same
样例输入
5
125 99
112 89
145 99
99 97
123 98
样例输出
same
worse
better
same
代码预览:
判断是否存在重复的数
给定3个数，判断是否存在2个数相等，如果存在输出"YES", 否者输出"NO"。
时间限制：5000
内存限制：65536
输入
1行，包含3个整数，以空格分隔。
输出
按照题目要求输出结果
样例输入
2 7 2
样例输出
YES
日期输出
给定两个整数，表示一个日期的月和日。请按照"MM-DD"的格式输出日期，即如果月和日不到2位时，填补0使得满足2位。
时间限制：10000
内存限制：65536
输入
2个整数m,d（0 < m <= 12, 0 < d <= 31）。数据保证日期合法。
输出
按照题目要求输出日期
样例输入
7 18
样例输出
07-18
计算表达式的值
给定整数x,y的值，计算3*x+2*y的值。
时间限制：3000
内存限制：65536
输入
一行包含2个整数x,y，以空格作为分隔。数据保证最后计算结果还在整数表示范围内。
输出
按照题目要求输出结果
样例输入
2 3
样例输出
12
与指定数字相同的数的个数
输出一个整数序列中与指定数字相同的数的个数。
时间限制：10000
内存限制：65536
输入
输入包含2行： 第1行为N和m，表示整数序列的长度(N <= 100)和指定的数字， 中间用一个空格分开； 第2行为N个整数，整数之间以一个空格分开。
输出
输出为N个数中与m相同的数的个数。
样例输入
3 2
2 3 2
样例输出
2青少年软件编程（C语言）等级考试试卷（二级）
分数：100 题数：5
一、编程题(共5题，共100分)
| 1. |
计算矩阵边缘元素之和 |
|
|
|
|
|
试题编号：20200621-203 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：20 |
|
是否评分：已评分 |
|
评价描述： |
| 2. |
最长最短单词 |
|
|
|
|
|
试题编号：20200621-202 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：0 |
|
是否评分：已评分 |
|
评价描述： |
| 3. |
啤酒厂选址 |
|
|
|
|
|
试题编号：20200621-205 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：20 |
|
是否评分：已评分 |
|
评价描述： |
| 4. |
统计误差范围内的数 |
|
|
|
|
|
试题编号：20200621-201 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：20 |
|
是否评分：已评分 |
|
评价描述： |
| 5. |
单词排序 |
|
|
|
|
|
试题编号：20200621-204 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
|
考生答案：（此题已作答） |
|
考生得分：20 |
|
是否评分：已评分 |
|
评价描述： |
计算矩阵边缘元素之和
输入一个整数矩阵，计算位于矩阵边缘的元素之和。所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。
时间限制：10000
内存限制：65536
输入
第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。 接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。
输出
输出对应矩阵的边缘元素和
样例输入
3 3
3 4 1
3 7 1
2 0 1
样例输出
15
最长最短单词
输入1行句子（不多于200个单词，每个单词长度不超过100），只包含字母、空格和逗号。单词由至少一个连续的字母构成，空格和逗号都是单词间的间隔。
试输出第1个最长的单词和第1个最短单词。
时间限制：10000
内存限制：65536
输入
一行句子。
输出
两行输出： 第1行，第一个最长的单词。 第2行，第一个最短的单词。
样例输入
I am studying Programming language C in Peking University
样例输出
Programming
I
提示
如果所有单词长度相同，那么第一个单词既是最长单词也是最短单词。
啤酒厂选址
海上有一个岛，在环海边上建有一条环岛高速公路，沿着公路有n（5 < n < 10000）个居民点，假设每个居民点有一个编号，从0开始，按顺时针依次从小到大（即，0,1，...，n-1）编号。在岛上啤酒很受青睐。某啤酒企业计划在岛上投资建一个啤酒厂，并根据啤酒需求每天向居住点送啤酒。已知两个相邻的居民点的距离以及每个居住点每天的啤酒需求量（假设每个居住点每天不超过2000桶）。假定每单位长度的路程送一桶啤酒需要的费用恒定（为单位费用）。请问，选择哪一个居民点建啤酒厂，才能使每天送啤酒的费用最小（空车不计费用）。
时间限制：10000
内存限制：65536
输入
第一行：为居民点数目n 后面为n行，每行为一个居民点的啤酒需求量以及按顺时针离下一个居民点的距离（均为整数,空格间隔），从编号为0的开始，按单增顺次给出。 注意：后面第n行对应于居民点（n-1)的啤酒需求量以及到编号为0的居民点距离。
输出
啤酒厂所在的居民点编号以及每天的运输费用，其间以逗号间隔
样例输入
6
500 10
300 30
350 25
400 60
700 28
200 35
样例输出
0,94100
代码预览:
单词排序
输入一行单词序列，相邻单词之间由1个或多个空格间隔，请按照字典序输出这些单词，要求重复的单词只输出一次。（区分大小写）
时间限制：10000
内存限制：65536
输入
一行单词序列，最少1个单词，最多100个单词，每个单词长度不超过50，单词之间用至少1个空格间隔。数据不含除字母、空格外的其他字符。
输出
按字典序输出这些单词，重复的单词只输出一次。
样例输入
She wants to go to Peking University to study Chinese
样例输出
Chinese
Peking
She
University
go
study
to
wants青少年软件编程（C语言）等级考试试卷（三级）
分数：100 题数：5
一、编程题(共5题，共100分)
| 1. |
最接近的分数 |
|
|
|
|
|
试题编号：20200621-302 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
| 2. |
和数 |
|
|
|
|
|
试题编号：20200621-301 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
| 3. |
吃糖果 |
|
|
|
|
|
试题编号：20200621-303 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
| 4. |
汉诺塔问题 |
|
|
|
|
|
试题编号：20200621-305 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
| 5. |
文件结构"图" |
|
|
|
|
|
试题编号：20200621-304 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
最接近的分数
分母不超过 N 且 小于 A/B 的最大最简分数是多少？
时间限制：10000
内存限制：65536
输入
三个正整数N，A，B，相邻两个数之间用单个空格隔开。1 <= A < B < N <= 1000。
输出
两个正整数，分别是所求分数的分子和分母，中间用单个空格隔开。
样例输入
100 7 13
样例输出
50 93
和数
给定一个正整数序列，判断其中有多少个数，等于数列中其他两个数的和。 比如，对于数列1 2 3 4, 这个问题的答案就是2, 因为3 = 2 + 1, 4 = 1 + 3。
时间限制：10000
内存限制：65536
输入
共两行，第一行是数列中数的个数n ( 1 <= n <= 100)，第二行是由n个不大于10000的正整数组成的数列，相邻两个整数之间用单个空格隔开。
输出
一个整数，即数列中等于其他两个数之和的数的个数。
样例输入
4
1 2 3 4
样例输出
2
吃糖果
现有n(20 > n > 0)个糖果,每天可以吃1个,也可以每天吃2个,也可以每天吃3个，请计算共有多少种不同的吃法。
时间限制：1000
内存限制：65536
输入
输入的每一行包括一组测试数据，即为糖果数n。最后一行为0，表示测试结束。
输出
每一行输出对应一行输入的结果，即为吃法的数目。
样例输入
1
2
3
4
0
样例输出
1
2
4
7
汉诺塔问题
约19世纪末，在欧州的商店中出售一种智力玩具，在一块铜板上有三根杆，最左边的杆上自上而下、由小到大顺序串着由64个圆盘构成的塔。目的是将最左边杆上的盘全部移到中间的杆上，条件是一次只能移动一个盘，且不允许大盘放在小盘的上面。 这是一个著名的问题，几乎所有的教材上都有这个问题。由于条件是一次只能移动一个盘，且不允许大盘放在小盘上面，所以64个盘的移动次数是：18,446,744,073,709,551,615 这是一个天文数字，若每一微秒可能计算(并不输出)一次移动，那么也需要几乎一百万年。我们仅能找出问题的解决方法并解决较小N值时的汉诺塔，但很难用计算机解决64层的汉诺塔。 假定圆盘从小到大编号为1, 2, ...
时间限制：11000
内存限制：65536
输入
输入为一个整数后面跟三个单字符字符串。 整数为盘子的数目，后三个字符表示三个杆子的编号。
输出
输出每一步移动盘子的记录。一次移动一行。 每次移动的记录为例如 a->3->b 的形式，即把编号为3的盘子从a杆移至b杆。
样例输入
2 a b c
样例输出
a->1->c
a->2->b
c->1->b
文件结构"图"
在计算机上看到文件系统的结构通常很有用。Microsoft Windows上面的"explorer"程序就是这样的一个例子。但是在有图形界面之前，没有图形化的表示方法的，那时候最好的方式是把目录和文件的结构显示成一个"图"的样子，而且使用缩排的形式来表示目录的结构。比如：
ROOT
| dir1
| file1
| file2
| file3
| dir2
| dir3
| file1
file1
file2
这个图说明：ROOT目录包括三个子目录和两个文件。第一个子目录包含3个文件，第二个子目录是空的，第三个子目录包含一个文件。
时间限制：1000
内存限制：65536
输入
你的任务是写一个程序读取一些测试数据。每组测试数据表示一个计算机的文件结构。每组测试数据以'*'结尾，而所有合理的输入数据以'#'结尾。一组测试数据包括一些文件和目录的名字（虽然在输入中我们没有给出，但是我们总假设ROOT目录是最外层的目录）。在输入中,以']'表示一个目录的内容的结束。目录名字的第一个字母是'd'，文件名字的第一个字母是'f'。文件名可能有扩展名也可能没有（比如fmyfile.dat和fmyfile）。文件和目录的名字中都不包括空格,长度都不超过30。一个目录下的子目录个数和文件个数之和不超过30。
输出
在显示一个目录中内容的时候，先显示其中的子目录（如果有的话），然后再显示文件（如果有的话）。文件要求按照名字的字母表的顺序显示（目录不用按照名字的字母表顺序显示，只需要按照目录出现的先后显示）。对每一组测试数据，我们要先输出"DATA SET x:"，这里x是测试数据的编号（从1开始）。在两组测试数据之间要输出一个空行来隔开。 你需要注意的是，我们使用一个'|'和5个空格来表示出缩排的层次。
样例输入
file1
file2
dir3
dir2
file1
file2
]
]
file4
dir1
]
file3
*
file2
file1
*
样例输出
DATA SET 1:
ROOT
| dir3
| | dir2
| | file1
| | file2
| dir1
file1
file2
file3
file4
DATA SET 2:
ROOT
file1
file2
提示
一个目录和它的子目录处于不同的层次 一个目录和它的里面的文件处于同一层次
代码预览:青少年软件编程（C语言）等级考试试卷（四级）
分数：100 题数：4
一、编程题(共4题，共100分)
| 1. |
最长上升子序列 |
|
|
|
|
|
试题编号：20200621-401 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
| 2. |
核电站 |
|
|
|
|
|
试题编号：20200621-403 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
| 3. |
山区建小学 |
|
|
|
|
|
试题编号：20200621-404 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
| 4. |
公共子序列 |
|
|
|
|
|
试题编号：20200621-402 |
|
试题类型：编程题 |
|
标准答案： |
|
试题难度：一般 |
|
试题解析： |
最长上升子序列
一个数的序列bi，当b1 < b2 < ... < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 <= i1 < i2 < ... < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4，比如子序列(1, 3, 5, 8). 你的任务，就是对于给定的序列，求出最长上升子序列的长度。
时间限制：11000
内存限制：65536
输入
输入的第一行是序列的长度N (1 <= N <= 1000)。第二行给出序列中的N个整数，这些整数的取值范围都在0到10000。
输出
最长上升子序列的长度。
样例输入
7
1 7 3 5 9 4 8
样例输出
4
核电站
一个核电站有N个放核物质的坑，坑排列在一条直线上。如果连续M个坑中放入核物质，则会发生爆炸，于是，在某些坑中可能不放核物质。
任务：对于给定的N和M，求不发生爆炸的放置核物质的方案总数
时间限制：6000
内存限制：131072
输入
只一行，两个正整数N，M( 1 < N < 50，2 ≤ M ≤ 5 )
输出
一个正整数S，表示方案总数。
样例输入
4 3
样例输出
13
山区建小学
政府在某山区修建了一条道路，恰好穿越总共m个村庄的每个村庄一次，没有回路或交叉，任意两个村庄只能通过这条路来往。已知任意两个相邻的村庄之间的距离为di（为正整数），其中，0 < i < m。为了提高山区的文化素质，政府又决定从m个村中选择n个村建小学（设 0 < n < = m < 500 ）。请根据给定的m、n以及所有相邻村庄的距离，选择在哪些村庄建小学，才使得所有村到最近小学的距离总和最小，计算最小值。
时间限制：24000
内存限制：65536
输入
第1行为m和n，其间用空格间隔 第2行为(m-1) 个整数，依次表示从一端到另一端的相邻村庄的距离，整数之间以空格间隔。 例如 10 3 2 4 6 5 2 4 3 1 3 表示在10个村庄建3所学校。第1个村庄与第2个村庄距离为2，第2个村庄与第3个村庄距离为4，第3个村庄与第4个村庄距离为6，...，第9个村庄到第10个村庄的距离为3。
输出
各村庄到最近学校的距离之和的最小值。
样例输入
10 2
3 1 3 1 1 1 1 1 3
样例输出
18
公共子序列
我们称序列Z = < z1, z2, ..., zk >是序列X = < x1, x2, ..., xm >的子序列当且仅当存在 严格上升 的序列< i1, i2, ..., ik >，使得对j = 1, 2, ... ,k, 有xij = zj。比如Z = < a, b, f, c > 是X = < a, b, c, f, b, c >的子序列。 现在给出两个序列X和Y，你的任务是找到X和Y的最大公共子序列，也就是说要找到一个最长的序列Z，使得Z既是X的子序列也是Y的子序列。
时间限制：3000
内存限制：65536
输入
输入包括多组测试数据。每组数据包括一行，给出两个长度不超过200的字符串，表示两个序列。两个字符串之间由若干个空格隔开。
输出
对每组输入数据，输出一行，给出两个序列的最大公共子序列的长度。
样例输入
abcfbc abfcab
programming contest
abcd mnp
样例输出
4
2
0青少年软件编程（C语言）等级考试试卷（一级）
加一
输入一个整数x，输出这个整数加1后的值，即x+1的值。
时间限制：1000
内存限制：65536
输入
一个整数x（0 ≤ x ≤ 1000）。
输出
按题目要求输出一个整数。
样例输入
9
样例输出
10
(a/b)*c的值
给定整数a、b、c，计算(a / b)*c的值，这里的除法为实数除法。
时间限制：1000
内存限制：65536
输入
一行，三个整数a、b、c，整数间以空格分隔。（1 ≤ a,b,c ≤ 1000）
输出
将计算结果保留6位小数输出。
样例输入
1 3 3
样例输出
1.000000
判断是否存在重复的数
给定3个数，判断是否存在2个数相等，如果存在输出"YES", 否者输出"NO"。
时间限制：5000
内存限制：65536
输入
1行，包含3个整数，以空格分隔。
输出
按照题目要求输出结果
样例输入
2 7 2
样例输出
YES
整数的立方和
给定一个正整数k（1<k<10），求1到k的立方和m。即m=1+2*2*2+...+k*k*k。
时间限制：1000
内存限制：65536
输入
输入只有一行，该行包含一个正整数k。
输出
输出只有一行，该行包含1到k的立方和。
样例输入
5
样例输出
225
自整除数
对一个整数n,如果其各个位数的数字相加得到的数m能整除n,则称n为自整除数.例如21,21%(2+1)==0,所以21是自整除数.现求出从10到n(n < 100)之间的所有自整除数.
时间限制：1000
内存限制：65536
输入
有一行,整数n,(10 <= n < 100)
输出
有多行.按从小到大的顺序输出所有大于等于10,小于等于n的自整除数,每行一个自整除数.
样例输入
47
样例输出
10
12
18
20
21
24
27
30
36
40
42
45青少年软件编程（C语言）等级考试试卷（二级）
数组逆序重放
将一个数组中的值按逆序重新存放。例如，原来的顺序为8,6,5,4,1。要求改为1,4,5,6,8。
时间限制：1000
内存限制：65536
输入
输入为两行：第一行数组中元素的个数n（1<n<100)，第二行是n个整数，每两个整数之间用空格分隔。
输出
输出为一行：输出逆序后数组的整数，每两个整数之间用空格分隔。
样例输入
5
8 6 5 4 1
样例输出
1 4 5 6 8
最长最短单词
输入1行句子（不多于200个单词，每个单词长度不超过100），只包含字母、空格和逗号。单词由至少一个连续的字母构成，空格和逗号都是单词间的间隔。
试输出第1个最长的单词和第1个最短单词。
时间限制：10000
内存限制：65536
输入
一行句子。
输出
两行输出： 第1行，第一个最长的单词。 第2行，第一个最短的单词。
样例输入
I am studying Programming language C in Peking University
样例输出
Programming
I
提示
如果所有单词长度相同，那么第一个单词既是最长单词也是最短单词。
计算鞍点
给定一个5*5的矩阵，每行只有一个最大值，每列只有一个最小值，寻找这个矩阵的鞍点。 鞍点指的是矩阵中的一个元素，它是所在行的最大值，并且是所在列的最小值。 例如：在下面的例子中（第4行第1列的元素就是鞍点，值为8 ）。
11 3 5 6 9
12 4 7 8 10
10 5 6 9 11
8 6 4 7 2
15 10 11 20 25
时间限制：1000
内存限制：65536
输入
输入包含一个5行5列的矩阵
输出
如果存在鞍点，输出鞍点所在的行、列及其值，如果不存在，输出"not found"
样例输入
11 3 5 6 9
12 4 7 8 10
10 5 6 9 11
8 6 4 7 2
15 10 11 20 25
样例输出
4 1 8
病人排队
病人登记看病，编写一个程序，将登记的病人按照以下原则排出看病的先后顺序： 1. 老年人（年龄 >= 60岁）比非老年人优先看病。 2. 老年人按年龄从大到小的顺序看病，年龄相同的按登记的先后顺序排序。 3. 非老年人按登记的先后顺序看病。
时间限制：1000
内存限制：65536
输入
第1行，输入一个小于100的正整数，表示病人的个数； 后面按照病人登记的先后顺序，每行输入一个病人的信息，包括：一个长度小于10的字符串表示病人的ID（每个病人的ID各不相同且只含数字和字母），一个整数表示病人的年龄，中间用单个空格隔开。
输出
按排好的看病顺序输出病人的ID，每行一个。
样例输入
5
021075 40
004003 15
010158 67
021033 75
102012 30
样例输出
021033
010158
021075
004003
102012
循环数
若一个n位的数字串满足下述条件，则称其是循环数（cyclic）：将这个数字串视为整数（可能带有前导0），并用任意一个 1 到 n 之间（包含1和n）的整数去乘它时, 会得到一个将原数字串首尾相接后，再在某处断开而得到的新数字串所对应的整数。例如，数字 142857 是循环数，因为: 142857 *1 = 142857 142857 *2 = 285714 142857 *3 = 428571 142857 *4 = 571428 142857 *5 = 714285 142857 *6 = 857142。
请写一个程序判断给定的数是否是循环数。
注意：在此题中，输入数字串允许带前导0，且前导0不能被忽略，例如"01"是两位数字串，而"1"是一位数字串。但将数字串转化为整数做乘法运算或比较运算时，可以忽略前导0。
时间限制：10000
内存限制：65536
输入
一行，一个长度在 2 到 60 位之间的数字串。
输出
一个整数，若输入的数字串是循环数，输出1，否则输出0。
样例输入
142857
样例输出
1青少年软件编程（C语言）等级考试试卷（三级）
鸡兔同笼
一个笼子里面关了鸡和兔子（鸡有2只脚，兔子有4只脚，没有例外）。已经知道了笼子里面脚的总数a，问笼子里面至少有多少只动物，至多有多少只动物。
时间限制：1000
内存限制：65536
输入
一行，一个正整数a (a < 32768)。
输出
一行，包含两个正整数，第一个是最少的动物数，第二个是最多的动物数，两个正整数用一个空格分开。 如果没有满足要求的答案，则输出两个0，中间用一个空格分开。
样例输入
20
样例输出
5 10
猴子吃桃
海滩上有一堆桃子，N只猴子来分。第一只猴子把这堆桃子平均分为N份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子接着把剩下的桃子平均分成N份，又多了一个，它同样把多的一个扔入海中，拿走了一份。第三、第四、......，第N只猴子仍是最终剩下的桃子分成N份，扔掉多了的一个，并拿走一份。 编写程序，输入猴子的数量N，输出海滩上最少的桃子数，使得每只猴子都可吃到桃子。
时间限制：3000
内存限制：65536
输入
一个整数N。
输出
输出当猴子数量为N时海滩上最少的桃子数。结果保证在int型范围内。
样例输入
2
样例输出
7
扩号匹配问题
在某个字符串（长度不超过100）中有左括号、右括号和大小写字母；规定（与常见的算数式子一样）任何一个左括号都从内到外与在它右边且距离最近的右括号匹配。写一个程序，找到无法匹配的左括号和右括号，输出原来字符串，并在下一行标出不能匹配的括号。不能匹配的左括号用"$"标注,不能匹配的右括号用"?"标注.
时间限制：3000
内存限制：65536
输入
输入包括多组数据，每组数据一行，包含一个字符串，只包含左右括号和大小写字母，字符串长度不超过100
输出
对每组输出数据，输出两行，第一行包含原始输入字符，第二行由"","?"和空格组成，""和"?"表示与之对应的左括号和右括号不能匹配。
样例输入
((ABCD(x)
)(rttyy())sss)(
样例输出
((ABCD(x)
)(rttyy())sss)(
? ?$
上台阶
楼梯有n(100 \> n \> 0)阶台阶,上楼时可以一步上1阶,也可以一步上2阶,也可以一步上3阶，编程计算共有多少种不同的走法。
时间限制：1000
内存限制：65536
输入
输入的每一行包括一组测试数据，即为台阶数n。最后一行为0，表示测试结束。
输出
每一行输出对应一行输入的结果，即为走法的数目。
样例输入
1
2
3
4
0
样例输出
1
2
4
7
田忌赛马
在田忌赛马的故事中，孙膑用自己的下等马对战对手的上等马，自己上等马对阵对手的中等马，自己的中等马对阵对手的下等马，从而赢得了胜利。现在即将进行的是N匹马的赛马比赛。双方队伍的马各分为N等。已知只有当我方马的等级比对方马等级高X等以上（包含X）时，我方才可以取得这场比赛的胜利。如果在N场比赛中我方的胜场数大于对方，则我方取得最终的胜利。现在已知对方这N场比赛的出战方案，请计算所有令我方最终获胜的出战方案。
时间限制：1000
内存限制：65536
输入
第一行两个整数，N和X。N≤9, 0 ≤ X \< N。 第二行N个正整数，A(1)....A(N)。A(i)表示第i场比赛对方马的等级，1≤i≤N。等级越高越强
输出
按字典序输出所有我方最终获胜的方案，每个方案一行。每行是N个正整数，第i个数表示我方第i场比赛马的等级。
样例输入
样例1输入
3 1
3 2 1
样例2输入
3 0
3 1 2
样例输出
样例1输出
1 3 2
样例2输出
1 2 3
1 3 2
2 1 3
3 1 2
3 2 1青少年软件编程（C语言）等级考试试卷（四级）
开餐馆
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。小明打算从中选择合适的位置开设一些餐馆。这 n 个地点排列在同一条直线上。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。我们用pi 表示在mi 处开餐馆的利润。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。请你帮助小明选择一个总利润最大的方案。
时间限制：1000
内存限制：65536
输入
标准的输入包含若干组测试数据。输入第一行是整数T (1 \<= T \<= 1000) ，表明有T组测试数据。紧接着有T组连续的测试。每组测试数据有3行, 第1行:地点总数 n (n \< 100), 距离限制 k (k \> 0 \&\& k \< 1000). 第2行:n 个地点的位置m1 , m2, ... mn ( 1000000 \> mi \> 0 且为整数,升序排列) 第3行:n 个地点的餐馆利润p1 , p2, ... pn ( 1000 \> pi \> 0 且为整数)
输出
对于每组测试数据可能的最大利润
样例输入
2
3 11
1 2 15
10 2 30
3 16
1 2 15
10 2 30
样例输出
40
30
糖果
由于在维护世界和平的事务中做出巨大贡献，Dzx被赠予糖果公司2010年5月23日当天无限量糖果免费优惠券。在这一天，Dzx可以从糖果公司的N件产品中任意选择若干件带回家享用。糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。当然，在满足这一条件的基础上，糖果总数越多越好。Dzx最多能带走多少糖果呢？ 注意：Dzx只能将糖果公司的产品整件带走。
时间限制：7000
内存限制：65536
输入
第一行包含两个整数N(1\<=N\<=100)和K(1\<=K\<=100) 以下N行每行1个整数，表示糖果公司该件产品中包含的糖果数目，不超过1000000
输出
符合要求的最多能达到的糖果总数，如果不能达到K的倍数这一要求，输出0
样例输入
5 7
1
2
3
4
5
样例输出
14
提示
Dzx的选择是2+3+4+5=14，这样糖果总数是7的倍数，并且是总数最多的选择。
鸡蛋的硬度
最近XX公司举办了一个奇怪的比赛：鸡蛋硬度之王争霸赛。参赛者是来自世 界各地的母鸡，比赛的内容是看谁下的蛋最硬，更奇怪的是XX公司并不使用什么精密仪器来测量蛋的硬度，他们采用了一种最老土的办法--从高度扔鸡蛋--来 测试鸡蛋的硬度，如果一次母鸡下的蛋从高楼的第a层摔下来没摔破，但是从a+1层摔下来时摔破了，那么就说这只母鸡的鸡蛋的硬度是a。你当然可以找出各种 理由说明这种方法不科学，比如同一只母鸡下的蛋硬度可能不一样等等，但是这不影响XX公司的争霸赛，因为他们只是为了吸引大家的眼球，一个个鸡蛋从100 层的高楼上掉下来的时候，这情景还是能吸引很多人驻足观看的，当然，XX公司也绝不会忘记在高楼上挂一条幅，写上"XX公司"的字样--这比赛不过是XX 公司的一个另类广告而已。 勤于思考的小A总是能从一件事情中发现一个数学问题，这件事也不例外。"假如有很多同样硬度的鸡蛋，那么我可以用二分的办法用最少的次数测出鸡蛋 的硬度"，小A对自己的这个结论感到很满意，不过很快麻烦来了，"但是，假如我的鸡蛋不够用呢，比如我只有1个鸡蛋，那么我就不得不从第1层楼开始一层一 层的扔，最坏情况下我要扔100次。如果有2个鸡蛋，那么就从2层楼开始的地方扔......等等，不对，好像应该从1/3的地方开始扔才对，嗯，好像也不一定 啊......3个鸡蛋怎么办，4个，5个，更多呢......"，和往常一样，小A又陷入了一个思维僵局，与其说他是勤于思考，不如说他是喜欢自找麻烦。 好吧，既然麻烦来了，就得有人去解决，小A的麻烦就靠你来解决了：）
时间限制：1000
内存限制：65536
输入
输入包括多组数据，每组数据一行，包含两个正整数n和m(1\<=n\<=100,1\<=m\<=10)，其中n表示楼的高度，m表示你现在拥有的鸡蛋个数，这些鸡蛋硬度相同（即它们从同样高的地方掉下来要么都摔碎要么都不碎），并且小于等于n。你可以假定硬度为x的鸡蛋从高度小于等于x的地方摔无论如何都不会碎（没摔碎的鸡蛋可以继续使用），而只要从比x高的地方扔必然会碎。 对每组输入数据，你可以假定鸡蛋的硬度在0至n之间，即在n+1层扔鸡蛋一定会碎。
输出
对于每一组输入，输出一个整数，表示使用最优策略在最坏情况下所需要的扔鸡蛋次数。
样例输入
100 1
100 2
样例输出
100
14
提示
最优策略指在最坏情况下所需要的扔鸡蛋次数最少的策略。 如果只有一个鸡蛋，你只能从第一层开始扔，在最坏的情况下，鸡蛋的硬度是100，所以需要扔100次。如果采用其他策略，你可能无法测出鸡蛋的硬度(比如你第一次在第二层的地方扔,结果碎了,这时你不能确定硬度是0还是1)，即在最坏情况下你需要扔无限次，所以第一组数据的答案是100。
山区建小学
政府在某山区修建了一条道路，恰好穿越总共m个村庄的每个村庄一次，没有回路或交叉，任意两个村庄只能通过这条路来往。已知任意两个相邻的村庄之间的距离为di（为正整数），其中，0 \< i \< m。为了提高山区的文化素质，政府又决定从m个村中选择n个村建小学（设 0 \< n \< = m \< 500 ）。请根据给定的m、n以及所有相邻村庄的距离，选择在哪些村庄建小学，才使得所有村到最近小学的距离总和最小，计算最小值。
时间限制：24000
内存限制：65536
输入
第1行为m和n，其间用空格间隔 第2行为(m-1) 个整数，依次表示从一端到另一端的相邻村庄的距离，整数之间以空格间隔。 例如 10 3 2 4 6 5 2 4 3 1 3 表示在10个村庄建3所学校。第1个村庄与第2个村庄距离为2，第2个村庄与第3个村庄距离为4，第3个村庄与第4个村庄距离为6，...，第9个村庄到第10个村庄的距离为3。
输出
各村庄到最近学校的距离之和的最小值。
样例输入
10 2
3 1 3 1 1 1 1 1 3
样例输出
18青少年软件编程（C语言）等级考试试卷（五级）
漫漫回国路
2020年5月，国际航班机票难求。一位在美国华盛顿的中国留学生，因为一些原因必须在本周内回到北京。现在已知各个机场之间的航班情况，求问他回不回得来（不考虑转机次数和机票价格）。
时间限制：1000
内存限制：65536
输入
第一行为case个数n(n \< 10)。 每一个case，第一行为机场个数N，N ≤ 10。 之后的N行，每一行包含N个整数。第i（1 ≤ i ≤ N）行的第j（1 ≤ j ≤ N）个整数代表从第i个机场出发到第j个机场的能买到的航班的最低票价t（0 \< t \< 10000）。如果不幸没有航班，那么用-1表示。第i行第i个整数为0。 起点华盛顿杜勒斯国际机场的编号为1，终点北京首都国际机场的编号为N。
输出
每一个case一行。 能够回国，输出字符串：YES。如果无法回国，输出字符串：NO
样例输入
2
3
0 100 -1
-1 0 200
-1 -1 0
4
0 1 5 -1
3 0 1 -1
2 4 0 -1
4 1 1 0
样例输出
YES
NO
通配符匹配
给定一个字符串s和一个字符模式p，请实现一个支持'?'和'\*'的通配符匹配功能。
其中'?'可以匹配任何单个字符，如'a?c'可以成功匹配'aac','abc'等字符串，但不可匹配'ac','aaac'等字符串 。
'\*' 可以匹配任意长度字符串（包括空字符串）,如'a\*c'可以成功匹配'ac','abdc','abc','aaac'等字符串，但不可匹配'acb'，'cac'等字符串。
两个字符串完全匹配才算匹配成功。
时间限制：2000
内存限制：262144
输入
输入为一个数字n表示测试字符串与字符模式对数，换行。(n ≤ 30) 后续2n行为每组匹配的s与p，每行字符串后换行。 s 非空，只包含从 a-z 的小写字母。 p 非空，只包含从 a-z 的小写字母，以及字符 ? 和 \*。 字符串s和p的长度均小于50
输出
每一组匹配串匹配成功输出'yes',否则输出'no'。
样例输入
3
abc
abc
abc
a\*c
abc
a??c
样例输出
yes
yes
no
求逆序对数
对于一个长度为N的整数序列A，满足i \< j 且 Ai \> Aj.的数对(i,j)称为整数序列A的一个逆序 \\\\
请求出整数序列A的所有逆序对个数
时间限制：500
内存限制：65536
输入
输入包含多组测试数据，每组测试数据有两行 第一行为整数N(1 \<= N \<= 20000)，当输入0时结束 第二行为N个整数，表示长为N的整数序列
输出
每组数据对应一行，输出逆序对的个数
样例输入
5
1 2 3 4 5
5
5 4 3 2 1
1
1
0
样例输出
0
10
0
分成互质组
给定n个正整数，将它们分组，使得每组中任意两个数互质。至少要分成多少个组？
时间限制：1000
内存限制：65536
输入
第一行是一个正整数n。1 \<= n \<= 10。 第二行是n个不大于10000的正整数。
输出
一个正整数，即最少需要的组数。
样例输入
6
14 20 33 117 143 175
样例输出
3青少年软件编程（C语言）等级考试试卷（六级）
区间合并
给定 n 个闭区间 \[ai; bi\]，其中i=1,2,...,n。任意两个相邻或相交的闭区间可以合并为一个闭区间。例如，\[1;2\] 和 \[2;3\] 可以合并为 \[1;3\]，\[1;3\] 和 \[2;4\] 可以合并为 \[1;4\]，但是\[1;2\] 和 \[3;4\] 不可以合并。
我们的任务是判断这些区间是否可以最终合并为一个闭区间，如果可以，将这个闭区间输出，否则输出no。
时间限制：1000
内存限制：65536
输入
第一行为一个整数n，3 ≤ n ≤ 50000。表示输入区间的数量。 之后n行，在第i行上（1 ≤ i ≤ n），为两个整数 ai 和 bi ，整数之间用一个空格分隔，表示区间 \[ai; bi\]（其中 1 ≤ ai ≤ bi ≤ 10000）。
输出
输出一行，如果这些区间最终可以合并为一个闭区间，输出这个闭区间的左右边界，用单个空格隔开；否则输出 no。
样例输入
5
5 6
1 5
10 10
6 9
8 10
样例输出
1 10
电话号码
给你一些电话号码，请判断它们是否是一致的，即是否有某个电话是另一个电话的前缀。比如： Emergency 911 Alice 97 625 999 Bob 91 12 54 26 在这个例子中，我们不可能拨通Bob的电话，因为Emergency的电话是它的前缀，当拨打Bob的电话时会先接通Emergency，所以这些电话号码不是一致的。
时间限制：1000
内存限制：65536
输入
第一行是一个整数t，1 ≤ t ≤ 40，表示测试数据的数目。 每个测试样例的第一行是一个整数n，1 ≤ n ≤ 10000，其后n行每行是一个不超过10位的电话号码。
输出
对于每个测试数据，如果是一致的输出"YES"，如果不是输出"NO"。
样例输入
2
3
911
97625999
91125426
5
113
12340
123440
12345
98346
样例输出
NO
YES
扑克牌排序
假设这里有36张扑克牌，分别为A1\~A9,B1\~B9,C1\~C9,D1\~D9，其中A代表方片，B代表草花，C代表红桃，D代表黑桃，那么，设定如下的排序规则：
1.对于两张卡牌，X1Y1与X2Y2，X1与X2表示A～D，Y1与Y2表示1～9，如果X1与X2不同，那么依照D\>C\>B\>A的方式进行排序
2.假如有X1与X2相同时，那么就比较Y1与Y2的大小。
例如，对于如下的四张牌，有如下的升序排序结果：
D3，C4，A4，C1
升序排序的结果为A4，C1，C4，D3
有人提出了如下的排序策略：
先建立9个队列，用于存放点数的大小，将卡牌依点数存放入各自的队列之中，然后再按队列1到队列9依次出队。
例如，对于上面的结果，依次进队后，结果如下：
队列1：C1；队列3：D3，队列4：C4，A4
将其依次出队后，结果为C1，D3，C4，A4
然后，再建立4个队列，用于存放花色。将卡牌依花色A～D存放入队列1～4中，然后再按队列1到队列4依次出队。
例如，对于上面刚刚出队的序列C1，D3，C4，A4，将其依次进队，结果如下：
队列1：A4；队列3：C1，C4；队列4：D3
将其依次出队后，结果为A4，C1，C4，D3，排序结束。
请根据上面的算法，编写一个用队列对扑克牌排序的程序，要求依照上面的排序规则，根据先花色后点数的方法进行排序。
时间限制：1000
内存限制：65536
输入
输入分为两行，第一行为一个整数n，表示一共有n张牌（1\<=n\<=100） 第二行用XY的形式表示每一张牌，其中X为A～D，Y为1～9
输出
输出三个部分 第一个部分为第一次进队出队的结果，用Queue1:...表示，共9行，结果用空格分隔，下同 第二部分为第二次进队出队的结果，用QueueA:...表示，共4行 第三部分为一行，即将卡牌排序后的结果（升序排序）
样例输入
8
D8 A6 C3 B8 C5 A1 B5 D3
样例输出
Queue1:A1
Queue2:
Queue3:C3 D3
Queue4:
Queue5:C5 B5
Queue6:A6
Queue7:
Queue8:D8 B8
Queue9:
QueueA:A1 A6
QueueB:B5 B8
QueueC:C3 C5
QueueD:D3 D8
A1 A6 B5 B8 C3 C5 D3 D8
提示
第二次入队出队时，可以复用第一次时9个队列中的4个。所以其实只需要开辟9个队列即可。
现代艺术
在对二维艺术作品感到厌烦之后，伟大的艺术牛Picowso决定从事创作一项更为小众的艺术形式，一维画。
尽管目前她的画作可以用一个由颜色组成的长度为N(1\~100000)的数组表示，但她的创作风格依然保持不变：从一张空白的矩形画布上，不断地画上一些矩形，在一维的情况下，这些矩形就只是一个区间。她用N种颜色，颜色编号为1\~N进行创作，每种颜色只使用一次，之后使用的颜色可以完全的覆盖之前在相同位置上的颜色。
令Picowso感到十分沮丧的是，她的竞争对手Moonet似乎弄明白了如何复制她的这些一维画作，Moonet会画一些不相交的间隔，等待这些颜色晾干，然后再画另外的一些间隔，直到画完。Moonet每次每种颜色最多只能画一个间隔，但是他可以一次画不同颜色不相交的多个间隔，只要这些间隔没有重叠部分。之后Moonet再进行下一轮绘制。请计算Moonet为了复制一幅画需要画几个回合。
时间限制：10000
内存限制：65536
输入
第一行是一个整数N，之后N行包含了N个整数，范围0到N表示纸带每个格点的颜色，0表示没有涂色。
输出
输出一行，需要复制这幅画作的最少回合数，如果这幅画不可能是Picowso的画作输出-1（比如说这幅画不可能是通过一次在一条上画一层的方法进行创作的）
样例输入
7
0
1
4
5
1
3
3
样例输出
2
提示
在这个样例中，第一轮涂成0111133，第二轮涂成0145133，所以共需两轮。青少年软件编程（C语言）等级考试试卷（七级）
走迷宫
一个迷宫由R行C列格子组成，有的格子里有障碍物，不能走；有的格子是空地，可以走。 给定一个迷宫，求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。只能在水平方向或垂直方向走，不能斜着走。
时间限制：1000
内存限制：65536
输入
第一行是两个整数，Ｒ和Ｃ，代表迷宫的长和宽。（ 1\<= R，C \<= 40) 接下来是Ｒ行，每行Ｃ个字符，代表整个迷宫。 空地格子用'.'表示，有障碍物的格子用'#'表示。 迷宫左上角和右下角都是'.'。
输出
输出从左上角走到右下角至少要经过多少步（即至少要经过多少个空地格子）。计算步数要包括起点和终点。
样例输入
5 5
..###
#....
#.#.#
#.#.#
#.#..
样例输出
9
重建二叉树
给定一棵二叉树的前序遍历和中序遍历的结果，求其后序遍历。
时间限制：1000
内存限制：65536
输入
输入可能有多组，以EOF结束。 每组输入包含两个字符串，分别为树的前序遍历和中序遍历。每个字符串中只包含大写字母且互不重复。
输出
对于每组输入，用一行来输出它后序遍历结果。
样例输入
DBACEGF ABCDEFG
BCAD CBAD
样例输出
ACBFGED
CDAB
快速堆猪
小明有很多猪，他喜欢玩叠猪游戏，就是将猪一头头叠起来。猪叠上去后，还可以把顶上的猪拿下来。小明知道每头猪的重量，而且他还随时想知道叠在那里的猪最轻的是多少斤。
时间限制：1000
内存限制：65536
输入
有三种输入 1)push n n是整数(0\<=0 \<=20000)，表示叠上一头重量是n斤的新猪 2)pop 表示将猪堆顶的猪赶走。如果猪堆没猪，就啥也不干 3)min 表示问现在猪堆里最轻的猪多重。如果猪堆没猪，就啥也不干 输入总数不超过100000条
输出
对每个min输入，输出答案。如果猪堆没猪，就啥也不干
样例输入
pop
min
push 5
push 2
push 3
min
push 4
min
样例输出
2
2
表达式·表达式树·表达式求值
众所周知，任何一个表达式，都可以用一棵表达式树来表示。例如，表达式a+b\*c，可以表示为如下的表达式树：
+ / \\ a \* / \\ b c
现在，给你一个中缀表达式，这个中缀表达式用变量来表示（不含数字），请你将这个中缀表达式用表达式二叉树的形式输出出来。
时间限制：1000
内存限制：65535
输入
输入分为三个部分。 第一部分为一行，即中缀表达式(长度不大于50)。中缀表达式可能含有小写字母代表变量（a-z），也可能含有运算符（+、-、\*、/、小括号），不含有数字，也不含有空格。 第二部分为一个整数n(n \< 10)，表示中缀表达式的变量数。 第三部分有n行，每行格式为C x，C为变量的字符，x为该变量的值。
输出
输出分为三个部分，第一个部分为该表达式的逆波兰式，即该表达式树的后根遍历结果。占一行。 第二部分为表达式树的显示，如样例输出所示。如果该二叉树是一棵满二叉树，则最底部的叶子结点，分别占据横坐标的第1、3、5、7......个位置（最左边的坐标是1），然后它们的父结点的横坐标，在两个子结点的中间。如果不是满二叉树，则没有结点的地方，用空格填充（但请略去所有的行末空格）。每一行父结点与子结点中隔开一行，用斜杠（/）与反斜杠（\\）来表示树的关系。/出现的横坐标位置为父结点的横坐标偏左一格，\\出现的横坐标位置为父结点的横坐标偏右一格。也就是说，如果树高为m，则输出就有2m-1行。 第三部分为一个整数，表示将值代入变量之后，该中缀表达式的值。需要注意的一点是，除法代表整除运算，即舍弃小数点后的部分。同时，测试数据保证不会出现除以0的现象。
样例输入
a+b\*c
3
a 2
b 7
c 5
样例输出
abc\*+
+
/ \\
a \*
/ \\
b c
37青少年软件编程（C语言）等级考试试卷（八级）
生理周期
人生来就有三个生理周期，分别为体力、感情和智力周期，它们的周期长度为23天、28天和33天。每一个周期中有一天是高峰。在高峰这天，人会在相应的方面表现出色。例如，智力周期的高峰，人会思维敏捷，精力容易高度集中。因为三个周期的周长不同，所以通常三个周期的高峰不会落在同一天。对于每个人，我们想知道何时三个高峰落在同一天。对于每个周期，我们会给出从当前年份的第一天开始，到出现高峰的天数（不一定是第一次高峰出现的时间）。你的任务是给定一个从当年第一天开始数的天数，输出从给定时间开始（不包括给定时间）下一次三个高峰落在同一天的时间（距给定时间的天数）。例如：给定时间为10，下次出现三个高峰同天的时间是12，则输出2（注意这里不是3）。
时间限制：1000
内存限制：65536
输入
一行，包含四个整数：p, e, i和d，相邻两个整数之间用单个空格隔开。 p, e, i分别表示体力、情感和智力高峰出现的时间（时间从当年的第一天开始计算）。d 是给定的时间，可能小于p, e, 或 i。 所有给定时间是非负的并且小于等于365, 所求的时间小于等于21252。
输出
一个整数，即从给定时间起，下一次三个高峰同天的时间（距离给定时间的天数）。
样例输入
4 5 6 7
样例输出
16994
开关问题
有N个相同的开关，每个开关都与某些开关有着联系，每当你打开或者关闭某个开关的时候，其他的与此开关相关联的开关也会相应地发生变化，即这些相联系的开关的状态如果原来为开就变为关，如果为关就变为开。你的目标是经过若干次开关操作后使得最后N个开关达到一个特定的状态。对于任意一个开关，最多只能进行一次开关操作。你的任务是，计算有多少种可以达到指定状态的方法。（不计开关操作的顺序）
时间限制：1000
内存限制：65536
输入
输入第一行有一个数K，表示以下有K组测试数据。 每组测试数据的格式如下： 第一行 一个数N（0 \< N \< 29） 第二行 N个0或者1的数，表示开始时N个开关状态。 第三行 N个0或者1的数，表示操作结束后N个开关的状态。 接下来 每行两个数I J，表示如果操作第 I 个开关，第J个开关的状态也会变化。每组数据以 0 0 结束。
输出
如果有可行方法，输出总数，否则输出"Oh,it's impossible\~!!" 不包括引号
样例输入
2
3
0 0 0
1 1 1
1 2
1 3
2 1
2 3
3 1
3 2
0 0
3
0 0 0
1 0 1
1 2
2 1
0 0
样例输出
4
Oh,it's impossible\~!!
提示
第一组数据的说明： 一共以下四种方法： 操作开关1 操作开关2 操作开关3 操作开关1、2、3 （不记顺序）
冰阔落 I
老王喜欢喝冰阔落。
初始时刻，桌面上有n杯阔落，编号为1到n。老王总想把其中一杯阔落倒到另一杯中，这样他一次性就能喝很多很多阔落，假设杯子的容量是足够大的。
有m 次操作，每次操作包含两个整数x与y。
若原始编号为x 的阔落与原始编号为y的阔落已经在同一杯，请输出"Yes"；否则，我们将原始编号为y 所在杯子的所有阔落，倒往原始编号为x 所在的杯子，并输出"No"。
最后，老王想知道哪些杯子有冰阔落。
时间限制：10000
内存限制：65536
输入
有多组测试数据，少于 5 组。 每组测试数据，第一行两个整数 n, m (n, m\<=50000)。接下来 m 行，每行两个整数 x, y (1\<=x, y\<=n)。
输出
每组测试数据，前 m 行输出 "Yes" 或者 "No"。 第 m+1 行输出一个整数，表示有阔落的杯子数量。 第 m+2 行有若干个整数，从小到大输出这些杯子的编号。
样例输入
3 2
1 2
2 1
4 2
1 2
4 3
样例输出
No
Yes
2
1 3
No
No
2
1 4
最短路
给定一个n个点, m条边的有向图, 求从点S出发, 到其它所有点的最短路径.
时间限制：2000
内存限制：65536
输入
第一行一个整数T, 表示有T组数据 对于每组测试数据, 第一行三个整数n, m, S, 表示有n个点, m条边, 起点为S. 接下来m行, 每行三个整数x, y, z, 代表从x到y有长度为z的边 点的编号从1到n T \<= 10, n \<= 10000, m \<= 20000, \|z\| \<= 10000. 所有数据的n之和 \<= 30000, 所有数据的m之和 \<= 60000.
输出
对于每组数据: 如果从S点出发可以走入负圈 (即到某些点的最短路径可以无限小), 那么输出一行Error. 否则, 输出一行用空格分隔的n个整数, 其中第i个整数表示从S点到i点的最短路长度. 如果从S点无法到达i点, 则第i个输出为"null".
样例输入
4
5 7 1
1 2 3
2 3 4
3 4 8
1 3 9
4 5 1
1 4 5
1 5 10
4 4 1
1 2 -4
2 3 8
1 3 5
3 4 0
3 3 2
1 2 -3
2 3 -4
3 1 6
4 2 1
1 2 1
3 4 2
样例输出
0 3 7 5 6
0 -4 4 4
Error
0 1 null null青少年软件编程（C语言）等级考试试卷（一级）
分数：100 题数：5
一、编程题(共5题，共100分)
1. 倒序输出 依次输入4个整数a、b、c、d,将他们倒序输出，即依次输出d、c、b、a这4个数。 时间限制：1000 内存限制：65536 输入 一行4个整数a、b、c、d，以空格分隔。 0 \< a,b,c,d \< 108 输出 一行4个整数d、c、b、a，整数之间以一个空格分隔。 样例输入 1 2 3 4 样例输出 4 3 2 1 试题编号：20240323-1-01 试题类型：编程题 标准答案： 试题难度：一般 试题解析： 展示地址：点击浏览 考生答案： #include\ using namespace std; int main(){ int a,b,c,d; cin\>\>a\>\>b\>\>c\>\>d; cout\<\ using namespace std; int main(){ int sum=0,x,y,z; cin\>\>x\>\>y\>\>z; sum+=x\*3; sum+=y\*1; sum+=z\*0; cout\<\ using namespace std; int main(){ int n,x,y; cin\>\>n\>\>x\>\>y; n=n-y\*1.0/x; if(n\<=0)n=0; cout\<\ using namespace std; int main(){ int k,x,a=0,b=0,c=0; cin\>\>k; for(int i=1;i\<=k;i++){ cin\>\>x; if(x==1)a+=1; if(x==5)b+=1; if(x==10)c+=1; } cout\<\
using namespace std;
int n, a, b, c, m, k;
int main() {
cin \>\> n;
for (int i = 100; i \<= 999; i++) {
a = i / 100;
b = (i / 10) % 10;
c = i % 10;
k = sqrt(i);
if (a == b \|\| a == c \|\| b == c) {
if (k \* k == i)
m++;
}
if (m == n) {
cout \<\< i;
return 0;
}
}
return 0;
}
考生得分：20
是否评分：已评分
评价描述：青少年软件编程（C语言）等级考试试卷（二级）
分数：100 题数：5
一、编程题(共5题，共100分)
1. 满足条件的数的累加2 现有n个整数，将其中个位数为k的数进行累加求和。 时间限制：1000 内存限制：65536 输入 第一行1个整数n。（ 0 \< n \< 1000） 第二行n个非负整数，以空格分隔，每个数不大于100000。 第三行1个整数k。(0 ≤ k ≤ 9) 输出 输出满足题目要求的累加和。 样例输入 10 2 5 7 17 11 18 4 27 1 7 7 样例输出 58 试题编号：20240323-2-01 试题类型：编程题 标准答案： 试题难度：一般 试题解析： 展示地址：点击浏览 考生答案： #include\ using namespace std; int main() { int n; cin\>\>n; int a\[n+1\]; for(int i=1;i\<=n;i++) { cin\>\>a\[i\]; } int k; cin\>\>k; int sum=0; for(int i=1;i\<=n;i++) { if(a\[i\]%10==k) { sum+=a\[i\]; } } cout\<\ using namespace std; int main(){ int n,score=-1,ans=0; cin\>\>n; for(int i=1;i\<=n;i++){ int sum=0,x; for(int j=1;j\<=n;j++){ cin\>\>x; if(x\>=3) sum++; } if(sum\>score){ score=sum; ans=i; } } cout\<\ using namespace std; bool f(int a,int b) { return a\>b; } int main() { int a\[10\],b\[10\],c\[10\]; int j,k; j=k=0; for(int i=0;i\<10;i++) { cin\>\>a\[i\]; } for(int i=0;i\<10;i++) { if(a\[i\]%2!=0) { b\[j++\]=a\[i\]; } else { c\[k++\]=a\[i\]; } } sort (b,b+j,f); for(int i=0;i\=0;i--) { cout\<\ using namespace std; int main(){ int a; cin\>\>a; for(int i=1;i\<100000;i++){ for(int j=1;j\<=i;j++){ if((i+1)\*i/2-j\*2==a){ cout\<\ using namespace std; char map_\[12\]\[12\]; int x\[4\]={-1,1,0,0}; int y\[4\]={0,0,-1,1}; int k,m,t,sign; void dfs(int a,int b,int n){ if(n\>t) return; for(int i=0;i\<4;i++){ int aa=a+x\[i\]; int bb=b+y\[i\]; if(aa\>=1\&\&aa\<=m\&\&bb\>=1\&\&bb\<=m){ if(map_\[aa\]\[bb\]=='.'){ map_\[aa\]\[bb\]='#'; dfs(aa,bb,n+1); map_\[aa\]\[bb\]='.'; } else if(map_\[aa\]\[bb\]=='E'){ sign=1;return; } } } } int main() { int x1,y1; cin\>\>k; while(k--){ cin\>\>m\>\>t; for(int i=1;i\<=m;i++) for(int j=1;j\<=m;j++){ cin\>\>map_\[i\]\[j\]; if(map_\[i\]\[j\]=='S'){ x1=i;y1=j; } } sign=0; dfs(x1,y1,1); if(sign) cout\<\<"YES"\<\ 1)标记, 代表该线索的难度 小Y需要按照难度递增的顺序解开各个线索，逃脱密室。 时间限制：1000 内存限制：65536 输入 第一行是一个整数 T，表示输入包含 T 组数据，分别是不同的游戏中小Y所处的密室。 对于每组数据，第一行包括两个整数：m（1 \<= m \<= 100）、n（1 \<= n \<= 100）。 接下来 m 行，每行有n个数字，第 i 行的第 j 个数字表示密室中第 i 行第 j 列的格子的类型。 题目保证进入密室处(1,1)不是墙壁，线索的难度都不相同。 输出 对于每组数据，你需要输出一个整数，表示小Y在这个密室中至少要移动多少次才能成功通关。 如果小Y不可能解开所有线索，输出-1. 样例输入 2 3 3 1 3 2 1 0 4 10 6 5 3 3 1 3 2 0 0 0 10 6 5 样例输出 8 -1 提示 样例解释：由于需要按难度顺序解开线索，在第一组数据中，小Y第一次移动到3时不能解密，在完成2之后需要回到3.最后小Y解开10时，她成功通关。 试题编号：20240323-5-02 试题类型：编程题 标准答案： 试题难度：一般 试题解析： 展示地址：点击浏览 考生答案： #include \ #include \ #include \ #include \ using namespace std; int m,n; int maze\[104\]\[104\] = {}; int dx\[4\] = {0,0,-1,1}; int dy\[4\] = {-1,1,0,0}; bool legal(int x, int y){ if(0 \<= x \&\& x\< m \&\& 0 \<= y \&\& y \< n \&\& maze\[x\]\[y\] != 0) return 1; return 0; } struct Node{ int x, y, k, t; }; int main() { int T; cin \>\> T; while(T--){ memset(maze, 0, sizeof(maze)); int vis\[104\]\[104\] = {}; memset(vis, 0xff, sizeof(vis)); int S\[10050\] = {}; int cnt = 0; cin \>\> m \>\> n; for(int i = 0; i \< m; ++i){ for(int j = 0; j \< n; ++j){ cin \>\> maze\[i\]\[j\]; if (maze\[i\]\[j\] \> 1) { S\[cnt++\] = maze\[i\]\[j\]; } } } queue\ open; sort(S, S + cnt); if (maze\[0\]\[0\] == S\[0\]) { open.push({0, 0, 1, 0}); vis\[0\]\[0\] = 1; } else { open.push({0, 0, 0, 0}); vis\[0\]\[0\] = 0; } bool flag = 0; while (!open.empty()) { Node temp = open.front(); open.pop(); if (temp.k == cnt) { flag = 1; cout \<\< temp.t \<\< endl; break; } for (int i = 0; i \< 4; i++) { int x = temp.x + dx\[i\], y = temp.y + dy\[i\], k = temp.k; if (!legal(x,y)) continue; if (maze\[x\]\[y\] == S\[k\]) k++; if (vis\[x\]\[y\] \>= k) continue; vis\[x\]\[y\] = k; open.push({x, y, k, temp.t + 1}); } } if (!flag) cout \<\< -1 \<\< endl; } return 0; } 考生得分：25 是否评分：已评分 评价描述：
3. 交易市场 市场里面一共有n种物品，有m种交易途径，每个交易途径可以由(x,y,z)表示，意思是可以用第x种物品换成第y种物品，并且得到z元的收益（z均大于0）。最开始你只有第一种物品，请问最多可以赚取多少收益。 时间限制：1000 内存限制：65536 输入 第一行两个正整数n和m(n ≤ 1000，m ≤ 4000) 接下来m行，每行三个正整数x, y, z，意思是可以用第x种物品换成第y种物品，并且得到z元的收益。（1 ≤ x,y ≤ n, 1 ≤ z ≤ 100） 输出 一个整数表示最大收益，如果可以赚取无穷多的收益则输出1000000000 样例输入 3 3 1 2 2 2 3 3 1 3 4 样例输出 5 试题编号：20240323-5-03 试题类型：编程题 标准答案： 试题难度：一般 试题解析： 展示地址：点击浏览 考生答案： #include \ #include \ #include \ #include \ #include \ #include \ #include \ #define INF 1000000000 using namespace std; struct exchangeTo { int target; int p; exchangeTo(int a, int b) :target(a), p(b) {} }; struct path { int pre; int val; }dp\[1005\]; map\ \>tables; bool inPath(int n, int k) { while (k != -1) { if (n == k) return true; k = dp\[k\].pre; } return false; } int main() { memset(dp, -1, sizeof(dp)); int n, m; cin \>\> n \>\> m; for (int i = 0; i \< m; i++) { int x, y, z; cin \>\> x \>\> y \>\> z; tables\[x\].push_back(exchangeTo(y, z)); } dp\[1\].val = 0, dp\[1\].pre = 0; bool done = false; int result = 0; queue\myqueues; myqueues.push(1); while (!myqueues.empty()) { int top = myqueues.front(); myqueues.pop(); if (!tables\[top\].empty()) { vector\::iterator ii; for (ii = tables\[top\].begin(); ii != tables\[top\].end(); ii++) { if (inPath(ii-\>target, top)) { result = INF; done = true; break; } if (dp\[top\].val + ii-\>p \> dp\[ii-\>target\].val) { dp\[ii-\>target\].val = dp\[top\].val + ii-\>p; dp\[ii-\>target\].pre = top; myqueues.push(ii-\>target); } result = max(result, dp\[ii-\>target\].val); } if (done)break; } } cout \<\< result \<\< endl; return 0; } 考生得分：25 是否评分：已评分 评价描述：
4. 求逆序对问题
给定N个数的序列a1,a2,...aN，定义一个数对(ai, aj)为"重要逆序对"的充要条件为 i \< j 且 ai \> 2aj。求给定序列中"重要逆序对"的个数。
时间限制：1000
内存限制：256000
输入
本题有多个测试点，每个测试点分为两行：第一行为序列中数字的个数N（1 ≤ N ≤ 200000），第二行为序列a1, a2 ... aN(0 ≤a ≤ 10000000)，由空格分开。N=0表示输入结束。
输出
每个测试点一行，输出一个整数，为给序列中"重要逆序对"的个数。
样例输入
10
0 9 8 7 6 5 4 3 2 1
0
样例输出
16
提示
请注意答案范围，如果使用printf输出long long类型，请用%lld
试题编号：20240323-5-04
试题类型：编程题
标准答案：
试题难度：一般
试题解析：
展示地址：点击浏览
考生答案：
#include \
using namespace std;
int arr\[200005\];
int tmp\[200005\];
int N;
long long mergesort(int start,int end){
long long cnt=0, mid=(start+end)/2;
if(start\>=end) return 0;
cnt+=mergesort(start,mid);
cnt+=mergesort(mid+1,end);
int i=start,j=mid+1;
while(i\<=mid \&\& j\<=end){
if(arr\[i\]\>2\*arr\[j\] \&\& j\<=end){
cnt+=(mid-i+1);
j++;
}else{
i++;
}
}
i=start,j=mid+1;
int idx=0;
while(i\<=mid \&\& j\<=end){
if(arr\[i\]\>arr\[j\]){
tmp\[idx++\]=arr\[j++\];
}else{
tmp\[idx++\]=arr\[i++\];
}
}
while(i\<=mid) tmp\[idx++\]=arr\[i++\];
while(j\<=end) tmp\[idx++\]=arr\[j++\];
for(int k=0;k\\>N){
if(N==0) break;
for(int i=1;i\<=N;i++){
cin\>\>arr\[i\];
}
cout\<\ using namespace std; struct shu { int n; string s; }a\[100010\]; bool cmp(shu a,shu b) { return a.n\\>N; for(int i=0;i\\>a\[i\].n\>\>a\[i\].s; } sort(a,a+N,cmp); for(int i=0;i\ using namespace std; char a\[101\],b\[101\]; int up(int c) { if(c==-1) return -1; else if(b\[c\]=='$') return c; else return up(c-1); } int main() { while(scanf("%s",a)!=-1) { printf("%s\\n",a); int n=strlen(a); memset(b,' ',sizeof(b)); for(int i=0;i\ using namespace std; string Struct; bool H; int push\[2005\]; int pop\[2005\]; int main() { int t; cin\>\>t; while(t--) { int n,type,val,Innum=0,Outnum=0; cin\>\>n; for(int i=0;i\\>type\>\>val; if(type==1) { push\[Innum++\]=val; } else { pop\[Outnum++\]=val; } } int num=min(Innum,Outnum); H=false; for(int i=0;i\
using namespace std;
int get_digit_number(int x, int i)
{
int tmp = pow(10, i);
x /= tmp;
return x % 10;
}
int how_many_digits(int x)
{
int ret = 1;
while ((x /= 10) != 0)
++ret;
return ret;
}
vector\ q\[5\]\[10\];
int main()
{
int n;
int max_digits = 0;
cin \>\> n;
for (int i = 0; i \< n; ++i)
{
int t; cin \>\> t;
max_digits = max(max_digits, how_many_digits(t));
q\[0\]\[t % 10\].push_back(t);
}
ostringstream sout;
for (int i = 1; i \<= max_digits; ++i)
{
printf("Step%d.\\n", i);
for (int j = 0; j \< 10; ++j)
{
printf("Queue%d:", j);
for (int e : q\[i-1\]\[j\])
{
printf("%d ", e);
if (i == max_digits)
sout \<\< e \<\< " ";
else
q\[i\]\[get_digit_number(e, i)\].push_back(e);
}
printf("\\n");
}
}
cout \<\< sout.str() \<\< endl;
return 0;
}
考生得分：25
是否评分：已评分
评价描述：青少年软件编程（C语言）等级考试试卷（七级）
分数：100 题数：4
一、编程题(共4题，共100分)
1. 走出迷宫 当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。 假设你已经得到了一个n\*m的迷宫的图纸，请你找出从起点到出口的最短路。 时间限制：1000 内存限制：65536 输入 第一行是两个整数n和m(1\<=n,m\<=100)，表示迷宫的行数和列数。 接下来n行，每行一个长为m的字符串，表示整个迷宫的布局。字符'.'表示空地，'#'表示墙，'S'表示起点,'T'表示出口。 输出 输出从起点到出口最少需要走的步数。 样例输入 3 3 S#T .#. ... 样例输出 6 试题编号：20240323-7-01 试题类型：编程题 标准答案： 试题难度：一般 试题解析： 展示地址：点击浏览 考生答案：（此题已作答） 考生得分：0 是否评分：已评分 评价描述：
2. 有多少种二叉树 输入n(1\ using namespace std; int main(){ long long n,n1=1,y=0; cin\>\>n; for(long long i=1;i\