目錄
基礎演算法案例
全套資源點擊此處下載
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字串
每文一語
基礎演算法案例
全套資源點擊此處下載
由于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.特殊回文數
問題描述：首先滿足它是一個回文數，然后滿足從走到右的數字相加等于我們輸入的數字我們稱之為特殊回文數，案例如下：
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)
每文一語
不知其人，則不為其友！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/267386.html
標籤：python