Scratch编程一级 题库
二叉树的深度
给定一棵二叉树,求该二叉树的深度
二叉树深度定义:从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的节点个数为树的深度
时间限制:1000
内存限制:65535
输入
第一行是一个整数n,表示二叉树的结点个数。二叉树结点编号从1到n,根结点为1,n <= 10 接下来有n行,依次对应二叉树的n个节点。 每行有两个整数,分别表示该节点的左儿子和右儿子的节点编号。如果第一个(第二个)数为-1则表示没有左(右)儿子
输出
输出一个整型数,表示树的深度
样例输入
3 2 3 -1 -1 -1 -1
样例输出
2
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
struct node {
int left, right;
} t[MAXN];
int n;
void build() {
for (int i = 1; i <= n; i++) {
cin >> t[i].left >> t[i].right;
}
}
#define rep1(i, n) for (int i = 1; i <= n; i++)
inline int dfs(int x) {
if (x == -1)
return 0;
return max(dfs(t[x].left), dfs(t[x].right)) + 1;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
build();
cout << dfs(1);
return 0;
}//题解2
#include <algorithm>
#include <iostream>
using namespace std;
int meng[102][30]; /*a[i][0]表示节点i的左孩子节点编号,
a[i][1]表示节点i的右孩子节点编号,a[i][2]表示i节点的父节点编号。*/
int a, b;
int dfs(int root) {
if (meng[root][0] == -1 && meng[root][1] == -1)
return 1;
else {
int left = 0, right = 0;
if (meng[root][0] >= 0)
left = dfs(meng[root][0]);
/*如果该节点满足不为-1证明它有父节点,
递归回去去证明它的父节点上面是否也有父节点*/
if (meng[root][1] >= 0) {
right = dfs(meng[root][1]);
}
return max(right, left) + 1;
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a >> b;
// 二维是为了更好的判断左孩子还是右孩子,父节点
meng[i][0] = a; // i的左孩子是a
meng[i][1] = b; // i的右孩子是b
}
cout << dfs(1) << endl;
return 0;
}Sequence
给定m个数字序列,每个序列包含n个非负整数。我们从每一个序列中选取一个数字组成一个新的序列,显然一共可以构造出nm个新序列。接下来我们对每一个新的序列中的数字进行求和,一共会得到nm个和,请找出最小的n个和
时间限制:3000
内存限制:65536
输入
输入的第一行是一个整数T,表示测试用例的数量,接下来是T个测试用例的输入 每个测试用例输入的第一行是两个正整数m(0 < m <= 100)和n(0 < n <= 2000),然后有m行,每行有n个数,数字之间用空格分开,表示这m个序列 序列中的数字不会大于10000
输出
对每组测试用例,输出一行用空格隔开的数,表示最小的n个和
样例输入
1 2 3 1 2 3 2 2 3
样例输出
3 3 4
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
priority_queue<int> que;
int a[2005];
int b[2005]; // 用作中间数组
int main() {
int T;
cin >> T;
int m, n;
while (T--) {
cin >> m >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n); // 用a做总的和数组
for (int i = 1; i < m; i++) // 轮接下来的序列
{
for (int j = 0; j < n; j++) {
scanf("%d", &b[j]);
que.push(a[0] + b[j]);
}
for (int j = 1; j < n; j++) {
for (int k = 0; k < n; k++) {
if (a[j] + b[k] < que.top()) {
que.pop();
que.push(a[j] +
b[k]); // 比最大值小就顶了它,想要得到ab两个里面最小的n个数
}
}
}
for (int i = 0; i < n; i++) {
a[n - i - 1] = que.top(); // 由于是最大值堆,要反过来让a有序
que.pop(); // 队列已经被清空了,轮下一次
}
}
for (int i = 0; i < n - 1; i++)
printf("%d ", a[i]);
printf("%d\n", a[n - 1]);
}
return 0;
}stack or queue
栈和队列都是常用的线性结构,它们都提供两个操作:
Push:加入一个元素。
Pop:弹出一个元素。
不同的是,栈是”先进后出”,而队列则是”先进先出”。
给出一个线性结构的进出顺序,判定这个结构是栈还是队列。
时间限制:1000
内存限制:65535
输入
第一行输入一个整数t,代表有t组测试数据 对于每组测试数据,第一行输入一个整数n,代表操作的次数。 随后输入n行,每行包含两个整数 type val。 当type = 1时,表示该次操作为push操作,val表示进入的数字。当type=2时,表示该次操作为pop操作,val代表出来的数字。 3<=n<=2000
输出
每组测试数据输出一行。 输出该组数据对应的线性结构,”Stack” 或者 “Queue”。 题目保证是栈或者队列的一种。
样例输入
2 6 1 1 1 2 1 3 2 3 2 2 2 1 4 1 1 1 2 2 1 2 2
样例输出
Stack Queue
#include <deque>
#include <iostream>
using namespace std;
int main() {
int t;
scanf("%d", &t);
deque<int> ds; // imitating stack
for (int i = 0; i < t; i++) {
int n;
bool tag = false;
scanf("%d", &n);
for (int j = 0; j < n; j++) {
int type, val;
scanf("%d%d", &type, &val);
if (tag)
continue;
if (type == 1) {
ds.push_back(val);
} else {
int s = ds.back();
ds.pop_back();
if (s != val) {
printf("Queue\n");
tag = true;
}
}
}
if (!tag)
printf("Stack\n");
ds.clear();
}
}栈的基本操作
栈是一种重要的数据结构,它具有push k和pop操作。push k是将数字k加入到栈中,pop则是从栈中取一个数出来。
栈是后进先出的:把栈也看成横向的一个通道,则push k是将k放到栈的最右边,而pop也是从栈的最右边取出一个数。
假设栈当前从左至右含有1和2两个数,则执行push 5和pop操作示例图如下:
push 5 pop
1
栈 1 2 -------> 1 2 5 ------> 1 2
现在,假设栈是空的。给定一系列push k和pop操作之后,输出栈中存储的数字。若栈已经空了,仍然接收到pop操作,则输出error。
时间限制:1000
内存限制:65536
输入
第一行为m,表示有m组测试输入,m<100。 每组第一行为n,表示下列有n行push k或pop操作。(n<150) 接下来n行,每行是push k或者pop,其中k是一个整数。 (输入保证同时在栈中的数不会超过100个)
输出
对每组测试数据输出一行。该行内容在正常情况下,是栈中从左到右存储的数字,数字直接以一个空格分隔,如果栈空,则不作输出;但若操作过程中出现栈已空仍然收到pop,则输出error。
样例输入
2 4 push 1 push 3 pop push 5 1 pop
样例输出
1 5 error
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define M 1000
typedef struct {
int num[M];
int top;
} stack;
void push(stack *p, int i) {
if (p->top == M - 1)
return;
else {
p->num[++(p->top)] = i;
return;
}
}
int pop(stack *p) {
if (p->top == -1) {
return 0;
} else
return (p->num[(p->top)--]);
}
int main() {
int m, n, i, j;
char s[5];
stack *p;
scanf("%d", &m);
while (m--) {
int t = 0;
p = (stack *)malloc(sizeof(stack));
p->top = -1;
scanf("%d", &n);
while (n--) {
scanf("%s", s);
if (strcmp(s, "push") == 0) {
scanf("%d", &i);
push(p, i);
} else {
if (p->top == -1)
t = 1;
pop(p);
}
}
if (t == 1)
printf("error\n");
else {
if (p->top != -1) {
for (j = 0; j < (p->top); j++)
printf("%d ", p->num[j]);
printf("%d\n", p->num[p->top]);
}
}
}
return 0;
}合影效果
小云和朋友们去爬香山,为美丽的景色所陶醉,想合影留念。如果他们站成一排,男生全部在左(从拍照者的角度),并按照从矮到高的顺序从左到右排,女生全部在右,并按照从高到矮的顺序从左到右排,请问他们合影的效果是什么样的(所有人的身高都不同)?
时间限制:1000
内存限制:65536
输入
第一行是人数n(2 <= n <= 40,且至少有1个男生和1个女生)。 后面紧跟n行,每行输入一个人的性别(男male或女female)和身高(浮点数,单位米),两个数据之间以空格分隔。
输出
n个浮点数,模拟站好队后,拍照者眼中从左到右每个人的身高。每个浮点数需保留到小数点后2位,相邻两个数之间用单个空格隔开。
样例输入
6 male 1.72 male 1.78 female 1.61 male 1.65 female 1.70 female 1.56
样例输出
1.65 1.72 1.78 1.70 1.61 1.56
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<float> Men;
vector<float> Women;
string gender;
float height;
for (int i = 1; i <= n; i++) {
cin >> gender >> height;
if (gender == "male") {
Men.push_back(height);
} else if (gender == "female") {
Women.push_back(height);
}
}
sort(Men.begin(), Men.end(), less<float>()); // sort ascending
sort(Women.begin(), Women.end(), greater<float>()); // sort descending
cout << setiosflags(ios::fixed);
copy(Men.begin(), Men.end(),
ostream_iterator<float>(cout << setprecision(2), " "));
copy(Women.begin(), Women.end(),
ostream_iterator<float>(cout << setprecision(2), " "));
cout << endl;
return 0;
}最长上升子序列
一个数的序列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
#include <bits/stdc++.h>
#define fio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
using namespace std;
const int maxn = 1010;
int a[maxn];
int maxLen[maxn];
int main() {
fio int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
maxLen[i] = 1;
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j < i; j++) {
if (a[i] > a[j]) {
maxLen[i] = max(maxLen[i], maxLen[j] + 1);
}
}
}
cout << *max_element(maxLen + 1, maxLen + n + 1) << endl;
}神奇的口袋
有一个神奇的口袋,总的容积是40,用这个口袋可以变出一些物品,这些物品的总体积必须是40。John现在有n个想要得到的物品,每个物品的体积分别是a1,a2……an。John可以从这些物品中选择一些,如果选出的物体的总体积是40,那么利用这个神奇的口袋,John就可以得到这些物品。现在的问题是,John有多少种不同的选择物品的方式。
时间限制:10000
内存限制:65536
输入
输入的第一行是正整数n (1 <= n <= 20),表示不同的物品的数目。接下来的n行,每行有一个1到40之间的正整数,分别给出a1,a2……an的值。
输出
输出不同的选择物品的方式的数目。
样例输入
3 20 20 20
样例输出
3
#include <bits/stdc++.h>
using namespace std;
int goods[30];
// 从前k种物品中选择一些,凑成体积w的做法数目
int ways(int w, int k) {
if (w == 0)
return 1; // 没有需要凑的体积了,刚好凑满
if (k <= 0)
return 0; // 还差体积或者体积过了,但是没有物品可以选了。
if (w >= goods[k]) {
return ways(w, k - 1) +
ways(w - goods[k], k - 1); // 体积:选择第k种物品 + 不选第k种物品
} else {
return ways(w, k - 1);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &goods[i]);
}
printf("%d", ways(40, n));
return 0;
}课程冲突
小 A 修了 n 门课程, 第 i 门课程是从第 ai 天一直上到第 bi 天。
定义两门课程的冲突程度为 : 有几天是这两门课程都要上的。
例如 a1=1,b1=3,a2=2,b2=4 时, 这两门课的冲突程度为 2。
现在你需要求的是这 n 门课中冲突程度最大的两门课的冲突程度。
时间限制:1000
内存限制:65536
输入
第一行一个正整数 n 表示课程数量。接下来 n 行,每行两个正整数 ai,bi。 2 ≤ n≤ 1000, 1 ≤ai ≤bi ≤ 1000。
输出
输出一个整数表示最大的冲突程度。
样例输入
3 1 3 2 4 5 5
样例输出
2
#include <bits/stdc++.h>
using namespace std;
// #define PPYDEBUG
struct lesson {
int no; // 课程编号
int a; // 课程开始a天
int b; // 课程结束b天
};
int max_chongtu(lesson x, lesson y) {
int r = min(x.b, y.b) - max(x.a, y.a) + 1;
if (r < 0) {
r = 0;
}
#ifdef PPYDEBUG
printf("%d = x[%d,%d] - y[%d,%d]\n", r, x.a, x.b, y.a, y.b);
#endif
return r;
}
int main() {
#ifdef LOCAL
freopen("202209_3_1.in", "r", stdin);
#endif
int n;
scanf("%d", &n);
lesson le[1010];
for (int i = 0; i < n; i++) {
le[i].no = i + 1;
scanf("%d%d", &le[i].a, &le[i].b);
}
int r = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
r = max(r, max_chongtu(le[i], le[j]));
}
}
printf("%d", r);
return 0;
}最长下坡
小明天天沿着未名湖环湖路跑,有时候也觉得蛮累。
累的时候跑下坡就很开心。小明想知道最长的一段下坡有多长。
环湖路是个圆形,周长n米。每隔一米测一下路面高度,两个测高点之间的高度是单调变化或不变的。
问最长的一段下坡有多少米长。小明只能顺时针跑。下坡必须高度单调减少。
时间限制:1000
内存限制:65536
输入
第一行是整数n,表示环湖路一共n米长(2<=n<=100)。 第二行是n个整数,每个整数范围[0,10000],按顺时针顺序给出了n个测高点的高度。
输出
最长下坡路段的长度。
样例输入
样例输入1:
5 2 1 5 6 3
样例输入2:
5 2 1 5 4 3
样例输入3:
4 1 1 1 1
样例输出
样例输出1:
3
样例输出2:
4
样例输出3:
0
提示
这是个简单枚举题,枚举起点即可
#include <stdio.h>
int main() {
int n, i, max = 0, t = 0, s;
int a[100];
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &a[i]);
s = a[0];
for (i = 1; i < n; i++) {
if (a[i] < s)
t++;
else {
if (t > max)
max = t;
t = 0;
}
s = a[i];
}
for (i = 0; i < n; i++) {
if (a[i] < s)
t++;
else {
if (t > max)
max = t;
break;
}
s = a[i];
}
printf("%d", max);
return 0;
}放苹果
把M个同样的苹果放在N个同样的盘子里,允许有的盘子空着不放,问共有多少种不同的分法?(用K表示)5,1,1和1,5,1 是同一种分法。
时间限制:1000
内存限制:65536
输入
第一行是测试数据的数目t(0 <= t <= 20)。以下每行均包含二个整数M和N,以空格分开。1<=M,N<=10。
输出
对输入的每组数据M和N,用一行输出相应的K。
样例输入
1 7 3
样例输出
8
#include <bits/stdc++.h>
using namespace std;
int dp(int m, int n) {
if (m == 0 or n == 1) {
// 如果,碟子只有1个,无论苹果有多少个都只有一种放法
return 1;
}
if (n > m) {
// 如果,碟子的个数大于苹果的个数
return dp(m, m);
} else {
return dp(m, n - 1) + dp(m - n, n);
}
}
int main() {
#ifdef LOCAL
freopen("202209_3_5.in", "r", stdin);
#endif
int t;
scanf("%d", &t);
int n, m;
for (int i = 0; i < t; i++) {
scanf("%d%d", &m, &n);
printf("%d", dp(m, n));
}
return 0;
}统计误差范围内的数
统计一个整数序列中与指定数字m误差范围小于等于X的数的个数。
时间限制:5000
内存限制:65536
输入
输入包含三行:
第一行为N,表示整数序列的长度(N <= 100);
第二行为N个整数,整数之间以一个空格分开;
第三行包含2个整数,为指定的整数m,误差范围X。
输出
输出为N个数中与指定数字m误差范围小于等于X的数的个数。
样例输入
5 1 2 3 4 5 3 1
样例输出
3
提示
样例中2,3,4都满足条件,故答案为3
#include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef LOCAL
freopen("1.in", "r", stdin);
#endif
int N;
scanf("%d", &N);
int *a = new int[N + 1];
for (int i = 0; i < N; i++) {
scanf("%d", &a[i]);
}
int m, X;
scanf("%d%d", &m, &X);
int count = 0;
for (int i = 0; i < N; i++) {
if (abs(a[i] - m) <= X) {
count = count + 1;
}
}
printf("%d", count);
return 0;
}全在其中
你设计了一个新的加密技术,可以用一种聪明的方式在一个字符串的字符间插入随机的字符串从而对信息进行编码。由于专利问题,我们将不会详细讨论如何在原有信息中产生和插入字符串。不过,为了验证你的方法,有必要写一个程序来验证原来的信息是否全在最后的字符串之中。
给定两个字符串s和t,你需要判断s是否是t的“子列”。也就是说,如果你去掉t中的某些字符,剩下字符将连接而成为s。
时间限制:1000
内存限制:65536
输入
输入包括多个测试样例。每一个都是由空格分隔的由字母数字ASCII字符组成的两个特定的字符串s和t。s和t的长度不超过100000
输出
对于每个测试样例,如果s是t的“子列”,则输出”Yes”,否则输出”No”
样例输入
sequence subsequence person compression VERDI vivaVittorioEmanueleReDiItalia caseDoesMatter CaseDoesMatter
样例输出
Yes No Yes No
#include <bits/stdc++.h>
using namespace std;
bool isok(string a, string b) {
int b_start = 0;
int count = 0;
for (int i = 0; i < a.length(); i++) {
for (int j = b_start; j < b.length(); j++) {
b_start = j + 1;
if (b[j] == a[i]) {
count++;
break;
}
}
}
if (count == a.length()) {
return true;
}
return false;
}
int main() {
#ifdef LOCAL
freopen("202209_2_2.in", "r", stdin);
#endif
string a;
string b;
while (cin >> a) {
cin >> b;
bool r = isok(a, b);
if (r == true) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}Lab杯
“Lab杯”乒乓球赛就要在PKU的实验室之间举行了。人工智能实验室的学生都是乒乓球的狂热分子,都强烈希望代表实验室去比赛。但是由于名额限制,他们之中只能由一个人被选作代表。
为了让选择的过程公平,他们决定打一次单循环赛,每一对学生之间都打一场五局三胜的比赛。赢得最多比赛的人就将代表实验室去比赛。现在Ava手里有一份表,表里面记录了每一场比赛的比分。她应该让谁去比赛?
时间限制:5000
内存限制:131072
输入
输入包含一组测试数据。第一行包含n(2 ≤ n ≤ 100),实验室里学生的数目。接下来给出一个n × n矩阵A。矩阵的每一个元素都是0、1、2、3中的一个。第i行第j列的元素aij是第i个学生在和第j个学生的比赛中赢的局数。aij和aji(i ≠ j)正好有一个是3,另外一个小于3。矩阵的所有对角线元素都是0。
输出
输出赢了最多比赛的学生的编号。如果有平分,选择编号最小的。
样例输入
4 0 0 3 2 3 0 3 1 2 2 0 2 3 3 3 0
样例输出
4
#include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef LOCAL
freopen("202209_2_3.in", "r", stdin);
#endif
int n;
scanf("%d", &n);
int a[110][110];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
}
}
int max_score = 0;
int no = 1;
for (int i = 0; i < n; i++) {
int t = 0;
for (int j = 0; j < n; j++) {
t = t + a[i][j];
}
if (t > max_score) {
max_score = t;
no = i + 1;
}
}
printf("%d", no);
return 0;
}有趣的跳跃
一个长度为n(n>0)的序列中存在“有趣的跳跃”当且仅当相邻元素的差的绝对值经过排序后正好是从1到(n-1)。例如,1 4 2 3存在“有趣的跳跃”,因为差的绝对值分别为3,2,1。当然,任何只包含单个元素的序列一定存在“有趣的跳跃”。你需要写一个程序判定给定序列是否存在“有趣的跳跃”。
时间限制:1000
内存限制:65536
输入
一行,第一个数是n(0 < n < 3000),为序列长度,接下来有n个整数,依次为序列中各元素,各元素的绝对值均不超过1,000,000,000
输出
一行,若该序列存在“有趣的跳跃”,输出"Jolly",否则输出"Not jolly"
样例输入
4 1 4 2 3
样例输出
Jolly
#include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef LOCAL
freopen("202209_2_4.in", "r", stdin);
#endif
int n;
scanf("%d", &n);
int *a = new int[n + 1]; // 元素列表
int *b = new int[n + 2]; // 元素差绝对值列表
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n - 1; i++) {
b[i] = abs(a[i] - a[i + 1]);
}
// 元素差绝对值列表从小到大排序
sort(b, b + n - 1);
for (int i = 0; i < n - 1; i++) {
if (b[i] != i + 1) {
printf("Not jolly");
return 0;
}
}
printf("Jolly");
return 0;
}反反复复
Mo和Larry发明了一种信息加密方法。他们首先决定好列数,然后将信息(只包含字母)从上往下依次填入各列,并在末尾补充一些随机字母使其成为一个完整的字母矩阵。例如,若信息是“There's no place like home on a snowy night”并且有5列,Mo会写成:
t o i o y
h p k n n
e l e a i
r a h s g
e c o n h
s e m o t
n l e w x
注意Mo只会填入字母,且全部是小写形式。在这个例子中,Mo用字母“x”填充了信息使之成为一个完整的矩阵,当然他使用任何字母都是可以的。
Mo根据这个矩阵重写信息:首先从左到右写下第一行,然后从右到左写下第二行,再从左到右写下第三行……以此左右交替地从上到下写下各行字母,形成新的字符串。这样,例子中的信息就被加密为:toioynnkpheleaigshareconhtomesnlewx。
你的工作是帮助Larry从加密后的信息中还原出原始信息(包括填充的字母)。
时间限制:1000
内存限制:65536
输入
第一行包含一个整数(范围2到20),表示使用的列数。 第二行是一个长度不超过200的字符串。
输出
一行,即原始信息。
样例输入
5
toioynnkpheleaigshareconhtomesnlewx
样例输出
theresnoplacelikehomeonasnowynightx
#include <stdio.h>
#include <string.h>
char sz[300], a[30][30], b[30][30];
int main() {
int n, i, j, mm, m, k = 0;
scanf("%d", &n);
scanf("%s", sz);
mm = strlen(sz);
m = mm / n;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
a[i][j] = sz[k++];
}
}
for (i = 0; i < m; i++) {
if (i % 2 == 0) {
for (j = 0; j < n; j++) {
b[i][j] = a[i][j];
}
}
if (i % 2 != 0) {
for (j = 0; j < n; j++) {
b[i][j] = a[i][n - j - 1];
}
}
}
for (j = 0; j < n; j++) {
for (i = 0; i < m; i++) {
printf("%c", b[i][j]);
}
}
}指定顺序输出
依次输入3个整数a、b、c,将他们以c、a、b的顺序输出。
时间限制:1000
内存限制:65536
输入
一行3个整数a、b、c,以空格分隔。 0 < a,b,c < 108
输出
一行3个整数c、a、b,整数之间以一个空格分隔。
样例输入
1 2 3
样例输出
3 1 2
#include <iostream>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << c << " " << a << " " << b;
}成绩判定
给定一门课的考试分数,如果分数大于等于60,则该门课成绩合格,记为"P", 否者成绩不合格,记为"F"。
时间限制:1000
内存限制:65536
输入
一个整数s,表示这门课的分数.(0 ≤ s ≤ 100)
输出
如果成绩合格,输出字母P,否者输出字母F。
样例输入
59
样例输出
F
#include <bits/stdc++.h>
using namespace std;
int main() {
int s;
scanf("%d", &s);
if (s >= 60) {
printf("P");
} else {
printf("F");
}
return 0;
}简单排序
依次输入3个整数a、b、c,将他们从小到大的顺序输出。
时间限制:1000
内存限制:65536
输入
一行3个整数a、b、c,以空格分隔。 0 < a,b,c < 108
输出
一行3个整数,即将a、b、c从小到大排序的3个整数,整数之间以一个空格分隔。
样例输入
10 5 20
样例输出
5 10 20
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[3];
scanf("%d%d%d", &a[0], &a[1], &a[2]);
sort(a, a + 3); // 从小到大排序
printf("%d %d %d", a[0], a[1], a[2]);
return 0;
}数字求和
给定一个正整数a,以及另外的5个正整数,问题是:这5个整数中,小于a的整数的和是多少?
时间限制:3000
内存限制:65536
输入
输入一行,只包括6个小于100的正整数,其中第一个正整数就是a。
输出
输出一行,给出一个正整数,是5个数中小于a的数的和。
样例输入
10 1 2 3 4 11
样例输出
10
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
scanf("%d", &a);
int sum = 0;
for (int i = 0; i < 5; i++) {
int t;
scanf("%d", &t);
if (t < a) {
sum = sum + t;
}
}
printf("%d", sum);
return 0;
}数1的个数
给定一个十进制正整数n,写下从1到n的所有整数,然后数一下其中出现的数字“1”的个数。
例如当n=2时,写下1,2。这样只出现了1个“1”;当n=12时,写下1,2,3,4,5,6,7,8,9,10,11,12。这样出现了5个“1”。
时间限制:1000
内存限制:65536
输入
正整数n。1 <= n <= 10000。
输出
一个正整数,即“1”的个数。
样例输入
12
样例输出
5
#include <bits/stdc++.h>
using namespace std;
// 把数字转字符串,统计字符串中有多少个'1'的字符
int count_1(int x) {
char m[20];
int r = 0;
int num = sprintf(&m[0], "%d", x);
for (int i = 0; i < num; i++) {
if (m[i] == '1') {
r = r + 1;
}
}
return r;
}
int main() {
int sum = 0;
int max_x = 0;
scanf("%d", &max_x);
for (int i = 1; i <= max_x; i++) {
sum = sum + count_1(i);
}
printf("%d", sum);
return 0;
}