首页 › 题库 › Scratch编程考级 › 7.1 逻辑推理

Scratch编程一级 题库

共 70 道题 ,第 4 / 4 页 · 按题型筛选,点「查看答案」核对解析
章节 7.1 逻辑推理 清除
61 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

单词的长度

输入一行单词序列,相邻单词之间由1个或多个空格间隔,请对应地计算各个单词的长度。

注意,如果有标点符号(如连字符,逗号),标点符号算作与之相连的词的一部分。没有被空格间开的符号串,都算作单词。

时间限制:1000

内存限制:65536

输入

一行单词序列,最少1个单词,最多300个单词,单词之间用至少1个空格间隔。单词序列总长度不超过1000。

输出

依次输出对应单词的长度,之间以逗号间隔。

样例输入

She was born in 1990-01-02  and  from Beijing city.

样例输出

3,3,4,2,10,3,4,7,5
答案与解析
参考答案
#include <bits/stdc++.h>
using namespace std;
string s, ch;
int main() {
  cin >> s;
  cout << s.size();
  while (cin >> ch) {
    cout << "," << ch.size();
  }
  return 0;
}
题目详情
62 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

扫雷游戏地雷数计算

扫雷游戏是一款十分经典的单机小游戏。它的精髓在于,通过已翻开格子所提示的周围格地雷数,来判断未翻开格子里是否是地雷。

现在给出n行m列的雷区中的地雷分布,要求计算出每个非地雷格的周围格地雷数。

注:每个格子周围格有八个:上、下、左、右、左上、右上、左下、右下。

时间限制:1000

内存限制:65536

输入

第一行包含两个整数n和m,分别表示雷区的行数和列数。1 <= n <= 100, 1 <= m <= 100。 接下来n行,每行m个字符,‘*’表示相应格子中是地雷,‘?’表示相应格子中无地雷。字符之间无任何分隔符。

输出

n行,每行m个字符,描述整个雷区。若相应格中是地雷,则用‘*’表示,否则用相应的周围格地雷数表示。字符之间无任何分隔符。

样例输入

3 3
*??
???
?*?

样例输出

*10
221
1*1
答案与解析
参考答案
#include <bits/stdc++.h>
using namespace std;
char a[102][102];
int dx[8] = {1, -1, 0, 0, 1, 1, -1, -1};
int dy[8] = {0, 0, 1, -1, 1, -1, 1, -1};
int main() {
  int n, m, sum;
  cin >> n >> m;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      cin >> a[i][j];
    }
  }
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      if (a[i][j] == '*') {
        cout << a[i][j];
        continue;
      } else {
        sum = 0;
        for (int k = 0; k < 8; k++) {
          if (a[i + dx[k]][j + dy[k]] == '*')
            sum++;
        }
        cout << sum;
      }
    }
    cout << endl;
  }
  return 0;
}
题目详情
63 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

古代密码

古罗马帝国有一个拥有各种部门的强大政府组织。其中一个部门就是保密服务部门。为了保险起见,在省与省之间传递的重要文件中的大写字母是加密的。当时最流行的加密方法是替换和重新排列。

替换方法是将所有出现的字符替换成其它的字符。有些字符会替换成它自己。例如:替换规则可以是将'A' 到 'Y'替换成它的下一个字符,将'Z'替换成 'A',如果原词是 "VICTORIOUS" 则它变成 "WJDUPSJPVT"。

排列方法改变原来单词中字母的顺序。例如:将顺序例如将顺序 < 2 1 5 4 3 7 6 10 9 8 > 应用到 "VICTORIOUS" 上,则得到"IVOTCIRSUO"。

人们很快意识到单独应用替换方法或排列方法加密,都是很不保险的。但是如果结合这两种方法,在当时就可以得到非常可靠的加密方法。所以,很多重要信息先使用替换方法加密,再将加密的结果用排列的方法加密。用两种方法结合就可以将"VICTORIOUS" 加密成"JWPUDJSTVP"。

考古学家最近在一个石台上发现了一些信息。初看起来它们毫无意义,所以有人设想它们可能是用替换和排列的方法被加密了。人们试着解读了石台上的密码,现在他们想检查解读的是否正确。他们需要一个计算机程序来验证,你的任务就是写这个验证程序。

时间限制:1000

内存限制:65536

输入

输入有两行。第一行是石台上的文字。文字中没有空格,并且只有大写英文字母。第二行是被解读出来的加密前的文字。第二行也是由大写英文字母构成的。 两行字符数目的长度都不超过100。

输出

如果第二行经过某种加密方法后可以产生第一行的信息,输出 "YES",否则输出"NO"。

样例输入

JWPUDJSTVP
VICTORIOUS

样例输出

YES
答案与解析
参考答案
#include <stdio.h>
#include <string.h>
// 记录字母出现次数
int ans[26];
int test[26];
// 记录字符串
char strA[105];
char strT[105];
int main() {
  while (1) {
    // 注意初始化
    memset(ans, 0, sizeof(ans));
    memset(test, 0, sizeof(test));
    if (scanf("%s", strA) == EOF) {
      return 0;
    }
    int lenA = strlen(strA);
    // 求出现次数
    for (int k = 0; k < lenA; k++) {
      ans[strA[k] - 'A']++;
    }
    scanf("%s", strT);
    int lenT = strlen(strT);
    for (int m = 0; m < lenT; m++) {
      test[strT[m] - 'A']++;
    }
    int flag = 0;
    int i;
    for (i = 0; i < 26; i++) {
      flag = 0;
      // 等于0时代表没有出现,跳过
      if (test[i] == 0) {
        continue;
      }
      for (int j = 0; j < 26; j++) {
        if (test[i] == ans[j]) {
          // 匹配了就把ans置零
          ans[j] = 0;
          flag = 1;
          break;
        }
      }
      if (flag == 0) {
        printf("NO\n");
        break;
      } else {
        continue;
      }
    }
    // 等于26代表所有字母都能有匹配
    if (i == 26) {
      printf("YES\n");
    }
  }
  return 0;
}
题目详情
64 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

足球联赛积分2

一场足球比赛中,两支参赛队A,B,如果A队的进球数大于B队,则A赢,A积3分B积0分,如果A队的进球数等于B队,则两队打平,各积1分,如果A队的进球数小于B队,则A输,A积0分B积3分。

现有一个球队一个赛季的比赛情况,请计算该球队的积分。

时间限制:1000

内存限制:65536

输入

第一行一个整数n(0 < n ≤ 40) 接下来n行,每行两个非负整数,表示一场该球队的进球数以及对手球队的进球数。

输出

一个整数,表示该球队的赛季积分。

样例输入

5
3 1
0 0
1 2
3 2
3 3

样例输出

8

提示

该球队5场比赛的结果分别为赢,平,输,赢,平,总计2赢2平1输,积分为8分。

答案与解析
参考答案
#include <iostream>
using namespace std;
int main() {
  int n, a, b, c = 0;
  cin >> n;
  for (int i = 1; i <= n; i++) {
    cin >> a >> b;
    if (a > b)
      c = c + 3;
    else if (a = b)
      c = c + 1;
  }
  cout << c;
  return 0;
}
题目详情
65 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

控制公司

有些公司是其他公司的部分拥有者,因为他们获得了其他公司发行的股票的一部分。例如,福特公司拥有马自达公司12%的股票。据说,如果至少满足了以下条件之一,公司A就可以控制公司B了:

l 公司A = 公司B。

l 公司A拥有大于50%的公司B的股票。

l 公司A控制K(K >= 1)个公司,记为C1, …, CK,每个公司Ci拥有xi%的公司B的股票,并且x1+ … + xK > 50%。(ps:A可以控制自己,即Ci可以为A)

你将被给予一系列的三对数(i,j,p),表明公司i拥有公司j的p%的股票。计算所有的数对(h,s),表明公司h控制公司s。

写一个程序读入三对数(i,j,p),并且找出所有的数对(h,s),使得公司h控制公司s。

时间限制:1000

内存限制:65536

输入

第一行: N,表明接下来三对数的数量。 第二行到第N+1行:每行三个整数作为一个三对数(i,j,p),如上文所述。 I,J≤100,N,P≤100

输出

输出零个或更多个的控制其他公司的公司。每行包括两个整数表明序号为第一个整数的公司控制了序号为第二个整数的公司。将输出的每行以第一个数字升序排列(并且第二个数字也升序排列来避免并列)。请不要输出控制自己的公司。

样例输入

3
1 2 80
2 3 80
3 1 20

样例输出

1 2
1 3
2 3
答案与解析
参考答案
#include <bits/stdc++.h>
using namespace std;
unsigned long long int n, gf[1000][1000], mp[1000][1000];
void jf(int x, int y) // x公司加上i公司股票
{
  for (int i = 1; i <= 100; i++) {
    if (gf[x][i] + gf[y][i] > 100)
      gf[x][i] = 100; // 判断
    else
      gf[x][i] += gf[y][i];
  }
  return;
}
void find(int x) // 递归
{
  for (int i = 1; i <= 100; i++) {
    if (gf[x][i] >= 50 && mp[x][i] == 0 && x != i) {
      mp[x][i] = 1; // 标记 x公司可以控制i公司
      jf(x, i);
      find(x); // 加上以后再找一遍
      return;
    }
  }
}
int main() {
  cin >> n;
  for (int i = 1; i <= n; i++) {
    int a, b, c;
    cin >> a >> b >> c;
    gf[a][b] = c;
  }
  int t = 1;
  while (t <= 100) // 枚举每一个公司
  {
    find(t);
    t++;
  }
  for (int i = 1; i <= 100; i++) {
    for (int j = 1; j <= 100; j++) {
      if (mp[i][j] == 1)
        cout << i << " " << j << endl;
    }
  }
}
题目详情
66 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

发型糟糕的一天

农夫John 的N(1 ≤ N ≤ 80,000)只奶牛中,有一些也许正在经历发型糟糕的一天。每只奶牛对自己乱糟糟的发型都有自知之明,农夫John想知道所有奶牛能看到其他奶牛头顶的数量之和。

任意奶牛i身高记为 hi (1 ≤ hi ≤ 1,000,000,000),所有奶牛面向东方(本题示意图的右面)依次站成一条线。因此,奶牛i能够看到在它前面的(奶牛i+1,i+2…)所有身高比它低的奶牛,直到被一头比它高的奶牛挡住

考虑如下的例子:

=

= =

= - = Cows facing right ->

= = =

= - = = =

= = = = = =

1 2 3 4 5 6 奶牛#1 可以看见奶牛#2, 3, 4的头顶

奶牛#2 无法看到任何奶牛的头顶

奶牛#3可以看见奶牛#4的头顶

奶牛#4无法看到任何奶牛的头顶

奶牛#5可以看见奶牛#6的头顶

奶牛#6无法看到任何奶牛的头顶!

用ci表示奶牛i能够看到头顶的奶牛个数;请计算c1 至cN的和。对于上面这个例子,其和为:3 + 0 + 1 + 0 + 1 + 0 = 5。

时间限制:2000

内存限制:65536

输入

第1行:奶牛数N第2行至N+1行:第i+1行包含一个整数,表示奶牛i的高度

输出

第1行:c1 至cN的累加和

样例输入

6
10
3
7
4
12
2

样例输出

5
答案与解析
参考答案
#include <iostream>
#include <stack>

using namespace std;
int main() {
  long long n, h, sum = 0;
  cin >> n;
  stack<int> s;
  cin >> h;
  s.push(h);
  n -= 1;
  while (n--) {
    cin >> h;
    while (!s.empty() && h >= s.top()) {
      s.pop();
    }
    sum += s.size();
    s.push(h);
  }
  cout << sum << endl;
  return 0;
}
题目详情
67 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

城堡问题

     1   2   3   4   5   6   7  

   #############################

 1 #   |   #   |   #   |   |   #

   #####---#####---#---#####---#

 2 #   #   |   #   #   #   #   #

   #---#####---#####---#####---#

 3 #   |   |   #   #   #   #   #

   #---#########---#####---#---#

 4 #   #   |   |   |   |   #   #

   #############################

              (图 1)

   #  = Wall   

   |  = No wall

   -  = No wall

1

2

3

4

5

6

7

8

9

10

11

12

13

14

图1是一个城堡的地形图。请你编写一个程序,计算城堡一共有多少房间,最大的房间有多大。城堡被分割成m×n(m≤50,n≤50)个方块,每个方块可以有0~4面墙。

时间限制:1000

内存限制:65536

输入

程序从标准输入设备读入数据。第1、2行每行1个整数,分别是南北向、东西向的方块数。在接下来的输入行里,每个方块用一个数字(0≤p≤50)描述。用一个数字表示方块周围的墙,1表示西墙,2表示北墙,4表示东墙,8表示南墙。每个方块用代表其周围墙的数字之和表示。城堡的内墙被计算两次,方块(1,1)的南墙同时也是方块(2,1)的北墙。输入的数据保证城堡至少有两个房间。

输出

输出2行,每行一个数,表示城堡的房间数、城堡中最大房间所包括的方块数。结果显示在标准输出设备上。

样例输入

4
7
11 6 11 6 3 10 6
7 9 6 13 5 15 5
1 10 12 7 13 7 5
13 11 10 8 10 12 13

样例输出

5
9
答案与解析
参考答案
#include <iostream>
using namespace std;
int Room[60][60];
int RoomSign[60][60];
int RoomArea;
int RoomNum;
int MaxRoomArea;
void DFS(int i, int j) {
  if (RoomSign[i][j])
    return;
  RoomSign[i][j] = 1;
  RoomArea++;
  if ((Room[i][j] & 1) == 0)
    DFS(i, j - 1);
  if ((Room[i][j] & 2) == 0)
    DFS(i - 1, j);
  if ((Room[i][j] & 4) == 0)
    DFS(i, j + 1);
  if ((Room[i][j] & 8) == 0)
    DFS(i + 1, j);
  return;
}
int main() {
  int m, n;
  cin >> m >> n;
  for (int i = 0; i < m; i++)
    for (int j = 0; j < n; j++)
      cin >> Room[i][j];
  for (int i = 0; i < m; i++) {
    for (int j = 0; j < n; j++) {
      if (!RoomSign[i][j]) {
        RoomArea = 0;
        RoomNum++;
        DFS(i, j);
        MaxRoomArea = max(MaxRoomArea, RoomArea);
      }
    }
  }
  cout << RoomNum << endl;
  cout << MaxRoomArea << endl;
  return 0;
}
题目详情
68 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

吃糖果

现有n(20 > n > 0)个糖果,每天可以吃1个,也可以每天吃2个,也可以每天吃3个,请计算共有多少种不同的吃法。

时间限制:1000

内存限制:65536

输入

输入的每一行包括一组测试数据,即为糖果数n。最后一行为0,表示测试结束。

输出

每一行输出对应一行输入的结果,即为吃法的数目。

样例输入

1
2
3
4
0

样例输出

1
2
4
7
答案与解析
参考答案
#include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef LOCAL
  freopen("202209_3_4.in", "r", stdin);
#endif
  int dp[30];
  dp[0] = 1;
  dp[1] = 2;
  dp[2] = 4; // 111,12,21,3

  for (int i = 3; i < 20; i++) {
    dp[i] = dp[i - 3] + dp[i - 2] + dp[i - 1];
  }
  int n;
  do {
    scanf("%d", &n);
    // printf("%d\n", n);
    if (n == 0) {
      break;
    }
    printf("%d\n", dp[n - 1]);
  } while (true);
  return 0;
}
题目详情
69 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

拦截导弹

某国为了防御敌国的导弹袭击, 发展出一种导弹拦截系统。 但是这种导弹拦截系统有一个缺陷: 虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能高于前一发的高度。 某天, 雷达捕捉到敌国的导弹来袭。 由于该系统还在试用阶段, 所以只有一套系统, 因此有可能不能拦截所有的导弹。

输入导弹依次飞来的高度(雷达给出的高度数据是不大于 30000 的正整数) , 计算这套系统最多能拦截多少导弹。

时间限制: 1000

内存限制: 65536

输入

第一行是一个整数 N(不超过 15) , 表示导弹数。 第二行包含 N 个整数, 为导弹依次飞来的高度(雷达给出的高度数据是不大于 30000的正整数) 。

输出

一个整数, 表示最多能拦截的导弹数。

样例输入

8
389 207 155 300 299 170 158 65

样例输出

6
答案与解析
参考答案
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;
int n[2002], t = 1, f;
int b1[2002], b2[2002], r1, r2;
int main() {
  int c;
  cin >> c;
  for (int i = 1; i <= c; i++) {
    cin >> n[i];
  }
  b1[1] = n[1];
  r1 = 1;
  for (int i = 2; i <= c; i++) {
    if (b1[r1] >= n[i]) {
      b1[++r1] = n[i];
    } else {
      *upper_bound(b1 + 1, b1 + r1 + 1, n[i], greater<int>()) = n[i];
    }
  }
  cout << r1 << endl;
}
题目详情
70 简答题 偏难 Scratch编程考级 ·Scratch编程一级 · 7.1 逻辑推理

生理周期

人生来就有三个生理周期,分别为体力、感情和智力周期,它们的周期长度为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
答案与解析
参考答案
#include <iostream>
using namespace std;
int main() {
  int p, e, i, d;
  cin >> p >> e >> i >> d;
  int k = d + 1;
  for (; k <= 21252; k++)
    if ((k - p) % 23 == 0 && (k - e) % 28 == 0 && (k - i) % 33 == 0)
      break;
  cout << k - d << endl;
  return 0;
}
题目详情