3位水仙花数计算pythonoj_Python解答蓝桥杯省赛真题之从入门到真题
若發(fā)現(xiàn)此文章消失，則是在等待審核中，稍等一會(huì)兒即可顯示，謝謝。
另外，我會(huì)盡量晚上上傳更新題目。
此文章太長(zhǎng)了，導(dǎo)致MD編輯器很卡，另寫了一篇接續(xù)
傳送門
Python解答藍(lán)橋杯省賽真題之從入門到真題 （續(xù)）
我的GitHub：https://github.com/libo-sober/LanQiaoCup
GitHub中代碼為第二刷，對(duì)本文中的好多代碼都進(jìn)行了優(yōu)化以及簡(jiǎn)化，歡迎大家Fork和Star。
不會(huì)使用Github伙伴們可以看我出的教程。
如何把自己開發(fā)的項(xiàng)目上傳到GitHub倉(cāng)庫(kù)或者碼云倉(cāng)庫(kù)？
如何把Github上好的項(xiàng)目pull到本地或者fork到本地（碼云倉(cāng)庫(kù)同理）？
搜了很多歷年藍(lán)橋杯真題解答，大多都是Java，C++，C這些語言編寫的代碼解析。Python解析的幾乎，甚至可以說沒有。而當(dāng)下Python又這么火熱，藍(lán)橋杯也出了Python組，所以打算寫一個(gè)Python解答藍(lán)橋杯真題的博客，供大家參考，也在這過程中和大家一起交流。
**自己編的的代碼，有時(shí)間就會(huì)更新。有誤之處，歡迎改正。
**
1.入門篇
1.1 Fibonacci數(shù)列題
問題描述
Fibonacci數(shù)列的遞推公式為：Fn=Fn-1+Fn-2，其中F1=F2=1。
當(dāng)n比較大時(shí)，Fn也非常大，現(xiàn)在我們想知道，Fn除以10007的余數(shù)是多少。
輸入描述
n
輸入格式輸入包含一個(gè)整數(shù)n。
輸出描述
輸出格式輸出一行，包含一個(gè)整數(shù)，表示Fn除以10007的余數(shù)。
說明：在本題中，答案是要求Fn除以10007的余數(shù)，因此我們只要能算出這個(gè)余數(shù)即可，而不需要先計(jì)算出Fn的準(zhǔn)確值，再將計(jì)算的結(jié)果除以10007取余數(shù)，直接計(jì)算余數(shù)往往比先算出原數(shù)再取余簡(jiǎn)單。
數(shù)據(jù)規(guī)模與約定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])
1.2 入門訓(xùn)練 圓的面積
問題描述
給定圓的半徑r，求圓的面積。
輸入格式
輸入包含一個(gè)整數(shù)r，表示圓的半徑。
輸出格式
輸出一行，包含一個(gè)實(shí)數(shù)，四舍五入保留小數(shù)點(diǎn)后7位，表示圓的面積。
樣例輸入
4
樣例輸出
50.2654825
數(shù)據(jù)規(guī)模與約定
1 <= r <= 10000。
import math
r = int(input())
area = math.pi * r * r
print('%.7f' % area)
1.3 入門訓(xùn)練 序列求和
問題描述
求1+2+3+…+n的值。
輸入格式
輸入包括一個(gè)整數(shù)n。
輸出格式
輸出一行，包括一個(gè)整數(shù)，表示1+2+3+…+n的值。
樣例輸入
4
樣例輸出
10
數(shù)據(jù)規(guī)模與約定
1 <= n <= 1,000,000,000.
注意不要用循環(huán)來做，否則當(dāng)數(shù)據(jù)規(guī)模變大時(shí)會(huì)超時(shí)
n = int(input())
s = n * (n + 1) / 2 # 等差數(shù)列公式，節(jié)省很多時(shí)間
print('%d' % s)
1.4 入門訓(xùn)練 A+B問題
問題描述
輸入A、B，輸出A+B。
輸入格式
輸入的第一行包括兩個(gè)整數(shù)，由空格分隔，分別表示A、B。
輸出格式
輸出一行，包括一個(gè)整數(shù)，表示A+B的值。
樣例輸入
12 45
樣例輸出
57
數(shù)據(jù)規(guī)模與約定
-10000 <= A, B <= 10000
# 注意：本體數(shù)據(jù)規(guī)模較小，可以正常計(jì)算
# 若數(shù)據(jù)規(guī)模過大，則考慮用字符串存取大數(shù)，然后用大數(shù)加法來計(jì)算結(jié)果并輸出
a, b = map(int, input().split())
print(a + b)
2.基礎(chǔ)篇
2.1 數(shù)列排序
問題描述
給定一個(gè)長(zhǎng)度為n的數(shù)列，將這個(gè)數(shù)列按從小到大的順序排列。1<=n<=200
輸入格式
第一行為一個(gè)整數(shù)n。
第二行包含n個(gè)整數(shù)，為待排序的數(shù)，每個(gè)整數(shù)的絕對(duì)值小于10000。
輸出格式
輸出一行，按從小到大的順序輸出排序后的數(shù)列。
樣例輸入
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='')
藍(lán)橋的練習(xí)系統(tǒng)沒有OJ那么嚴(yán)格，故意試了一下，代碼1最后一個(gè)數(shù)字輸出時(shí)后邊會(huì)有一個(gè)空格，OJ上這樣是不予通過的，但是藍(lán)橋練習(xí)系統(tǒng)這樣提交了之后仍然通過。代碼2最后無空格進(jìn)行換行，藍(lán)橋練習(xí)系統(tǒng)也通過了。代碼3最后不換行，也不輸出空格，輸出最后一個(gè)數(shù)后就停止，藍(lán)橋練習(xí)系統(tǒng)也通過了。看來對(duì)這個(gè)藍(lán)橋要求不嚴(yán)格。考試時(shí)自己斟酌。
2.2 十六進(jìn)制轉(zhuǎn)八進(jìn)制
問題描述
給定n個(gè)十六進(jìn)制正整數(shù)，輸出它們對(duì)應(yīng)的八進(jìn)制數(shù)。
輸入格式
輸入的第一行為一個(gè)正整數(shù)n （1<=n<=10）。
接下來n行，每行一個(gè)由09、大寫字母AF組成的字符串，表示要轉(zhuǎn)換的十六進(jìn)制正整數(shù)，每個(gè)十六進(jìn)制數(shù)長(zhǎng)度不超過100000。
輸出格式
輸出n行，每行為輸入對(duì)應(yīng)的八進(jìn)制正整數(shù)。
【注意】
輸入的十六進(jìn)制數(shù)不會(huì)有前導(dǎo)0，比如012A。
輸出的八進(jìn)制數(shù)也不能有前導(dǎo)0。
樣例輸入
2
39
123ABC
樣例輸出
71
4435274
【提示】
先將十六進(jìn)制數(shù)轉(zhuǎn)換成某進(jìn)制數(shù)，再由某進(jìn)制數(shù)轉(zhuǎn)換成八進(jìn)制。
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)
參考知識(shí)
2.3 十六進(jìn)制轉(zhuǎn)十進(jìn)制
問題描述
從鍵盤輸入一個(gè)不超過8位的正的十六進(jìn)制數(shù)字符串，將它轉(zhuǎn)換為正的十進(jìn)制數(shù)后輸出。
注：十六進(jìn)制數(shù)中的10~15分別用大寫的英文字母A、B、C、D、E、F表示。
樣例輸入
FFFF
樣例輸出
65535
n = input()
print(int(n, 16))
# 你沒有看錯(cuò)，python就是這么干脆，兩行搞定
2.4 十進(jìn)制轉(zhuǎn)十六進(jìn)制
問題描述
十六進(jìn)制數(shù)是在程序設(shè)計(jì)時(shí)經(jīng)常要使用到的一種整數(shù)的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16個(gè)符號(hào)，分別表示十進(jìn)制數(shù)的0至15。十六進(jìn)制的計(jì)數(shù)方法是滿16進(jìn)1，所以十進(jìn)制數(shù)16在十六進(jìn)制中是10，而十進(jìn)制的17在十六進(jìn)制中是11，以此類推，十進(jìn)制的30在十六進(jìn)制中是1E。
給出一個(gè)非負(fù)整數(shù)，將它表示成十六進(jìn)制的形式。
輸入格式
輸入包含一個(gè)非負(fù)整數(shù)a，表示要轉(zhuǎn)換的數(shù)。0<=a<=2147483647
輸出格式
輸出這個(gè)整數(shù)的16進(jìn)制表示
樣例輸入
30
樣例輸出
1E
n = int(input())
print(format(n, 'X')) # x 輸出字母為小寫 X 輸出字母為大寫
2.5 特殊回文數(shù)
問題描述
123321是一個(gè)非常特殊的數(shù)，它從左邊讀和從右邊讀是一樣的。
輸入一個(gè)正整數(shù)n， 編程求所有這樣的五位和六位十進(jìn)制數(shù)，滿足各位數(shù)字之和等于n 。
輸入格式
輸入一行，包含一個(gè)正整數(shù)n。
輸出格式
按從小到大的順序輸出滿足條件的整數(shù)，每個(gè)整數(shù)占一行。
樣例輸入
52
樣例輸出
899998
989989
998899
數(shù)據(jù)規(guī)模和約定
1<=n<=54。
Python這個(gè)時(shí)候我發(fā)現(xiàn)出了點(diǎn)問題：
同樣的代碼C寫的程序會(huì)比Python寫的程序運(yùn)行時(shí)間短。
上述題目時(shí)限為1s，C程序如下，藍(lán)橋練習(xí)系統(tǒng)提交通過。
#include
int a(int n)//求出5位數(shù)和6位數(shù)中的回文數(shù)函數(shù)
{
int i,j,sum,temp,len;
int a,b,c;
for(i=10000;i<1000000;++i)
{
sum=0;
temp=i;
len=0;
while(temp!=0)
{
sum=sum*10+temp%10;
temp=temp/10;
len++;//累計(jì)位數(shù)以此判斷是5位數(shù)還是6位數(shù)
}
if(sum==i)//先把回文數(shù)求出來，下面再來比較各位數(shù)字之和是否等于n
{
a=i%10;//個(gè)位
b=i/10%10;//十位
c=i/100%10;//百位
if(5==len)
{
if(n==(2*a+2*b+c))
{
printf("%d\n",i);
}
}
if(6==len)
{
if(n==(2*a+2*b+2*c))
{
printf("%d\n",i);
}
}
}
}
}
//主函數(shù)
int main()
{
int n;
scanf("%d",&n);
a(n);
return 0;
}
然而把語言換成Python，算法思想一樣，提交卻超時(shí)，一看，時(shí)間已經(jīng)為5s多了
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)
運(yùn)行結(jié)果
時(shí)間為5.1s多
自己又寫了一個(gè)代碼
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)
運(yùn)行結(jié)果
時(shí)間為2s多，還是不通過。
目前不清楚這個(gè)問題要怎么解決，待解答。
2.6 回文數(shù)
正著數(shù)和倒著數(shù)都一樣，輸出所有的這樣的四位數(shù)
如 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
2.7 水仙花數(shù)
問題描述
153是一個(gè)非常特殊的數(shù)，它等于它的每位數(shù)字的立方和，即153=111+555+333。編程求所有滿足這種條件的三位十進(jìn)制數(shù)。
輸出格式
按從小到大的順序輸出滿足條件的三位十進(jìn)制數(shù)，每個(gè)數(shù)占一行。
def is_nar(i_):
a = i_ % 10 # 十位
b = int((i_ / 10)) % 10 # 百位 注意Python中除法一定會(huì)得到浮點(diǎn)數(shù) 要取整 而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
2.8 楊輝三角
問題描述
楊輝三角形又稱Pascal三角形，它的第i+1行是(a+b)i的展開式的系數(shù)。
它的一個(gè)重要性質(zhì)是：三角形中的每個(gè)數(shù)字等于它兩肩上的數(shù)字相加。
下面給出了楊輝三角形的前4行：
1
1 1
1 2 1
1 3 3 1
給出n，輸出它的前n行。
輸入格式
輸入包含一個(gè)數(shù)n。
輸出格式
輸出楊輝三角形的前n行。每一行從這一行的第一個(gè)數(shù)開始依次輸出，中間使用一個(gè)空格分隔。請(qǐng)不要在前面輸出多余的空格。
樣例輸入
4
樣例輸出
1
1 1
1 2 1
1 3 3 1
數(shù)據(jù)規(guī)模與約定
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): # 第一列和每一行的最后一個(gè)為1
triangle_yang[i][0] = triangle_yang[i][-1] = 1
while k < n:
m = 1
while m < k: # 兩肩數(shù)值之和
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()
2.9 查找整數(shù)
問題描述
給出一個(gè)包含n個(gè)整數(shù)的數(shù)列，問整數(shù)a在數(shù)列中的第一次出現(xiàn)是第幾個(gè)。
輸入格式
第一行包含一個(gè)整數(shù)n。
第二行包含n個(gè)非負(fù)整數(shù)，為給定的數(shù)列，數(shù)列中的每個(gè)數(shù)都不大于10000。
第三行包含一個(gè)整數(shù)a，為待查找的數(shù)。
輸出格式
如果a在數(shù)列中出現(xiàn)了，輸出它第一次出現(xiàn)的位置(位置從1開始編號(hào))，否則輸出-1。
樣例輸入
6
1 9 4 8 3 9
9
樣例輸出
2
數(shù)據(jù)規(guī)模與約定
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)
2.10 數(shù)列特征
問題描述
給出n個(gè)數(shù)，找出這n個(gè)數(shù)的最大值，最小值，和。
輸入格式
第一行為整數(shù)n，表示數(shù)的個(gè)數(shù)。
第二行有n個(gè)數(shù)，為給定的n個(gè)數(shù)，每個(gè)數(shù)的絕對(duì)值都小于10000。
輸出格式
輸出三行，每行一個(gè)整數(shù)。第一行表示這些數(shù)中的最大值，第二行表示這些數(shù)中的最小值，第三行表示這些數(shù)的和。
樣例輸入
5
1 3 -2 4 5
樣例輸出
5
-2
11
數(shù)據(jù)規(guī)模與約定
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))) # 求和
注意
python的列表中的sort()函數(shù)是無法對(duì)有負(fù)數(shù)元素的列表進(jìn)行排序的，這點(diǎn)需要謹(jǐn)記，以防后續(xù)使用中出現(xiàn)錯(cuò)誤
2.11 字母圖形
問題描述
利用字母可以組成一些美麗的圖形，下面給出了一個(gè)例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
這是一個(gè)5行7列的圖形，請(qǐng)找出這個(gè)圖形的規(guī)律，并輸出一個(gè)n行m列的圖形。
輸入格式
輸入一行，包含兩個(gè)整數(shù)n和m，分別表示你要輸出的圖形的行數(shù)的列數(shù)。
輸出格式
輸出n行，每個(gè)m個(gè)字符，為你的圖形。
樣例輸入
5 7
樣例輸出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
數(shù)據(jù)規(guī)模與約定
1 <= n, m <= 26。
n, m = map(int, input().split())
graph = [[0 for j in range(m)] for i in range(n)] # 空二維數(shù)組
for i in range(n):
for j in range(m):
if j >= i: # 數(shù)組中字母規(guī)律
graph[i][j] = chr(ord('A') + j - i)
else:
graph[i][j] = chr(ord('A') + i - j)
for i in range(n): # 輸出二維數(shù)組
for j in range(m):
print(graph[i][j], end='')
print()
字符轉(zhuǎn)ASCII碼函數(shù)：ord(‘A’)–>64
ASCII碼轉(zhuǎn)字符函數(shù)：chr(64)–>A
以上進(jìn)制轉(zhuǎn)換題目提到過ASCII碼與字符轉(zhuǎn)換，可以點(diǎn)擊鏈接觀看。
2.12 字串01
問題描述
對(duì)于長(zhǎng)度為5位的一個(gè)01串，每一位都可能是0或1，一共有32種可能。它們的前幾個(gè)是：
00000
00001
00010
00011
00100
請(qǐng)按從小到大的順序輸出這32種01串。
輸入格式
本試題沒有輸入。
輸出格式
輸出32行，按從小到大的順序每行一個(gè)長(zhǎng)度為5的01串。
樣例輸出
00000
00001
00010
00011
<以下部分省略>
# Python就是兩行解決問題。。。
for i in range(32):
print("{0:0>5}".format(format(i, 'b')))
參考資料
2.13 閏年判斷
問題描述
給定一個(gè)年份，判斷這一年是不是閏年。
當(dāng)以下情況之一滿足時(shí)，這一年是閏年：
年份是4的倍數(shù)而不是100的倍數(shù)；
年份是400的倍數(shù)。
其他的年份都不是閏年。
輸入格式
輸入包含一個(gè)整數(shù)y，表示當(dāng)前的年份。
輸出格式
輸出一行，如果給定的年份是閏年，則輸出yes，否則輸出no。
說明：當(dāng)試題指定你輸出一個(gè)字符串作為結(jié)果（比如本題的yes或者no，你需要嚴(yán)格按照試題中給定的大小寫，寫錯(cuò)大小寫將不得分。
樣例輸入
2013
樣例輸出
no
樣例輸入
2016
樣例輸出
yes
數(shù)據(jù)規(guī)模與約定
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')
裝逼解法
# 裝逼解法
import datetime # python的標(biāo)準(zhǔn)庫(kù)，藍(lán)橋考試可以放心使用
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) # 存儲(chǔ)時(shí)間的變化量
# class datetime.date(year, month, day)
dt = datetime.date(year=year, month=3, day=1) # 指定輸入年份的3月1號(hào)
res = dt - time_delta # 讓dt存儲(chǔ)的日期往前走一天
# print(dt)
if res.day == 29: # 如果那年的2月分又29天為閏年
print('yes')
else:
print('no')
2.14 階乘計(jì)算
問題描述
輸入一個(gè)正整數(shù)n，輸出n!的值。
其中n!=123*…*n。
算法描述
n!可能很大，而計(jì)算機(jī)能表示的整數(shù)范圍有限，需要使用高精度計(jì)算的方法。使用一個(gè)數(shù)組A來表示一個(gè)大整數(shù)a，A[0]表示a的個(gè)位，A[1]表示a的十位，依次類推。
將a乘以一個(gè)整數(shù)k變?yōu)閷?shù)組A的每一個(gè)元素都乘以k，請(qǐng)注意處理相應(yīng)的進(jìn)位。
首先將a設(shè)為1，然后乘2，乘3，當(dāng)乘到n時(shí)，即得到了n!的值。
輸入格式
輸入包含一個(gè)正整數(shù)n，n<=1000。
輸出格式
輸出n!的準(zhǔn)確值。
樣例輸入
10
樣例輸出
3628800
特別注意n的規(guī)模
首先用遞歸只能解決1到幾百以內(nèi)的階乘
def factorial(n):
if n == 1:
return n
else:
return n * factorial(n-1)
n = int(input())
result = factorial(n)
print(result)
這種遞歸方式1000的階乘是算不了的！
去網(wǎng)上查詢到了一個(gè)用數(shù)組處理大數(shù)階乘的思想方法，跟題目要求的一樣，用Python寫了一下，提交后運(yùn)行超時(shí)？！
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='')
真。。。。
然后用最簡(jiǎn)單的連乘計(jì)算，發(fā)現(xiàn)提交過了，100分，emmmmmmm…
代碼如此簡(jiǎn)單
n = int(input())
a = s =1
while a <= n:
s = s * a
a += 1
print(s)
看來有時(shí)候想的太多也不見得是一種好事啊！
2.15 長(zhǎng)整數(shù)加法
問題描述
輸入兩個(gè)整數(shù)a和b，輸出這兩個(gè)整數(shù)的和。a和b都不超過100位。
算法描述
由于a和b都比較大，所以不能直接使用語言中的標(biāo)準(zhǔn)數(shù)據(jù)類型來存儲(chǔ)。對(duì)于這種問題，一般使用數(shù)組來處理。
定義一個(gè)數(shù)組A，A[0]用于存儲(chǔ)a的個(gè)位，A[1]用于存儲(chǔ)a的十位，依此類推。同樣可以用一個(gè)數(shù)組B來存儲(chǔ)b。
計(jì)算c = a + b的時(shí)候，首先將A[0]與B[0]相加，如果有進(jìn)位產(chǎn)生，則把進(jìn)位（即和的十位數(shù)）存入r，把和的個(gè)位數(shù)存入C[0]，即C[0]等于(A[0]+B[0])%10。然后計(jì)算A[1]與B[1]相加，這時(shí)還應(yīng)將低位進(jìn)上來的值r也加起來，即C[1]應(yīng)該是A[1]、B[1]和r三個(gè)數(shù)的和．如果又有進(jìn)位產(chǎn)生，則仍可將新的進(jìn)位存入到r中，和的個(gè)位存到C[1]中。依此類推，即可求出C的所有位。
最后將C輸出即可。
輸入格式
輸入包括兩行，第一行為一個(gè)非負(fù)整數(shù)a，第二行為一個(gè)非負(fù)整數(shù)b。兩個(gè)整數(shù)都不超過100位，兩數(shù)的最高位都不是0。
輸出格式
輸出一行，表示a + b的值。
樣例輸入
20100122201001221234567890
2010012220100122
樣例輸出
20100122203011233454668012
def change_length(arr, l):
"""此方法使兩字符串長(zhǎng)度相等"""
arr = '0' * (l - len(arr)) + arr
return arr
arr = input()
arr_2 = input()
# 兩數(shù)長(zhǎng)度若不等，短的數(shù)加前導(dǎo)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)] # 結(jié)果最多是最長(zhǎng)數(shù)的長(zhǎng)度加1
k = 0 # 進(jìn)位
for i in range(len(arr)):
rs = k + int(arr[len(arr) - i - 1]) + int(arr_2[len(arr_2) - i - 1]) # 從個(gè)位開始加，同時(shí)加上進(jìn)位
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])
2.16 哈夫曼樹
問題描述
Huffman樹在編碼中有著廣泛的應(yīng)用。在這里，我們只關(guān)心Huffman樹的構(gòu)造過程。
給出一列數(shù){pi}={p0, p1, …, pn-1}，用這列數(shù)構(gòu)造Huffman樹的過程如下：
1. 找到{pi}中最小的兩個(gè)數(shù)，設(shè)為pa和pb，將pa和pb從{pi}中刪除掉，然后將它們的和加入到{pi}中。這個(gè)過程的費(fèi)用記為pa + pb。
2. 重復(fù)步驟1，直到{pi}中只剩下一個(gè)數(shù)。
在上面的操作過程中，把所有的費(fèi)用相加，就得到了構(gòu)造Huffman樹的總費(fèi)用。
本題任務(wù)：對(duì)于給定的一個(gè)數(shù)列，現(xiàn)在請(qǐng)你求出用該數(shù)列構(gòu)造Huffman樹的總費(fèi)用。
例如，對(duì)于數(shù)列{pi}={5, 3, 8, 2, 9}，Huffman樹的構(gòu)造過程如下：
1. 找到{5, 3, 8, 2, 9}中最小的兩個(gè)數(shù)，分別是2和3，從{pi}中刪除它們并將和5加入，得到{5, 8, 9, 5}，費(fèi)用為5。
2. 找到{5, 8, 9, 5}中最小的兩個(gè)數(shù)，分別是5和5，從{pi}中刪除它們并將和10加入，得到{8, 9, 10}，費(fèi)用為10。
3. 找到{8, 9, 10}中最小的兩個(gè)數(shù)，分別是8和9，從{pi}中刪除它們并將和17加入，得到{10, 17}，費(fèi)用為17。
4. 找到{10, 17}中最小的兩個(gè)數(shù)，分別是10和17，從{pi}中刪除它們并將和27加入，得到{27}，費(fèi)用為27。
5. 現(xiàn)在，數(shù)列中只剩下一個(gè)數(shù)27，構(gòu)造過程結(jié)束，總費(fèi)用為5+10+17+27=59。
輸入格式
輸入的第一行包含一個(gè)正整數(shù)n（n<=100）。
接下來是n個(gè)正整數(shù)，表示p0, p1, …, pn-1，每個(gè)數(shù)不超過1000。
輸出格式
輸出用這些數(shù)構(gòu)造Huffman樹的總費(fèi)用。
樣例輸入
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))
2.17 N皇后問題
要在n*n的國(guó)際象棋棋盤中放n個(gè)皇后，使任意兩個(gè)皇后都不能互相吃掉。規(guī)則：皇后能吃掉同一行、同一列、同一對(duì)角線的任意棋子。求所有的解。n=8是就是著名的八皇后問題了。
def queen(A, cur=0):
# 遞歸回溯思想解決n皇后問題
if cur == len(A): # 所有的皇后都正確放置完畢，輸出每個(gè)皇后所在的位置
print(A)
return 0
for col in range(len(A)):
A[cur], flag = col, True
for row in range(cur): # 檢測(cè)本次所放皇后的位置是否在同行同列或同一對(duì)角線上
if A[row] == col or abs(col - A[row]) == cur - row: # 是的話，該位置不能放，向上回溯
flag = False
break
if flag: # 否的話，繼續(xù)放下一個(gè)皇后
queen(A, cur+1)
n = int(input()) # n為8，就是著名的八皇后問題啦
queen([None] * n)
2.18 報(bào)時(shí)助手
問題描述
給定當(dāng)前的時(shí)間，請(qǐng)用英文的讀法將它讀出來。
時(shí)間用時(shí)h和分m表示，在英文的讀法中，讀一個(gè)時(shí)間的方法是：
如果m為0，則將時(shí)讀出來，然后加上“o’clock”，如3:00讀作“three o’clock”。
如果m不為0，則將時(shí)讀出來，然后將分讀出來，如5:30讀作“five thirty”。
時(shí)和分的讀法使用的是英文數(shù)字的讀法，其中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。
對(duì)于大于20小于60的數(shù)字，首先讀整十的數(shù)，然后再加上個(gè)位數(shù)。如31首先讀30再加1的讀法，讀作“thirty one”。
按上面的規(guī)則21:54讀作“twenty one fifty four”，9:07讀作“nine seven”，0:15讀作“zero fifteen”。
輸入格式
輸入包含兩個(gè)非負(fù)整數(shù)h和m，表示時(shí)間的時(shí)和分。非零的數(shù)字前沒有前導(dǎo)0。h小于24，m小于60。
輸出格式
輸出時(shí)間時(shí)刻的英文。
樣例輸入
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'}
# 其實(shí)21，22，23可以不加入字典中，但為了后邊小時(shí)略去判斷簡(jiǎn)化代碼，直接加在字典中，方便后邊直接輸出小時(shí)
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])
2.19 回形取數(shù)
問題描述
回形取數(shù)就是沿矩陣的邊取數(shù)，若當(dāng)前方向上無數(shù)可取或已經(jīng)取過，則左轉(zhuǎn)90度。一開始位于矩陣左上角，方向向下。
輸入格式
輸入第一行是兩個(gè)不超過200的正整數(shù)m, n，表示矩陣的行和列。接下來m行每行n個(gè)整數(shù)，表示這個(gè)矩陣。
輸出格式
輸出只有一行，共mn個(gè)數(shù)，為輸入矩陣回形取數(shù)得到的結(jié)果。數(shù)之間用一個(gè)空格分隔，行末不要有多余的空格。
樣例輸入
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
注意
行末要求不要有多余的空格，不知意思是一個(gè)空格也不能有還是只可以有一個(gè)空格，由于控制最后一個(gè)數(shù)的輸出很麻煩，這里博主在行末輸出了一個(gè)空格，提交藍(lán)橋系統(tǒng)100分通過
另外，讀者們可以嘗試去尋找最后一個(gè)數(shù)的輸出位置規(guī)律，使得最后一個(gè)數(shù)單獨(dú)輸出，這樣就無空格啦，這里博主有時(shí)間的話回去再嘗試，然后會(huì)發(fā)出相應(yīng)代碼，敬請(qǐng)期待。
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個(gè)數(shù)
while row < m and matrix[row][col] != -1: # 向下取數(shù)
print(matrix[row][col], end=' ')
matrix[row][col] = -1 # 將去過的位置置為-1
row += 1
count += 1
row -= 1 # 上個(gè)循環(huán)結(jié)束后row的值為m,需要減1，否則越界
col += 1 # 列值加1，因?yàn)榈诹懔性谏蟼€(gè)循環(huán)已經(jīng)輸出，往右推一行
while col < n and matrix[row][col] != -1: # 向右取數(shù)
print(matrix[row][col], end=' ')
matrix[row][col] = -1 # 將去過的位置置為-1
col += 1
count += 1
row -= 1 # 往上推一行
col -= 1 # 上個(gè)循環(huán)使列值為n
while row >= 0 and matrix[row][col] != -1: # 向上取數(shù)
print(matrix[row][col], end=' ')
matrix[row][col] = -1 # 將去過的位置置為-1
row -= 1
count += 1
row += 1 # 上個(gè)循環(huán)使行值為-1
col -= 1 # 往左推一行
while col >= 0 and matrix[row][col] != -1: # 向左取數(shù)
print(matrix[row][col], end=' ')
matrix[row][col] = -1 # 將去過的位置置為-1
col -= 1
count += 1
col += 1 # 上個(gè)循環(huán)使列值為-1
row += 1 # 向下推一行
2.20 龜兔賽跑預(yù)測(cè)
問題描述
話說這個(gè)世界上有各種各樣的兔子和烏龜，但是研究發(fā)現(xiàn)，所有的兔子和烏龜都有一個(gè)共同的特點(diǎn)——喜歡賽跑。于是世界上各個(gè)角落都不斷在發(fā)生著烏龜和兔子的比賽，小華對(duì)此很感興趣，于是決定研究不同兔子和烏龜?shù)馁惻堋Ｋl(fā)現(xiàn)，兔子雖然跑比烏龜快，但它們有眾所周知的毛病——驕傲且懶惰，于是在與烏龜?shù)谋荣愔?#xff0c;一旦任一秒結(jié)束后兔子發(fā)現(xiàn)自己領(lǐng)先t米或以上，它們就會(huì)停下來休息s秒。對(duì)于不同的兔子，t，s的數(shù)值是不同的，但是所有的烏龜卻是一致——它們不到終點(diǎn)決不停止。
然而有些比賽相當(dāng)漫長(zhǎng)，全程觀看會(huì)耗費(fèi)大量時(shí)間，而小華發(fā)現(xiàn)只要在每場(chǎng)比賽開始后記錄下兔子和烏龜?shù)臄?shù)據(jù)——兔子的速度v1（表示每秒兔子能跑v1米），烏龜?shù)乃俣葀2，以及兔子對(duì)應(yīng)的t，s值，以及賽道的長(zhǎng)度l——就能預(yù)測(cè)出比賽的結(jié)果。但是小華很懶，不想通過手工計(jì)算推測(cè)出比賽的結(jié)果，于是他找到了你——清華大學(xué)計(jì)算機(jī)系的高才生——請(qǐng)求幫助，請(qǐng)你寫一個(gè)程序，對(duì)于輸入的一場(chǎng)比賽的數(shù)據(jù)v1，v2，t，s，l，預(yù)測(cè)該場(chǎng)比賽的結(jié)果。
輸入格式
輸入只有一行，包含用空格隔開的五個(gè)正整數(shù)v1，v2，t，s，l，其中(v1,v2<=100;t<=300;s<=10;l<=10000且為v1,v2的公倍數(shù))
輸出格式
輸出包含兩行，第一行輸出比賽結(jié)果——一個(gè)大寫字母“T”或“R”或“D”，分別表示烏龜獲勝，兔子獲勝，或者兩者同時(shí)到達(dá)終點(diǎn)。
第二行輸出一個(gè)正整數(shù)，表示獲勝者（或者雙方同時(shí)）到達(dá)終點(diǎn)所耗費(fèi)的時(shí)間（秒數(shù)）。
樣例輸入
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]: # 如果兔子或?yàn)觚數(shù)竭_(dá)終點(diǎn)，結(jié)束
break
if rabbit - tortoise >= data[2]: # 兔子達(dá)到領(lǐng)先條件，休息
for i in range(data[3]): # 休息時(shí)間按秒增加，烏龜路程按秒增加
tortoise += data[1]
time += 1
if tortoise == data[-1]: # 兔子休息時(shí)，烏龜?shù)竭_(dá)了終點(diǎn)，結(jié)束。
# 注意：有可能兔子在休息中，烏龜就到達(dá)了終點(diǎn)
# 所以休息時(shí)間未必循環(huán)完
# 如：兔子要休息10s，烏龜可能在兔子休息的第9s就到達(dá)了終點(diǎn)
# 這里的flag就起到提前結(jié)束的功能
flag = True
break
if flag: # 如果提前結(jié)束，則全部結(jié)束
break
time += 1 # 每走一秒，兔子和烏龜按相應(yīng)速度增加相應(yīng)距離
rabbit += data[0]
tortoise += data[1]
if rabbit > tortoise: # 誰先到達(dá)終點(diǎn)，誰的距離大
print('R')
print(time)
elif rabbit < tortoise:
print('T')
print(time)
else: # 相等則平局
print('D')
print(time)
2.21 芯片測(cè)試
問題描述
有n（2≤n≤20）塊芯片，有好有壞，已知好芯片比壞芯片多。
每個(gè)芯片都能用來測(cè)試其他芯片。用好芯片測(cè)試其他芯片時(shí)，能正確給出被測(cè)試芯片是好還是壞。而用壞芯片測(cè)試其他芯片時(shí)，會(huì)隨機(jī)給出好或是壞的測(cè)試結(jié)果（即此結(jié)果與被測(cè)試芯片實(shí)際的好壞無關(guān)）。
給出所有芯片的測(cè)試結(jié)果，問哪些芯片是好芯片。
輸入格式
輸入數(shù)據(jù)第一行為一個(gè)整數(shù)n，表示芯片個(gè)數(shù)。
第二行到第n+1行為n*n的一張表，每行n個(gè)數(shù)據(jù)。表中的每個(gè)數(shù)據(jù)為0或1，在這n行中的第i行第j列（1≤i, j≤n）的數(shù)據(jù)表示用第i塊芯片測(cè)試第j塊芯片時(shí)得到的測(cè)試結(jié)果，1表示好，0表示壞，i=j時(shí)一律為1（并不表示該芯片對(duì)本身的測(cè)試結(jié)果。芯片不能對(duì)本身進(jìn)行測(cè)試）。
輸出格式
按從小到大的順序輸出所有好芯片的編號(hào)
樣例輸入
3
1 0 1
0 1 0
1 0 1
樣例輸出
1 3
解題思路：
重點(diǎn)是好芯片比壞芯片多
如果忽略這個(gè)問題就很難解決，本人開始你就不幸忽略了。。。
既然好芯片比壞芯片多，那么我們只需記錄每一列0的個(gè)數(shù)就行了，若個(gè)數(shù)超過n/2，則此芯片為壞芯片
一個(gè)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=' ')
2.22 FJ字符串
問題描述
FJ在沙盤上寫了這樣一些字符串：
A1 = “A”
A2 = “ABA”
A3 = “ABACABA”
A4 = “ABACABADABACABA”
… …
你能找出其中的規(guī)律并寫所有的數(shù)列AN嗎？
輸入格式
僅有一個(gè)數(shù)：N ≤ 26。
輸出格式
請(qǐng)輸出相應(yīng)的字符串AN，以一個(gè)換行符結(jié)束。輸出中不得含有多余的空格或換行、回車符。
樣例輸入
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)
2.23 sin之舞
問題描述
最近FJ為他的奶牛們開設(shè)了數(shù)學(xué)分析課，FJ知道若要學(xué)好這門課，必須有一個(gè)好的三角函數(shù)基本功。所以他準(zhǔn)備和奶牛們做一個(gè)“Sine之舞”的游戲，寓教于樂，提高奶牛們的計(jì)算能力。
不妨設(shè)
An=sin(1–sin(2+sin(3–sin(4+…sin(n))…)
Sn=(…(A1+n)A2+n-1)A3+…+2)An+1
FJ想讓奶牛們計(jì)算Sn的值，請(qǐng)你幫助FJ打印出Sn的完整表達(dá)式，以方便奶牛們做題。
輸入格式
僅有一個(gè)數(shù)：N<201。
輸出格式
請(qǐng)輸出相應(yīng)的表達(dá)式Sn，以一個(gè)換行符結(jié)束。輸出中不得含有多余的空格或換行、回車符。
樣例輸入
3
樣例輸出
((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1
解題思路：
這里主要運(yùn)用到遞歸的思想
先遞歸求An
然后求Sn
Sn通用過調(diào)用An求出
def A(n, k):
if n == k:
return
print('sin(%d' % (n + 1), end='')
if n + 1 != k: # 若后邊還有式子，判斷是輸出+號(hào)還是-號(hào)
if n % 2 == 1:
print('+', end='')
else:
print('-', end='')
else: # 若后邊沒有式子，輸出右括號(hào)結(jié)束
# 注意，這里只輸出最后一次的右括號(hào)，前邊左括號(hào)對(duì)應(yīng)的右括號(hào)在S()函數(shù)中補(bǔ)全
print(')', end='')
n += 1
A(n, k) # 遞歸調(diào)用自身
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()函數(shù)中的括號(hào)
print(')', end='')
print('+%d' % n, end='')
if n != 1: # 最后一項(xiàng)加完整數(shù)之和不必再輸出右括號(hào)
print(')', end='')
k += 1
t += 1
n -= 1
n = int(input())
# A(0, 3)
S(n)
2.24 數(shù)的讀法
問題描述
Tom教授正在給研究生講授一門關(guān)于基因的課程，有一件事情讓他頗為頭疼：一條染色體上有成千上萬個(gè)堿基對(duì)，它們從0開始編號(hào)，到幾百萬，幾千萬，甚至上億。
比如說，在對(duì)學(xué)生講解第1234567009號(hào)位置上的堿基時(shí)，光看著數(shù)字是很難準(zhǔn)確的念出來的。
所以，他迫切地需要一個(gè)系統(tǒng)，然后當(dāng)他輸入12 3456 7009時(shí)，會(huì)給出相應(yīng)的念法：
十二億三千四百五十六萬七千零九
用漢語拼音表示為
shi er yi san qian si bai wu shi liu wan qi qian ling jiu
這樣他只需要照著念就可以了。
你的任務(wù)是幫他設(shè)計(jì)這樣一個(gè)系統(tǒng)：給定一個(gè)阿拉伯?dāng)?shù)字串，你幫他按照中文讀寫的規(guī)范轉(zhuǎn)為漢語拼音字串，相鄰的兩個(gè)音節(jié)用一個(gè)空格符格開。
注意必須嚴(yán)格按照規(guī)范，比如說“10010”讀作“yi wan ling yi shi”而不是“yi wan ling shi”，“100000”讀作“shi wan”而不是“yi shi wan”，“2000”讀作“er qian”而不是“l(fā)iang qian”。
輸入格式
有一個(gè)數(shù)字串，數(shù)值大小不超過2,000,000,000。
輸出格式
是一個(gè)由小寫英文字母，逗號(hào)和空格組成的字符串，表示該數(shù)的英文讀法。
樣例輸入
1234567009
樣例輸出
shi er yi san qian si bai wu shi liu wan qi qian ling jiu
解題思路：
開始我按位置一位一位讀，讀到1萬代碼就開始很復(fù)雜了，所以考慮一定有相應(yīng)讀法的規(guī)律
利用循環(huán)來搞定，苦思冥想之后，還是利用度娘，一下就清晰了。。。
首先，讀一個(gè)數(shù)，要處理開頭為1的位置要不要讀的問題
其次就是，處理多個(gè)連續(xù)0的讀法問題
處理1的代碼塊下方已注釋
就是不要把11，讀作yi shi yi,111111不要讀作yi shi yi wan yi qian yi bai yi shi yi
處理0的連續(xù)問題代碼塊中也給與了注釋
就是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時(shí)的讀法
if (l - i == 2 or l - i == 6 or l - i == 10) and j == 1:
# 在十位，十萬位，十億位置且位于開頭的1不讀
# 例子：
# 1111111111 會(huì)讀出 yi shi yi yi yi qian yi bai yi shi yi wan yi qian yi bai yi shi yi
# 111111 會(huì)讀出 yi shi yi wan yi qian yi bai yi shi yi
# 11 會(huì)讀出 yi shi yi
# 加上此約束后，則不會(huì)讀出開頭的 yi
if i != 0: # 第一個(gè)1不輸出1， 若不添加此條件，12會(huì)讀出 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，或者，當(dāng)前是最后以為，則不讀此0
continue
print(pin_yin['0'], end=' ') # 否則才讀出這個(gè)零
2.25 完美的代價(jià)
問題描述
回文串，是一種特殊的字符串，它從左往右讀和從右往左讀是一樣的。小龍龍認(rèn)為回文串才是完美的。現(xiàn)在給你一個(gè)串，它不一定是回文的，請(qǐng)你計(jì)算最少的交換次數(shù)使得該串變成一個(gè)完美的回文串。
交換的定義是：交換兩個(gè)相鄰的字符
例如mamad
第一次交換 ad : mamda
第二次交換 md : madma
第三次交換 ma : madam (回文！完美！)
輸入格式
第一行是一個(gè)整數(shù)N，表示接下來的字符串的長(zhǎng)度(N <= 8000)
第二行是一個(gè)字符串，長(zhǎng)度為N.只包含小寫字母
輸出格式
如果可能，輸出最少的交換次數(shù)。
否則輸出Impossible
樣例輸入
5
mamad
樣例輸出
3
解題思路
兩種情況：
1.impossible的情況：如果有一個(gè)字符出現(xiàn)的次數(shù)是奇數(shù)次數(shù)，而且n是偶數(shù)，那么不可能構(gòu)成回文。
如果n是奇數(shù)，但是已經(jīng)有一個(gè)字符出現(xiàn)的次數(shù)是奇數(shù)次數(shù)了，那么如果又有一個(gè)字符是奇數(shù)次數(shù)，就不可能構(gòu)成回文。
2.如果n是奇數(shù)，計(jì)算中間那個(gè)字符交換的次數(shù)的時(shí)候，不需要模擬把這個(gè)數(shù)移動(dòng)到中間去，因?yàn)橐苿?dòng)到中間的話假設(shè)有一對(duì)數(shù)都在左邊或者都在右邊。那么交換成回文的時(shí)候就要經(jīng)過中間，就會(huì)每次把cnt多加了1，而這個(gè)1是沒有必要的，因?yàn)榭梢运械幕匚囊苿?dòng)完了之后再把這個(gè)獨(dú)立的奇數(shù)移動(dòng)過去，才能保證交換次數(shù)最少。
例如：
此圖片引用自博客：qq_40605470
n = int(input())
pal = list(input())
count = flag = 0 # count計(jì)數(shù)，flag判斷是否已經(jīng)有一個(gè)單獨(dú)的奇?zhèn)€數(shù)的字符了
m = n - 1
for i in range(m): # 從頭遍歷到倒數(shù)第二個(gè)字符
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): # 找到相同的，進(jìn)行交換
pal[j], pal[j + 1] = pal[j + 1], pal[j]
count += 1 # 計(jì)數(shù)器加1
m -= 1 # 最后拍好序的不在進(jìn)行比較
break
print(count)
這個(gè)出現(xiàn)了之前遇到同樣的問題，提交后十組測(cè)試數(shù)據(jù)，九組正確，但是有一組超時(shí)，不得分。但是同樣的算法，C++版本的代碼提交后完美通過，100分！目前不知道怎么辦還，有明白的請(qǐng)不吝賜教，非常感謝。
C++版代碼如下：
#include
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int j = n - 1;
int cnt = 0;//cnt用來統(tǒng)計(jì)交換的次數(shù)
int flag = 0;//flag判斷是否已經(jīng)有一個(gè)單獨(dú)的奇?zhèn)€數(shù)的字符了
for(int i = 0; i < j; i++) {//i指針從頭遍歷到倒數(shù)第二個(gè)字符
for(int k = j; k >= i; k--) {//k指針從后面往前一直到i尋找和s[i]相同的s[k]
if(k == i) {//如果找不到相同的
if(n % 2 == 0 || flag == 1) {//impossible的兩種情況
cout << "Impossible";
return 0;
}
flag = 1;
cnt += n / 2 - i;
} else if(s[k] == s[i]) {
for(int l = k; l < j; l++) {
swap(s[l], s[l+1]);//把s[k]換到s[j]處
cnt++;//統(tǒng)計(jì)交換次數(shù)
}
j--;
break;
}
}
}
cout << cnt;
return 0;
}
注：此代碼完美通過！
2.26 矩形面積交
問題描述
平面上有兩個(gè)矩形，它們的邊平行于直角坐標(biāo)系的X軸或Y軸。對(duì)于每個(gè)矩形，我們給出它的一對(duì)相對(duì)頂點(diǎn)的坐標(biāo)，請(qǐng)你編程算出兩個(gè)矩形的交的面積。
輸入格式
輸入僅包含兩行，每行描述一個(gè)矩形。
在每行中，給出矩形的一對(duì)相對(duì)頂點(diǎn)的坐標(biāo)，每個(gè)點(diǎn)的坐標(biāo)都用兩個(gè)絕對(duì)值不超過10^7的實(shí)數(shù)表示。
輸出格式
輸出僅包含一個(gè)實(shí)數(shù)，為交的面積，保留到小數(shù)后兩位。
樣例輸入
1 1 3 3
2 2 4 4
樣例輸出
1.00
解題思路：
重點(diǎn)是找到兩個(gè)矩形產(chǎn)生交集的條件
矩陣1的對(duì)角點(diǎn)坐標(biāo)的橫坐標(biāo)取最小， 矩陣2的對(duì)角點(diǎn)坐標(biāo)的橫坐標(biāo)取最小，然后再?gòu)倪@兩個(gè)值中取最大，得x1
矩陣1的對(duì)角點(diǎn)坐標(biāo)的橫坐標(biāo)取最大， 矩陣2的對(duì)角點(diǎn)坐標(biāo)的橫坐標(biāo)取最大，然后再?gòu)倪@兩個(gè)值中取最小，得x2
如果x1
縱坐標(biāo)同理
最后交集的面積就為：
area = (x2 - x1) * (y2 - y1)
rect_1 = list(map(float, input().split()))
rect_2 = list(map(float, input().split()))
area = 0
x1 = max(min(rect_1[0], rect_1[2]), min(rect_2[0], rect_2[2]))
y1 = max(min(rect_1[1], rect_1[3]), min(rect_2[1], rect_2[3]))
x2 = min(max(rect_1[0], rect_1[2]), max(rect_2[0], rect_2[2]))
y2 = min(max(rect_1[1], rect_1[3]), max(rect_2[1], rect_2[3]))
if x1 < x2 and y1 < y2:
area = (x2 - x1) * (y2 - y1)
print('%.2f' % area)
else:
print('%.2f' % area)
2.27 矩陣乘法
問題描述
給定一個(gè)N階矩陣A，輸出A的M次冪（M是非負(fù)整數(shù)）
例如：
A =
1 2
3 4
A的2次冪
7 10
15 22
輸入格式
第一行是一個(gè)正整數(shù)N、M（1<=N<=30, 0<=M<=5），表示矩陣A的階數(shù)和要求的冪數(shù)
接下來N行，每行N個(gè)絕對(duì)值不超過10的非負(fù)整數(shù)，描述矩陣A的值
輸出格式
輸出共N行，每行N個(gè)整數(shù)，表示A的M次冪所對(duì)應(yīng)的矩陣。相鄰的數(shù)之間用一個(gè)空格隔開
樣例輸入
2 2
1 2
3 4
樣例輸出
7 10
15 22
注意：
1.不要忘記方陣的0次冪這一特殊情況，它的結(jié)果是人為定義的，為n階單位陣。
2.博主的代碼中矩陣乘法函數(shù)，是一個(gè)普遍適用的矩陣乘法函數(shù)，即不是兩個(gè)方陣相乘也行，只要兩矩陣滿足矩陣乘法定理即可，相應(yīng)解釋已在代碼塊中給出。
3.若你在參加考試，則代碼越簡(jiǎn)化越好，如這題的矩陣乘法函數(shù)，題中給的輸入矩陣必為n階方陣，所以寫矩陣乘法的函數(shù)就只針對(duì)n階方陣來寫就好了，以降低出錯(cuò)率，相應(yīng)代碼請(qǐng)讀者自行寫出，以加深理解。
def multi_rect(rect_1, shape_1, rect_2, shape_2):
"""矩陣乘法
:param rect_1: 矩陣A
:param shape_1: 矩陣A的形狀
:param rect_2: 矩陣B
:param shape_2: 矩陣B的形狀
:return: 兩矩陣之積和積的矩陣形狀
"""
if shape_1[1] != shape_2[0]:
return
rect_ = [[0 for _ in range(shape_2[1])] for _ in range(shape_1[0])]
shape_ = (shape_1[0], shape_2[1])
for i in range(shape_1[0]):
for k in range(shape_2[1]):
for j in range(shape_1[1]):
rect_[i][k] += rect_1[i][j] * rect_2[j][k] # 矩陣乘法定義
return rect_, shape_
n, m = map(int, input().split())
rect = [[] for _ in range(n)]
for i in range(n):
arr = input().split()
for j in range(n):
rect[i].append(int(arr[j]))
result, shape = rect, (n, n)
if m == 0: # 0次冪只有為方陣才有，此時(shí)result為n階單位陣
result = [[0 for _ in range(n)] for _ in range(n)] # shape仍然為(n, n)
for i in range(n):
result[i][i] = 1
else: # m不為0，計(jì)算它的m次冪
for _ in range(m - 1):
result, shape = multi_rect(rect, (n, n), result, shape)
for i in range(shape[0]):
for j in range(shape[1]):
print(result[i][j], end=' ')
print()
2.28 2n皇后問題
問題描述
給定一個(gè)n*n的棋盤，棋盤中有一些位置不能放皇后。現(xiàn)在要向棋盤中放入n個(gè)黑皇后和n個(gè)白皇后，使任意的兩個(gè)黑皇后都不在同一行、同一列或同一條對(duì)角線上，任意的兩個(gè)白皇后都不在同一行、同一列或同一條對(duì)角線上。問總共有多少種放法？n小于等于8。
輸入格式
輸入的第一行為一個(gè)整數(shù)n，表示棋盤的大小。
接下來n行，每行n個(gè)0或1的整數(shù)，如果一個(gè)整數(shù)為1，表示對(duì)應(yīng)的位置可以放皇后，如果一個(gè)整數(shù)為0，表示對(duì)應(yīng)的位置不可以放皇后。
輸出格式
輸出一個(gè)整數(shù)，表示總共有多少種放法。
樣例輸入
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
前面2.17簡(jiǎn)單介紹了N皇后問題，這里的題目為2n皇后問題，就是先放置好白皇后，然后再不沖突的情況下按上述規(guī)則放置黑皇后
例2.17是網(wǎng)上給出的python版經(jīng)典求解N皇后問題算法，此處作者自己查閱資料寫了個(gè)N皇后問題代碼，下方貼出，因?yàn)?n皇后問題求解是在此基礎(chǔ)上求解的。
def n_queen(k):
global count
for i in range(k - 1): # 判斷是否可放置皇后的條件
judge = queen[i] - queen[k - 1]
if judge == 0 or abs(k - 1 - i) == abs(judge):
return
if k == n:
print(queen) # 輸出皇后放置序列
count += 1 # 解的個(gè)數(shù)
return
for i in range(n): # 放置皇后
queen[k] = i
n_queen(k + 1)
count = 0
n = 4 # 此處的n為幾，則為幾皇后問題
queen = [0 for _ in range(n)]
n_queen(0)
print(count)
下面給出2n皇后問題解的python代碼，但是提交后十組測(cè)試數(shù)據(jù)有九組通過，一組運(yùn)行超時(shí)，但結(jié)果也是正確的，同意的代碼思想，改編為C語言版就能通過，而不會(huì)提示運(yùn)行超時(shí)，這個(gè)問題遇到過不止一次了，一直不知道怎么解決，是在重新設(shè)計(jì)一個(gè)更快的算法才行嗎，很苦惱。
同樣算法思想寫出的代碼，python運(yùn)行時(shí)間會(huì)比C,C++的運(yùn)行時(shí)間長(zhǎng)，從而導(dǎo)致提交python代碼后結(jié)果為運(yùn)行超時(shí)，而其他代碼則完美通過。
python代碼，得分83分，有一組數(shù)據(jù)運(yùn)行超時(shí)。
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)
C語言代碼，100分。
#include
#include
#include
#define MAXSIZE 1000
int bqueen[MAXSIZE];//黑皇后
int wqueen[MAXSIZE];//白皇后
int chessboard[MAXSIZE][MAXSIZE];//1:能放 0:不能放
int count =0;
int n;
int BlackQueen(int k)
{
int i;
int j;
for(i =0; i < k -1; i++)
{
int judge = bqueen[i]- bqueen[k -1];
if(judge ==0|| fabs(k -1- i)== fabs(judge))
return 0;
}
if(k == n)
{
count++;
return 0;
}
for( j =0; j < n; j++)
{
if(j != wqueen[k]&& chessboard[k][j])
{
bqueen[k]= j;
BlackQueen(k +1);
}
}
}
int WhiteQueen(int k)
{
int i;
int j;
for( i =0; i < k -1; i++)
{
int judge = wqueen[i]- wqueen[k -1];
if(judge ==0|| fabs(k -1- i)== fabs(judge))
return 0;
}
if(k == n)
{
BlackQueen(0);
return 0;
}
for( j =0; j < n; j++)
{
if(chessboard[k][j])
{
wqueen[k]= j;
WhiteQueen(k +1);
}
}
}
int main(void)
{ int i;
int j;
// freopen("input3.txt","r",stdin);//這是我直接從文件中讀取數(shù)據(jù)
scanf("%d",&n);
for(i =0; i < n; i++)
for(j =0; j < n; j++)
scanf("%d",&chessboard[i][j]);
WhiteQueen(0);
printf("%d\n",count);
return 0;
}
2.29 分解質(zhì)因數(shù)
問題描述
求出區(qū)間[a,b]中所有整數(shù)的質(zhì)因數(shù)分解。
輸入格式
輸入兩個(gè)整數(shù)a，b。
輸出格式
每行輸出一個(gè)數(shù)的分解，形如k=a1a2a3…(a1<=a2<=a3…，k也是從小到大的)(具體可看樣例)
樣例輸入
3 10
樣例輸出
3=3
4=22
5=5
6=23
7=7
8=222
9=33
10=25
提示
先篩出所有素?cái)?shù)，然后再分解。
數(shù)據(jù)規(guī)模和約定
2<=a<=b<=10000
解題思路：
對(duì)一個(gè)數(shù)進(jìn)行質(zhì)因數(shù)分解
首先判斷它本身是否為質(zhì)數(shù)
是，則直接輸出等于自身
否，進(jìn)行循環(huán)，從2開始，輸出最多的因數(shù)個(gè)數(shù)后才遞增，這樣保證不會(huì)有非質(zhì)數(shù)因子
如，8 = 2 * 2 * 2
首先把最多的2輸出，之后就不會(huì)出現(xiàn)2的倍數(shù)這樣的因數(shù)啦。
又出現(xiàn)了同樣的問題，python代碼超時(shí)，C代碼運(yùn)行100分！好煩哦~
python代碼
def is_prime(n):
for i in range(2, n):
if n % i == 0:
return False
return True
a, b = map(int, input().split())
for i in range(a, b + 1):
if is_prime(i): # 如果是素?cái)?shù)，則等于它本身
print(i, '=', i, sep='')
else:
print(i, '=', sep='', end='')
temp = i
j = 2
while temp > 1:
if temp % j == 0: # 分解質(zhì)因數(shù)，從j=2開始除,直到對(duì)i取余不為0時(shí)，才j += 1，保證每個(gè)j出現(xiàn)最多
temp = int(temp / j)
print(j, end='')
if temp != 1:
print('*', end='')
else:
j += 1
print()
C語言代碼
#include
using namespace std;
bool issu(int n){ //判斷素?cái)?shù)
bool t = true;
for(int i = 2;i <= n - 1;i++){
if(n % i == 0){
t = false;
break;
}
}
return t;
}
int main(){
int a;
int b;
cin>>a>>b;
for(int i = a;i <= b;i++){
if(issu(i)){
cout<
}else{
cout<
int tt = i;
int j = 2;
while(tt > 1){ //分解質(zhì)因數(shù)，從i=2開始除,直到對(duì)i取余不為0時(shí)，才i++
// 保證每個(gè)i出現(xiàn)最多
if(tt % j == 0){
tt = tt / j;
cout<
if(tt != 1){
cout<<"*";
}
}else{
j++;
}
}
cout<
}
}
return 0;
}
2.30 字符串對(duì)比
問題描述
給定兩個(gè)僅由大寫字母或小寫字母組成的字符串(長(zhǎng)度介于1到10之間)，它們之間的關(guān)系是以下4中情況之一：
1：兩個(gè)字符串長(zhǎng)度不等。比如 Beijing 和 Hebei
2：兩個(gè)字符串不僅長(zhǎng)度相等，而且相應(yīng)位置上的字符完全一致(區(qū)分大小寫)，比如 Beijing 和 Beijing
3：兩個(gè)字符串長(zhǎng)度相等，相應(yīng)位置上的字符僅在不區(qū)分大小寫的前提下才能達(dá)到完全一致（也就是說，它并不滿足情況2）。比如 beijing 和 BEIjing
4：兩個(gè)字符串長(zhǎng)度相等，但是即使是不區(qū)分大小寫也不能使這兩個(gè)字符串一致。比如 Beijing 和 Nanjing
編程判斷輸入的兩個(gè)字符串之間的關(guān)系屬于這四類中的哪一類，給出所屬的類的編號(hào)。
輸入格式
包括兩行，每行都是一個(gè)字符串
輸出格式
僅有一個(gè)數(shù)字，表明這兩個(gè)字符串的關(guān)系編號(hào)
樣例輸入
BEIjing
beiJing
樣例輸出
3
注意：
代碼塊中的upper函數(shù)也可以改為lower函數(shù)
就是樣字符串中的英文字母全部改為大寫或者小寫
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)
參考知識(shí)：
2.31 時(shí)間轉(zhuǎn)換
問題描述
給定一個(gè)以秒為單位的時(shí)間t，要求用H:M:S的格式來表示這個(gè)時(shí)間。H表示時(shí)間，M表示分鐘，而S表示秒，它們都是整數(shù)且沒有前導(dǎo)的“0”。例如，若t=0，則應(yīng)輸出是“0:0:0”；若t=3661，則輸出“1:1:1”。
輸入格式
輸入只有一行，是一個(gè)整數(shù)t（0<=t<=86399）。
輸出格式
輸出只有一行，是以“H:M:S”的格式所表示的時(shí)間，不包括引號(hào)。
樣例輸入
0
樣例輸出
0:0:0
樣例輸入
5436
樣例輸出
1:30:36
解題思路：
這道題目就是單純的把秒轉(zhuǎn)換成小時(shí)和分鐘，較為簡(jiǎn)單，不再贅述。
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='')
3.提高篇
3.1 預(yù)測(cè)身高
問題描述：
生理衛(wèi)生老師在課堂上娓娓道來：
你能看見你未來的樣子嗎？顯然不能。但你能預(yù)測(cè)自己成年后的身高，有公式：
男孩成人后身高=（父親身高+母親身高）/21.08
女孩成人后身高=(父親身高0.923+母親身高）/2
數(shù)學(xué)老師聽見了，回頭說：這是大樣本統(tǒng)計(jì)擬合公式，準(zhǔn)確性不錯(cuò)。
生物老師聽見了，回頭說：結(jié)果不是絕對(duì)的，影響身高的因素很多，比如營(yíng)養(yǎng)、疾病、體育鍛煉、睡眠、情緒、環(huán)境因素等。
老師們齊回頭，看見同學(xué)們都正在預(yù)測(cè)自己的身高。
毛老師見此情形，推推眼鏡說：何必手算，編程又快又簡(jiǎn)單…
約定：
身高的單位用米表示，所以自然是會(huì)有小數(shù)的。
男性用整數(shù)1表示，女性用整數(shù)0表示。
預(yù)測(cè)的身高保留三位小數(shù)
輸入格式
用空格分開的三個(gè)數(shù)，整數(shù) 小數(shù) 小數(shù)
分別表示：性別 父親身高 母親身高
輸出格式
一個(gè)小數(shù)，表示根據(jù)上述表示預(yù)測(cè)的身高（保留三位小數(shù)）
樣例輸入
1 1.91 1.70
樣例輸出
1.949
樣例輸入
0 1.00 2.077
樣例輸出
1.500
數(shù)據(jù)規(guī)模和約定
父母身高范圍（0，3]
時(shí)間限制1.0秒
隨機(jī)從算法訓(xùn)練里抽取的一道題目，題干挺長(zhǎng)，但是讀完后發(fā)現(xiàn)太簡(jiǎn)單啦，不想發(fā)出來侮辱大家智商。但是做都做啦，就更新一下吧。。。
gender, father_height, mother_height = map(float, input().split())
if gender == 1:
height = (father_height + mother_height) / 2 * 1.08
else:
height = (father_height * 0.923 + mother_height) / 2
print('%.3f' % height)
3.2 最長(zhǎng)滑雪道
問題描述
小袁非常喜歡滑雪， 因?yàn)榛┖艽碳ぁ榱双@得速度，滑的區(qū)域必須向下傾斜，而且當(dāng)你滑到坡底，你不得不再次走上坡或者等待升降機(jī)來載你。 小袁想知道在某個(gè)區(qū)域中最長(zhǎng)的一個(gè)滑坡。區(qū)域由一個(gè)二維數(shù)組給出。數(shù)組的每個(gè)數(shù)字代表點(diǎn)的高度。如下：
一個(gè)人可以從某個(gè)點(diǎn)滑向上下左右相鄰四個(gè)點(diǎn)之一，當(dāng)且僅當(dāng)高度減小。在上面的例子中，一條可滑行的滑坡為24-17-16-1。當(dāng)然25-24-23-…-3-2-1更長(zhǎng)。事實(shí)上，這是最長(zhǎng)的一條。
你的任務(wù)就是找到最長(zhǎng)的一條滑坡，并且將滑坡的長(zhǎng)度輸出。 滑坡的長(zhǎng)度定義為經(jīng)過點(diǎn)的個(gè)數(shù)，例如滑坡24-17-16-1的長(zhǎng)度是4。
輸入格式
輸入的第一行表示區(qū)域的行數(shù)R和列數(shù)C(1<=R, C<=10)。下面是R行，每行有C個(gè)整數(shù)，依次是每個(gè)點(diǎn)的高度h（0<= h <=10000）。
輸出格式
只有一行，為一個(gè)整數(shù)，即最長(zhǎng)區(qū)域的長(zhǎng)度。
樣例輸入
5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
樣例輸出
25
解題思路：
1.偶然發(fā)現(xiàn)了一中二位數(shù)組輸入的更簡(jiǎn)便方式：
arr = [list(map(int, input().split())) for _ in range(row)]
以后按二維數(shù)組的輸入統(tǒng)統(tǒng)按此方法處理，前邊已經(jīng)寫好的代碼不再進(jìn)行修改。
2.對(duì)于區(qū)域內(nèi)每個(gè)點(diǎn)進(jìn)行dfs，對(duì)每個(gè)點(diǎn)來說進(jìn)行四個(gè)方向的dfs取最大值，然后取所有點(diǎn)為起點(diǎn)的最大長(zhǎng)度的最大值，即為答案。
3.詳細(xì)解釋在代碼塊中相應(yīng)位置給出。
def dfs(x, y):
"""
深度遞歸搜索
:param x: 橫坐標(biāo)
:param y: 縱坐標(biāo)
:return: 最大距離
"""
max_height = 1 # 初始距離為1
if dp[x][y] > 0: # 如果已經(jīng)有了當(dāng)前位置出發(fā)的最大距離，則直接返回
return dp[x][y]
for k in range(4): # 判斷該位置的上下左右四個(gè)位置
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) # 符合，遞歸搜索下一個(gè)位置且距離加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)] # 記錄從每個(gè)位置(x, y)開始，它的最大長(zhǎng)度
arr = [list(map(int, input().split())) for _ in range(row)] # 這里發(fā)明了二位數(shù)組python輸入方法的一種全新方式，偶然發(fā)現(xiàn)的
next_ = [[0, 1], [1, 0], [0, -1], [-1, 0]] # 用來表示(x, y)的上下左右四個(gè)位置
ans = 0
for i in range(row):
for j in range(col):
ans = max(ans, dfs(i, j))
print(ans)
3.3 K好數(shù)
資源限制
時(shí)間限制：1.0s 內(nèi)存限制：256.0MB
問題描述
如果一個(gè)自然數(shù)N的K進(jìn)制表示中任意的相鄰的兩位都不是相鄰的數(shù)字，那么我們就說這個(gè)數(shù)是K好數(shù)。求L位K進(jìn)制數(shù)中K好數(shù)的數(shù)目。例如K = 4，L = 2的時(shí)候，所有K好數(shù)為11、13、20、22、30、31、33 共7個(gè)。由于這個(gè)數(shù)目很大，請(qǐng)你輸出它對(duì)1000000007取模后的值。
輸入格式
輸入包含兩個(gè)正整數(shù)，K和L。
輸出格式
輸出一個(gè)整數(shù)，表示答案對(duì)1000000007取模后的值。
樣例輸入
4 2
樣例輸出
7
數(shù)據(jù)規(guī)模與約定
對(duì)于30%的數(shù)據(jù)，KL <= 106；
對(duì)于50%的數(shù)據(jù)，K <= 16， L <= 10；
對(duì)于100%的數(shù)據(jù)，1 <= K,L <= 100。
動(dòng)態(tài)規(guī)劃DP問題
“L位K進(jìn)制數(shù)”：如：“2位4進(jìn)制數(shù)”，它是指這個(gè)數(shù)是個(gè)兩位數(shù)，其中個(gè)位數(shù)是4進(jìn)制數(shù)（即從[0,3]中取一個(gè)數(shù)作為個(gè)位），十位數(shù)也是4進(jìn)制數(shù)。同理，“3位7進(jìn)制數(shù)”則指這個(gè)數(shù)是個(gè)3位數(shù)，其中個(gè)位、十位、百位都是7進(jìn)制數(shù)。
K好數(shù)的要求：任意相鄰的兩位不是相鄰的數(shù)字。
核心：dp[i][j]=dp[i][j]+dp[i-1][k]
當(dāng)前位置的數(shù)總數(shù)=當(dāng)前位置的數(shù)的數(shù)目+前一個(gè)位置的數(shù)的總數(shù)。
def count(length, kind, ans):
for i in range(1, kind):
dp[0][i] = 1
for i in range(1, length):
for j in range(kind):
for k in range(kind):
if abs(j - k) != 1:
if j - 1 == 0 and k == 0: # 排除首位為0的情況
continue
dp[i][j] = dp[i][j]+dp[i-1][k]
dp[i][j] %= MOD
for i in range(kind):
ans += dp[length - 1][i]
ans %= MOD
return ans
K, L = map(int, input().split())
ans = 0
MOD = 1000000007
dp = [[0 for _ in range(max(L,K))] for _ in range(max(L,K))]
if K == 1 and L == 1:
print(0)
elif K > 1 and L == 1: # 1位的K進(jìn)制的K好數(shù)總數(shù)就是K個(gè)
print(K)
elif L > 1:
print(count(L, K, ans))
3.4 石子游戲
資源限制
時(shí)間限制：1.0s 內(nèi)存限制：256.0MB
問題描述
石子游戲的規(guī)則如下：
地上有n堆石子，每次操作可選取兩堆石子（石子個(gè)數(shù)分別為x和y）并將它們合并，操作的得分記為(x+1)×(y+1)，對(duì)地上的石子堆進(jìn)行操作直到只剩下一堆石子時(shí)停止游戲。
請(qǐng)問在整個(gè)游戲過程中操作的總得分的最大值是多少？
輸入格式
輸入數(shù)據(jù)的第一行為整數(shù)n，表示地上的石子堆數(shù)；第二行至第n+1行是每堆石子的個(gè)數(shù)。
輸出格式
程序輸出一行，為游戲總得分的最大值。
樣例輸入
10
5105
19400
27309
19892
27814
25129
19272
12517
25419
4053
樣例輸出
15212676150
數(shù)據(jù)規(guī)模和約定
1≤n≤1000，1≤一堆中石子數(shù)≤50000
每次取最大的，符合貪心原則
這里直接排序，然后選取兩個(gè)前二大數(shù)
計(jì)算結(jié)果，合并，刪掉最后一個(gè)
列表長(zhǎng)度不為1時(shí)循環(huán)
python的列表可以看作棧或隊(duì)列
n = int(input())
result = 0
data = [int(input()) for _ in range(n)]
while len(data) != 1:
data.sort()
result += (data[-1] + 1) * (data[-2] + 1)
data[-2] += data[-1]
data.pop(-1)
print(result)
3.5 幸運(yùn)顧客
資源限制
時(shí)間限制：2.0s 內(nèi)存限制：256.0MB
為了吸引更多的顧客，某商場(chǎng)決定推行有獎(jiǎng)抽彩活動(dòng)。“本商場(chǎng)每日將產(chǎn)生一名幸運(yùn)顧客，凡購(gòu)買30元以上商品者均有機(jī)會(huì)獲得本商場(chǎng)提供的一份精美禮品。”該商場(chǎng)的幸運(yùn)顧客產(chǎn)生方式十分奇特：每位顧客可至抽獎(jiǎng)臺(tái)抽取一個(gè)幸運(yùn)號(hào)碼，該商場(chǎng)在抽獎(jiǎng)活動(dòng)推出的第i天將從所有顧客中（包括不在本日購(gòu)物滿30元者）挑出幸運(yùn)號(hào)第i小的顧客作為當(dāng)日的幸運(yùn)顧客。該商場(chǎng)的商品本就價(jià)廉物美，自從有獎(jiǎng)活動(dòng)推出后，顧客更是絡(luò)繹不絕，因此急需你編寫一個(gè)程序，為他解決幸運(yùn)顧客的產(chǎn)生問題。
【輸入數(shù)據(jù)】
第1行一個(gè)整數(shù)N，表示命令數(shù)。
第2~N+1行，每行一個(gè)數(shù)，表示命令。如果x>=0，表示有一顧客抽取了號(hào)碼x；如果x=-1，表示傍晚抽取該日的幸運(yùn)號(hào)碼。
【輸出數(shù)據(jù)】
對(duì)應(yīng)各命令-1輸出幸運(yùn)號(hào)碼；每行一個(gè)號(hào)碼。(兩個(gè)相同的幸運(yùn)號(hào)看作兩個(gè)號(hào)碼)
樣例輸入
6
3
4
-1
-1
3
-1
樣例輸出
3
4
4
解釋
只關(guān)注獲獎(jiǎng)的號(hào)碼是多少，每個(gè)號(hào)碼可以獲獎(jiǎng)多次。
數(shù)據(jù)規(guī)模及約定
共10組數(shù)據(jù)。
對(duì)100%的數(shù)據(jù)，N=10^6所有命令為-1或int范圍內(nèi)的非負(fù)數(shù)，前i的命令中-1的數(shù)量不超過[i/2]（向下取整）。
很簡(jiǎn)單，不多說啦。
n = int(input())
arr = []
rs = []
ans = 0
for i in range(n):
data = int(input())
if data != -1:
arr.append(data)
else:
arr.sort()
rs.append(arr[ans])
ans += 1
for i in range(len(rs)):
print(rs[i])
3.6 最長(zhǎng)公共子序列（LCS）
資源限制
時(shí)間限制：1.0s 內(nèi)存限制：256.0MB
問題描述
給定兩個(gè)字符串，尋找這兩個(gè)字串之間的最長(zhǎng)公共子序列。
輸入格式
輸入兩行，分別包含一個(gè)字符串，僅含有小寫字母。
輸出格式
最長(zhǎng)公共子序列的長(zhǎng)度。
樣例輸入
abcdgh
aedfhb
樣例輸出
3
樣例說明
最長(zhǎng)公共子序列為a，d，h。
數(shù)據(jù)規(guī)模和約定
字串長(zhǎng)度1~1000。
動(dòng)態(tài)規(guī)劃問題，參考下面鏈接
最長(zhǎng)公告子序列詳解
def lcs(str_a, str_b):
len_a = len(a)
len_b = len(b)
arr = [[0 for _ in range(len_b + 1)] for _ in range(len_a + 1)]
for i in range(len_a + 1):
for j in range(len_b + 1):
if i == 0 or j == 0:
arr[i][j] = 0
elif i > 0 and j > 0 and str_a[i - 1] == str_b[j - 1]:
arr[i][j] = arr[i - 1][j - 1] + 1
else:
arr[i][j] = max(arr[i][j - 1], arr[i - 1][j])
return arr[len_a][len_b]
a = input()
b = input()
print(lcs(a, b))
3.7 復(fù)數(shù)求和
資源限制
時(shí)間限制：1.0s 內(nèi)存限制：512.0MB
從鍵盤讀入n個(gè)復(fù)數(shù)（實(shí)部和虛部都為整數(shù)）用鏈表存儲(chǔ)，遍歷鏈表求出n個(gè)復(fù)數(shù)的和并輸出。
樣例輸入:
3
3 4
5 2
1 3
樣例輸出:
9+9i
樣例輸入:
7
1 2
3 4
2 5
1 8
6 4
7 9
3 7
樣例輸出:
23+39i
列表中的元素是元組
n = int(input())
real = 0
imaginary = 0
com = [tuple(map(int, input().split())) for _ in range(n)]
for i in range(n):
real += com[i][0]
imaginary += com[i][1]
print(real, '+', imaginary, 'i', sep='')
3.8 成績(jī)排名（結(jié)構(gòu)體）
資源限制
時(shí)間限制：1.0s 內(nèi)存限制：256.0MB
問題描述
小明剛經(jīng)過了一次數(shù)學(xué)考試，老師由于忙碌忘記排名了，于是老師把這個(gè)光榮的任務(wù)交給了小明，小明則找到了聰明的你，希望你能幫他解決這個(gè)問題。
輸入格式
第一行包含一個(gè)正整數(shù)N，表示有個(gè)人參加了考試。接下來N行，每行有一個(gè)字符串和一個(gè)正整數(shù)，分別表示人名和對(duì)應(yīng)的成績(jī)，用一個(gè)空格分隔。
輸出格式
輸出一共有N行，每行一個(gè)字符串，第i行的字符串表示成績(jī)從高到低排在第i位的人的名字，若分?jǐn)?shù)一樣則按人名的字典序順序從小到大。
樣例輸入
3
aaa 47
bbb 90
ccc 70
樣例輸出
bbb
ccc
aaa 【數(shù)據(jù)規(guī)模和約定】
人數(shù)<=100,分?jǐn)?shù)<=100,人名僅包含小寫字母。
主要是對(duì)排序函數(shù)的利用
sort()函數(shù)
n = int(input())
information = [tuple(input().split()) for _ in range(n)]
information.sort(key=lambda x: x[0]) # 先排姓名，按字母順序
information.sort(key=lambda x: int(x[1]),reverse=True) # 后排成績(jī)，從大到小
for i in range(n):
print(information[i][0])
3.9 遞歸倒置字符數(shù)組
資源限制
時(shí)間限制：1.0s 內(nèi)存限制：512.0MB
問題描述
完成一個(gè)遞歸程序，倒置字符數(shù)組。并打印實(shí)現(xiàn)過程
遞歸邏輯為：
當(dāng)字符長(zhǎng)度等于1時(shí)，直接返回
否則，調(diào)換首尾兩個(gè)字符，在遞歸地倒置字符數(shù)組的剩下部分
輸入格式
字符數(shù)組長(zhǎng)度及該數(shù)組
輸出格式
在求解過程中，打印字符數(shù)組的變化情況。
最后空一行，在程序結(jié)尾處打印倒置后該數(shù)組的各個(gè)元素。
樣例輸入
Sample 1
5 abcde
Sample 2
1 a
樣例輸出
Sample 1
ebcda
edcba
edcba
Sample 2
a
有一點(diǎn)需要注意
字符串是不可變的，要想改變，需要把它強(qiáng)轉(zhuǎn)為列表
再者，提醒一下
這個(gè)符號(hào) // 是取商，這個(gè)符號(hào) % 是求余
還有python中獨(dú)有的二變量交換
a, b = b, a
n, s = input().split()
n = int(n)
s = list(s)
i = 0
while i < n // 2:
s[i], s[n - i - 1] = s[n - i - 1], s[i]
print(''.join(s))
i += 1
print('\n'+''.join(s))
3.10 字符串跳步
資源限制
時(shí)間限制：1.0s 內(nèi)存限制：256.0MB
問題描述
給定一個(gè)字符串，你需要從第start位開始每隔step位輸出字符串對(duì)應(yīng)位置上的字符。
輸入格式
第一行一個(gè)只包含小寫字母的字符串。
第二行兩個(gè)非負(fù)整數(shù)start和step，意義見上。
輸出格式
一行，表示對(duì)應(yīng)輸出。
樣例輸入
abcdefg
2 2
樣例輸出
ceg
數(shù)據(jù)規(guī)模和約定
start從0開始計(jì)數(shù)。
字符串長(zhǎng)度不超過100000。
python如此簡(jiǎn)單
s = input()
start, step = map(int, input().split())
print(s[start: : step])
3.11 最長(zhǎng)字符序列（同LCS）
資源限制
時(shí)間限制：1.0s 內(nèi)存限制：256.0MB
最長(zhǎng)字符序列
問題描述
設(shè)x(i), y(i), z(i)表示單個(gè)字符，則X={x(1)x(2)……x(m)}，Y={y(1)y(2)……y(n)}，Z={z(1)z(2)……z(k)},我們稱其為字符序列，其中m,n和k分別是字符序列X，Y，Z的長(zhǎng)度，括號(hào)()中的數(shù)字被稱作字符序列的下標(biāo)。
如果存在一個(gè)嚴(yán)格遞增而且長(zhǎng)度大于0的下標(biāo)序列{i1,i2……ik}，使得對(duì)所有的j=1,2,……k，有x(ij)=z(j)，那么我們稱Z是X的字符子序列。而且，如果Z既是X的字符子序列又是Y的字符子序列，那么我們稱Z為X和Y的公共字符序列。
在我們今天的問題中，我們希望計(jì)算兩個(gè)給定字符序列X和Y的最大長(zhǎng)度的公共字符序列，這里我們只要求輸出這個(gè)最大長(zhǎng)度公共子序列對(duì)應(yīng)的長(zhǎng)度值。
舉例來說，字符序列X=abcd，Y=acde，那么它們的最大長(zhǎng)度為3，相應(yīng)的公共字符序列為acd。
輸入格式
輸入一行，用空格隔開的兩個(gè)字符串
輸出格式
輸出這兩個(gè)字符序列對(duì)應(yīng)的最大長(zhǎng)度公共字符序列的長(zhǎng)度值
樣例輸入
aAbB aabb
樣例輸出
2
數(shù)據(jù)規(guī)模和約定
輸入字符串長(zhǎng)度最長(zhǎng)為100，區(qū)分大小寫。
def lcs(str_a, str_b):
len_a = len(a)
len_b = len(b)
arr = [[0 for _ in range(len_b + 1)] for _ in range(len_a + 1)]
for i in range(len_a + 1):
for j in range(len_b + 1):
if i == 0 or j == 0:
arr[i][j] = 0
elif i > 0 and j > 0 and str_a[i - 1] == str_b[j - 1]:
arr[i][j] = arr[i - 1][j - 1] + 1
else:
arr[i][j] = max(arr[i][j - 1], arr[i - 1][j])
return arr[len_a][len_b]
a, b = input().split()
print(lcs(a, b))
3.12 隊(duì)列操作
問題描述
隊(duì)列操作題。根據(jù)輸入的操作命令，操作隊(duì)列（1）入隊(duì)、（2）出隊(duì)并輸出、（3）計(jì)算隊(duì)中元素個(gè)數(shù)并輸出。
輸入格式
第一行一個(gè)數(shù)字N。
下面N行，每行第一個(gè)數(shù)字為操作命令（1）入隊(duì)、（2）出隊(duì)并輸出、（3）計(jì)算隊(duì)中元素個(gè)數(shù)并輸出。
輸出格式
若干行每行顯示一個(gè)2或3命令的輸出結(jié)果。注意：2.出隊(duì)命令可能會(huì)出現(xiàn)空隊(duì)出隊(duì)（下溢），請(qǐng)輸出“no”，并退出。
樣例輸入
7
1 19
1 56
2
3
2
3
2
樣例輸出
19
1
56
0
no
數(shù)據(jù)規(guī)模和約定
1<=N<=50
N = int(input())
queue = []
for _ in range(N):
command = list(map(int, input().split()))
if command[0] == 1:
queue.append(command[1])
elif command[0] == 2:
if len(queue) == 0:
print('no')
else:
print(queue[0])
queue.pop(0)
else:
print(len(queue))
3.13 字符串操作
問題描述
給出一個(gè)字符串和多行文字，在這些文字中找到字符串出現(xiàn)的那些行。你的程序還需支持大小寫敏感選項(xiàng)：當(dāng)選項(xiàng)打開時(shí)，表示同一個(gè)字母的大寫和小寫看作不同的字符；當(dāng)選項(xiàng)關(guān)閉時(shí)，表示同一個(gè)字母的大寫和小寫看作相同的字符。
輸入格式
輸入的第一行包含一個(gè)字符串S，由大小寫英文字母組成。
第二行包含一個(gè)數(shù)字，表示大小寫敏感的選項(xiàng)，當(dāng)數(shù)字為0時(shí)表示大小寫不敏感，當(dāng)數(shù)字為1時(shí)表示大小寫敏感。
第三行包含一個(gè)整數(shù)n，表示給出的文字的行數(shù)。
接下來n行，每行包含一個(gè)字符串，字符串由大小寫英文字母組成，不含空格和其他字符。
輸出格式
輸出多行，每行包含一個(gè)字符串，按出現(xiàn)的順序依次給出那些包含了字符串S的行。
樣例輸入
Hello
1
5
HelloWorld
HiHiHelloHiHi
GrepIsAGreatTool
HELLO
HELLOisNOTHello
樣例輸出
HelloWorld
HiHiHelloHiHi
HELLOisNOTHello
樣例說明
在上面的樣例中，第四個(gè)字符串雖然也是Hello，但是大小寫不正確。如果將輸入的第二行改為0，則第四個(gè)字符串應(yīng)該輸出。
評(píng)測(cè)用例規(guī)模與約定
1<=n<=100，每個(gè)字符串的長(zhǎng)度不超過100。
S = input()
alpha_switch = int(input())
n = int(input())
for _ in range(n):
s_ = input()
if alpha_switch == 1:
if S in s_:
print(s_)
else:
if S.upper() in s_.upper():
print(s_)
字符串大小寫轉(zhuǎn)換函數(shù)
字符串的find()、index()、rfind()、rindex()
參考地址
3.14 金陵十三釵
問題描述
在電影《金陵十三釵》中有十二個(gè)秦淮河的女人要自我犧牲代替十二個(gè)女學(xué)生去赴日本人的死亡宴會(huì)。為了不讓日本人發(fā)現(xiàn)，自然需要一番喬裝打扮。但由于天生材質(zhì)的原因，每個(gè)人和每個(gè)人之間的相似度是不同的。由于我們這是編程題，因此情況就變成了金陵n釵。給出n個(gè)女人和n個(gè)學(xué)生的相似度矩陣，求她們之間的匹配所能獲得的最大相似度。
所謂相似度矩陣是一個(gè)n*n的二維數(shù)組like[i][j]。其中i,j分別為女人的編號(hào)和學(xué)生的編號(hào)，皆從0到n-1編號(hào)。like[i][j]是一個(gè)0到100的整數(shù)值，表示第i個(gè)女人和第j個(gè)學(xué)生的相似度，值越大相似度越大，比如0表示完全不相似，100表示百分之百一樣。每個(gè)女人都需要找一個(gè)自己代替的女學(xué)生。
最終要使兩邊一一配對(duì)，形成一個(gè)匹配。請(qǐng)編程找到一種匹配方案，使各對(duì)女人和女學(xué)生之間的相似度之和最大。
輸入格式
第一行一個(gè)正整數(shù)n表示有n個(gè)秦淮河女人和n個(gè)女學(xué)生
接下來n行給出相似度，每行n個(gè)0到100的整數(shù)，依次對(duì)應(yīng)二維矩陣的n行n列。
輸出格式
僅一行，一個(gè)整數(shù)，表示可獲得的最大相似度。
樣例輸入
4
97 91 68 14
8 33 27 92
36 32 98 53
73 7 17 82
樣例輸出
354
數(shù)據(jù)規(guī)模和約定
對(duì)于70%的數(shù)據(jù)，n<=10
對(duì)于100%的數(shù)據(jù)，n<=13
樣例說明
最大相似度為91+92+98+73=354
n皇后弱化版
def queen(cur=0):
global sum1, n
if cur == n: # 所有的皇后都正確放置完畢，輸出每個(gè)皇后所在的位置
sum2 = 0
for i in range(n):
sum2 += a[i][b[i]]
if sum2 > sum1:
sum1 = sum2
return 0
for i in range(n):
flag = True
for j in range(cur): # 檢測(cè)本次所放的位置是否在同行同列
if b[j] == i: # 是的話，該位置不能放，向上回溯
flag = False
break
if flag: # 否的話，繼續(xù)放下一個(gè)
b[cur] = i
queen(cur+1)
n = int(input())
sum1 = 0
a = [list(map(int, input().split())) for _ in range(n)]
b = [0 for _ in range(n)]
queen()
print(sum1)
4.真題篇
待更新…
4.1不同子串
題目描述
一個(gè)字符串的非空子串是指字符串中長(zhǎng)度至少為 1 的連續(xù)的一段字符組成 的串。例如，字符串a(chǎn)aab 有非空子串a(chǎn), b, aa, ab, aaa, aab, aaab，一共 7 個(gè)。 注意在計(jì)算時(shí)，只算本質(zhì)不同的串的個(gè)數(shù)。
請(qǐng)問，字符串0100110001010001 有多少個(gè)不同的非空子串？
【答案提交】
這是一道結(jié)果填空的題，你只需要算出結(jié)果后提交即可。本題的結(jié)果為一 個(gè)整數(shù)，在提交答案時(shí)只填寫這個(gè)整數(shù)，填寫多余的內(nèi)容將無法得分。
這道題不難，大家都是能想到的應(yīng)該。話不多說，直接上代碼。
var = '0100110001010001' # var = 'aaab' 運(yùn)行結(jié)果為7 表示算法正確
num = 1 # 自身也是1個(gè)，循環(huán)中沒有去考慮他串本身，所以這里基數(shù)直接設(shè)置為1
sep = 1
var_n = []
while sep < len(var):
var_n.append(var[0:sep])
for i in range(len(var)-sep): # 以sep為間隔依次向前推進(jìn)，sep每輪循環(huán)增1
if var[i+1:i+sep+1] in var_n:
continue
else:
var_n.append(var[i+1:i+sep+1])
sep += 1
num += len(var_n)
# print(var_n)
var_n = []
print(num)
運(yùn)行結(jié)果
直接提交100就可以了。
4.2 年號(hào)字串
小明用字母A 對(duì)應(yīng)數(shù)字1，B 對(duì)應(yīng)2，以此類推，用Z 對(duì)應(yīng)26。對(duì)于27
以上的數(shù)字，小明用兩位或更長(zhǎng)位的字符串來對(duì)應(yīng)，例如AA 對(duì)應(yīng)27，AB 對(duì)
應(yīng)28，AZ 對(duì)應(yīng)52，LQ 對(duì)應(yīng)329。
請(qǐng)問2019 對(duì)應(yīng)的字符串是什么？
實(shí)際上即為進(jìn)制轉(zhuǎn)換
"""
類似于進(jìn)制轉(zhuǎn)換，只是多了一步，把對(duì)應(yīng)的字母換上
A~Z代表1~26，每26進(jìn)1，27即為AA
17 77 Q
25 2 Y
2 0 B
BYQ
17 + 25 * 26 + 2 * 26 * 26 = 2019
"""
string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ans = [0 for _ in range(5)]
index = 0
n = 2019
while n != 0:
t = n % 26
n = int(n / 26)
ans[index] = string[t - 1]
# print(t, n, ans[index])
index += 1
for i in range(index - 1, -1, -1):
print(ans[i], end='')
直接提交BYQ就可以啦。
4.3 數(shù)列求值
【問題描述】
給定數(shù)列 1, 1, 1, 3, 5, 9, 17, …，從第 4 項(xiàng)開始，每項(xiàng)都是前 3 項(xiàng)的和。求第 20190324 項(xiàng)的最后 4 位數(shù)字。
【答案提交】
這是一道結(jié)果填空的題，你只需要算出結(jié)果后提交即可。本題的結(jié)果為一個(gè) 4 位整數(shù)（提示：答案的千位不為 0），在提交答案時(shí)只填寫這個(gè)整數(shù)，填寫多余的內(nèi)容將無法得分。
只求后四位就可以啦
arr = [0 for _ in range(20190325)]
arr[0] = arr[1] = arr[2] = 1
for i in range(3, 20190324):
arr[i] = (arr[i - 1] + arr[i - 2] + arr[i - 3]) % 10000
print(arr[20190323])
答案：4659
4.4 數(shù)的分解
【問題描述】
把 2019 分解成 3 個(gè)各不相同的正整數(shù)之和，并且要求每個(gè)正整數(shù)都不包含數(shù)字 2 和 4，一共有多少種不同的分解方法？
注意交換 3 個(gè)整數(shù)的順序被視為同一種方法，例如 1000+1001+18 和 1001+1000+18 被視為同一種。
【答案提交】
這是一道結(jié)果填空的題，你只需要算出結(jié)果后提交即可。本題的結(jié)果為一 個(gè)整數(shù)，在提交答案時(shí)只填寫這個(gè)整數(shù)，填寫多余的內(nèi)容將無法得分。
count = 0
def check(x):
while x != 0:
t = x % 10
x = int(x / 10)
if t == 2 or t == 4:
return False
return True
for i in range(1, 2019):
if check(i):
for j in range(i + 1, 2019):
if check(j):
k = 2019 - i - j
if k > j and check(k):
count += 1
print(i, j, k)
print(count)
答案：40785
4.5 迷宮
數(shù)據(jù)
01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000
其他語言都為廣度搜索，此方法類似，用隊(duì)列來操作節(jié)點(diǎn)
此題為藍(lán)橋練習(xí)系統(tǒng)的一道原題（非常類似，答案完全可以拿來直接用）：學(xué)霸的迷宮
class Node(object): # 節(jié)點(diǎn)類
def __init__(self, x, y, w): # 添加類變量
self.x = x
self.y = y
self.w = w
def __str__(self): # 類方法，調(diào)用此方法時(shí)返回w的內(nèi)容
return self.w
def up(node):
return Node(node.x - 1, node.y, node.w+"U") # 向上的情況
def down(node):
return Node(node.x + 1, node.y, node.w+"D") # 向下的情況
def left(node):
return Node(node.x, node.y - 1, node.w+"L") # 向左的情況
def right(node):
return Node(node.x, node.y + 1, node.w+"R") # 向右的情況
if __name__ == '__main__':
m, n = map(int, input().split())
visited = set() # 存儲(chǔ)訪問過的節(jié)點(diǎn)
queue = [] # 首先建一個(gè)空隊(duì)列用來存儲(chǔ)訪問的節(jié)點(diǎn)
map_int = [[0] * (n + 1)] # 第一行全置0
for i in range(1, m+1):
map_int.append([0]*(n+1))
nums = input() # 輸入數(shù)據(jù)
nums = "0" + nums # 第一列全置0
for j in range(0, n+1):
map_int[i][j] = ord(nums[j]) - 48 # 把字符‘1’、‘0’轉(zhuǎn)為數(shù)字
# print(map_int)
# exit()
node = Node(1, 1, "") # 開始位置節(jié)點(diǎn)
queue.append(node) # 放入隊(duì)列
while len(queue) != 0: # 隊(duì)不空時(shí)循環(huán)
moveNode = queue[0] # 移動(dòng)節(jié)點(diǎn)
queue.pop(0) # 移動(dòng)節(jié)點(diǎn)出隊(duì)列
moveStr = str(moveNode.x) + " "+ str(moveNode.y) # 移動(dòng)節(jié)點(diǎn)位置
if moveStr not in visited: # 移動(dòng)節(jié)點(diǎn)若未訪問
visited.add(moveStr) # 放入已訪問節(jié)點(diǎn)列表
if moveNode.x == m and moveNode.y == n: # 到達(dá)最后位置時(shí)停止循環(huán)
print(len(moveNode.__str__())) # 輸出步數(shù)，即長(zhǎng)度
print(moveNode) # 輸出路徑
break
if moveNode.x < m:
if map_int[moveNode.x + 1][moveNode.y] == 0: # 向下的情況
queue.append(down(moveNode))
if moveNode.y > 1:
if map_int[moveNode.x][moveNode.y - 1] == 0: # 向左的情況
queue.append(left(moveNode))
if moveNode.y < n:
if map_int[moveNode.x][moveNode.y + 1] == 0: # 向右的情況
queue.append(right(moveNode))
if moveNode.x > 1:
if map_int[moveNode.x - 1][moveNode.y] == 0: # 向上的情況
queue.append(up(moveNode))
參考答案：
DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR
共186步
4.6 特別數(shù)的和
此題數(shù)據(jù)規(guī)模不大，直接暴力搜索解決就可以，較為簡(jiǎn)單
n = int(input())
s = 0
for i in range(1, n + 1):
a = i
while a != 0:
temp = a % 10
a = int(a / 10)
if temp in [2, 0, 1, 9]:
s += i
falg = True
break
print(s)
4.7 完全二叉樹的和
解題思路：
完全二叉樹每一行的最后一個(gè)數(shù)的下標(biāo)都是等于(2^n)-1
用deep表示當(dāng)前深度，從當(dāng)前這行的第一項(xiàng)加到最后一項(xiàng)然后和最大值max_sum比較。
n = int(input())
data = list(map(int, input().split()))
deep = flag_deep = 1
max_sum = 0
while 2 ** deep - 1 <= n:
data_sum = sum(data[2 ** (deep - 1) - 1:(2 ** deep)])
if max_sum < data_sum:
max_sum = data_sum
flag_deep = deep
deep += 1
print(flag_deep)
# 一組測(cè)試數(shù)據(jù)
# 15
# 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
# 4
4.8 等差數(shù)列
解題思路：
先排序，然后找出等差數(shù)列的差值（各相鄰數(shù)差值最小的），之后從所給數(shù)組的最小到最大開始循環(huán)，步長(zhǎng)為所求的差值diff，利用count來計(jì)數(shù)
n = int(input())
data = list(map(int, input().split()))
count = 0
data.sort()
diff = float('inf') # float('inf') 為無窮大，float('-inf') 為無窮小
for i in range(1, n):
now_diff = data[i] - data[i - 1]
if now_diff < diff:
diff = now_diff
for i in range(data[0], data[-1], diff):
count += 1
print(count + 1)
4.9 換鈔票
x星球的鈔票的面額只有：100元，5元，2元，1元，共4種。
小明去x星旅游，他手里只有2張100元的x星幣，太不方便，恰好路過x星銀行就去換零錢。
小明有點(diǎn)強(qiáng)迫癥，他堅(jiān)持要求200元換出的零鈔中2元的張數(shù)剛好是1元的張數(shù)的10倍，
剩下的當(dāng)然都是5元面額的。
銀行的工作人員有點(diǎn)為難，你能幫助算出：在滿足小明要求的前提下，最少要換給他多少?gòu)堚n票嗎？
（5元，2元，1元面額的必須都有，不能是0）
注意，需要提交的是一個(gè)整數(shù)，不要填寫任何多余的內(nèi)容。
for one in range(1,10):
five = 0
two = one * 10
money = 200 - two * 2 - one
if money % 5 == 0:
five = money / 5
count = one + two + five
print(one, two, five, count)
因?yàn)閿?shù)目較小，很簡(jiǎn)單。這里代碼直接列出了所有情況，運(yùn)行結(jié)果如下：
排除5元張數(shù)為0的情況就只剩下一種啦。
且結(jié)果為整數(shù)，則為74.
4.10 調(diào)手表
小明買了塊高端大氣上檔次的電子手表，他正準(zhǔn)備調(diào)時(shí)間呢。
在 M78 星云，時(shí)間的計(jì)量單位和地球上不同，M78 星云的一個(gè)小時(shí)有 n 分鐘。
大家都知道，手表只有一個(gè)按鈕可以把當(dāng)前的數(shù)加一。在調(diào)分鐘的時(shí)候，如果當(dāng)前顯示的數(shù)是 0 ，那么按一下按鈕就會(huì)變成 1，再按一次變成 2 。如果當(dāng)前的數(shù)是 n - 1，按一次后會(huì)變成 0 。
作為強(qiáng)迫癥患者，小明一定要把手表的時(shí)間調(diào)對(duì)。如果手表上的時(shí)間比當(dāng)前時(shí)間多1，則要按 n - 1 次加一按鈕才能調(diào)回正確時(shí)間。
小明想，如果手表可以再添加一個(gè)按鈕，表示把當(dāng)前的數(shù)加 k 該多好啊……
他想知道，如果有了這個(gè) +k 按鈕，按照最優(yōu)策略按鍵，從任意一個(gè)分鐘數(shù)調(diào)到另外任意一個(gè)分鐘數(shù)最多要按多少次。
注意，按 +k 按鈕時(shí)，如果加k后數(shù)字超過n-1,則會(huì)對(duì)n取模。
比如，n=10, k=6 的時(shí)候，假設(shè)當(dāng)前時(shí)間是0，連按2次 +k 按鈕，則調(diào)為2。
「輸入格式」
一行兩個(gè)整數(shù) n, k ，意義如題。
「輸出格式」
一行一個(gè)整數(shù)
表示：按照最優(yōu)策略按鍵，從一個(gè)時(shí)間調(diào)到另一個(gè)時(shí)間最多要按多少次。
「樣例輸入」
5 3
「樣例輸出」
2
「樣例解釋」
如果時(shí)間正確則按0次。否則要按的次數(shù)和操作系列之間的關(guān)系如下：
1：+1
2：+1, +1
3：+3
4：+3, +1
「數(shù)據(jù)范圍」
對(duì)于 30% 的數(shù)據(jù) 0 < k < n <= 5
對(duì)于 60% 的數(shù)據(jù) 0 < k < n <= 100
對(duì)于 100% 的數(shù)據(jù) 0 < k < n <= 100000
資源約定：
峰值內(nèi)存消耗（含虛擬機(jī)） < 256M
CPU消耗 < 1000ms
請(qǐng)嚴(yán)格按要求輸出，不要畫蛇添足地打印類似：“請(qǐng)您輸入…” 的多余內(nèi)容。
注意：
main函數(shù)需要返回0;
只使用ANSI C/ANSI C++ 標(biāo)準(zhǔn);
不要調(diào)用依賴于編譯環(huán)境或操作系統(tǒng)的特殊函數(shù)。
所有依賴的函數(shù)必須明確地在源文件中 #include
不能通過工程設(shè)置而省略常用頭文件。
提交程序時(shí)，注意選擇所期望的語言類型和編譯器類型。
記住要求：
按照最優(yōu)策略下的最多次數(shù)
開始我就困擾了，求成了最少次數(shù)
每次加1，遇到被整除的地方，原先的計(jì)數(shù)器置零，整除計(jì)數(shù)器加1
記錄每次整除后的數(shù)值，求出最大的哪個(gè)數(shù)就是
n, k = map(int, input().split())
ans = []
count = count_ =0
for i in range(1, n):
if i % k != 0:
count += 1
else:
count = 0
count_ += 1
ans.append(count + count_)
print(max(ans))
樣例中的 5 3
對(duì)應(yīng)的ans=[1, 2, 1, 2]
最大為2
比網(wǎng)上的其他df和bfs之類的要簡(jiǎn)單而且好理解的多
4.11 矩陣求和
經(jīng)過重重筆試面試的考驗(yàn)，小明成功進(jìn)入 Macrohard 公司工作。 今天小明的任務(wù)是填滿這么一張表： 表有 n 行 n 列，行和列的編號(hào)都從1算起。 其中第 i 行第 j 個(gè)元素的值是 gcd(i, j)的平方， gcd 表示最大公約數(shù)，以下是這個(gè)表的前四行的前四列： 1 1 1 1 1 4 1 4 1 1 9 1 1 4 1 16
小明突然冒出一個(gè)奇怪的想法，他想知道這張表中所有元素的和。 由于表過于龐大，他希望借助計(jì)算機(jī)的力量。
「輸入格式」 一行一個(gè)正整數(shù) n 意義見題。
「輸出格式」 一行一個(gè)數(shù)，表示所有元素的和。由于答案比較大，請(qǐng)輸出模 (10^9 + 7)(即：十億零七) 后的結(jié)果。
「樣例輸入」 4
「樣例輸出」 48
「數(shù)據(jù)范圍」 對(duì)于 30% 的數(shù)據(jù)，n <= 1000 存在 10% 的數(shù)據(jù)，n = 10^5 對(duì)于 60% 的數(shù)據(jù)，n <= 10^6 對(duì)于 100% 的數(shù)據(jù)，n <= 10^7
暴力求解是大家都會(huì)想到的，但是肯定會(huì)超時(shí)
這個(gè)題滿分的話要用到數(shù)論的知識(shí)：歐拉函數(shù)+莫比烏斯反演。
暴力代碼
def gcd(i, j):
while j !=0:
k = i % j
i = j
j = k
return i
n = int(input())
sum_arr = 0
mod = 10 ** 9 + 7
for i in range(n):
for j in range(n):
t = gcd(i, j) ** 2
sum_arr += t % mod
print(sum_arr)
能得到一部分分?jǐn)?shù)，考試時(shí)不會(huì)可以拿到一定的分?jǐn)?shù)。
歐拉函數(shù)
莫比烏斯反演
大家可以研究一下
下面給出代碼
MOD = 10 ** 9 + 7
phi = []
sum_ = []
ans = 0
def euler_table(n):
for _ in range(n + 1):
phi.append(0)
sum_.append(0)
phi[1] = 1
for i in range(2, n + 1):
if phi[i] == 0:
j = i
while j <= n:
if phi[j] == 0:
phi[j] = j
phi[j] = int(phi[j] / i) * (i - 1)
j += i
sum_[1] = 1
for i in range(2, n + 1):
sum_[i] = sum_[i - 1] + phi[i] * 2
n = int(input())
euler_table(n)
for i in range(1, n + 1):
ans = (ans + sum_[int(n / i)] * i % MOD * i % MOD) % MOD
print(ans)
4.12 分?jǐn)?shù)
標(biāo)題：分?jǐn)?shù)
1/1 + 1/2 + 1/4 + 1/8 + 1/16 + …
每項(xiàng)是前一項(xiàng)的一半，如果一共有20項(xiàng),
求這個(gè)和是多少，結(jié)果用分?jǐn)?shù)表示出來。
類似：
3/2
當(dāng)然，這只是加了前2項(xiàng)而已。分子分母要求互質(zhì)。
注意：
需要提交的是已經(jīng)約分過的分?jǐn)?shù)，中間任何位置不能含有空格。
請(qǐng)不要填寫任何多余的文字或符號(hào)
求出分母，分子為2^19
用gcd函數(shù)通分
def gcd(a, b):
while b != 0:
c = a % b
a = b
b = c
return a
molecule = 0
for i in range(20):
molecule += 2 ** i
gc = gcd(molecule, 2 ** 19)
print(molecule // gc,'/',2 ** 19 // gc, sep='')
4.13 購(gòu)物單
標(biāo)題： 購(gòu)物單
小明剛剛找到工作，老板人很好，只是老板夫人很愛購(gòu)物。老板忙的時(shí)候經(jīng)常讓小明幫忙到商場(chǎng)代為購(gòu)物。小明很厭煩，但又不好推辭。
這不，XX大促銷又來了！老板夫人開出了長(zhǎng)長(zhǎng)的購(gòu)物單，都是有打折優(yōu)惠的。
小明也有個(gè)怪癖，不到萬不得已，從不刷卡，直接現(xiàn)金搞定。
現(xiàn)在小明很心煩，請(qǐng)你幫他計(jì)算一下，需要從取款機(jī)上取多少現(xiàn)金，才能搞定這次購(gòu)物。
取款機(jī)只能提供100元面額的紙幣。小明想盡可能少取些現(xiàn)金，夠用就行了。
你的任務(wù)是計(jì)算出，小明最少需要取多少現(xiàn)金。
以下是讓人頭疼的購(gòu)物單，為了保護(hù)隱私，``物品名稱被隱藏了。
**** 180.90 88折
**** 10.25 65折
**** 56.14 9折
**** 104.65 9折
**** 100.30 88折
**** 297.15 半價(jià)
**** 26.75 65折
**** 130.62 半價(jià)
**** 240.28 58折
**** 270.62 8折
**** 115.87 88折
**** 247.34 95折
**** 73.21 9折
**** 101.00 半價(jià)
**** 79.54 半價(jià)
**** 278.44 7折
**** 199.26 半價(jià)
**** 12.97 9折
**** 166.30 78折
**** 125.50 58折
**** 84.98 9折
**** 113.35 68折
**** 166.57 半價(jià)
**** 42.56 9折
**** 81.90 95折
**** 131.78 8折
**** 255.89 78折
**** 109.17 9折
**** 146.69 68折
**** 139.33 65折
**** 141.16 78折
**** 154.74 8折
**** 59.42 8折
**** 85.44 68折
**** 293.70 88折
**** 261.79 65折
**** 11.30 88折
**** 268.27 58折
**** 128.29 88折
**** 251.03 8折
**** 208.39 75折
**** 128.88 75折
**** 62.06 9折
**** 225.87 75折
**** 12.89 75折
**** 34.28 75折
**** 62.16 58折
**** 129.12 半價(jià)
**** 218.37 半價(jià)
**** 289.69 8折
需要說明的是，88折指的是按標(biāo)價(jià)的88%計(jì)算，而8折是按80%計(jì)算，余者類推。
特別地，半價(jià)是按50%計(jì)算。
請(qǐng)?zhí)峤恍∶饕獜娜】顧C(jī)上提取的金額，單位是元。
答案是一個(gè)整數(shù)，類似4300的樣子，結(jié)尾必然是00，不要填寫任何多余的內(nèi)容。
特別提醒：不許攜帶計(jì)算器入場(chǎng)，也不能打開手機(jī)。
首先在把數(shù)據(jù)復(fù)制到記事本中
其次用Ctrl+H鍵替換
把****用空格替換
把7折、8折、9折替換為70、80、90
半價(jià)替換為50
其余折用空格替換
預(yù)處理后數(shù)據(jù)為
180.90 88
10.25 65
56.14 90
104.65 90
100.30 88
297.15 50
26.75 65
130.62 50
240.28 58
270.62 80
115.87 88
247.34 95
73.21 90
101.00 50
79.54 50
278.44 70
199.26 50
12.97 90
166.30 78
125.50 58
84.98 90
113.35 68
166.57 50
42.56 90
81.90 95
131.78 80
255.89 78
109.17 90
146.69 68
139.33 65
141.16 78
154.74 80
59.42 80
85.44 68
293.70 88
261.79 65
11.30 88
268.27 58
128.29 88
251.03 80
208.39 75
128.88 75
62.06 90
225.87 75
12.89 75
34.28 75
62.16 58
129.12 50
218.37 50
289.69 80
然后用代碼計(jì)算就可以了
def result(s):
return (float(s[0]) * float(s[1])) / 100
file = open('data.txt', 'r')
ans = 0
for line in file.readlines():
s = line.split()
ans += result(s)
file.close()
print(ans)
運(yùn)行后結(jié)果
5136.859500000001
所以最終答案為5200
4.14 等差素?cái)?shù)列
2,3,5,7,11,13,…是素?cái)?shù)序列。
類似：7,37,67,97,127,157 這樣完全由素?cái)?shù)組成的等差數(shù)列，叫等差素?cái)?shù)數(shù)列。
上邊的數(shù)列公差為30，長(zhǎng)度為6。
2004年，格林與華人陶哲軒合作證明了：存在任意長(zhǎng)度的素?cái)?shù)等差數(shù)列。
這是數(shù)論領(lǐng)域一項(xiàng)驚人的成果！
有這一理論為基礎(chǔ)，請(qǐng)你借助手中的計(jì)算機(jī)，滿懷信心地搜索：
長(zhǎng)度為10的等差素?cái)?shù)列，其公差最小值是多少？
注意：需要提交的是一個(gè)整數(shù)，不要填寫任何多余的內(nèi)容和說明文字。
解釋注釋部分
def init_num():
global tot
for i in range(2, N):
if dp[i] == 1:
continue
prim[tot] = i # 記錄N以內(nèi)的所有素?cái)?shù)
tot += 1
j = i
while i * j < N:
dp[i * j] = 1 # 不是素?cái)?shù)的位置標(biāo)記1
j += 1
N = 1000010 # N的大小自己可以估計(jì)一下 想想也應(yīng)該挺大的 多試幾次
dp = [1, 1] + [ 0] * N
tot = 0
dif = 1
prim = [0] * N
init_num()
# print(dp[:100])
# print(prim[:100])
print(tot)
while dif * 10 < N:
for j in range(tot):
flag, temp = True, prim[j]
for k in range(1, 10): # temp后邊是否再有9個(gè)滿足等差條件的素?cái)?shù)
if temp + dif >= N or dp[temp + dif] == 1:
flag = False
break
else:
temp += dif
if flag == True:
print(dif, prim[j])
exit()
dif += 1
運(yùn)行結(jié)果
78499
210 199
解釋：
N以內(nèi)一共78499個(gè)素?cái)?shù)
dif為210
起點(diǎn)199
十個(gè)數(shù)為：
dif_arr = [199]
dif = 210
for i in range(9):
dif_arr.append(dif_arr[-1] + dif)
print(dif_arr)
[199, 409, 619, 829, 1039, 1249, 1459, 1669, 1879, 2089]
4.15 承壓計(jì)算
X星球的高科技實(shí)驗(yàn)室中整齊地堆放著某批珍貴金屬原料。
每塊金屬原料的外形、尺寸完全一致，但重量不同。
金屬材料被嚴(yán)格地堆放成金字塔形。
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
其中的數(shù)字代表金屬塊的重量（計(jì)量單位較大）。
最下一層的X代表30臺(tái)極高精度的電子秤。
假設(shè)每塊原料的重量都十分精確地平均落在下方的兩個(gè)金屬塊上，
最后，所有的金屬塊的重量都嚴(yán)格精確地平分落在最底層的電子秤上。
電子秤的計(jì)量單位很小，所以顯示的數(shù)字很大。
工作人員發(fā)現(xiàn)，其中讀數(shù)最小的電子秤的示數(shù)為：2086458231
請(qǐng)你推算出：讀數(shù)最大的電子秤的示數(shù)為多少？
注意：需要提交的是一個(gè)整數(shù)，不要填寫任何多余的內(nèi)容。
把數(shù)據(jù)存到二維表里進(jìn)行計(jì)算
arr = [[0] * 30 for _ in range(30)]
k = 0
file = open('data.txt', 'r')
for line in file.readlines():
new_line = line.split()
for i in range(len(new_line)):
arr[k][i] = int(new_line[i])
k += 1
for i in range(1, 30):
for j in range(29):
arr[i][j] += arr[i - 1][j] / 2
arr[i][j + 1] += arr[i - 1][j] / 2
# print(min(arr[29]), max(arr[29]))
print(2086458231 / min(arr[29]) * max(arr[29]))
72665192664.0
總結(jié)
以上是生活随笔為你收集整理的3位水仙花数计算pythonoj_Python解答蓝桥杯省赛真题之从入门到真题的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 不连续曲线 highcharts_什么是
- 下一篇： websocket python爬虫_p