目录

基础算法案例

全套资源点击此处下载

1.特殊回文数

2.特殊回文数

3.A+B案例

4.数组排序

5.序列求和

6.十六进制转八进制

7.十六进制转十进制

8.查找数字出现次数

9.水仙花

10.杨辉三角

11.数列特征提取

12.字母图形

13.闰年判断

14.阶乘计算

15.长整数加法

16.哈夫曼树

17.N皇后问题

18.回形取数

19.龟兔赛跑预测

20.芯片好坏测试

21.时间转换

22.字符串比较

23.分解质因数

24.2N皇后问题

25.完美的代价

26.数值的读出

27.sin之舞

28.最长滑雪道

29.九九乘法表

30.FJ字符串

每文一语

---

基础算法案例

蓝桥杯2011-2018国赛真题（Python，java，C）_蓝桥杯国赛真题java,蓝桥杯国赛真题python-讲义文档类资源-CSDN下载

由于Python近几年才加入蓝桥杯的队伍中，全网的资源比较的少，资源相对于其他编程语言较少，Python组的资源网上比较的稀缺，通过全网资源过滤收集了大量的真题与VIP试题讲解案例，汇总在压缩包内供大家学习！

1.特殊回文数

问题描述：左边往右边看，右边往左边看，都是同一个数叫做回文数，比如19291就是一个回文数，那么我们输入一个两位及以上的数字，返回回文数，案例如下：

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

n=int(input("输入大于10的数："))
i = 10
while i < n:
    if is_pal(i):
        print(i)
    i += 1

2.特殊回文数

问题描述：首先满足它是一个回文数，然后满足从走到右的数字相加等于我们输入的数字我们称之为特殊回文数，输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。输入限制：1<=n<=54，案例如下：

import time
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())
start = time.time()
i = 10000
while i < 1000000:
    if is_pal(i):
        if sum_i(i) == n:
            print(i)
    i += 1

end = time.time()
print("耗时{}秒".format(end - start))

 3.A+B案例

问题描述：输入12，32，输出44，案例如下：

a, b = map(int, input().split(","))
print(a + b)

4.数组排序

问题描述：输入5,1,3,2,4 输出1 2 3 4 5，案例如下：

n = int(input("输入数列的长度："))
arr = list(map(int, input("输入数列以逗号分割：").split(',')))
arr.sort()
for i in range(n):
    print(arr[i], end=' ')

5.序列求和

问题描述：输入一个整数，计算序列之和，例如输入100000000，计算从1+.....+100000000，案例如下：

import time
n = int(input("输入你要计算的整数之和："))
start=time.time()

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

print('%d' % s)
end=time.time()
print('总运行耗时: %s 秒'%(end-start))

n = int(input("输入你要计算的整数之和："))
starts=time.time()
s=0
for i in range(n):
    i+=1
    s+=i
print(s)
ends=time.time()
print('总运行耗时: %s 秒'%(ends-starts))

事实证明我们在设计算法的时候要避免出现循环，如果循环次数过多的话，时间上没有优势！

6.十六进制转八进制

问题描述：先输入你想要转换多少次，然后依次输入一个十六进制的数，输出一个八进制的数，案例如下：

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)

7.十六进制转十进制

问题描述：输入一个十六进制的数，输出一个十进制的数，案例如下：

n = input("输入十六进制的数字：")
print(int(n, 16))

 8.查找数字出现次数

问题描述：输入一个数组长度，然后按照规则输入数组，最后输入需要查找的数字，输出该数字的出现的次数，案例如下：

n = int(input("输入数组长度："))
arr = input("输入数组按照逗号分割:").split(',')
a = input("输入你要查找的数字：")
i = 0
for i in range(n):
    if a == arr[i]:
        i += 1

print("{}出现了{}次".format(a,i))

9.水仙花

问题描述：153=1^3+5^3+3^3满足这样的规律的数字我们称之为水仙花数，就是这个数的每一位的三次方之和最后等于该数字，案例如下：

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

10.杨辉三角

问题描述：三角形中的每个数字等于它两肩上的数字相加称之为杨辉三角，输入你想要展示的阶数，输出杨辉三角，案例如下：

n = int(input())

k = 2

triangle_yang = [] # 杨辉三角

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

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()

11.数列特征提取

问题描述：输入一系列数组，然后输出最大最小值，总和，案例如下：

arr = input("按照逗号分割输入一些数组：").split(',')
n=len(arr)

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))) # 求和

12.字母图形

问题描述：输入几行几列的数组类别，输出该数组，按照字母的特定的规律排列组合，案例如下：

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()

13.闰年判断

问题描述：输入年份，输出该年是否为闰年，案例如下：

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('闰年')
else:
    print('非闰年')

14.阶乘计算

问题描述：输入一个小于1000的数字，算出该范围的阶乘，案例如下：

n = int(input("输入阶乘范围："))

a = s =1

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

注意：输入过大容易导致内存溢出，无法计算！

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的所有位。

设计思路：首先就来判断输入的两个数，长度是否是一样的，如果不一样那么我们就来约束，前面的补0就好了

其次就按照，上面的特定算法运算就好了

def change_length(arr, l):
    arr = '0' * (l - len(arr)) + arr
    return arr

arr = input("输入数1：")
arr_2 = input("输入数2：")

# 两数长度若不等，短的数加前导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])

16.哈夫曼树

 问题描述：Huffman树在编码中有着广泛的应用，给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下：
1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
2. 重复步骤1，直到{pi}中只剩下一个数。
3.在上面的操作过程中，把所有的费用相加，就得到了构造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。

案例如下：

arr = list(map(int, input("输入一段数组按照逗号分割：").split(',')))
n=len(arr)
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))

17.N皇后问题

问题描述：要在n*n的国际象棋棋盘中放n个皇后，使任意两个皇后都不能互相吃掉。规则：皇后能吃掉同一行、同一列、同一对角线的任意棋子。求所有的解。n=8是就是著名的八皇后问题了。

# 递归回溯思想解决n皇后问题
def queen(A, cur=0):
    if cur == len(A):  # 所有的皇后都正确放置完毕，输出每个皇后所在的位置
        print(A)
        return 0
    for col in range(len(A)):
        A[cur], flag = col, True
        for row in range(cur): # 检测本次所放皇后的位置是否在同行同列或同一对角线上
            if A[row] == col or abs(col - A[row]) == cur - row: # 是的话，该位置不能放，向上回溯
                flag = False
                break
        if flag: # 否的话，继续放下一个皇后
            queen(A, cur+1)


n = int(input("输入皇后个数：")) # n为8，就是著名的八皇后问题啦

queen([None] * n)

18.回形取数

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

输入数组的类别，输入数组，输出一行数组，案例如下：

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  # 向下推一行

19.龟兔赛跑预测

问题描述：

话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先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”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。
第二行输出一个正整数，表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。案例如下：

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('兔子获胜！')
    print("耗时：",time)
elif rabbit < tortoise:
    print('乌龟获胜！')
    print("耗时：",time)
else:  # 相等则平局
    print('同时到达目的地！')
    print("耗时：",time)

20.芯片好坏测试

问题描述：有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（并不表示该芯片对本身的测试结果。芯片不能对本身进行测试）。
 

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=' ')

1和3块芯片比较好！

21.时间转换

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

n = int(input("输入秒数："))

h = int(n / 3600)

m = int((n - h * 3600) / 60)

s = int(n - h * 3600 - m * 60)

print(h, ':', m, ':', s, sep='')

22.字符串比较

问题描述：输入两个字符串，输出两个字符串的信息对比，案例如下：

str_1 = input("输入字符串1：")

str_2 = input("输入字符串2:")

if len(str_1) != len(str_2):
    print("二者字符串不相等！")
elif str_1 == str_2:
    print("二者字符串完全相等!")
elif str_1.upper() == str_2.upper():
    print('二者字符串不区分大小写相等！')
else:
    print("其他")

23.分解质因数

问题描述：求出区间[a,b]中所有整数的质因数分解，例如：2=2,4=2*2..........案例如下：

def is_prime(n):

    for i in range(2, n):
        if n % i == 0:
            return False

    return True


a, b = map(int, input("输入数值的范围例如1,10:").split(','))

for i in range(a, b + 1):
    if is_prime(i):  # 如果是素数，则等于它本身
        print(i, '=', i, sep='')
    else:
        print(i, '=', sep='', end='')
        temp = i
        j = 2
        while temp > 1:
            if temp % j == 0:  # 分解质因数，从j=2开始除,直到对i取余不为0时，才j += 1，保证每个j出现最多
                temp = int(temp / j)
                print(j, end='')
                if temp != 1:
                    print('*', end='')
            else:
                j += 1
        print()

24.2N皇后问题

问题描述：

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

def black_queen(k):

    global count

    for i in range(k - 1):
        judge = b_queen[i] - b_queen[k - 1]
        if judge == 0 or abs(k - 1 - i) == abs(judge):
            return

    if k == n:
        count += 1
        return

    for i in range(n):
        if i != w_queen[k] and chessboard[k][i] == 1:
            b_queen[k] = i
            black_queen(k + 1)


def white_queen(k):

    for i in range(k - 1):
        judge = w_queen[i] - w_queen[k - 1]
        if judge == 0 or abs(k - 1 - i) == abs(judge):
            return

    if k == n:
        black_queen(0)
        return

    for i in range(n):
        if chessboard[k][i] == 1:
            w_queen[k] = i
            white_queen(k + 1)


n = int(input())

count = 0

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

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

w_queen = [0 for _ in range(n)]
b_queen = [0 for _ in range(n)]

white_queen(0)

print(count)

 

25.完美的代价

问题描述：回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。

交换的定义是：交换两个相邻的字符
　　例如mamad
　　第一次交换 ad : mamda
　　第二次交换 md : madma
　　第三次交换 ma : madam (回文！完美！)

n = int(input("输入长度："))

pal = list(input("输入一段小写的字符串："))

count = flag = 0  # count计数，flag判断是否已经有一个单独的奇个数的字符了

m = n - 1

for i in range(m):  # 从头遍历到倒数第二个字符
    for k in range(m, i - 1, -1):  # 从后面往前一直到i寻找和pal[i]相同的pal[k]
        if k == i:  # 如果找不到相同的
            if n % 2 == 0 or flag == 1:  # impossible的两种情况
                print('Impossible')
                exit()
            flag = 1
            count += int(n / 2) - i
        elif pal[k] == pal[i]:
            for j in range(k, m):  # 找到相同的，进行交换
                pal[j], pal[j + 1] = pal[j + 1], pal[j]
                count += 1  # 计数器加1
            m -= 1  # 最后拍好序的不在进行比较
            break

print(count)

26.数值的读出

问题描述：我们有时候会遇到一些大量的数字，但是我们不能立刻读出它的中文，这个时候我们就可以自己设计一个算法了，案例如下：

n = input("请输入数值：")

pin_yin = {'0': '零', '1': '一', '2': '二', '3': '三', '4': '四', '5': '五',
           '6': '六', '7': '七', '8': '八', '9': '九'}
pin_yin_2 = {0: '', 1: '', 2: '十', 3: '百', 4: '千', 5: '万', 6: '十',
             7: '百', 8: '千', 9: '亿', 10: '十'}
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=' ')  # 否则才读出这个零

27.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的完整表达式，以方便奶牛们做题。案例如下：

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)

28.最长滑雪道

问题描述：

小袁非常喜欢滑雪， 因为滑雪很刺激。为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。 小袁想知道在某个区域中最长的一个滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。如下：

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-…-3-2-1更长。事实上，这是最长的一条。你的任务就是找到最长的一条滑坡，并且将滑坡的长度输出。 滑坡的长度定义为经过点的个数，例如滑坡24-17-16-1的长度是4。

1.偶然发现了一中二位数组输入的更简便方式：
arr = [list(map(int, input().split())) for _ in range(row)]
以后按二维数组的输入统统按此方法处理，前边已经写好的代码不再进行修改。
2.对于区域内每个点进行dfs，对每个点来说进行四个方向的dfs取最大值，然后取所有点为起点的最大长度的最大值，即为答案。
3.详细解释在代码块中相应位置给出。

def dfs(x, y):
    """
    深度递归搜索
    :param x: 横坐标
    :param y: 纵坐标
    :return: 最大距离
    """
    max_height = 1  # 初始距离为1
    if dp[x][y] > 0:  # 如果已经有了当前位置出发的最大距离，则直接返回
        return dp[x][y]
    for k in range(4):  # 判断该位置的上下左右四个位置
        tx = x + next_[k][0]
        ty = y + next_[k][1]
        if tx < 0 or tx >= row or ty < 0 or ty >= col:  # 越界情况
            continue
        if arr[tx][ty] >= arr[x][y]:  # 不符合高到低的情况
            continue
        max_height = max(max_height, dfs(tx, ty) + 1)  # 符合，递归搜索下一个位置且距离加1

    dp[x][y] = max_height  # 最终距离放在此矩阵中保存

    return dp[x][y]  # 返回该位置下的最大距离


row, col = map(int, input().split())

dp = [[0 for _ in range(col)] for _ in range(row)]  # 记录从每个位置(x, y)开始，它的最大长度

arr = [list(map(int, input().split())) for _ in range(row)]  # 这里发明了二位数组python输入方法的一种全新方式，偶然发现的

next_ = [[0, 1], [1, 0], [0, -1], [-1, 0]]  # 用来表示(x, y)的上下左右四个位置

ans = 0

for i in range(row):
    for j in range(col):
        ans = max(ans, dfs(i, j))

print(ans)

 

29.九九乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        print('{}x{}={}\t'.format(j, i, i * j), end='')
    print()

30.FJ字符串

问题描述：

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

输入格式
　　仅有一个数：N ≤ 26。
输出格式
　　请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
样例输入

n = int(input())

str_n = ''

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

print(str_n)

每文一语

不知其人，则不为其友！