牛客网语法篇练习复合类型

1.试计算在区间1 到n 的所有整数中，数字x（0 ≤ x ≤ 9）共出现了多少次？
例如，在1到11 中，即在1、2、3、4、5、6、7、8、9、10、11 中，数字1 出现了4 次。

n,x =list(map(int,input().split()))
s = ''.join(str(i) for i in range(1,n+1))
print(s.count(str(x)))

---

2.输入10个整数，要求按输入时的逆序把这10个数打印出来。
   逆序输出，就是按照输入相反的顺序打印这10个数。

num =  input().split()
print(' '.join( num[::-1]))

---

3.输入数字N，然后输入N个数，计算这N个数和。

n = int(input())
s = list(map(int,input().split()))
print(sum(s))

---

4.输入n个成绩，换行输出n个成绩中最高分数和最低分数的差。

n=int(input())
b=list(map(int,input().split()))
print(max(b)-min(b))

---

5.期中考试开始了，大家都想取得好成绩，争夺前五名。
从键盘输入 n 个学生成绩，输出每组排在前五高的成绩。

a=int(input())
b=list(map(int,input().split(" ")))
c=sorted(b,reverse=True)
d=' '.join(map(str,c[0:5]))
print(d)

---

6.输入两个升序排列的序列，将两个序列合并为一个有序序列并输出。

n,m =map(int,input().split())
a,b = [], []
a = list(map(int,input().split()))
b = list(map(int,input().split()))
a.extend(b)
a.sort()
print(*list(a))

---

7.输入一个整数序列，判断是否是有序序列，
即序列中的整数从小到大排序或者从大到小排序(相同元素也视为有序)。

n = int(input())
a = list(map(int, input().split()))
b = sorted(a)
c = sorted(a, reverse=True)
if a == b or a == c:
    print('sorted')
else:
    print('unsorted')

---

8.有一个有序数字序列，从小到大排序，将一个新输入的数插入到序列中，
保证插入新数后，序列仍然是升序。

n = int(input())
l = list(map(int,input().split()))
l.append(int(input()))
l.sort()
c= map(str,l)
print(" ".join(c))

---

9.有一个整数序列（可能有重复的整数），现删除指定的某一个整数，
输出删除指定数字之后的序列，序列中未被删除数字的前后位置没有发生改变。

n = input()
data = list(input().strip().split())
x = input()
while data.count(x):
    data.remove(x)
for i in data:
    print(i,end=" ")

---

10.输入n个整数的序列，要求对这个序列进行去重操作。所谓去重，
是指对这个序列中每个重复出现的整数，只保留该数第一次出现的位置，删除其余位置。

num=int(input())
lis=list(map(int,input().split(" ")))
new_lis=list(set(lis))
new_lis.sort(key=lis.index)
print(" ".join(map(str,new_lis)))

---

11.给定n个整数和一个整数x，小乐乐想从n个整数中判断x出现几次，请编程帮他实现。

n=int(input())
a=list(map(int,input().split(' ')))
f=int(input())
res=a.count(f)
print(res)

---

12.用筛选法求n以内的素数。筛选法求解过程为：将2~n之间的正整数放在数组内存储，将数组中2之后的所有能被2整除的数清0，再将3之后的所有能被3整除的数清0 ，以此类推，直到n为止。数组中不为0 的数即为素数。

def prime(n):
    a = []
    m = list(range(2, n+1))
    a = m
    count = 0
    for i in m:
        for j in a:
            if j%i==0 and j!=i:
                m.remove(j)
                count +=1
    print(*m)
    print(count)

while True:
    try:
        n =  int(input())
        prime(n)
    except:
        break

---

13.输入一个班级5个学生各5科成绩，输出5个学生各5科成绩及总分。

li =[]
for i in range(5):
    li.append(list(map(float,input().split())))
for i in li:
    print('%.1f %.1f %.1f %.1f %.1f %.1f'%(i[0],i[1],i[2],i[3],i[4],sum(i)))
            

---

14.KiKi得到了一个n行m列的矩阵，现在他想知道第x行第y列值是多少，请帮助他完成这个任务。

n,m=map(int,input().split())
m=[]
for i in range(n):
    a=list(input().split(' '))
    m.append(a)
x,y=map(int,input().split())
print(m[x-1][y-1])

---

15.KiKi想从n行m列的方阵队列中找到身高最高的人的位置，请你帮助他完成这个任务。

n,m=map(int,input().split(" "))
lis=[list(map(int,input().split(" "))) for i in range(0,n)]
a=[]
for i in range(0,n):
   a.append(max(lis[i]))
max_num=max(a)
x=a.index(max_num)
y=lis[x].index(max_num)
print(x+1,y+1)

---

16.KiKi得到了两个n行m列的矩阵，他想知道两个矩阵是否相等，请你回答他。
(当两个矩阵对应数组元素都相等时两个矩阵相等)。

n, m = map(int, input().split())
l = [[] * n for _ in range(n)]

for i in range(n):
    l[i] = list(map(int, input().split()))
    l_list = l.copy()
    
for i in range(n):
    l[i] = list(map(int, input().split()))
    l2_list = l.copy()
    
if l_list == l2_list:
    print('Yes')
else:
    print('No')

---

  17.输入NxM矩阵，矩阵元素均为整数，计算其中大于零的元素之和。

a,b = map(int,input().split())
list1 = []
sum = 0
for i in range(a):
    list1.extend(list(map(int,input().split())))
for i in list1:
    if i>0:
        sum+=i
print(sum)

---

18.给你一个整数n，按要求输出n∗n的回型矩阵。

n = int(input())
a = [[0] * n for i in range(n)]
p = 0
q = n - 1
t = 1
while p < q:
    for i in range(p, q):
        a[p][i] = t
        t += 1
    
    for i in range(p, q):
        a[i][q] = t
        t += 1
    
    for i in range(q, p, -1):
        a[q][i] = t
        t += 1
    
    for i in range(q, p, -1):
        a[i][p] = t
        t += 1
        
    p += 1
    q -= 1
    
if p == q:
    a[p][q] = t

for i in range(n):
        print(*a[i])

---

19.给你一个整数n，输出n∗n的蛇形矩阵。

n = int(input())
lis = [[1]]
a = 0
b = 0
index = 1

for i in range(n-1):
    lis.append([])
#print(lis)

tem = 2
if n > 1:
    while(tem <= n**2):
        if (a == 0 and index == 1):
            b = b + 1
            index = -1
        elif (b == 0 and index == -1):
            a = a + 1
            index = 1
        else:
                a = a - index
                b = b + index
                
        if (a < n and b < n):
            lis[a].append(tem)
            tem += 1
            
for i in range(n):
    print(*lis[i])

---

20.给出两幅相同大小的黑白图像（用0-1矩阵）表示，求它们的相似度。若两幅图像在相同位置上的像素点颜色相同，则称它们在该位置具有相同的像素点。两幅图像的相似度定义为相同像素点数占总像素点数的百分比。
 

a,b = map(int,input().split(' '))
m = []
n = []
for i in range(a):
    m.append(list(map(int,input().split())))
for i in range(a):
    n.append(list(map(int,input().split())))
count=0
for i in range(a):
    for j in range(b):
        if m[i][j]==n[i][j]:
            count+=1
print('%.2f'%(count*100/(a*b)))

---

21.KiKi想知道一个n阶方矩是否为上三角矩阵，请帮他编程判定。上三角矩阵即主对角线以下的元素都为0的矩阵，主对角线为从矩阵的左上角至右下角的连线。

n=int(input())
a=[]
sumall=0
for i in range(n):
    raw=list(map(int,input().split()))
    a.append(raw)
for i in range(n):
    for j in range(n):
        if i>j:
            sumall=sumall+a[i][j]
if (sumall)==0:
    print('YES')
else:
    print('NO')

---

22.KiKi现在得到一个包含n*m个数的整数序列，现在他需要把这n*m个数按顺序规划成一个n行m列的矩阵并输出，请你帮他完成这个任务。

a,b=map(int, input().split())
nlist=list(map(int, input().split()))
for i in range(a):
    for j in range(b):
        print(nlist[j+i*b],end=" ")
    print()

---

23.KiKi有一个矩阵，他想知道转置后的矩阵（将矩阵的行列互换得到的新矩阵称为转置矩阵），请编程帮他解答。

n,m=map(int, input().split())
lis = [list(map(int,input().split())) for i in range(0,n)]
for i in range(0,m):
    for j in range(0,n):
        print(lis[j][i],end=' ')
    print()

---

24.KiKi有一个矩阵，他想知道经过k次行变换或列变换后得到的矩阵。请编程帮他解答。

n,m=list(map(int,input().split()))
a=[]
for i in range(n):
    a.append(list(map(int,input().split())))
t=int(input())
for j in range(t):
    r,v1,v2=input().split()
    r,v1,v2=str(r),int(v1),int(v2)
    if r=='r':
        a[v1-1],a[v2-1]=a[v2-1],a[v1-1]
    elif r=='c':
        for i in range(n):
            a[i][v1-1],a[i][v2-1]=a[i][v2-1],a[i][v1-1]

    
for i in range(n):
    for j in range(m):
        print(a[i][j],end=' ')
    print()

---

25.KiKi知道什么叫杨辉三角之后对杨辉三角产生了浓厚的兴趣，他想知道杨辉三角的前n行，请编程帮他解答。杨辉三角，本质上是二项式(a+b)的n次方展开后各项的系数排成的三角形。其性质包括：每行的端点数为1， 一个数也为1；每个数等于它左上方和上方的两数之和。

n=int(input())
s = [[0]*i for i in range(1, 31)]
for i in range(30):
    for j in range(i+1):
        if j==0 or i==j:
            s[i][j]=1
        else:
            s[i][j]=s[i-1][j-1]+s[i-1][j]
s1=s[:n]
for i in range(len(s1)):
    for j in range(len(s1[i])):
        c=str(s[i][j])
        print(' '*(5-len(c))+c,end='')
    print('')

---

26.KiKi和BoBo玩 “井”字棋。也就是在九宫格中，只要任意行、列，或者任意对角线上面出现三个连续相同的棋子，就能获胜。请根据棋盘状态，判断当前输赢。

n=input().split()
m=input().split()
j=input().split()
if n[0]==m[1]==j[2]=='K' or n[2]==m[1]==j[0]=='K':
    print('KiKi wins!')
elif n[0]==m[1]==j[2]=='B' or n[2]==m[1]==j[0]=='B':
    print('BoBo wins!')
elif n[0]==n[1]==n[2]=='K' or m[0]==m[1]==m[2]=='K' or 
j[0]==j[1]==j[2]=='K' or n[0]==m[0]==j[0]=='K' or 
n[1]==m[1]==j[1]=='K' or n[2]==m[2]==j[2]=='K':
    print('KiKi wins!')
elif n[0]==n[1]==n[2]=='B' or m[0]==m[1]==m[2]=='B' or 
j[0]==j[1]==j[2]=='B' or n[0]==m[0]==j[0]=='B' or 
n[1]==m[1]==j[1]=='B' or n[2]==m[2]==j[2]=='B':
    print('BoBo wins!')
else:
    print('No winner!')

---

27.小sun上课的时候非常喜欢玩扫雷。他现小sun有一个初始的雷矩阵，他希望你帮他生成一个扫雷矩阵。

n,m=list(map(int,input().split()))
a=[['-' for i in range(m+2)]]
for i in range(n):
    b=list('-'+input()+'-')
    a.append(b)
a.append(['-' for i in range(m+2)])
for i in range(1,n+1):
    for j in range(1,m+1):
        if a[i][j]!='*':
            s=0
            if a[i-1][j]=='*':
                s=s+1
            if a[i-1][j-1]=='*':
                s=s+1
            if a[i-1][j+1]=='*':
                s=s+1
            if a[i][j-1]=='*':
                s=s+1
            if a[i][j+1]=='*':
                s=s+1
            if a[i+1][j]=='*':
                s=s+1
            if a[i+1][j-1]=='*':
                s=s+1
            if a[i+1][j+1]=='*':
                s=s+1
            a[i][j]=s
for i in a[1:-1]:
    print(''.join(str(j) for j in i[1:-1]))

---

28.凯刚写了一篇美妙的作文，请问这篇作文的标题中有多少个字符？
注意：标题中可能包含大、小写英文字母、数字字符、空格和换行符。统计标题字 符数时，空格和换行符不计算在内。

print(len(input().replace(' ','').replace('\n','')))

---

29.有个软件系统登录的用户名和密码为（用户名：admin，密码：admin），用户输入用户名和密码，判断是否登录成功。

a,b = input().split()
if a=='admin' and b=='admin':
    print("Login Success!")
else:
    print("Login Fail!")

---

30.笨小猴的词汇量很小，所以每次做英语选择题的时候都很头疼。但是他找到了一种方法，经试验证明，用这种方法去选择选项的时候选对的几率非常大！这种方法的具体描述如下：假设maxn是单词中出现次数最多的字母的出现次数，minn是单词中出现次数最少的字母的出现次数，如果maxn-minn是一个质数，那么笨小猴就认为这是个Lucky Word，这样的单词很可能就是正确的答案。

import math
def zishu(n):
    if n<=1:
        return False
    for i in range(2,int(math.sqrt(n)+1)):
        if n%i==0:
            return False
    else:
        return True
    
word=input()
arr=[0 for i in range(26)]
for c in word:
    arr[ord(c)-97]+=1
arr.sort()
minx=0
for x in arr:
    if x>0:
        minx=x
        break
res=arr[-1]-minx
if zishu(res):
    print('Lucky Word')
    print(res)
else:
    print('No Answer')
    print(0)

---

31.对于一个较大的整数 N(1<=N<=2,000,000,000)比如 980364535，我们常常需要一位一位数这个数字是几位数，但是如果在这 个数字每三位加一个逗号，它会变得更加易于朗读。因此，这个数字加上逗号成如下的模样：980,364,535请写一个程序帮她完成这件事情

n=list(input())
i=3
while i 

---

32.假设你们社团要竞选社长，有两名候选人分别是A和B，社团每名同学必须并且只能投一票，最终得票多的人为社长。

s = input()
a = s.count('A')
b = s.count('B')
if a > b:
    print('A')
elif a < b:
    print('B')
else:
    print('E')

---

33.给定长度为n的只有小写字母的字符串s，进行m次操作，每次将[l,r]范围内所有c1字符改成c2，输出操作完的字符串。

m, n = map(int, input().split())
str_use = list(input())
for j in range(n):
    a, b, c, d = input().split()
    for j in range(int(a)-1,int(b)):
        if str_use[j]==c:
            str_use[j]=d
print(''.join(str_use))

---

34.规定一种对于复合词的简写方式为只保留每个组成单词的首字母，并将首字母大写后再连接在一起比如 “College English Test”可以简写成“CET”，“Computer Science”可以简写为“CS”，“I am Bob”简写为“IAB”输入一个长复合词（组成单词数 sum,sum≥1且sum≤100,每个单词长度len,len,len≥1且len≤50），请你输出它的简写。

n=input().split()
for i in n:
    print(i[0].upper(),end='')

---