蓝桥杯基础练习学习记录

数列排序

给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200

直接采用数组自带的排序方法

n = int(input())
test_list = list(map(int, input().split()))
# a = sorted(test_list) 
test_list.sort()
for i in test_list:
    print(i, end=' ')

十六进制转八进制

给定n个十六进制正整数，输出它们对应的八进制数。

n = int(input())
res = []
for i in range(n):
    a = int(input(), 16)
    res.append(format(a, 'o'))
print('\n'.join(res))

十六进制转十进制

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

print(int(input(), 16))

What can I say???

十进制转十六进制

十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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。
给出一个非负整数，将它表示成十六进制的形式。

n = int(input())
print(format(n, 'x').upper())

特殊回文数

123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。

n = int(input())
if n % 2 != 0:
    for i in range(10, 100):
        a = i // 10
        b = i % 10
        c = n - 2 * (a + b)
        if c >= 0 and c < 10:
            print(a * 10000 + b * 1000 + c * 100 + b * 10 + a)
else:
    for i in range(10, 100):
        a = i // 10
        b = i % 10
        c = n - 2 * (a + b)
        if c >= 0 and c < 10:
            print(a * 10000 + b * 1000 + c * 100 + b * 10 + a)
    for i in range(100, 1000):
        a = i // 100
        b = i // 10 % 10
        c = i % 10
        if 2 * (a + b + c) == n:
            print(a * 100000 + b * 10000 + c * 1000 + c * 100 + b * 10 + a))

回文数

1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。

for i in range(10, 100):
    a = i // 10
    b = i % 10
    print(a * 1001 + b * 110)

特殊的数字

153是一个非常特殊的数，它等于它的每位数字的立方和，即153=111+555+333。编程求所有满足这种条件的三位十进制数。

for i in range(100, 1000):
    a = i // 100
    b = i // 10 % 10
    c = i % 10
    if a**3 + b**3 + c**3 == i:
        print(i)

杨辉三角形

杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。

它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。

下面给出了杨辉三角形的前4行：

1

1 1

1 2 1

1 3 3 1

给出n，输出它的前n行。

def yanghui(n):
    if n == 1:
        return [1]
    elif n == 2:
        return [[1], [1, 1]]
    else:
        res = [[1], [1, 1]]
        for i in range(n - 2):
            new_list = [1]
            for j in range(len(res[-1]) - 1):
                new_list.append(res[-1][j] + res[-1][j + 1])
            new_list.append(1)
            res.append(new_list)
        return res

n = int(input())
my_list = yanghui(n)
for i in my_list:
    print(' '.join('%s' %id for id in i))

查找整数

给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。

n = input()
my_list = list(map(int, input().split()))
find_num = int(input())
if find_num not in my_list:
    print('-1')
for i in range(len(my_list)):
    if my_list[i] == find_num:
        print(i + 1)
        break

数列特征

给出n个数，找出这n个数的最大值，最小值，和。

n = input()
my_list = list(map(int, input().split()))
print(max(my_list))
print(min(my_list))
print(sum(my_list))

字母图形

利用字母可以组成一些美丽的图形，下面给出了一个例子：

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

n, m = map(int, input().split())
my_list = []
res_list = []
max = m if m > n else n
for i in range(max):
    my_list.append(chr(ord('A') + i))
for j in range(0, n):
    new_list = []
    if j==0:
        for k in range(m):
            new_list.append(my_list[k])
    else:
        new_list.append(my_list[j])
        for k in range(m - 1):
            new_list.append(res_list[-1][k])
    res_list.append(new_list)
    print(''.join(res_list[-1]))

01字串

对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：

00000

00001

00010

00011

00100

请按从小到大的顺序输出这32种01串。

for i in range(32):
    print('{:0>5b}'.format(i))

闰年判断

给定一个年份，判断这一年是不是闰年。

当以下情况之一满足时，这一年是闰年：

1. 年份是4的倍数而不是100的倍数；

2. 年份是400的倍数。

其他的年份都不是闰年。

year = int(input())
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
    print('yes')
else:
    print('no')

Fibonacci数列

Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。

当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。

def fibonacci(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fibonacci(n - 1) % 10007 + fibonacci(n - 2) % 10007
n = int(input())
print(fibonacci(n))

a = []
a.append(1)
a.append(1)
n = int(input())
f = n - 1
for i in range(2, n):
    a.append((a[i - 1] + a[i - 2]) % 10007)
print(a[f])

圆的面积

给定圆的半径r，求圆的面积。

import math
r = int(input())
sq = math.pi*r**2
print('{:.7f}'.format(sq))

序列求和

求1+2+3+…+n的值。

n = int(input())
print('%d' % ((n + 1) * n / 2))

阶乘计算

输入一个正整数n，输出n!的值。
其中n!=1 2 3*…n。**

(n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。
将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。
首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。)

n = int(input())
my_list = [0 for i in range(10000)]
length = 1
my_list[0] = 1
if n > 1:
    for i in range(2, n + 1):
        carry = 0
        for j in range(length):
            temp = my_list[j] * i + carry
            carry = temp // 10
            my_list[j] = temp % 10
        while carry > 0:
            my_list[length] += carry % 10
            length += 1
            carry //= 10
while length > 0:
    length -= 1
    print(my_list[length], end='')

高精度加法

输入两个整数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 = list(input())
b = list(input())
if len(a) > len(b):
    for i in range(len(a) - len(b)):
        b.insert(0, 0)
elif len(a) < len(b):
    for i in range(len(b) - len(a)):
        a.insert(0, 0)
c = []
r = 0
for x, y in zip(a[::-1], b[::-1]):
    ss = int(x) + int(y) + r
    c.insert(0, str(ss % 10))
    if ss >= 10:
        r = 1
    else:
        r = 0
if r == 1:
    c.insert(0, '1')
print(''.join(c))

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。

input()
my_list = list(map(int, input().split()))
my_list.sort()
sum = 0
while len(my_list) != 1:
    a = my_list[0] + my_list[1]
    sum += a
    del my_list[0:2]
    my_list.append(a)
    my_list.sort()
print(sum)

2n皇后问题

给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。

def checkw(row, col):
    if row == 0:
        return True
    for i in range(row):
        if white_list[i] == col or abs(row - i) == abs(col - white_list[i]):
            return False
    return True

def checkb(row, col):
    if row == 0:
        return True
    for i in range(row):
        if black_list[i] == col or abs(row - i) == abs(col - black_list[i]):
            return False
    return True

def dfsb(r):
    if r == n:
        global num
        num += 1
    else:
        for i in range(n):
            if rule_list[r][i] == 0:
                continue
            elif white_list[r] == i:
                continue
            elif checkb(r, i) is False:
                continue
            else:
                black_list[r] = i
                dfsb(r + 1)

def dfsw(r):
    if r == n:
        dfsb(0)
    else:
        for i in range(n):
            if rule_list[r][i] == 0:
                continue
            elif checkw(r, i) is False:
                continue
            else:
                white_list[r] = i
                dfsw(r + 1)

n = int(input())
num = 0
rule_list = []
black_list = [0]*8
white_list = [0]*8
for i in range(n):
    rule_list.append(list(map(int, input().split())))
dfsw(0)
print(num)

有点小难！！！

报时助手

给定当前的时间，请用英文的读法将它读出来。
时间用时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”。

a, b = map(int, input().split())
digit2en_dict = {
    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'
}
if a <= 20:
    x = digit2en_dict[a]
else:
    x = digit2en_dict[20] + ' ' + digit2en_dict[a - 20]
if b == 0:
    y = "o'clock"
elif 0 < b <= 20 or b in (30, 40, 50):
    y = digit2en_dict[b]
else:
    y = digit2en_dict[b - b % 10] + ' ' + digit2en_dict[b % 10]
print(x+' '+y)

回形取数

回形取数就是沿矩阵的边取数，若当前方向上无数可取或已经取过，则左转90度。一开始位于矩阵左上角，方向向下。

def get_num_h(y):
    if my_list == []:
        pass
    else:
        if y == -1:
            for i in range(len(my_list[-1])):
                print(my_list[-1][i], end=' ')
            del my_list[-1]
            get_num_l(-1)
        else:
            for i in range(len(my_list[-1]) - 1, -1, -1):
                print(my_list[0][i], end=' ')
            del my_list[0]
            get_num_l(0)

def get_num_l(x):
    if my_list == []:
        pass
    else:
        if x == 0:
            for i in range(len(my_list)):
                print(my_list[i][0], end=' ')
                my_list[i].pop(0)
            for i in range(len(my_list) - 1, -1, -1):
                if my_list[i] == []:
                    del my_list[i]
            get_num_h(-1)
        else:
            for i in range(len(my_list) - 1, -1, -1):
                print(my_list[i][-1], end=' ')
                my_list[i].pop(-1)
            for i in range(len(my_list) - 1, -1, -1):
                if my_list[i] == []:
                    del my_list[i]
            get_num_h(0)

a, b = map(int, input().split())
my_list = []
for i in range(a):
    my_list.append(list(map(int, input().split())))
get_num_l(0)

龟兔赛跑预测

话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先t米或以上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。
然而有些比赛相当漫长，全程观看会耗费大量时间，而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1（表示每秒兔子能跑v1米），乌龟的速度v2，以及兔子对应的t，s值，以及赛道的长度l——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找到了你——清华大学计算机系的高才生——请求帮助，请你写一个程序，对于输入的一场比赛的数据v1，v2，t，s，l，预测该场比赛的结果。

from math import ceil

v1, v2, s, t, l = map(int, input().split())
t_t = l / v2
t_first = t_t
t1 = 0
t1_list = []
n = 0
while t1 < t_t:
    t1 = (s + v1 * n * t) / (v1 - v2)
    t1_list.append(ceil(t1))
    n += 1
for i in range(len(t1_list)):
    l_r = v1 * (t1_list[i] - i * t)
    if l_r < l:
        continue
    elif l_r == l:
        t_r = t1_list[i]
        break
    else:
        distance = l - v1 * (t1_list[i - 1] - (i - 1) * t)
        t_r = t1_list[i - 1] + distance / v1 + t
        break
if t_r == t_t:
    print('D')
elif t_r < t_t:
    t_first = t_r
    print('R')
else:
    print('T')
print(int(t_first))

芯片测试

有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。
每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。
给出所有芯片的测试结果，问哪些芯片是好芯片。

n = int(input())
my_list = []
for i in range(n):
    my_list.append(list(map(int, input().split())))
for i in range(n):
    a = 0
    for j in range(n):
        if i == j:
            pass
        elif my_list[j][i] == 1:
            a += 1
        if a >= n // 2:
            print(i + 1, end=' ')
            break

FJ的字符串

FJ在沙盘上写了这样一些字符串：
A1 = “A”
A2 = “ABA”
A3 = “ABACABA”
A4 = “ABACABADABACABA”
… …
你能找出其中的规律并写所有的数列AN吗？

def func(n):
    if n == 65:
        return "A"
    else:
        return func(n - 1) + chr(n) + func(n - 1)

n = int(input())
new_n = 64 + n
print(func(new_n))

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的完整表达式，以方便奶牛们做题。

def func1(n, max):
    if n == max:
        return f'sin({n})'
    elif n % 2 == 1:
        return f'sin({n}-{func1(n+1,max)})'
    else:
        return f'sin({n}+{func1(n+1,max)})'

def func2(n, max):
    if max == n:
        return func1(1, max) + '+1'
    else:
        return f'({func1(1,n)}+{max-n+1})' + func2(n + 1, max)

max = int(input())
print(func2(1, max))

数的读法

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”。

num = int(input())
res = []
digit_table = ['ling', 'yi', 'er', 'san', 'si', 'wu', 'liu', 'qi', 'ba', 'jiu']
wei_table = ['shi', 'bai', 'qian', 'wan', 'yi']
i = 0
l = [0, 0]
while num != 0:
    a = num % 10
    num = num // 10
    if a != 0:
        if i >= 4 and l[int(i / 4) - 1] == 0:
            l[int(i / 4) - 1] = 1
            res.append(wei_table[int(i / 4) + 2])
        if i % 4 != 0:
            res.append(wei_table[i % 4 - 1])
        res.append(digit_table[a])
    elif res!=[] and res[-1] != digit_table[0]:
        res.append(digit_table[0])
    i += 1
if res[-1] != 'yi' or len(res) == 1 or res[-2] != 'shi':
    print(res[-1], end=' ')
for i in range(len(res) - 2, -1, - 1):
    print(res[i], end=' ')

完美的代价

回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
交换的定义是：交换两个相邻的字符
例如mamad
第一次交换 ad : mamda
第二次交换 md : madma
第三次交换 ma : madam (回文！完美！)

n = int(input())
s = list(input())

def to_solve(s, n):
    m = n - 1
    cnt = 0
    flag = 0
    i = 0
    while i < m:
        for j in range(m, i - 1, -1):
            if j == i:
                if n % 2 == 0 or flag == 1:
                    print("Impossible")
                    return None
                flag = 1
                cnt += n // 2 - i
            elif s[j] == s[i]:
                for k in range(j, m):
                    s[k], s[k+1] = s[k+1], s[k]
                    cnt += 1
                m -= 1
                break
        i += 1
    return cnt

res = to_solve(s, n)
if res is not None:
    print(res)

矩形面积交

平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。

sq1 = list(map(float, input().split()))
sq2 = list(map(float, input().split()))
x1 = max(min(sq1[0], sq1[2]), min(sq2[0], sq2[2]))
x2 = min(max(sq1[0], sq1[2]), max(sq2[0], sq2[2]))
y1 = max(min(sq1[1], sq1[3]), min(sq2[1], sq2[3]))
y2 = min(max(sq1[1], sq1[3]), max(sq2[1], sq2[3]))
if x2 > x1 and y2 > y1:
    print('%.2f' % ((x2 - x1) * (y2 - y1)))
else:
    print("0.00")

矩阵乘法

给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
例如：
A =
1 2
3 4
A的2次幂
7 10
15 22

n, m = map(int, input().split())
my_list = []
for i in range(n):
    my_list.append(list(map(int, input().split())))

def func(s):
    res = []
    for i in range(n):
        a = s[i]
        hang = []
        for j in range(n):
            b = 0
            for k in range(n):
                b += a[k] * my_list[k][j]
            hang.append(b)
        res.append(hang)
    return res

res = []
if m == 0:
    for i in range(n):
        temp = []
        for j in range(n):
            if i == j:
                temp.append(1)
            else:
                temp.append(0)
        res.append(temp)
elif m == 1:
    res = my_list
else:
    res = func(my_list)
    if m > 2:
        for i in range(m - 2):
            res = func(res)
for i in res:
    i = [str(j) for j in i]
    print(' '.join(i))

分解质因数

求出区间[a,b]中所有整数的质因数分解。

def func(n):
    s = str(n) + '='
    i = 2
    while i <= n:
        if n % i == 0:
            s = s + str(i) + '*'
            n = n // i
            i -= 1
        i += 1
    return s[:-1]

a, b = map(int, input().split())
for i in range(a, b + 1):
    print(func(i))

字符串对比

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

s1 = list(input())
s2 = list(input())
flag = 0
if len(s1) != len(s2):
    print(1)
else:
    for i in range(len(s1)):
        if s1[i] != s2[i]:
            if ord(s1[i]) >= 97:
                if chr(ord(s1[i]) - 32) == s2[i]:
                    flag = 1
                else:
                    flag = 2
                    break
            if ord(s1[i]) <= 90:
                if chr(ord(s1[i]) + 32) == s2[i]:
                    flag = 1
                else:
                    flag = 2
                    break
    if flag == 0:
        print(2)
    elif flag == 1:
        print(3)
    elif flag == 2:
        print(4)

时间转换

给定一个以秒为单位的时间t，要求用“<H>:<M>:<S>”的格式来表示这个时间。<H>表示时间，<M>表示分钟，而<S>表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。

n = int(input())
h = n // 3600
m = n % 3600 // 60
s = n % 3600 % 60
print(f'{h}:{m}:{s}')