Python蓝桥杯

Python蓝桥杯

入门篇

1.1 Fibonacci数列题

问题描述

Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。

输入描述
n
输入格式输入包含一个整数n。

输出描述

输出格式输出一行，包含一个整数，表示Fn除以10007的余数。

说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。

---

样例输入:
10
样例输出:
55
样例输入:
22
样例输出:
7704
数据规模与约定:
1 <= n <= 1,000,000。

n = int(input())

Fib = [1 for i in range(n+1)]

k = 3

while k<=n:
    
    Fib[k] = (Fib[k-1] + Fib[k-2]) % 10007

    k += 1

print(Fib[n])

另外一种方法：

while True:#异常处理
    try:
        n=int(input())#键盘读入
        F1,F2=1,1
        for i in range(3,n+1):
            F1,F2=F2%10007,(F1+F2)%10007#先取余再递推防止超时
        print(F2)
    except:
        break

入门训练 圆的面积

问题描述

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

输入格式

输入包含一个整数r，表示圆的半径。

输出格式

输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。

样例输入

4

样例输出

50.2654825

数据规模与约定

1 <= r <= 10000。

import math

r = int(input())

area = math.pi * r * r

print('%.7f' % area)

1.3 入门训练 序列求和

问题描述

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

输入格式

输入包括一个整数n。

输出格式

输出一行，包括一个整数，表示1+2+3+…+n的值。

样例输入

4

样例输出

10

数据规模与约定

1 <= n <= 1,000,000,000.

注意不要用循环来做，否则当数据规模变大时会超时

n = int(input())

s = n * (n + 1) / 2 # 等差数列公式，节省很多时间

print('%d' % s)

另外一种方法：

n=int(input())#input()是获取键盘读入函数
#注意这里不能直接迭代求和，一方面占用资源多，另一方面可能会超时。
#仔细分析问题发现是一道等差数列求和问题，直接用数学公式解决
sum=0.5*n*n+0.5*n
print(int(sum))

1.4 入门训练 A+B问题

问题描述

输入A、B，输出A+B。

输入格式

输入的第一行包括两个整数，由空格分隔，分别表示A、B。

输出格式

输出一行，包括一个整数，表示A+B的值。

样例输入

12 45

样例输出

57

数据规模与约定

-10000 <= A, B <= 10000

# 注意：本体数据规模较小，可以正常计算
# 若数据规模过大，则考虑用字符串存取大数，然后用大数加法来计算结果并输出
a, b = map(int, input().split())
print(a + b)

A,B=map(int,input().split());print(A+B);

2.基础篇

2.1 数列排序

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

# 代码1
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
for i in range(n):
    print(arr[i], end=' ')

# 代码2
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
for i in range(n - 1):
    print(arr[i], end=' ')
print(arr[n-1])

# 代码3
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
for i in range(n - 1):
    print(arr[i], end=' ')
print(arr[n-1], end='')

#代码4：
while True:
    try:
        n=int(input())
        if n>=1 and n<=200:
            sl=list(map(int,input().split()))
            sl.sort()#默认reverse=False从小到大输出,reverse=True则相反
            for i in range(len(sl)):
                print(sl[i],end=' ')#end=' '的作用是输出不换行
    except:
        break

2.2 十六进制转八进制

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

输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。
　　接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

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

【注意】
　　输入的十六进制数不会有前导0，比如012A。
　　输出的八进制数也不能有前导0。

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

【提示】
　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

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

#执行的代码
n=int(input())
for i in range(n):
    if n<=10:
        s=input()#所有输入默认字符串
        if len(s)<=100000:
            res_1=int(s,16)#这里的int(s,16)代表把16进制的s转化成10进制
            res_2=oct(res_1)#这里的oct代表把一个整数转化为八进制
            print(res_2[2:])#这里的[2:]是代表结果从第三位开始输出
#下方是关于进制转换的一些信息,刚上手Python建议读一下       
'''本题目可以将输入的16进制数转化为某进制，再将某进制转化为8进制，
于是我在这里拓展一下进制转化的一些方法：
在python中二进制用0b加相应数字来表示，8进制用0o加相应数字来表示，16进制用0x加相应数字来表示。即：
#其他进制转换二进制#
>>> bin(2)  #十进制转换二进制#
'0b10'
>>> bin(0o10) #八进制转换二进制#
'0b1000'
>>> bin(0xf) #十六进制转换二进制#
'0b1111'
 
#其他进制转换为八进制#
>>> oct(0b101)
'0o5'
>>> oct(0xf)
'0o17'
>>> oct(0o123)
'0o123'
 
#其他进制转换为十六进制#
>>> hex(0o10)
'0x8'
>>> hex(3)
'0x3'
>>> hex(0b111)
'0x7'
 '''
'''
#其他进制转换为十进制#
>>> int(0o10)
8
>>> int(0xf)
15
>>> int(0b10)
2
'''

十六进制转十进制

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

n = input()
print(int(n, 16))
# 你没有看错，python就是这么干脆，两行搞定

while True:#异常处理
    try:
        str1=input()
        num=int(str1,16)#int(str1,16)表示把一个16进制的数转化为10进制
        print(num)
    except:
        break

十进制转十六进制

问题描述
　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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

n = int(input())
print(format(n, 'X')) # x 输出字母为小写 X 输出字母为大写

n=int(input())
if n>=0 and n<=2147483647:
    s=hex(n).upper()#.upper()将字符串中的小写字符自动转化为大写
    print(s[2:])
'''这里拓展一下字符串大小写转化的方法：
lower()方法可将字符串中的所有大写字母变为小写
而capwords并不是字符串本身的方法，而是string模块中的函数,
使用capwords函数将一个字符串中的所有独立的英文单词的首字母都转换为大写。
'''
'''
import string
s='CASsds sads'
print(string.capwords(s))
'''

特殊回文数

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

import time

start = time.clock()

n = int(input())
i = 10000
while i < 1000000:
    s = 0
    temp = i
    length = 0
    while temp != 0:
        s = s * 10 + temp % 10
        temp = int(temp / 10)
        length += 1

    if s == i:
        a = i % 10
        b = int(i / 10) % 10
        c = int(i / 100) % 10
        if length == 5:
            if n == 2 * (a + b) + c:
                print(i)
        if length == 6:
            if n == 2 * (a + b + c):
                print(i)

    i += 1

end = time.clock()

print(end - start)

另外一种方法：

while True:
    try:
        
        n=int(input())
        for i in range(10000,1000000):
            a=str(i)
            b=0
            if a==a[::-1]:#这里的a[::-1]表示把字符串a倒序
               for j in a:
                   b+=int(j)
               if b==n:
                    print(a)
    except:
        break

import time

start = time.clock()

def is_pal(i_):
    i_s = str(i_)
    if i_s == i_s[::-1]:
        return True
    else:
        return False


def sum_i(i_):
    s = 0
    i_s = str(i)
    for j in range(len(i_s)):
        s += int(i_s[j])
    return s


n = int(input())
i = 10000
while i < 1000000:
    if is_pal(i):
        if sum_i(i) == n:
            print(i)
    i += 1

end = time.clock()

print(end - start)

回文数

正着数和倒着数都一样，输出所有的这样的四位数
如 1221

def is_pal(i_):
    i_s = str(i_)
    if i_s == i_s[::-1]:
        return True
    else:
        return False


i = 1000
while i < 10000:
    if is_pal(i):
        print(i)
    i += 1

1234567891011121314

for i in range(1000,10000):
    if str(i)==str(i)[::-1]:#str(i)[::-1]作用是将字符串倒置
        print(i)

2.7 水仙花数

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

def is_nar(i_):
    a = i_ % 10 # 十位
    b = int((i_ / 10)) % 10 # 百位 注意Python中除法一定会得到浮点数 要取整 而C中则不需要
    c = int(i_ / 100)
    if i_ == a ** 3 + b ** 3 + c ** 3:
        return True
    else:
        return False


i = 100
while i < 1000:
    if is_nar(i):
        print(i)
    i += 1

12345678910111213141516

2.8 杨辉三角

问题描述

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

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

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

1

1 1

1 2 1

1 3 3 1

给出n，输出它的前n行。
输入格式

输入包含一个数n。
输出格式
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。
样例输入
4
样例输出
1
1 1
1 2 1
1 3 3 1
数据规模与约定
1 <= n <= 34。

n = int(input())

k = 2

triangle_yang = [] # 杨辉三角

for i in range(n): # 定义空的杨辉三角
    triangle_yang.append([0 for j in range(i+1)])

# print(triangle_yang)
# exit()
for i in range(n): # 第一列和每一行的最后一个为1
    triangle_yang[i][0] = triangle_yang[i][-1] = 1

while k < n:
    m = 1
    while m < k: # 两肩数值之和
        triangle_yang[k][m] = triangle_yang[k-1][m-1] + triangle_yang[k-1][m]
        m += 1
    k += 1

for i in range(n): # 输出杨辉三角
    for j in range(i+1):
        print(triangle_yang[i][j], end=' ')
    print()

1234567891011121314151617181920212223242526

while True:
    try:
        n=int(input())
        nums=[[0]*n for i in range(n)]#初始化一个n*n的零阵
        for i in range(n):
            for j in range(n):
                if j==0:
                    nums[i][j]=1
                else:
                    nums[i][j]=nums[i-1][j-1]+nums[i-1][j]
                if nums[i][j]!=0:
                    print(nums[i][j],end=' ')
            print()
    except:
        break

2.9 查找整数

问题描述

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

第一行包含一个整数n。

第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。

第三行包含一个整数a，为待查找的数。
输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000。

n = int(input())

arr = input().split()

a = input()

i = 0

while i < n:
    if a == arr[i]:
        print(i+1)
        break
    i += 1

if i == n:
    print(-1)

1234567891011121314151617

while True:
    try:
         count=0#引入计数器
         n=int(input())
         nums=list(map(int,input().split()))
         a=int(input())
         for i in range(len(nums)):
             if a==nums[i]:
                 print(i+1)
                 coun+=1
                 break
         if count==0:
             print(-1)
    except:
        break

2.10 数列特征

问题描述

给出n个数，找出这n个数的最大值，最小值，和。
输入格式

第一行为整数n，表示数的个数。

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

n = int(input())

arr = input().split()

print(max(int(arr[i]) for i in range(n))) # 最大值
print(min(int(arr[i]) for i in range(n))) # 最小值
print(sum(int(arr[i]) for i in range(n))) # 求和

12345678

注意

python的列表中的sort()函数是无法对有负数元素的列表进行排序的，这点需要谨记，以防后续使用中出现错误

while True:
    try:
        
        a=int(input())
        b=input().split()
        nums=[int(i) for i in b]
        print(max(nums))#使用python内置函数很方便，=.=
        print(min(nums))
        print(sum(nums))
    except:
        break

2.11 字母图形

问题描述

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

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。
输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
输出格式
输出n行，每个m个字符，为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模与约定
1 <= n, m <= 26。

n, m = map(int, input().split())

graph = [[0 for j in range(m)] for i in range(n)] # 空二维数组

for i in range(n):
    for j in range(m):
        if j >= i: # 数组中字母规律
            graph[i][j] = chr(ord('A') + j - i)
        else:
            graph[i][j] = chr(ord('A') + i - j)

for i in range(n): # 输出二维数组
    for j in range(m):
        print(graph[i][j], end='')
    print()

'''
主页有：
      ①2011——2018蓝桥杯真题以及第十届蓝桥杯大赛决赛真题。
        蓝桥杯VIP题目提交渠道，超详细截图教程。
      ②蓝桥杯题库赛题Python代码解析
      ③python版的数据结构和算法，并且配备各阶段的例题，适合新手入门看。
    欢迎关注=.=，如果这个博客对你有帮助的话可以点个赞，有问题
    或者别的意见可以在评论下方提出，我看到会及时回复，谢谢~

    另外，刚刚上手Python的同学可以参考菜鸟教程学习：
    https://www.runoob.com/python3.html
>>
使用jupyter notebook，按h可以查看快捷键,按m可以将当前代码块code cell切换成可编辑markdown cell，
按y可以将markdown cell转换成code cell
shift + enter 可以运行当前代码块code cell并跳到下一个代码块的开头
'''
n,m=map(int,input().split())
str1=[]
for i in range(m):
    str1.append(chr(ord('A')+i))#这里的chr('a')就是把'a'转化为对应的ASCII码值；ord(97)就是把ASCII码值转化为对应的ASCII符号
for j in range(len(str1)):
    print(str1[j],end='')
print()
for k in range(1,n):
    str1.insert(0,chr(ord('A')+k))
    str1.pop()
    for p in range(len(str1)):
        print(str1[p],end='')
    print()

2.12 字串01

问题描述

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

00000

00001

00010

00011

00100

请按从小到大的顺序输出这32种01串。
输入格式
本试题没有输入。
输出格式
输出32行，按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011
<以下部分省略>

# Python就是两行解决问题。。。
for i in range(32):
    print("{0:0>5}".format(format(i, 'b')))

#00000=0,11111=31,利用十进制转二进制函数bin()可快速处理
for i in range(0,32):
    a=str(bin(i)[2:])
    a='0000'+a#位数不足补零
    print(a[-5:])

2.13 闰年判断

问题描述

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

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

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

其他的年份都不是闰年。
输入格式
输入包含一个整数y，表示当前的年份。
输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。

说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。
样例输入
2013
样例输出
no
样例输入
2016
样例输出
yes
数据规模与约定
1990 <= y <= 2050。

def is_leap_year(year):
    if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
        return True
    return False


year = int(input())

if is_leap_year(year):
    print('yes')
else:
    print('no')

12345678910111213

装逼解法

# 装逼解法
import datetime  # python的标准库，蓝桥考试可以放心使用

year = int(input())
# class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
# All arguments are optional and default to 0. Arguments may be integers or floats, and may be positive or negative.
time_delta = datetime.timedelta(days=1)  # 存储时间的变化量
# class datetime.date(year, month, day)
dt = datetime.date(year=year, month=3, day=1)  # 指定输入年份的3月1号

res = dt - time_delta  # 让dt存储的日期往前走一天
# print(dt)

if res.day == 29:  # 如果那年的2月分又29天为闰年
    print('yes')
else:
    print('no')

123456789101112131415161718

while True:
    try:
        y=int(input())
        if (y%4==0 and y%100!=0) or y%400==0: #逻辑运算符优先级:not>and>or
            print('yes')
        else:
            print('no')
    except:
        break

2.14 阶乘计算

问题描述
　　输入一个正整数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
特别注意n的规模
首先用递归只能解决1到几百以内的阶乘

def factorial(n):
	if n == 1:
		return n
	else:
		return n * factorial(n-1)
	
n = int(input())

result = factorial(n)

print(result)

123456789101112

这种递归方式1000的阶乘是算不了的！
去网上查询到了一个用数组处理大数阶乘的思想方法，跟题目要求的一样，用Python写了一下，提交后运行超时？！

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


while length > 0:
    length -= 1
    print(a[length], end='')

12345678910111213141516171819

真。。。。
然后用最简单的连乘计算，发现提交过了，100分，emmmmmmm…
代码如此简单

n = int(input())

a = s =1

while a <= n:
    s = s * a
    a += 1
print(s)

123456789

看来有时候想的太多也不见得是一种好事啊！

解法一：直接调用math库factorial函数

#主页有蓝桥杯真题免费下载
import math
print(math.factorial(int(input())))
#math.factorial(x)	 返回x的阶乘
#>>> math.factorial(5)
#120
123456

解法二：for循环

n=int(input())
ans=1
for i in range(1,n+1):
    ans*=i
print(ans)
12345

解法三：数组存储

n=int(input())
L=[1]#赋初值，不然无法启动
def loop(n):
    global L
    for i in range(len(L)):#正常乘法，每位各自乘
        L[i]*=n
    for i in range(len(L)-1):#进位，但是首位进位不在此列
        L[i+1]+=int(L[i]/10)
        L[i]=L[i]%10
    L1=list(str(L[-1]))#分解首项
    L.pop()#删除首项
    for i in range(len(L1)-1,-1,-1):#倒序归入原序列，注意倒叙！！！
        L.append(int(L1[i]))
for i in range(2,n+1):#n！定义
    loop(i)
for i in range(len(L)):#转化形式
    L[i]=str(L[i])
print(''.join(L[::-1]))#join（）输出

高精度加法

题目描述
输入两个整数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

解法一：

因为python中没有long或者longlong型的数据类型，int类型具有无限精度，所以可以直接求解。

a,b=int(input()),int(input())
print(a+b)
12

解法二：

'''
主页有：
      ①2011——2018蓝桥杯真题以及第十届蓝桥杯大赛决赛真题。
        蓝桥杯VIP题目提交渠道，超详细截图教程。
      ②蓝桥杯题库赛题Python代码解析
      ③python版的数据结构和算法，并且配备各阶段的例题，适合新手入门看。
    欢迎关注=.=，如果这个博客对你有帮助的话可以点个赞，有问题
    或者别的意见可以在评论下方提出，我看到会及时回复，谢谢~

    另外，刚刚上手Python的同学可以参考菜鸟教程学习：
    https://www.runoob.com/python3.html
'''
def trans(a):#将输入的字符串变成列表输出
    A=[]
    for i in range(len(a)):
        A.append(eval(a)%10)
        a=a[:-1]
    return A

a=input()
b=input()
A=trans(a)+[0]*(100-len(a))#初始化A，B的长度为100
B=trans(b)+[0]*(100-len(b))
C=[0]*101 #初始化C的长度为101
r=0 #这个是存放的中间变量
for i in range(100):
    o=A[i]+B[i]+r
    C[i]=o%10
    r=o//10
C.reverse()
for i in range(len(C)): #输出结果
    if C[i]!=0:
        for j in C[i:]:
            print(j,end='')
        break

2.15 长整数加法

问题描述
　　输入两个整数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 change_length(arr, l):
	"""此方法使两字符串长度相等"""
    arr = '0' * (l - len(arr)) + arr
    return arr


arr = input()
arr_2 = input()

# 两数长度若不等，短的数加前导0
if len(arr) > len(arr_2):
    arr_2 = change_length(arr_2, len(arr))
elif len(arr) < len(arr_2):
    arr = change_length(arr, len(arr_2))

result = [0 for i in range(len(arr) + 1)] # 结果最多是最长数的长度加1
k = 0 # 进位
for i in range(len(arr)):
    rs = k + int(arr[len(arr) - i - 1]) + int(arr_2[len(arr_2) - i - 1]) # 从个位开始加，同时加上进位
    result[len(arr) - i] = rs % 10
    k = 0
    if rs >= 10:
        k = int(rs / 10)

if k != 0: # k != 0 则最高位为k
    result[0] = k
    for i in range(len(result) - 1):
        print(result[i], end='')
    print(result[-1])
else: # 否则最高为为0不输出
    for i in range(len(result) - 2):
        print(result[i+1], end='')
    print(result[-1])

12345678910111213141516171819202122232425262728293031323334

2.16 哈夫曼树

问题描述
　　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

n = int(input())

arr = list(map(int, input().split()))

price = [0 for i in range(n - 1)]

for i in range(n - 1):
    arr.sort()
    # print(arr)
    value = arr.pop(0)
    value_2 = arr.pop(0)
    price[i] = value + value_2
    arr.append(price[i])

print(sum(price))

12345678910111213141516

2.28 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

思路

• 先在index放置黑皇后
• 递归，在index+1行放置黑皇后
• 递归到底，index == n ，这个时候说明黑皇后已经全部放置完毕（一种情况），这个时候再开始第二次dfs2（0），这个时候是放置白皇后，白皇后也放置完毕以后，一个解就找到了。

代码：

from collections import defaultdict

n = int(input())
board = []
for i in range(n):
    board.append(input().split())
col1 = defaultdict(bool)
dia11 = defaultdict(bool)
dia21 = defaultdict(bool)
col2 = defaultdict(bool)
dia12 = defaultdict(bool)
dia22 = defaultdict(bool)
count = 0


def dfs2(index):
    global count
    if index == n:
        count += 1
        return
    # 在第index行放置黑皇后
    for j in range(n):
        if not col2[j] and not dia12[index + j] and not dia22[index - j] \
                and board[index][j] == "1":
            col2[j] = True
            dia12[index + j] = True
            dia22[index - j] = True
            board[index][j] = "0"
            dfs2(index + 1)
            col2[j] = False
            dia12[index + j] = False
            dia22[index - j] = False
            board[index][j] = "1"

    return 0

def dfs1(index):
    if n <= 0:
        return 0
    if index == n:
        dfs2(0)
        return
    # 在第index行放置黑皇后
    for j in range(n):
        if not col1[j] and not dia11[index + j] and not dia21[index - j] \
                and board[index][j] == "1":
            col1[j] = True
            dia11[index + j] = True
            dia21[index - j] = True
            board[index][j] = "0"
            dfs1(index + 1)
            col1[j] = False
            dia11[index + j] = False
            dia21[index - j] = False
            board[index][j] = "1"

    return 0


dfs1(0)
print(count)

2.18 报时助手

问题描述
　　给定当前的时间，请用英文的读法将它读出来。
　　时间用时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 = map(int, input().split())

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'}
        # 其实21，22，23可以不加入字典中，但为了后边小时略去判断简化代码，直接加在字典中，方便后边直接输出小时

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

1234567891011121314151617181920212223

'''
主页有：
      ①2011——2018蓝桥杯真题以及第十届蓝桥杯大赛决赛真题。
        蓝桥杯VIP题目提交渠道，超详细截图教程。
      ②蓝桥杯题库赛题Python代码解析
      ③python版的数据结构和算法，并且配备各阶段的例题，适合新手入门看。
    欢迎关注=.=，如果这个博客对你有帮助的话可以点个赞，有问题
    或者别的意见可以在评论下方提出，我看到会及时回复，谢谢~

    另外，刚刚上手Python的同学可以参考菜鸟教程学习：
    https://www.runoob.com/python3.html
'''
#创建字典
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','30':'thirty','40':'forty','50':'fifty'}
nowtime=list(map(int,input().split()))#输入h,m添加到列表nowtime
for i in range(len(nowtime)):
    if nowtime[1]==0:#当输入的m==0时
        print(Time[str(nowtime[i])]+" o'clock")
        break
    elif nowtime[i]<=20 or nowtime[i]%10==0:
        print(Time[str(nowtime[i])],end=' ')
    else:
        print(Time[str(nowtime[i]-nowtime[i]%10)]+' '+Time[str(nowtime[i]%10)],end=' ')
    

2.19 回形取数

问题描述
　　回形取数就是沿矩阵的边取数，若当前方向上无数可取或已经取过，则左转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
注意

行末要求不要有多余的空格，不知意思是一个空格也不能有还是只可以有一个空格，由于控制最后一个数的输出很麻烦，这里博主在行末输出了一个空格，提交蓝桥系统100分通过
另外，读者们可以尝试去寻找最后一个数的输出位置规律，使得最后一个数单独输出，这样就无空格啦，这里博主有时间的话回去再尝试，然后会发出相应代码，敬请期待。

m, n = map(int, input().split())
row = col = count = 0
matrix = [[] for _ in range(m)]

for i in range(m):
    arr = input().split()
    for j in range(n):
        matrix[i].append(int(arr[j]))

while count < m * n:  # 总共m*n个数
    while row < m and matrix[row][col] != -1:  # 向下取数
        print(matrix[row][col], end=' ')
        matrix[row][col] = -1  # 将去过的位置置为-1
        row += 1
        count += 1
    row -= 1  # 上个循环结束后row的值为m,需要减1，否则越界
    col += 1  # 列值加1，因为第零列在上个循环已经输出，往右推一行
    while col < n and matrix[row][col] != -1:  # 向右取数
        print(matrix[row][col], end=' ')
        matrix[row][col] = -1  # 将去过的位置置为-1
        col += 1
        count += 1
    row -= 1  # 往上推一行
    col -= 1  # 上个循环使列值为n
    while row >= 0 and matrix[row][col] != -1:  # 向上取数
        print(matrix[row][col], end=' ')
        matrix[row][col] = -1  # 将去过的位置置为-1
        row -= 1
        count += 1
    row += 1  # 上个循环使行值为-1
    col -= 1  # 往左推一行
    while col >= 0 and matrix[row][col] != -1:  # 向左取数
        print(matrix[row][col], end=' ')
        matrix[row][col] = -1  # 将去过的位置置为-1
        col -= 1
        count += 1
    col += 1  # 上个循环使列值为-1
    row += 1  # 向下推一行

123456789101112131415161718192021222324252627282930313233343536373839

import math  #导入math包
r,c=map(int,input().split())#其中r,c分别代表要输入数据的行数和列数
list1=[]#列表用来存放键盘输入的数据
ans=[]#用来存放要输出的数据
for i in range(0,r):#二维列表输入实例
    list1.append(input().split())
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；
        ans.append(list1[x][j])
    for y in range(j+1,c-j):#将第j圈的下“一”字形x放入ans;
        ans.append(list1[r-1-j][y])
    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-j-2,j,-1):#将第j圈的上“一”字形放入ans；
            ans.append(list1[j][q])
for x in ans:
    print(x,'',end='')

2.20 龟兔赛跑预测

问题描述
　　话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先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

data = list(map(int, input().split()))

rabbit = tortoise = time = 0

flag = False

while True:
    if rabbit == data[-1] or tortoise == data[-1]:  # 如果兔子或乌龟到达终点，结束
        break
    if rabbit - tortoise >= data[2]:  # 兔子达到领先条件，休息
        for i in range(data[3]):  # 休息时间按秒增加，乌龟路程按秒增加
            tortoise += data[1]
            time += 1
            if tortoise == data[-1]:  # 兔子休息时，乌龟到达了终点，结束。
                # 注意：有可能兔子在休息中，乌龟就到达了终点
                # 所以休息时间未必循环完
                # 如：兔子要休息10s，乌龟可能在兔子休息的第9s就到达了终点
                # 这里的flag就起到提前结束的功能
                flag = True
                break
        if flag:  # 如果提前结束，则全部结束
            break
    time += 1  # 每走一秒，兔子和乌龟按相应速度增加相应距离
    rabbit += data[0]
    tortoise += data[1]


if rabbit > tortoise:  # 谁先到达终点，谁的距离大
    print('R')
    print(time)
elif rabbit < tortoise:
    print('T')
    print(time)
else:  # 相等则平局
    print('D')
    print(time)

12345678910111213141516171819202122232425262728293031323334353637

'''
主页有①蓝桥杯VIP题目提交渠道，超详细截图教程。
      ②蓝桥杯题库赛题Python代码解析
      ③python版的数据结构和算法，并且配备各阶段的例题，适合新手入门看。
    欢迎关注=.=，如果这个博客对你有帮助的话可以点个赞，有问题
    或者别的意见可以在评论下方提出，我看到会及时回复，谢谢~

    另外，刚刚上手Python的同学可以参考菜鸟教程学习：
    https://www.runoob.com/python3.html
'''
import math
while True:
    try:
        v1,v2,t,s,x=map(int,input().split())#v1,v2分别是乌龟和兔子的速度，t是兔子的领先阀值，s是兔子领先t米后偷懒的时间，x跑道长度
        g1=0;t1=0;time=0#分别是Rabbit和Turtle的跑步里程,裁判手里的计时器
        while g1=t and t1=x or t1>=x:
                        break
        if g1==t1:
            print('D')
        elif g1>t1:
            print('T')
        else:
            print('R')
        print(time)
    except:
        break

2.21 芯片测试

问题描述
　　有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
解题思路：

重点是好芯片比坏芯片多
如果忽略这个问题就很难解决，本人开始你就不幸忽略了。。。
既然好芯片比坏芯片多，那么我们只需记录每一列0的个数就行了，若个数超过n/2，则此芯片为坏芯片
一个chip列表来记录芯片的好坏

n = int(input())

arr = [[] for _ in range(n)]

chip = [True for _ in range(n)]

for i in range(n):
    arr_ = input().split()
    for j in range(n):
        arr[i].append(int(arr_[j]))

for i in range(n):
    count = 0
    for j in range(n):
        if arr[j][i] == 0:
            count += 1
    if count > n / 2:
        chip[i] = False

for i in range(n):
    if chip[i]:
        print(i + 1, end=' ')
12345678910111213141516171819202122

#博客主页有蓝桥杯python的一系列题解及算法，欢迎来阅~
n=int(input())
testarray=[]
ans=[]
for i in range(n):
    testarray.append(list(map(int,input().split())))#testarray列表存放芯片的测试结果
for j in range(n):
    num=0
    for i in range(n):
        if testarray[i][j]==1:
            num+=1
    if num>n/2:
        print(j+1,end=' ')
    

2.22 FJ字符串

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

n = int(input())

str_n = ''

for i in range(n):
    str_n = str_n + chr(ord('A') + i) + str_n

print(str_n)

123456789

import copy
N=int(input())
AN=[]
AN.append('A')
for i in range(1,N):
    B=copy.copy(AN)

    #关键步骤
    AN.append(chr(ord('A')+i))#ord('a')是把a转化为对应的数字，chr('a')是把数字转化为对应的ASCII值
    for k in range(0,len(B)):
        AN.append(B[k])
for j in range(0,2**N-1):
    print(AN[j],end='')
print()

2.23 sin之舞

问题描述
　　最近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
解题思路：

这里主要运用到递归的思想
先递归求An
然后求Sn
Sn通用过调用An求出

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='')
    else:  # 若后边没有式子，输出右括号结束
        # 注意，这里只输出最后一次的右括号，前边左括号对应的右括号在S()函数中补全
        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):  # 不全A()函数中的括号
            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)

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849

for循环方法：

'''
主页有①蓝桥杯VIP题目提交渠道，超详细截图教程。
      ②蓝桥杯题库赛题Python代码解析
      ③python版的数据结构和算法，并且配备各阶段的例题，适合新手入门看。
    欢迎关注=.=，如果这个博客对你有帮助的话可以点个赞，有问题
    或者别的意见可以在评论下方提出，我看到会及时回复，谢谢~

    另外，刚刚上手Python的同学可以参考菜鸟教程学习：
    https://www.runoob.com/python3.html
'''
#这里的sep其实无用，sep()函数主要是两个字符串输出时中间用什么连接
#比如：print('jia','jianghao',sep='AAA')
#猜猜会输出什么？好了，其实是jiaAAAjianghao
N=int(input())
def An(n):
    for i in range(1,n):
        print('sin('+str(i),sep='',end='')
        if i%2==0:
            print('+',sep='',end='')
        else:
            print('-',sep='',end='')
    print('sin('+str(n),sep='',end='')
    for j in range(0,n):
        print(')',end='')
    return ''
def Sn(n):
    for i in range(1,n):
        print('(',end='')
    for j in range(1,n+1):
        print(str(An(j))+'+'+str(n+1-j),end='')
        if j!=n:
            print(')',end='')
    return ''
a=Sn(N)
print(a)

递归方法：

def An(n,i=1):
    if i==n:
        return 'sin('+str(n)+')'
    else:
        if i%2==0:
            s='+'
        else:
            s='-'
        return 'sin('+str(i)+s+An(n,i+1)+')'
def Sn(m,i=1):
    if m==1:
        return An(m)+'+'+str(i)
    else:
        return '('+Sn(m-1,i+1)+')'+An(m)+'+'+str(i)
num=int(input())
print(Sn(num))

2.24 数的读法

问题描述
　　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
解题思路：

开始我按位置一位一位读，读到1万代码就开始很复杂了，所以考虑一定有相应读法的规律
利用循环来搞定，苦思冥想之后，还是利用度娘，一下就清晰了。。。
首先，读一个数，要处理开头为1的位置要不要读的问题
其次就是，处理多个连续0的读法问题
处理1的代码块下方已注释
就是不要把11，读作yi shi yi,111111不要读作yi shi yi wan yi qian yi bai yi shi yi
处理0的连续问题代码块中也给与了注释
就是10001不要读作yi wan ling ling ling ling yi,而是yi wan ling yi
参考以下代码

n = 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

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不读
            # 例子：
            # 1111111111 会读出 yi shi yi yi yi qian yi bai yi shi yi wan yi qian yi bai yi shi yi
            # 111111 会读出 yi shi yi wan yi qian yi bai yi shi yi
            # 11 会读出 yi shi yi
            # 加上此约束后，则不会读出开头的 yi
            if i != 0:  # 第一个1不输出1， 若不添加此条件，12会读出 yi shi er
                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=' ')  # 否则才读出这个零

d = {'1':'yi', '2':'er','3':'san','4':'si','5':'wu','6':'liu','7':'qi','8':'ba','9':'jiu','0':'ling'}
n = input().strip()#str.strip()就是把这个字符串头和尾的空格，以及位于头尾的\n \t之类给删掉
a = []
b = [] #b存的是逆序的读法，最后再逆序输出即为结果
def numexchange(i): 
    i = i[::-1]
    for j in range(len(i)):
        if j == 0:
            if i[j]!='0':
                b.append(d[i[j]])
        elif j == 1:
            if i[j]=='0'  and  i[0]!='0':
                b.append(d['0'])
            elif i[j] == '1' and ( len(i)==2 or i[2] == i[3] == '0'):
                b.append('shi')
            elif i[j]!='0':
                b.append('shi')
                b.append(d[i[j]])
        elif j == 2:
            if i[j]=='0'  and i[1]!='0':
                b.append(d['0'])
            elif i[j]!='0':
                b.append('bai')
                b.append(d[i[j]])
        elif j == 3:
            if  i[j]!='0':
                b.append('qian')
                b.append(d[i[j]])
            elif i[j]=='0'  and i[2]!='0':
                b.append(d['0'])

while n!='':  #倒着读，每四位为一组字符串
    if len(n)>=4:
        s = n[-4:] #取后四位
        n = n[:-4] #删除后四位
        a.append(s) 
    else:
        a.append(n)
        n = ''
for i in range(len(a)):
    if i == 0:
        numexchange(a[i])
    elif i == 1:
        b.append('wan')
        numexchange(a[i])
    elif i == 2:
        b.append('yi')
        numexchange(a[i])
for i in range(len(b)-1,-1,-1):
    if i == len(b)-1:
        print(b[i],end='')
    else:
        print(' %s'%(b[i]),end='')

2.30 字符串对比

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

beiJing

样例输出
3

注意：

代码块中的upper函数也可以改为lower函数
就是样字符串中的英文字母全部改为大写或者小写

str_1 = input()

str_2 = input()

if len(str_1) != len(str_2):
    print(1)
elif str_1 == str_2:
    print(2)
elif str_1.upper() == str_2.upper():
    print(3)
else:
    print(4)

12345678910111213

参考知识：

两个字符串处理函数
将字符串中字母全部改为大写的upper()函数
将字符串中字母全部改为小写的lower()函数

'''
主页有①蓝桥杯VIP题目提交渠道，超详细截图教程。
      ②蓝桥杯题库赛题Python代码解析
    欢迎关注=.=，如果这个博客对你有帮助的话可以点个赞=.=，有问题
    或者别的意见可以在评论下方提出，我看到会及时回复，谢谢~
'''
class Solution:
    def __strcmp__(self,str1,str2):
        if str1.upper()==str2.upper():
            if str1==str2:
                return(2)
            else:
                return(3)
        elif len(list(str1))!=len(list(str2)):
            return(1)
        else:
            return(4)

str1=input()
str2=input()
s=Solution()
print(s.__strcmp__(str1,str2))