蓝桥题目汇总1-20

First Post:

Last Update:

门牌制作

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝要为一条街的住户制作门牌号。

这条街一共有 $2020$ 位住户，门牌号从 $1$ 到 $2020$ 编号。

小蓝制作门牌的方法是先制作 $0$ 到 $9$ 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符 $1、0、1、7$，即需要 $1$ 个字符 $0$，$2$ 个字符 $1$，$1$ 个字符 $7$。

请问要制作所有的 $1$ 到 $2020$ 号门牌，总共需要多少个字符 $2$？

运行限制

  • 最大运行时间：1s
  • 最大运行内存: 128M

常规思路

1
2
3
4
5
s=[]
for i in range(1,2021):
    s.append(i)
s=str(s)
print(s.count("2"))
1
2
3
s=''
for i in range(1,2021):s+=str(i)
print(s.count("2"))

似乎熟悉了python之后，用python求解也很快。

简单方法

使用excel的功能

image-20240312203337676

使用序列

image-20240312203422558

使用快捷键CTRL+H，唤出替换，替换所有的2。

image-20240312203629711

可以快速得到结果624，准确又省时间。

迷宫

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

X 星球的一处迷宫游乐场建在某个小山坡上。它是由 $10 \times 10$ 相互连通的小房间组成的。

房间的地板上写着一个很大的字母。我们假设玩家是面朝上坡的方向站立，则：

  • $L$ 表示走到左边的房间，
  • $R$ 表示走到右边的房间，
  • $U$ 表示走到上坡方向的房间，
  • $D$ 表示走到下坡方向的房间。

X 星球的居民有点懒，不愿意费力思考。他们更喜欢玩运气类的游戏。这个游戏也是如此！

开始的时候，直升机把 $100$ 名玩家放入一个个小房间内。玩家一定要按照地上的字母移动。

迷宫地图如下：

1
2
3
4
5
6
7
8
9
10
UDDLUULRUL  
UURLLLRRRU  
RRUURLDLRD  
RUDDDDUUUU  
URUDLLRRUU  
DURLRLDLRL  
ULLURLLRDU  
RDLULLRDDD  
UUDDUDUDLL  
ULRDLUURRR

请你计算一下，最后，有多少玩家会走出迷宫，而不是在里边兜圈子？

如果你还没明白游戏规则，可以参看下面一个简化的 4x4 迷宫的解说图：

图片描述

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

解题思路

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
str='UDDLUULRULUURLLLRRRURRUURLDLRDRUDDDDUUUUURUDLLRRUUDURLRLDLRLULLURLLRDURDLULLRDDDUUDDUDUDLLULRDLUURRR'
sum=0 #计算有几个人出来
for i in range(100):
  a=i//10 #一个点的坐标（a，b）
  b=i%10
  c = [{a:b}] #用于存放经过的点，若重复经过，说明走不出去了
  while(1):
    if(str[a*10+b]=='U'):
      a=a-1
    elif (str[a*10+b]=='D'):
      a=a+1
    elif (str[a*10+b]=='L'):
      b=b-1
    else:
      b=b+1
    if({a:b} in c):
      break
    if({a:b} not in c):
      c.append({a:b})
    if(a<0 or a>9 or b<0 or b>9):
      sum+=1
      break
print(sum)

DFS解法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def dfs(x,y):
  if 0<=x<10 and 0<=y<10: 
    if v[x][y] == 0:
      v[x][y] = 1   #打上标识，证明此处已走过
      if map[x][y] == 'U':
        flag = dfs(x-1,y)
      elif map[x][y] == 'D':
        flag = dfs(x+1,y)
      elif map[x][y] == 'L':
        flag = dfs(x,y-1)
      elif map[x][y] == 'R':
        flag = dfs(x,y+1)
      v[x][y] = 0  #按层返回，清除标识
      return flag  
    else:  #如果回到已经走过的地方，说明发生循环，直接返回0标识走不出去
      return 0
  else:      #超限说明走出去了  返回1
    return 1

n = 0
map = [list(input()) for i in range(10)] #读入迷宫
v = [[0]*10 for i in range(10)]  #列表v用来标识该点是否重复经过，避免循环
for i in range(10):
  for j in range(10):
    n += dfs(i,j)   #对每一个人进行走出迷宫的模拟，n记录最后能走出的人的总数
print(n)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#深度dfs递归
map = ['UDDLUULRUL',
       'UURLLLRRRU',
       'RRUURLDLRD',
       'RUDDDDUUUU',
       'URUDLLRRUU',
       'DURLRLDLRL',
       'ULLURLLRDU',
       'RDLULLRDDD',
       'UUDDUDUDLL',
       'ULRDLUURRR']#这里字符串元素要用单引号括起，用双引号，后面会提示数组越界
count = 0
tablist = [[0] * 10 for i in range(10)]


def find(x, y):
    if x < 0 or x > 9 or y < 0 or y > 9:  # 走出迷宫
        global count
        count += 1
        return True

    if tablist[x][y] == 1:  # 已走过
        return False

    tablist[x][y] = 1  # 若之前没走过，则标记走过

    if map[x][y] == "U":
        find(x - 1, y)#递归
    elif map[x][y] == "D":
        find(x + 1, y)
    elif map[x][y] == "L":
        find(x, y - 1)
    elif map[x][y] == "R":
        find(x, y + 1)
    return False


for i in list(range(10)):
    for j in list(range(10)):
        tablist = [[0] * 10 for i in range(10)]#遍历每个坐标起点开始前都先清零
        find(i, j)

print(count)

星期一

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

整个 $20$ 世纪（$1901$ 年 $1$ 月 $1$ 日至 $2000$ 年 $12$ 月 $31$ 日之间），一共有多少个星期一？(不要告诉我你不知道今天是星期几)

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

解题思路

直接用 Python datetime 库求解，第 6 行可以输出某个日期是星期几。

1
2
3
4
5
6
from datetime import* 
dt1=datetime(1901,1,1) 
dt2=datetime(2000,12,31) 
print(dt1.weekday()) # 周一为0，周二为1... 
td=dt2-dt1 
print(td.days//7)

乘积尾零

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

如下的 $10$ 行数据，每行有 $10$ 个整数，请你求出它们的乘积的末尾有多少个零？

1
5650 4542 3554 473 946 4114 3871 9073 90 4329 2758 7949 6113 5659 5245 7432 3051 4434 6704 3594 9937 1173 6866 3397 4759 7557 3070 2287 1453 9899 1486 5722 3135 1170 4014 5510 5120 729 2880 9019 2049 698 4582 4346 4427 646 9742 7340 1230 7683 5693 7015 6887 7381 4172 4341 2909 2027 7355 5649 6701 6645 1671 5978 2704 9926 295 3125 3878 6785 2066 4247 4800 1578 6652 4616 1113 6205 3264 2915 3966 5291 2904 1285 2193 1428 2265 8730 9436 7074 689 5510 8243 6114 337 4096 8199 7313 3685 211

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

解题思路

将字符串转换成表格，先计算乘积，然后结果由int整数型转换成str字符型，再存入列表中，这时候使用pop方法和列表切片，简单的遍历一下，就能得到结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
s="""
5650 4542 3554 473 946 4114 3871 9073 90 4329 
2758 7949 6113 5659 5245 7432 3051 4434 6704 3594 
9937 1173 6866 3397 4759 7557 3070 2287 1453 9899 
1486 5722 3135 1170 4014 5510 5120 729 2880 9019 
2049 698 4582 4346 4427 646 9742 7340 1230 7683 
5693 7015 6887 7381 4172 4341 2909 2027 7355 5649 
6701 6645 1671 5978 2704 9926 295 3125 3878 6785 
2066 4247 4800 1578 6652 4616 1113 6205 3264 2915 
3966 5291 2904 1285 2193 1428 2265 8730 9436 7074 
689 5510 8243 6114 337 4096 8199 7313 3685 211 
"""
cnt=1
for i in s.split():cnt*=int(i)
cnt,res = list(str(cnt)),0
for i in cnt[::-1]:
    if i == '0':
        cnt.pop()
        res+=1
    else:break
print(res)

当然，也可以不使用列表

图片描述

付账问题

题目描述

几个人一起出去吃饭是常有的事。但在结帐的时候，常常会出现一些争执。

现在有 $n$ 个人出去吃饭，他们总共消费了 $S$ 元。其中第 $i$ 个人带了 $a_i$元。幸运的是，所有人带的钱的总数是足够付账的，但现在问题来了：每个人分别要出多少钱呢？

为了公平起见，我们希望在总付钱量恰好为 $S$ 的前提下，最后每个人付的钱的标准差最小。这里我们约定，每个人支付的钱数可以是任意非负实数，即可以不是 1 分钱的整数倍。你需要输出最小的标准差是多少。

标准差的介绍：标准差是多个数与它们平均数差值的平方平均数，一般用于刻画这些数之间的”偏差有多大”。形式化地说，设第 $i$ 个人付的钱为 $b_i$ 元，那么标准差为 :

$S=\sqrt{\frac{1}{n}\sum_{i=1}^{n}(b_i-\frac{1}{n}\sum_{i=1}^{n}b_i)^{2}}$

输入描述

第一行包含两个整数 $n、S$；

第二行包含 $n$ 个非负整数 $a_1, \cdots, a_n$。

其中，$n \leq 5 \times 10^5, 0 \leq a_i \leq 10^9$ 。

输出描述

输出最小的标准差，四舍五入保留 4 位小数。

保证正确答案在加上或减去 $10^{−9}$ 后不会导致四舍五入的结果发生变化。

输入输出样例

示例

输入

1
2
5 2333 
666 666 666 666 666

输出

1
0.0000

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

解题思路

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from math import *
n, s = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
avg = s/n
sum = 0
for i in range(n):
     if a[i]*(n-i) < s:
          sum += pow(a[i]-avg,2)
          s -= a[i]
     else:
          cur_avg = s/(n-i);      #更新平均出钱数
          sum += pow(cur_avg-avg,2)*(n-i)
          break
print("{:.4f}".format(sqrt(sum/(n))))

数字三角形

题目描述

图片描述

上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和（路径上的每一步只可沿左斜线向下或右斜线向下走）。

输入描述

输入的第一行包含一个整数 $N\ (1 \leq N \leq 100)$，表示三角形的行数。

下面的 $N$ 行给出数字三角形。数字三角形上的数都是 $0$ 至 $99$ 之间的整数。

输出描述

输出一个整数，表示答案。

输入输出样例

示例

输入

1
2
3
4
5
6
5 
7 
3 8
8 1 0
2 7 4 4
4 5 2 6 5

输出

1
30

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

42点问题

题目描述

请你设计一个程序对该问题进行解答。

众所周知在扑克牌中，有一个老掉牙的游戏叫做 $24$ 点，选取 $4$ 张牌进行加减乘除，看是否能得出 $24$ 这个答案。

现在小蓝同学发明了一个新游戏，他从扑克牌中依次抽出6张牌，注意不是一次抽出，进行计算，看是否能够组成 $42$ 点,满足输出 YES，反之输出 NO。

最先抽出来的牌作为第一个操作数，抽出牌做第二个操作数，运算结果再当作第一个操作数，继续进行操作。

注：除不尽的情况保留整数，而且扑克牌的四张 $10$ 都丢了，不会出现 $10$。

请设计一个程序对该问题进行解答。

输入描述

输出仅一行包含 $6$ 个字符。

保证字符 $\in$ 3 4 5 6 7 8 9 10 J Q K A 2。

输出描述

若给出到字符能够组成 $42$ 点 , 满足输出 YES，反之输出 NO。

输入输出样例

示例

输入

1
K A Q 6 2 3

输出

1
YES

样例说明

  • $K\times A=K$ 即 $13\times 1=13$
  • $13/12=1$ 保留整数
  • $1+6=7$
  • $7*2=14$
  • $14*3=42$

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

数的划分

题目描述

将整数 $n$ 分成 $k$ 份，且每份不能为空，任意两份不能相同(不考虑顺序)。

例如：$n=7，k=3$，下面三种分法被认为是相同的。

$1，1，5; 1，5，1; 5，1，1;$

问有多少种不同的分法。

输入描述

输入一行，$2$ 个整数 $n,k\ (6 \leq n \leq 200，2 \leq k \leq 6)$。

输出描述

输出一个整数，即不同的分法。

输入输出样例

示例 1

输入

1
7 3

输出

1
4

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

数的计算

题目描述

输入一个自然数 $n\ (n \leq 1000)$，我们对此自然数按照如下方法进行处理:

  1. 不作任何处理;

  2. 在它的左边加上一个自然数,但该自然数不能超过原数的一半;

  3. 加上数后,继续按此规则进行处理,直到不能再加自然数为止。

问总共可以产生多少个数。

输入描述

输入一个正整数 $n$。

输出描述

输出一个整数，表示答案。

输入输出样例

示例 1

输入

1
6

输出

1
6

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

N皇后问题

题目描述

在 $N\times N$ 的方格棋盘放置了 $N$ 个皇后，使得它们不相互攻击（即任意 $2$ 个皇后不允许处在同一排，同一列，也不允许处在与棋盘边框成 $45$ 角的斜线上。你的任务是，对于给定的 $N$，求出有多少种合法的放置方法。

输入描述

输入中有一个正整数 $N≤10$，表示棋盘和皇后的数量

输出描述

为一个正整数，表示对应输入行的皇后的不同放置数量。

输入输出样例

示例 1

输入

1
5

输出

1
10

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

路径之谜

题目描述

小明冒充 $X$ 星球的骑士，进入了一个奇怪的城堡。

城堡里边什么都没有，只有方形石头铺成的地面。

假设城堡地面是 $n \times n$ 个方格。如下图所示。

图1

按习俗，骑士要从西北角走到东南角。可以横向或纵向移动，但不能斜着走，也不能跳跃。每走到一个新方格，就要向正北方和正西方各射一箭。（城堡的西墙和北墙内各有 $n$ 个靶子）同一个方格只允许经过一次。但不必走完所有的方格。如果只给出靶子上箭的数目，你能推断出骑士的行走路线吗？有时是可以的，比如上图中的例子。

本题的要求就是已知箭靶数字，求骑士的行走路径（测试数据保证路径唯一）

输入描述

第一行一个整数 $N$ ($0 \leq N \leq 20$)，表示地面有 $N \times N$ 个方格。

第二行 $N$ 个整数，空格分开，表示北边的箭靶上的数字（自西向东）

第三行 $N$ 个整数，空格分开，表示西边的箭靶上的数字（自北向南）

输出描述

输出一行若干个整数，表示骑士路径。

为了方便表示，我们约定每个小格子用一个数字代表，从西北角开始编号: 0,1,2,3 $\cdots$

比如，上图中的方块编号为：

0 1 2 3

4 5 6 7

8 9 10 11

12 13 14 15

输入输出样例

示例

输入

1
2
3
4
2 4 3 4
4 3 3 3

输出

1
0 4 5 1 2 3 7 11 10 9 13 14 15

运行限制

语言 最大运行时间 最大运行内存
C++ 5s 256M
C 5s 256M
Python3 5s 256M
Java 5s 256M

最大数字

问题描述

给定一个正整数 $N$ 。你可以对 $N$ 的任意一位数字执行任意次以下 2 种操 作：

  1. 将该位数字加 1 。如果该位数字已经是 9 , 加 1 之后变成 0 。

  2. 将该位数字减 1 。如果该位数字已经是 0 , 减 1 之后变成 9 。

你现在总共可以执行 1 号操作不超过 $A$ 次, 2 号操作不超过 $B$ 次。 请问你最大可以将 $N$ 变成多少?

输入格式

第一行包含 3 个整数: $N, A, B$ 。

输出格式

一个整数代表答案。

样例输入

1
123 1 2

样例输出

1
933

样例说明

对百位数字执行 2 次 2 号操作, 对十位数字执行 1 次 1 号操作。

评测用例规模与约定

对于 $30 %$ 的数据, $1 \leq N \leq 100 ; 0 \leq A, B \leq 10$。

对于 $100 %$ 的数据, $1 \leq N \leq 10^{17} ; 0 \leq A, B \leq 100$

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 512M
C 1s 512M
Python3 1s 512M
Java 1s 512M

长草

题目描述

小明有一块空地，他将这块空地划分为 $n$ 行 $m$ 列的小块，每行和每列的长度都为 1。

小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。

这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，

这四小块空地都将变为有草的小块。请告诉小明，$k$ 个月后空地上哪些地方有草。

输入描述

输入的第一行包含两个整数 $n, m$。

接下来 $n$ 行，每行包含 $m$ 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 $g$，表示种了草。

接下来包含一个整数 $k$。 其中，$2 \leq n, m \leq 1000，1 \leq k \leq 1000$。

输出描述

输出 $n$ 行，每行包含 $m$ 个字母，表示 $k$ 个月后空地的状态。如果为小数点，表示为空地，如果字母为 $g$，表示长了草。

输入输出样例

示例

输入

1
2
3
4
5
6
4 5 
.g...
.....
..g..
.....
2

输出

1
2
3
4
gggg.
gggg.
ggggg 
.ggg.

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

走迷宫

题目描述

给定一个 $N\times M$ 的网格迷宫 $G$。$G$ 的每个格子要么是道路，要么是障碍物（道路用 $1$ 表示，障碍物用 $0$ 表示）。

已知迷宫的入口位置为 $(x_1,y_1)$，出口位置为 $(x_2 , y_2)$。问从入口走到出口，最少要走多少个格子。

输入描述

输入第 $1$ 行包含两个正整数 $N,M$，分别表示迷宫的大小。

接下来输入一个 $N\times M$ 的矩阵。若 $G_{i,j}=1$ 表示其为道路，否则表示其为障碍物。

最后一行输入四个整数 $x_1,y_1,x_2,y_2$，表示入口的位置和出口的位置。

$1\leq N,M\leq10^2$，$0\leq G_{i,j}\leq 1$，$1\leq x_1,x_2\leq N$，$1\leq y_1,y_2\leq M$。

输出描述

输出仅一行，包含一个整数表示答案。

若无法从入口到出口，则输出 $-1$。

输入输出样例

示例 1

输入

1
2
3
4
5
6
7
5 5
1 0 1 1 0 
1 1 0 1 1 
0 1 0 1 1 
1 1 1 1 1 
1 0 0 0 1
1 1 5 5

输出

1
8

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

迷宫

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

下图给出了一个迷宫的平面图，其中标记为 $1$ 的为障碍，标记为 $0$ 的为可以通行的地方。

1
2
3
4
010000 
000100
001001 
110000

迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。

对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 $10$ 步。其中 $D、U、L、R$ 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（$30$ 行 $50$ 列），请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。

请注意在字典序中 $D<L<R<U$。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
01010101001011001001010110010110100100001000101010 
00001000100000101010010000100000001001100110100101 
01111011010010001000001101001011100011000000010000 
01000000001010100011010000101000001010101011001011 
00011111000000101000010010100010100000101100000000 
11001000110101000010101100011010011010101011110111 
00011011010101001001001010000001000101001110000000 
10100000101000100110101010111110011000010000111010 
00111000001010100001100010000001000101001100001001 
11000110100001110010001001010101010101010001101000 
00010000100100000101001010101110100010101010000101 
11100100101001001000010000010101010100100100010100 
00000010000000101011001111010001100000101010100011 
10101010011100001000011000010110011110110100001000 
10101010100001101010100101000010100000111011101001 
10000000101100010000101100101101001011100000000100 
10101001000000010100100001000100000100011110101001 
00101001010101101001010100011010101101110000110101 
11001010000100001100000010100101000001000111000010 
00001000110000110101101000000100101001001000011101 
10100101000101000000001110110010110101101010100001 
00101000010000110101010000100010001001000100010101 
10100001000110010001000010101001010101011111010010 
00000100101000000110010100101001000001000000000010 
11010000001001110111001001000011101001011011101000 
00000110100010001000100000001000011101000000110011 
10101000101000100010001111100010101001010000001000 
10000010100101001010110000000100101010001011101000 
00111100001000010000000110111000000001000000001011 
10000001100111010111010001000110111010101101111000

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

公共抽签

题目描述

小$A$的学校，蓝桥杯的参赛名额非常有限，只有 $m$ 个名额，但是共有 $n$ 个人报名。

作为老师非常苦恼，他不知道该让谁去，他在寻求一个绝对公平的方式。

于是他准备让大家抽签决定，即 $m$ 个签是去，剩下的是不去。

小 $A$ 非常想弄明白最后的抽签结果会有多少种不同到情况，请你设计一个程序帮帮小 $A$！

输入描述

输入第一行包含两个字符 $n,m$，其含义如题所述。

接下来第二行到第 $n+1$ 行每行包含一个字符串 $S$ ，表示个人名。

$1\leq m\leq n\leq 15$。

输出描述

输出共若干行，每行包含 $m$ 个字符串，表示该结果被选中到人名（需按字符串的输入顺序大小对结果进行排序）。

输入输出样例

示例

输入

1
2
3
4
3 2 
xiaowang
xiaoA 
xiaoli

输出

1
2
3
xiaowang xiaoA
xiaowang xiaoli
xiaoA xiaoli

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

座次问题

题目描述

小 $A$ 的学校，老师好不容易解决了蓝桥杯的报名问题，现在老师又犯愁了。

现在有 $N$ 位同学参加比赛，但是老师想给他们排座位，但是排列方式太多了。

老师非常想弄明白最后的排座次的结果是什么样子的，到底有多少种结果。

请设计一个程序帮助老师。

最后输出各种情况的人名即可，一行一种情况，每种情况的名字按照报名即输入顺序排序。

输入描述

输入第一行包含一个整数 $N$。

接下来 $N$ 行每行包含一个字符串 $S_i$，表示人名。

$1\leq N \leq 10$，$\sum\limits_{i=1}^{N} |S_i| \leq 10^2$。

输出描述

输出共若干行，每行输出各种情况的人名。一行一种情况，每种情况的名字按照报名即输入顺序排序。

输入输出样例

示例

输入

1
2
3
4
3 
xiaowang
xiaoA 
xiaoli

输出

1
2
3
4
5
6
xiaowang xiaoA xiaoli
xiaowang xiaoli xiaoA 
xiaoA xiaowang xiaoli
xiaoA xiaoli xiaowang 
xiaoli xiaowang xiaoA
xiaoli xiaoA xiaowang

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

CLZ银行问题

题目描述

$CLZ$ 银行只有两个接待窗口，$VIP$ 窗口和普通窗口，$VIP$ 用户进入 $VIP$ 窗口排队，剩下的进入普通窗口排队。现有 $M$ 次操作，操作有四种类型，如下：

  • IN name V：表示一名叫 name 的用户到 $VIP$ 窗口排队
  • OUT V：表示 $VIP$ 窗口队头的用户离开排队
  • IN name N：表示一名叫 name 的用户到普通窗口排队
  • OUT N：表示普通窗口队头的用户离开排队

求 $M$ 次操作结束后 $VIP$ 窗口队列和普通窗口队列中的姓名。

输入描述

第一行是一个整数 $M（1\leq M \leq 1000）$，表示一共有 $M$ 次操作。

第二行到第 $M+1$ 行输入操作，格式如下：

  • IN name V
  • OUT V
  • IN name N
  • OUT N

输出描述

输出 $M$ 次操作后 $VIP$ 窗口队列和普通窗口队列中的姓名（从头到尾），先输出 $VIP$ 窗口队列后输出普通窗口队列。

输入输出样例

示例 1

输入

1
2
3
4
5
6
5 
IN xiaoming N 
IN Adel V 
IN laozhao N
OUT N 
IN CLZ V

输出

1
2
3
Adel
CLZ
laozhao

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

费里的语言

题目描述

小发明家弗里想创造一种新的语言，众所周知，发明一门语言是非常困难的，首先你就要克服一个困难就是，有大量的单词需要处理，现在弗里求助你帮他写一款程序，判断是否出现重复的两个单词。

输入描述

第 $1$ 行，输入 $N$，代表共计创造了多少个单词。

第 $2$ 行至第 $N+1$ 行，输入 $N$ 个单词。

$1\leq N \leq 10^4$，保证字符串的总输入量不超过 $10^6$。

输出描述

输出仅一行。若有重复的单词，就输出重复单词，没有重复单词，就输出 NO，多个重复单词输出最先出现的。

输入输出样例

示例1

输入

1
2
3
4
5
6
7
6
1fagas 
dsafa32j 
lkiuopybncv
hfgdjytr 
cncxfg 
sdhrest

输出

1
NO

示例2

输入

1
2
3
4
5
6
5 
sdfggfds
fgsdhsdf
dsfhsdhr 
sdfhdfh 
sdfggfds

输出

1
sdfggfds

运行限制

语言 最大运行时间 最大运行内存
C++ 3s 512M
C 3s 512M
Python3 3s 512M
Java 3s 512M

快递分拣

题目描述

蓝桥王国的每个快递都包含两个参数：1.快递单号 2.快递城市。

小李是蓝桥王国的一名快递员，每天的快递分拣让他苦不堪言。

于是他想要你帮他设计一个程序用于快递的分拣（将不同快递按城市信息分开）。

输入描述

输入第一行包含一个整数 $N$,表示快递的个数。

接下来第 $2 \sim N+1$ 行每行包含一个字符串 $S$ 和一个字符串 $P$，分别快递单号以及快递对应的城市。

$1\leq N \leq 10^3$，保证数据量不超过 $10^6$。

输出描述

输出共若干行。按城市的输入顺序依次输出城市的名称以及城市的快递个数，以及该城市的所有快递单号（单号按照输入顺序排序）。

输入输出样例

示例

输入

1
2
3
4
5
6
7
8
9
10
11
10 
10124214 北京
12421565 上海
sdafasdg213 天津
fasdfga124 北京 
145252 上海 
235wtdfsg 济南 
3242356fgdfsg 成都
23423 武汉 
23423565f 沈阳 
1245dfwfs 成都

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
北京 2 
10124214 fasdfga124 
上海 2 
12421565 145252 
天津 1 
sdafasdg213
济南 1 
235wtdfsg 
成都 2 
3242356fgdfsg 
1245dfwfs 
武汉 1 
23423 
沈阳 1 
23423565f

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M
≡