蓝桥杯练习题(二)：Python组之基础练习三十题

一:数列排序

• 问题描述:给定一个长度为n的数列，将这个数列按从小到大的顺序排列 1<=n<=200
• 输入格式:第一行为一个整数n,第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000
• 输出格式:输出一行，按从小到大的顺序输出排序后的数列
• 样例输入:
  5
  8 3 6 4 9
• 样例输出:
  3 4 6 8 9

具体代码:

x = eval(input())
y = list(map(int,input().split()))
y.sort()
for i in range(x):
    print(y[i],end=' ')

运行结果:

二:十六进制转八进制

• 问题描述:给定n个十六进制正整数，输出它们对应的八进制数

• 输入格式:输入的第一行为一个正整数n (1<=n<=10),接下来n行，每行一个由0到9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000

• 输出格式:输出n行，每行为输入对应的八进制正整数

• 样例输入:
  　2
  　39
  　123ABC

• 样例输出:
  　　71
  　　4435274

• 提示:先将十六进制数转换成某进制数，再由某进制数转换成八进制

具体代码:

t = int(input())
for i in range(t):
    n = input()
    ans = oct(int(n, 16))
    print(ans[2:])

运行结果:

三:十六进制转十进制

• 问题描述:从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示
• 样例输入:FFFF
• 样例输出:65535

具体代码:

x=input()
c = int(x,16)
print(c)

运行结果:

四:十进制转十六进制

• 问题描述:十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。 　 给出一个非负整数，将它表示成十六进制的形式
• 输入格式:输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647
• 输出格式:输出这个整数的16进制表示。
• 样例输入:30
• 样例输出:1E

具体代码:

x=eval(input())
c = format(x,'X')
print(c)

运行结果:

五:特殊回文数

• 问题描述:123321是一个非常特殊的数，它从左边读和从右边读是一样的。 　　输入一个正整数n,编程求所有这样的五位和六位十进制数，满足各位数字之和等于n
• 输入格式:输入一行，包含一个正整数n
• 输出格式:按从小到大的顺序输出满足条件的整数，每个整数占一行
• 样例输入:52
• 样例输出:899998 989989 998899
• 数据规模和约定:1<=n<=54
  具体代码:

def is_hui(i):
    i = str(i)
    if i==i[::-1]:
        return True
    else:
        return False

def totle(i):
    sum=0
    while i > 0:
        a = int(i%10)
        i = int(i//10)
        sum+=a
    return sum

if __name__ == '__main__':
    x=int(input())
    i=10000
    while i < 1000000:
        if is_hui(i):
            if totle(i)==x:
                print(i)
        i+=1

运行结果:

六:回文数

• 问题描述:1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
• 输出格式:按从小到大的顺序输出满足条件的四位十进制数。

具体代码:

def is_hui(i):
    i = str(i)
    if i==i[::-1]:
        return True
    else:
        return False


if __name__ == '__main__':
    i=1000
    while i < 10000:
        if is_hui(i):
            print(i)
        i+=1

运行结果:

七:水仙花数

• 问题描述:153是一个非常特殊的数，它等于它的每位数字的立方和，即153=111+555+333。编程求所有满足这种条件的三位十进制数
• 输出格式:按从小到大的顺序输出满足条件的三位十进制数，每个数占一行

具体代码:

def is_spe(i):
    a = int(i%10)
    b = int(i/10)
    c = int(b%10)
    d = int(b/10)
    sum = a*a*a+c*c*c+d*d*d
    if sum==int(i):
        return True
    else:
        return False


if __name__ == '__main__':
    i=100
    while i < 1000:
        if is_spe(i):
            print(i)
        i+=1

运行结果：

八:杨辉三角形

• 问题描述:杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。
• 输入格式:输入包含一个数n。
• 输出格式:输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。
• 样例输入:4
• 样例输出:
  1
  1 1
  1 2 1
  1 3 3 1
• 数据规模和约定:1 <= n <= 34。

具体代码:

def YangHui(n):
    print(1)
    # print('1'.center(width))
    print(1,1)
    line = [1, 1]

    for i in range(2,n):
        r=[]
        for j in range(0,len(line)-1):
            r.append(line[j]+line[j+1])
        # print(r)
        line = [1]+r+[1]
        str_array = " ".join(map(str, line))
        # print(str_array.center(width))
        print(str_array)


if __name__ == '__main__':
    n = int(input())
    # width=n*6
    YangHui(n)

运行结果:

九:查找整数

• 问题描述:给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。
• 输入格式:第一行包含一个整数n。第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。第三行包含一个整数a，为待查找的数。
• 输出格式:如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
• 样例输入:
  6
  1 9 4 8 3 9
  9
• 样例输出:2
• 数据规模和约定:1 <= n <= 1000

具体代码:

n = int(input())
array = input().split()
x = str(input())
i=0
while i<n:
    if x==array[i]:
        print(i+1)
        break
    i+=1
if i==n:
    print(-1)

运行结果:

十:数列特征

• 问题描述:给出n个数，找出这n个数的最大值，最小值，和。
• 输入格式:第一行为整数n，表示数的个数。第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。
• 输出格式:输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
• 样例输入:
  5
  1 3 -2 4 5
• 样例输出:
  5
  -2
  11
• 数据规模和约定:1 <= n <= 10000

具体代码:

number = int(input())
arr=input().split()
sum = 0
for i in range(number):
    sum += int(arr[i])
print(max(int(arr[i]) for i in range(number)))
print(min(int(arr[i]) for i in range(number)))
print(sum)

运行结果:

十一:字母图形

• 问题描述:利用字母可以组成一些美丽的图形，请找出这个图形的规律，并输出一个n行m列的图形。
• 输入格式:输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
• 输出格式:输出n行，每个m个字符，为你的图形。
• 样例输入:5 7
• 样例输出:
  ABCDEFG
  BABCDEF
  CBABCDE
  DCBABCD
  EDCBABC
• 数据规模和约定:1 <= n, m <= 26

具体代码:

# 先定义一个空二维数组
n,m = list(map(int,input().split()))
arr = [[0 for j in range(m)] for i in range(n)]

# 字符转ASCII码函数：ord(‘A’)–>64
# ASCII码转字符函数：chr(64)–>A
for i in range(n):
    for j in range(m):
        if j>=i:
            arr[i][j]=chr(ord('A')+j-i)
        else:
            arr[i][j] = chr(ord('A') + i - j)

# 显现二维数组
for i in range(n):
    for j in range(m):
        print(arr[i][j],end='')
    print()

运行结果:

十二:01字串

• 问题描述:对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。
• 输入格式:本试题没有输入。
• 输出格式:输出32行，按从小到大的顺序每行一个长度为5的01串。
• 样例输出:
  00000
  00001
  00010
  00011
  <以下部分省略>

具体代码:

for i in range(32):
    # format(integer, 'x') 将integer转换为16进制，不带0x。integer为整型，'x'可换为'o','b','d'相对应八、二、十进制。
    # 关于Python如何使用str.format添加前导零？ https://cloud.tencent.com/developer/ask/52170 
    print("{0:0>5}".format(format(i,'b')))

运行结果:

十三：闰年判断

• 问题描述:给定一个年份，判断这一年是不是闰年。当以下情况之一满足时，这一年是闰年：1. 年份是4的倍数而不是100的倍数；2. 年份是400的倍数。其他的年份都不是闰年。
• 输入格式:输入包含一个整数y，表示当前的年份。
• 输出格式:输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
• 样例输入:2013
• 样例输出:no
• 样例输入:2016
• 样例输出:yes

具体代码:

def is_leap(n):
    if n%4==0 and n%100!=0 or n%400==0:
        return True
    else:
        return False

if __name__ == '__main__':
    n = int(input())
    if is_leap(n):
        print("yes")
    else:
        print("no")

运行结果:

十四：阶乘计算

• 问题描述:输入一个正整数n，输出n!的值。其中n!=123*…*n。
• 算法描述：n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。
• 输入格式:输入包含一个正整数n，n<=1000。
• 输出格式:输出n!的准确值。
• 样例输入:10
• 样例输出:3628800

具体代码:

def tier(n):
    sum = 1
    for i in range(n):
        sum*=i+1
    return sum

if __name__ == '__main__':
    n = int(input())
    print(tier(n))

运行结果:

十五：高精度加法

• 问题描述:输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。
• 算法描述：由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。定义一个数组A，A[0]用于存储a的个位，A[1]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。计算c = a + b的时候，首先将A[0]与B[0]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C[0]，即C[0]等于(A[0]+B[0])%10。然后计算A[1]与B[1]相加，这时还应将低位进上来的值r也加起来，即C[1]应该是A[1]、B[1]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C[1]中。依此类推，即可求出C的所有位。最后将C输出即可。
• 输入格式:输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。
• 输出格式:输出一行，表示a + b的值。
• 样例输入:
  20100122201001221234567890
  2010012220100122
• 样例输出:20100122203011233454668012

具体代码:

def sum(n,m):
    return n+m
if __name__ == '__main__':
    n = int(input())
    m = int(input())
    # print(tier(n))
    print(sum(n,m))

运行结果:

十六：Huffuman树

• 问题描述:Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下：
  　　1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
  　　2. 重复步骤1，直到{pi}中只剩下一个数。
  　　在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。
  　　本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。
  　　例如，对于数列{pi}={5, 3, 8, 2, 9}，Huffman树的构造过程如下：
  　　1. 找到{5, 3, 8, 2, 9}中最小的两个数，分别是2和3，从{pi}中删除它们并将和5加入，得到{5, 8, 9, 5}，费用为5。
  　　2. 找到{5, 8, 9, 5}中最小的两个数，分别是5和5，从{pi}中删除它们并将和10加入，得到{8, 9, 10}，费用为10。
  　　3. 找到{8, 9, 10}中最小的两个数，分别是8和9，从{pi}中删除它们并将和17加入，得到{10, 17}，费用为17。
  　　4. 找到{10, 17}中最小的两个数，分别是10和17，从{pi}中删除它们并将和27加入，得到{27}，费用为27。
  　　5. 现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。
• 输入格式:输入的第一行包含一个正整数n（n<=100).接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。
• 输出格式:输出用这些数构造Huffman树的总费用。
• 样例输入:
  5
  5 3 8 2 9
• 样例输出:59

具体代码:

def Huffuman(arr):
    new_1=[]
    for i in range(len(arr)-1):
        arr,new=reduce(arr)
        new_1.append(new)
        # print(arr)
    return new_1

def reduce(arr):
    arr.sort()
    arr1=[]
    new=0
    for i in range(len(arr)):
        if i==0:
            arr1.append(arr[i]+arr[i+1])
            new=arr[i]+arr[i+1]
        if i!=0 and i!=1:
            arr1.append(arr[i])
    return arr1,new
if __name__ == '__main__':
    n=int(input())
    arr=list(map(int,input().split()))
    result=Huffuman(arr)
    sum=0
    for i in range(len(result)):
        # print(result[i])
        sum+=result[i]
    print(sum)

运行结果:

十七：2n皇后问题

• 问题描述:给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。
• 输入格式:输入的第一行为一个整数n，表示棋盘的大小。接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，如果一个整数为0，表示对应的位置不可以放皇后。
• 输出格式:输出一个整数，表示总共有多少种放法。
• 样例输入:
  4
  1 1 1 1
  1 1 1 1
  1 1 1 1
  1 1 1 1
• 样例输出:2
• 样例输入:
  4
  1 0 1 1
  1 1 1 1
  1 1 1 1
  1 1 1 1
• 样例输出:0

具体代码:

运行结果:

十八：报时助手

• 问题描述:给定当前的时间，请用英文的读法将它读出来。
  　　时间用时h和分m表示，在英文的读法中，读一个时间的方法是：
  　　如果m为0，则将时读出来，然后加上“o’clock”，如3:00读作“three o’clock”。
  　　如果m不为0，则将时读出来，然后将分读出来，如5:30读作“five thirty”。
  　　时和分的读法使用的是英文数字的读法，其中0~20读作：
  　　0:zero, 1: one, 2:two, 3:three, 4:four, 5:five, 6:six, 7:seven, 8:eight, 9:nine, 10:ten, 11:eleven, 12:twelve, 13:thirteen, 14:fourteen, 15:fifteen, 16:sixteen, 17:seventeen, 18:eighteen, 19:nineteen, 20:twenty。
  　　30读作thirty，40读作forty，50读作fifty。
  　　对于大于20小于60的数字，首先读整十的数，然后再加上个位数。如31首先读30再加1的读法，读作“thirty one”。
  　　按上面的规则21:54读作“twenty one fifty four”，9:07读作“nine seven”，0:15读作“zero fifteen”。
• 输入格式:输入包含两个非负整数h和m，表示时间的时和分。非零的数字前没有前导0。h小于24，m小于60。
• 输出格式:输出时间时刻的英文。
• 样例输入:0 15
• 样例输出:zero fifteen

具体代码:

h,m = list(map(int,input().split()))
dic_time={0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine',
        10: 'ten', 11: 'eleven', 12: 'twelve', 13: 'thirteen', 14: 'fourteen', 15: 'fifteen', 16: 'sixteen',
        17: 'seventeen', 18: 'eighteen', 19: 'nineteen', 20: 'twenty',21:'twenty one', 22:'twenty two',23:'twenty three',30:'thirty',40:'forty',50:'fifty'}

if m==0:
    print(dic_time[h]+' o\'clock')
else:
    if 0<m<20 :
        print(dic_time[h]+' '+dic_time[m])
    elif m==30 or m==40 or m==50:
        print(dic_time[h]+' '+dic_time[m])
    elif 20<m<30:
        print(dic_time[h]+' '+dic_time[20]+' '+dic_time[m-20])
    elif 30<m<40:
        print(dic_time[h]+' '+dic_time[30]+' '+dic_time[m-30])
    elif 40<m<50:
        print(dic_time[h]+' '+dic_time[40]+' '+dic_time[m-40])
    else:
        print(dic_time[h]+' '+dic_time[50]+' '+dic_time[m-50])

运行结果:

十九：回形取数

• 问题描述:回形取数就是沿矩阵的边取数，若当前方向上无数可取或已经取过，则左转90度。一开始位于矩阵左上角，方向向下。
• 输入格式:输入第一行是两个不超过200的正整数m, n，表示矩阵的行和列。接下来m行每行n个整数，表示这个矩阵。
• 输出格式:输出只有一行，共mn个数，为输入矩阵回形取数得到的结果。数之间用一个空格分隔，行末不要有多余的空格。
• 样例输入:
  3 3
  1 2 3
  4 5 6
  7 8 9
• 样例输出:1 4 7 8 9 6 3 2 5
• 样例输入:
  3 2
  1 2
  3 4
  5 6
• 样例输出:1 3 5 6 4 2

具体代码:

import math
r,c=map(int,input().split())#其中r,c分别代表要输入数据的行数和列数
list1=[]#列表用来存放键盘输入的数据
ans=[]#用来存放要输出的数据
for i in range(0,r):#二维列表输入实例
    list1.append(input().split())
print(list1)
for j in range(0,math.ceil(min(r,c)/2)):#math.ceil（）函数是用来向上取整，向下取整直接整数相除即可，math.ceil(min(r,c)/2表示要转的圈数
    for x in range(j,r-j):#将第j圈的左“1”字形x放入ans；0-3为0，1，2
        ans.append(list1[x][j])
    for y in range(j+1,c-j):#将第j圈的下“一”字形x放入ans
        # print(r-1-j)
        # print(y)
        ans.append(list1[r-1-j][y])
# print(ans)
    if c-1>2*j:#判断一下是否还有多余的列需要转圈
        for p in range(r-j-2,j-1,-1):#将第j圈的右“1”字形放入ans；
            ans.append(list1[p][c-1-j])
    if r-1>2*j:#判断一下是否还有多余的行需要转圈
        for q in range(c-2-j,0,-1):#将第j圈的上“一”字形放入ans；
            ans.append(list1[j][q])
for x in ans:
    print(x,'',end='')

运行结果:

二十：龟兔赛跑预测

• 问题描述:话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先t米或以上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1（表示每秒兔子能跑v1米），乌龟的速度v2，以及兔子对应的t，s值，以及赛道的长度l——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找到了你——清华大学计算机系的高才生——请求帮助，请你写一个程序，对于输入的一场比赛的数据v1，v2，t，s，l，预测该场比赛的结果
• 输入格式:输入只有一行，包含用空格隔开的五个正整数v1，v2，t，s，l，其中(v1,v2<=100;t<=300;s<=10;l<=10000且为v1,v2的公倍数)
• 输出格式:输出包含两行，第一行输出比赛结果——一个大写字母“T”或“R”或“D”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。第二行输出一个正整数，表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。
• 样例输入:10 5 5 2 20
• 样例输出:
  D
  4
• 样例输入:10 5 5 1 20
• 样例输出:
  R
  3
• 样例输入:10 5 5 3 20
• 样例输出:
  T
  4

具体代码:

v1,v2,t,s,l = list(map(int,input().split()))

rabbit_t=tortoise_t=time=0

flag = False
while True:
    if rabbit_t==l or tortoise_t==l:
        break
    if rabbit_t-tortoise_t>=t:
        for i in range(s):
            tortoise_t+=v2
            time+=1
            if tortoise_t==l:
                flag=True
                break
        if flag:
            break
    time+=1
    rabbit_t+=v1
    tortoise_t+=v2


if rabbit_t>tortoise_t:
    print('R')
    print(time)
elif rabbit_t<tortoise_t:
    print('T')
    print(time)
else:
    print('D')
    print(time)

运行结果:

二十一：芯片测试

• 问题描述:　有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。给出所有芯片的测试结果，问哪些芯片是好芯片。
• 输入格式:输入数据第一行为一个整数n，表示芯片个数。第二行到第n+1行为n*n的一张表，每行n个数据。表中的每个数据为0或1，在这n行中的第i行第j列（1≤i, j≤n）的数据表示用第i块芯片测试第j块芯片时得到的测试结果，1表示好，0表示坏，i=j时一律为1（并不表示该芯片对本身的测试结果。芯片不能对本身进行测试）。
• 输出格式:按从小到大的顺序输出所有好芯片的编号
• 样例输入:
  3
  1 0 1
  0 1 0
  1 0 1
• 样例输出:
  1 3

具体代码:

#方法1：
def cover(list): # 生成转置array
    o=[]
    for i in range(n):
        e=[]
        for j in list:
            e.append(j[i])
        o.append(e)
    return o

n=int(input())
arr=[]
test=[True for i in range(n)]
for i in range(n):
    a=list(map(int,input().split()))
    arr.append(a)
sum1=[]
arr1=cover(arr)
for i in arr1:
    sum=0
    for j in range(n):
        if i[j]==0:
            sum+=1
    sum1.append(sum)
for i in range(n):
    if sum1[i]>=n/2:
        test[i]=False
for i in range(n):
    if test[i]==True:
        print(i+1,end=' ')
        
#方法2：
n=int(input())
tet1=[True for i in range(n)]
arr1=[]
for i in range(n):
    arr1.append(list(map(int,input().split())))
arr=list(map(list,zip(*arr1)))
sum1=[]
for i in arr:
    sum=0
    for j in range(n):
        if i[j]==0:
            sum+=1
    sum1.append(sum)
for i in range(n):
    if sum1[i]<=n/2:
        print(i+1,end=' ')

运行结果:

二十二：FJ的字符串

• 问题描述:　FJ在沙盘上写了这样一些字符串：
  　　A1 = “A”
  　　A2 = “ABA”
  　　A3 = “ABACABA”
  　　A4 = “ABACABADABACABA”
  　　… …
  　　你能找出其中的规律并写所有的数列AN吗？
• 输入格式:　仅有一个数：N ≤ 26。
• 输出格式:请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
• 样例输入:3
• 样例输出:
  ABACABA

具体代码:

n=int(input())
sum=''
for i in range(n):
    sum=sum+chr(ord('A')+i)+sum
print(sum)

运行结果:

二十三：Sine之舞

• 问题描述:　最近FJ为他的奶牛们开设了数学分析课，FJ知道若要学好这门课，必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏，寓教于乐，提高奶牛们的计算能力。
  　　不妨设
  　　An=sin(1–sin(2+sin(3–sin(4+…sin(n))…)
  　　Sn=(…(A1+n)A2+n-1)A3+…+2)An+1
  　　FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式，以方便奶牛们做题。
• 输入格式:　仅有一个数：N<201。
• 输出格式:请输出相应的表达式Sn，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
• 样例输入:3
• 样例输出:
  ((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1

具体代码:

def A(n, k):

    if n == k:
        return

    print('sin(%d'%(n+1),end='')

    # 若后边还有式子，判断是输出+号还是-号
    if n+1!=k:
        if n%2==1:
            print('+',end='')
        else:
            print('-',end='')
    # 若后边没有式子，输出右括号结束
    # 注意，这里只输出最后一次的右括号，前边左括号对应的右括号在S()函数中补全
    else:
        print(')',end='')
    n += 1
    A(n, k)  # 递归调用自身


def S(n):

    k = t = 1

    if n == 0:
        return

    for i in range(n-1):
        print('(',end='')

    while n!=0:
        A(0,k)
        for i in range(t-1):
            print(')',end='')
        print('+%d' % n, end='')
        if n != 1:  # 最后一项加完整数之和不必再输出右括号
            print(')', end='')
        k += 1
        t += 1
        n -= 1


n = int(input())

# A(0, 3)

S(n)

运行结果:

二十四：数的读法

• 问题描述:　Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。
  　　比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。
  　　所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法：
  　　十二亿三千四百五十六万七千零九
  　　用汉语拼音表示为
  　　shi er yi san qian si bai wu shi liu wan qi qian ling jiu
  　　这样他只需要照着念就可以了。
  　　你的任务是帮他设计这样一个系统：给定一个阿拉伯数字串，你帮他按照中文读写的规范转为汉语拼音字串，相邻的两个音节用一个空格符格开。
  　　注意必须严格按照规范，比如说“10010”读作“yi wan ling yi shi”而不是“yi wan ling shi”，“100000”读作“shi wan”而不是“yi shi wan”，“2000”读作“er qian”而不是“liang qian”。
• 输入格式:　有一个数字串，数值大小不超过2,000,000,000。
• 输出格式:是一个由小写英文字母，逗号和空格组成的字符串，表示该数的英文读法。
• 样例输入:1234567009
• 样例输出:
  shi er yi san qian si bai wu shi liu wan qi qian ling jiu

具体代码:

n = str(input())

pin_yin = {'0': 'ling', '1': 'yi', '2': 'er', '3': 'san', '4': 'si', '5': 'wu',
           '6': 'liu', '7': 'qi', '8': 'ba', '9': 'jiu'}
pin_yin_2 = {0: '', 1: '', 2: 'shi', 3: 'bai', 4: 'qian', 5: 'wan', 6: 'shi',
             7: 'bai', 8: 'qian', 9: 'yi', 10: 'shi'}
n = n + ' '
l = len(n) - 1
# print(l)

for i in range(l):
    j = int(n[i])
    if j != 0:  # 不为0时的读法
        if (l-i==2 or l-i==6 or l-i==10)and j==1:# 在十位，十万位，十亿位置且位于开头的1不读
            if i!=0:
                print(pin_yin['1'],end=' ')
            print(pin_yin_2[2],end=' ')
            continue
        print(pin_yin[n[i]],end=' ')
        print(pin_yin_2[l-i],end=' ')
    else:  # 处理0的读法问题
        if l-i==5 or l-i==9: # 如果此0是在万位或亿位，则读出万或亿
            print(pin_yin_2[l-i],end=' ')
        if n[i+1]=='0' or i==l-1: # 下一位还为0或者最后一位为0 不管它
            continue
        print(pin_yin['0'], end=' ')  # 否则才读出这个零

运行结果:

二十五：完美的代价

• 问题描述:　回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
  　　交换的定义是：交换两个相邻的字符
  　　例如mamad
  　　第一次交换 ad : mamda
  　　第二次交换 md : madma
  　　第三次交换 ma : madam (回文！完美！)。
• 输入格式:第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)
  　　第二行是一个字符串，长度为N.只包含小写字母
• 输出格式:如果可能，输出最少的交换次数。否则输出Impossible
• 样例输入:
  5
  mamad
• 样例输出:
  3

具体代码:

n = int(input())
pal = list(input())

count = 0 #count用来计交换的次数
flag = 0  #flag判断是否已经有一个单独的奇个数的字符了
i=0 #用于计数外层丢弃的字符（单侧）

while(len(pal)>1):
    for k in range(len(pal)-1,0,-1):  # 从后面往前一直到1，寻找和pal[0]相同的pal[k]
        if pal[k] == pal[0]:
            count += len(pal) - k - 1  # 计数器加 len(pal)-k-1
            #最外层的已构成回文，不考虑了
            pal.pop(0)#注：pal(i)被pop掉后，索引整体前移1，所以k的位置需要-1
            i+=1
            pal.pop(k-1)#把找到的字符直接移到最外层，即直接pop掉
            break

        elif k == 1:  # 如果找不到相同的，该字符放到中间
            pal.pop(0)  #找不到的这个数丢弃，不能影响后续判断
            # impossible的两种情况:
            # ①偶数个字符，却存在一个字符出现奇数次
            # ②奇数个字符，但已经有一个字符只出现奇数次了，不能再出现下一个
            if n % 2 == 0 or flag == 1:
                print('Impossible')
                exit()
            flag = 1
            count += int(n/2) - i #把出现奇数次的字符直接移到中间需要的步数
print(count)

运行结果:

二十六：矩形面积交

• 问题描述:　平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。
• 输入格式:输入仅包含两行，每行描述一个矩形。在每行中，给出矩形的一对相对顶点的坐标，每个点的坐标都用两个绝对值不超过10^7的实数表示。
• 输出格式:输出仅包含一个实数，为交的面积，保留到小数后两位。
• 样例输入:
  1 1 3 3
  2 2 4 4
• 样例输出:
  1.00

具体代码:

"""矩形面积交"""
list1=list(map(float,input().split()))
list2=list(map(float,input().split()))
area = 0
x1 = max(min(list1[0],list1[2]),min(list2[0],list2[2]))
y1 = max(min(list1[1],list1[3]),min(list2[1],list2[3]))
x2 = min(max(list1[0],list1[2]),max(list2[0],list2[2]))
y2 = min(max(list1[1],list1[3]),max(list2[1],list2[3]))
if x1<x2 and y1<y2:
    area = (x2-x1)*(y2-y1)
    print('%.2f'%area)
else:
    print('%.2f'%area)

运行结果:

二十七：矩阵乘法

• 问题描述:给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
  　　例如：
  　　A =
  　　1 2
  　　3 4
  　　A的2次幂
  　　7 10
  　　15 22
• 输入格式:第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数,接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值
• 输出格式:输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开
• 样例输入:
  2 2
  1 2
  3 4
• 样例输出:
  7 10
  15 22
• 1.不要忘记方阵的0次幂这一特殊情况，它的结果是人为定义的，为n阶单位阵。
  2.博主的代码中矩阵乘法函数，是一个普遍适用的矩阵乘法函数，即不是两个方阵相乘也行，只要两矩阵满足矩阵乘法定理即可，相应解释已在代码块中给出。
  3.若你在参加考试，则代码越简化越好，如这题的矩阵乘法函数，题中给的输入矩阵必为n阶方阵，所以写矩阵乘法的函数就只针对n阶方阵来写就好了，以降低出错率，相应代码请读者自行写出，以加深理解。

具体代码:

# 生成“竖排列表”
def matrix_multi(arr, arr_cover):
    arr_sum = []
    for i in arr:
        arr1_sum = []
        for j in arr_cover:
            sum = 0
            for k in range(n):
                sum += i[k] * j[k]
            arr1_sum.append(sum)
        arr_sum.append(arr1_sum)
    return arr_sum

def mi(list,num):
    result=matrix_multi(list,arr_cover)
    if num==2:
        the_result_Arr(result)
    else:
        mi(result,num-1)
def the_result_Arr(list):
    for i in list:
        for j in i:
            print(j, end=' ')
        print()

n,k=list(map(int,input().split()))
arr=[]
for i in range(n):
    arr.append(list(map(int,input().split())))
arr_cover=list(map(list,zip(*arr)))
if k == 0:  # 0次幂只有为方阵才有，此时result为n阶单位阵
    arr1 = [[0 for i in range(n)] for j in range(n)]
    for i in range(n):
        arr1[i][i]=1
    the_result_Arr(arr1)
elif k==1:
    the_result_Arr(arr)
else:
    mi(arr,k)

运行结果：

二十八：分解质因数

• 问题描述:　求出区间[a,b]中所有整数的质因数分解。
• 输入格式:输入两个整数a，b。
• 输出格式:每行输出一个数的分解，形如k=a1a2a3…(a1<=a2<=a3…，k也是从小到大的)(具体可看样例)
• 样例输入:
  3 10
• 样例输出:
  

具体代码:

def factory(n):
    e=[]
    while n>1:
        for i in range(n):
            k=i+2
            if n%k==0:
                e.append(k)
                n=int(n/k)
                break
    return e

n,m=list(map(int,input().split()))
for i in range(n,m+1):
    print(i,'=',sep='',end='')
    e=factory(i)
    for j in range(len(e)):
        print(e[j],sep='',end='')
        if j!=len(e)-1:
            print('*',end='')
    print()

运行结果:

二十九：字符串对比

• 问题描述:　给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
  　　1：两个字符串长度不等。比如 Beijing 和 Hebei
  　　2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
  　　3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
  　　4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
  　　编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。
• 输入格式:包括两行，每行都是一个字符串
• 输出格式:仅有一个数字，表明这两个字符串的关系编号
• 样例输入:
  BEIjing
  beiJing
• 样例输出:
  3

具体代码:

list1=str(input())
list2=str(input())
if len(list1)!=len(list2):
    print('1')
elif list1==list2:
    print('2')
elif list1.lower()==list2.lower():
    print('3')
else:
    print('4')

运行结果:

三十：时间转换

• 问题描述:　给定一个以秒为单位的时间t，要求用H:M:S的格式来表示这个时间。H表示时间，M表示分钟，而S表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。
• 输入格式:输入只有一行，是一个整数t（0<=t<=86399）。
• 输出格式:输出只有一行，是以“H:M:S”的格式所表示的时间，不包括引号。
• 样例输入:
  0
• 样例输出:
  0:0:0
• 样例输入:
  5436
• 样例输出:
  1:30:36
• 这道题目就是单纯的把秒转换成小时和分钟。

具体代码:

sec=int(input())
hour = sec//3600
sec1 = sec-hour*3600
min = sec1//60
sec2 = sec1-min*60
print(hour,':',min,':',sec2,sep='')

运行结果: