類型：函數
描述
寫一個函數isPrime(n)用於判斷一個數字n是不是素數，用戶輸入一個正整數，在一行內輸出不大於該數的所有素數，各數後面用一個空格分隔。
輸入格式
輸入一個正整數
輸出格式
不大於該數的所有素數，各數後面用一個空格分隔。
示例
輸入：100
輸出：2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
標准答案
def isPrime(n): #判斷素數的函數
if n < 2:
return False #0和1不是素數
for i in range(2, n):
if n % i == 0:
return False
break
else:
return True
num = int(input()) #接收用戶輸入並轉成整數
for i in range(num):
if isPrime(i):
print(i,end=' ') #在同一行內輸出結果，不換行，中間用空格分隔
類型：函數
描述
設計一個用二分法計算一個大於或等於 1 的實數 n 的平方根的函數sqrt_binary(n)，計算精度控制在計算結果的平方與輸入的誤差不大於1e-6。
注：初始區間取[0,n]
輸入格式
輸入一個實數 n（大於或等於1）
輸出格式
第一行輸出用自己設計的函數計算得到的平方根
第二行輸出用math庫開平方函數計算得到的平方根
示例
輸入：5.0
輸出：
2.2360679507255554
2.23606797749979
標准答案
import math
def sqrt_binary(num):
low, high= 0,num
while True:
x = (high + low)/2
if abs(x**2 - num)<=1e-6:
return x
elif x**2 - num<0:
low = x
else:
high = x
num = float(input())
if num >=0:
print(sqrt_binary(num))
print(math.sqrt(num))
else:
print('請輸入一個非負數！')
類型：函數
描述
設計一個用二分法計算一個大於或等於 0 的實數 n 的平方根的函數sqrt_binary(n)，實數 n和計算精度控制由用戶在同一行內輸入，用逗號進行分隔，輸出結果保留8位小數。當(abs(x * x - n) )小於或等於設定的精度時，近似認為 x * x == n。
注：初始區間取[0,n+0.25]
輸入格式
在同 行內輸入一個實數 n（大於或等於0）和一個代表精度的數字（可用1e-m格式輸入），逗號間隔
輸出格式
第一行輸出用自己設計的函數計算得到的平方根
第二行輸出用math庫開平方函數計算得到的平方根
示例
輸入：5.0,1e-7
輸出：
2.23606796
2.23606798
標准答案
import math
def sqrt_binary(num, accuracy):
"""接收一個浮點數num和一個表示計算精度的浮點數accuracy為參數，用二分法計算浮點數的平方根x，
當 abs(x * x - num) <= accuracy時認為達到計算精度，以浮點數類型返回計算得到的平方根。"""
low, high = 0, num + 0.25 # 設定初始區間
while True: # 構建無限循環
x = (high + low) / 2 # 假設平方根落在區間的二分之一處，即中點
if abs(x * x - num) <= accuracy: # 當誤差小於計算精度時，終止循環
return x # 返回當前的x值為平方根
elif x * x - num < 0: # 當前x的平方小於num時，平方根應該位於右側區間
low = x # 以當前數值為區間下限，縮小區間為原來的一半
else: # 當前x的平方大於num時，平方根應該位於左側區間
high = x # 以當前數值為區間上限，縮小區間為原來的一半
n, error = map(float, input().split(',')) # 輸入浮點數 n 和計算精度
print('{:.8f}'.format(sqrt_binary(n, error))) # 調用二分法函數計算平方根
print('{:.8f}'.format(math.sqrt(n))) # 用math庫中的sqrt()計算平方根
類型：函數
描述
我的微信ID是大寫字母WHUT後面的數字是兩個素數連在一起，大的在前，小的在後，如果我告訴你兩數的乘積是多少，你能計算出我的ID號嗎？
如果輸入一個[0-9]之間的數字，你能統計出從1開始到我ID中的數字的序列裡，一共出現多少次這個數字嗎？
輸入格式
第一行輸入ID中兩個素數的乘積
第二行輸入一個[0-9]之間的數字
輸出格式
第一行輸出ID號
第二行輸出數字的次數
輸入輸出示例
示例
輸入：
196409
3
輸出：
WHUT997197
599140
標准答案
def isPrime(n): # 判斷參數 n 是否為素數的函數
if n < 2: # 小於2的數字都不是素數
return False
for i in range(2, int(n ** 0.5) + 1): # 根據素數定義判定是否是素數，是素數返回1
if n % i == 0: # 從 2到n-1中如果存在一個數是i，使n 可以整除i，則n不是素數
return False
else: # 若for循環未遇到return正常結束，則n是素數
return True
def checkId(n):
if n % 2 == 0 and isPrime(n // 2): # 如果n能被2整除，單獨處理，提高效率
return int(str(n // 2) + str(2))
else:
for num in range(3,n//2+1,2): # 如果n不能被2整除，則兩個素數不包括2，都是奇數
if isPrime(num) and n % num == 0 and isPrime(n // num): # isPrime(n // num)放在最後，利用短路效應，可以使大數的素數判定次數最少
return int(str(n // num) + str(num)) # 返回值轉字符串拼接後再轉整數
def countnumber(n,num):
m, countnum = 1, 0
while n//m > 0:
high, mod = divmod(n, m*10)
curNum, low = divmod(mod, m)
if curNum > num:
countnum += high*m + m
elif curNum == num:
countnum += high*m + low + 1
else:
countnum+= high*m
m = m*10
return countnum
if __name__ == '__main__':
n = int(input()) # 輸入ID,整數，保證是兩個素數的積
number = int(input()) # 輸入0-9之間的一個數字
ID = checkId(n)
countNumber = countnumber(ID,number) # 統計 number的個數
print('WHUT' + str(ID))
print(countNumber)
# def occ3(n,num):
# s = 0
# for i in range(len(str(n))):
# x = int(str(n)[-i-1])
# s += n//10**(i+1)*10**i
# if x == num:
# s += n%10**i+1
# if x > num:
# s += 10**i
# return s
# def isPrime(n): #判斷素數的函數
# if n < 2 or n % 2==0:
# return False #0、1、負數以及偶數都不是素數
# for i in range(3, int(n**0.5)+1,2):
# if n % i == 0: #能被2到其自身減1的數整除的數不是素數
# return False
# else:
# return True #for循環正常結束，未遇到return的數是素數
# n = int(input()) #接收用戶輸入並轉成整數707829217
# number = int(input())
# for i in range(n):
# if isPrime(i) and n%i==0 and isPrime(n//i): #判斷i和N-i是否同時是素數，同時保證兩個數加和為N
# print("WHUT{}{}".format(n//i,i))
# break #找到一個符合條件的數就結束循環
# m = int(str(n//i)+str(i))
# print(occ3(m,number))
# print(three(m,number))
# m = int(str(n//i)+str(i))
# num=0
# for j in range(1,m+1):
# if number in str(j):
# num=num+str(j).count(number)
# print(num)
類型：函數
描述
回文素數是指一個數既是素數又是回文數。例如，131，既是素數又是回文數。 用戶輸入一個正整數 n , 請你在一行內輸出從小到大排列的的前n個回文素數，數字後面用一個空格進行分隔。
輸入格式
輸入一個正整數
輸出格式
符合要求的回文素數
示例
輸入：10
輸出：2 3 5 7 11 101 131 151 181 191
標准答案
def is_prime(n):
"""判斷素數的函數,接收一個正整數為參數，參數是素數時返回True，否則返回False
減小判定區間，減少循環次數，提升效率。
"""
if n < 2:
return False # 0、1、負數以及偶數都不是素數
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0: # 能被2到其根號n之間的整數整除的數不是素數
return False
else:
return True # for循環正常結束，未遇到return的數是素數
def palindromic(num):
"""接收一個數字為參數，判定其是否為回文數，返回布爾值。"""
if str(num) == str(num)[::-1]:
return True
else:
return False
def output_prime(num):
"""接收一個正整數num為參數，在一行中從小到大輸出前num個回文素數。
函數無返回值
"""
i = 2 # 從最小的素數2開始測試
count = 0 # 計數器置0
while True: # 無限循環
if palindromic(i) and is_prime(i): # 先判斷回文再判斷素數，效率高
print(i, end=' ') # i為回文素數時輸出i，輸出後不換行
count = count + 1 # 每發現一個回文素數計數增加1
if count == num: # 如果找到回文素數數量與要求數量相同時
break # 結束循環
i = i + 1 # 測試下一個數字
if __name__ == "__main__":
n = int(input())
output_prime(n)
類型：函數
描述
反素數(逆向拼寫的素數)是指一個將其逆向拼寫後也是一個素數的非回文數。
例如：
13和31都是素數，且13和31都不是回文數，所以，13和31是反素數。
輸入一個正整數 n , 請在同一行輸出從小到大排列的的前n個反素數，每個數字後面加一個空格。
輸入格式
輸入一個正整數
輸出格式
符合條件的反素數
示例
輸入：
10
輸出：
13 17 31 37 71 73 79 97 107 113
標准答案
def is_prime(n):
if n <= 1: # 小於2的數字單獨處理
return True
for i in range(2, int(n ** (1 / 2) + 1)): # 根據素數定義判定是否是素數，是素數返回1
if n % i == 0:
return False
return True
def palindromic(num):
"""接收一個數字為參數，判定其是否為回文數，返回布爾值。"""
return str(num) == str(num)[::-1]
def reverse_num(num):
"""接收一個整數，返回其逆序字符串對應的整數"""
return int(str(num)[::-1])
def reverse_prime(number):
i = 2
count = 0
while True:
if not palindromic(i) and is_prime(i) and is_prime(reverse_num(i)):
print(i, end=' ') # i為回文素數時輸出i，輸出後不換行
count = count + 1
if count == number:
break
i = i + 1
if __name__ == "__main__":
n = int(input())
reverse_prime(n)
類型：函數
描述
數學領域著名的“哥德巴赫猜想”的大致意思是：任何一個大於2的偶數總能表示為兩個素數之和。例如：24=5+19，其中5和19都是素數。本實驗的任務是設計一個程序，驗證20億以內的偶數都可以分解成兩個素數之和。輸入一個大於2的正整數，當輸入為偶數時，在一行中按照格式“N = p + q”輸出N的素數分解，其中p 、 q均為素數且p ≤ q。因為這樣的分解可能不唯一（例如24還可以分解為7+17），要求必須輸出所有解中p最小的解。當輸入為奇數時，輸出'Data error!' 。
輸入格式
輸入一個大於2的正整數
輸出格式
當輸入為偶數時，按照格式“N = p + q”輸出N的素數分解；當輸入為奇數時，輸出'Data error!' 。
示例
輸入：36
輸出：36 = 5 + 31
標准答案
def isPrime(n): #判斷素數的函數
if n < 2:
return False #0和1不是素數
for i in range(2, n):
if n % i == 0:
return False
else:
return True
N = int(input()) #接收用戶輸入並轉成整數
flag = False
if N % 2 == 0:
for i in range(N):
for j in range(N):
if isPrime(i) and isPrime(j) and i+j==N:
print("{} = {} + {}".format(N, i,N-i))
flag = True
break
if flag:
break
else:
print('Data error!')
'''
def isPrime(n): #判斷素數的函數
if n < 2:
return False #0和1不是素數
for i in range(2, n):
if n % i == 0:
return False
else:
return True
N = int(input()) #接收用戶輸入並轉成整數
if N % 2 == 0:
for i in range(N):
if isPrime(i) and isPrime(N - i) :
print("{} = {} + {}".format(N, i,N-i))
break
else:
print('Data error!')
'''
類型：函數
描述
侯先生每天都會爬樓梯鍛煉身體，他爬樓梯的上跨步長有且僅有兩種，或者一次上跨一級，或者一次上跨兩級。
有一天侯先生想弄明白一個很難的問題：從最下面的平台開始到頂端的第n級一共有多少種走法呢？
例如n是2時，有兩種走法：直接從平台上跨兩步到第2級，或者從平台跨一步到1級再跨一步到第2級。
請你幫幫侯先生，給你n（1<=n<40）的值，你幫忙計算並輸出有多少種爬到頂端的方法。
輸入格式
輸入n的值，n是1到40之間的整數。
輸出格式
輸出一共有多少種從平台到第n級台階的走法。
輸入輸出示例：
示例1
輸入:3
輸出:3
示例2
輸入:5
輸出:8
標准答案
def upstrs(n):
if n==1:
return 1
elif n==2:
return 2
else:
return upstrs(n-1)+upstrs(n-2)
n=int(input())
print(upstrs(n))
類型：函數
描述
定義一個函數實現整數的冪運算，用以計算 x 的 n 次方。
輸入格式
在一行內輸入兩個非負整數 x 和 n，數字間用空格分隔。
輸出格式
x 的 n 次冪的運算結果
示例
輸入：2 3
輸出：8
標准答案
def power(x,n):
po=1
for i in range(n):
po=po*x
return po
x,n = map(int,input().split())
print(power(x,n))
類型：函數
描述
編寫一個函數實現從 1 到 N 共 N 個數的累加
輸入格式
一個正整數N
輸出格式
計算結果
示例
輸入：100
輸出：5050
標准答案
def summ(n):
sum = 0
for i in range(1,n+1):
sum = sum + i
return sum
print(summ(int(input())))
類型：函數
描述
漢諾塔：漢諾塔（又稱河內塔）問題是源於印度一個古老傳說的益智玩具。大梵天創造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞著64片黃金圓盤。大梵天命令婆羅門把圓盤從下面開始按大小順序重新擺放在另一根柱子上。並且規定，在小圓盤上不能放大圓盤，在三根柱子之間一次只能移動一個圓盤。
柱子編號為a, b, c，將所有圓盤從a移到c可以描述為： 如果a只有一個圓盤，可以直接移動到c； 如果a有N個圓盤，可以看成a有1個圓盤（底盤） + (N-1)個圓盤，首先需要把 (N-1) 個圓盤移動到 b，然後，將 a的最後一個圓盤移動到c，再將b的(N-1)個圓盤移動到c。 請編寫一個函數move(n, a, b, c) ，給定輸入 n, a, b, c，打印出移動的步驟： 例如，輸入 move(2, ‘A’, ‘B’, ‘C’)，打印出： A –> B A –> C B –> C
輸入格式
有兩行：
第一行一個正整數
第二行有三個符號，如A、B、C或a,b,c等，輸入時用空格分隔開。
輸出格式
移動過程的記錄
示例
輸入：
2
A B C
輸出：
A --> B
A --> C
B --> C
標准答案
def hanoi_move(n, a, b, c):
"""接收一個表示圓盤數量的整數n和三個表示柱子的字符，打印輸出把n個圓盤從第一個柱子移動到第三個柱子的過程。"""
if n == 1: # 終止條件，當只有一個圓盤時，從A移動到C後結束程序
print(a, '-->', c)
return None
else: # 遞歸調用，每調用一次圓盤次減少一個
hanoi_move(n - 1, a, c, b) # 首先需要把 (N-1) 個圓盤移動到 b
hanoi_move(1, a, b, c) # 將a的最後一個圓盤移動到c
hanoi_move(n - 1, b, a, c) # 再將b的(N-1)個圓盤移動到c
if __name__ == '__main__': # 使前面定義的函數可以被其他模塊調用
num = int(input()) # 輸入最初圓盤數量
s1, s2, s3 = input().split() # 輸入表示柱子的字符，例如輸入A B C
hanoi_move(num, s1, s2, s3) # 調用遞歸函數移動圓盤
類型：函數
描述
1179 能用 3 種方法表示為 3 個不同素數平方和的整數。
如：
1179 = 1717 + 1919 + 23*23
1179 = 77 + 1313 + 31*31
1179 = 77 + 1717 + 29*29
請輸出能用 6 種方式表示為 3 個不同素數平方和的最小整數。
（本題涉及的最大素數不超過100）
輸入格式
該題目沒有輸入
輸出格式
輸出能用 6 種方式表示為 3 個不同素數平方和的最小整數
輸入輸出示例
能用 3 種方法表示為 3 個不同素數平方和的最小的整數的輸出形式如下，按相同規律輸出本題結果：
示例
輸出：1179
標准答案
# 先獲取所有100以內的素數列表
# 再利用itertools中的 combinations可以快速獲得所有不重復的3個素數的組合
# 再獲得每組素數的平方和的列表,統計這個列表中每個數的出現次數,如果出現6次,便是題目答案
from itertools import combinations
def is_prime(n):
"""判斷素數的函數,接收一個正整數為參數，參數是素數時返回True，否則返回False
減小判定區間，減少循環次數，提升效率"""
if n < 2:
return False # 0、1、負數以及偶數都不是素數
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0: # 能被2到其n-1之間的數整除的數不是素數
return False
else:
return True # for循環正常結束，未遇到return的數是素數
def combine(ls_of_prime, n):
"""根據n獲得列表中的所有可能組合（3個元素為一組）"""
comb_of_prime = []
for c in combinations(ls_of_prime, n):
comb_of_prime.append(c)
return comb_of_prime
def six_ways(comb_of_prime):
"""傳入所有三個素數的組合列表，計算每個組合中的元素的平方和，產生新的列表，
遍歷10000以下的整數，如果這個整數在列表中出現的次數為6次，那麼便是最小的、
可以有6 種表示方法表示為3個素數平方和的那個數"""
result = [sum((c[0] ** 2, c[1] ** 2, c[2] ** 2)) for c in comb_of_prime]
for i in range(10000):
if result.count(i) == 6: # 統計當前數字在列表中出現的次數
return i
if __name__ == '__main__':
lsOfPrime = [i for i in range(100) if is_prime(i)]
combOfPrime = combine(lsOfPrime, 3)
print(six_ways(combOfPrime))
# 也可以直接求解,但效率較低
def is_prime(n):
# """判斷素數的函數,接收一個正整數為參數，參數是素數時返回True，否則返回False
# 減小判定區間，減少循環次數，提升效率"""
# if n < 2:
# return False # 0、1、負數以及偶數都不是素數
# for i in range(2, int(n ** 0.5) + 1):
# if n % i == 0: # 能被2到其n-1之間的數整除的數不是素數
# return False
# else:
# return True # for循環正常結束，未遇到return的數是素數
#
# def six_ways():
# i = 2
# while True:
# lsnew = [tuple(sorted(list((i, j, k, l)))) for j in ls for k in ls for l in ls if
# i == j * j + k * k + l * l and j != k and k != l and j != l]
# if len(set(lsnew)) == 6: # 若列表中不重復的元素有6個，則找到答案
# return i
# else:
# i = i + 1
#
#
# ls = [i for i in range(100) if is_prime(i)] # 為提升效率，先生成100以內素數列表
# print(six_ways())
類型：函數
描述
調用附件中的函數進行四則運算
輸入格式
兩個整數
輸出格式
和
示例
輸入：3 4
輸出：7
標准答案
import cal
a,b = map(int,input().split())
print(cal.add(a,b))
類型：函數
描述
猴子第1天摘了一堆桃子吃了一半又多一個，第2天吃了剩下的一半又多一個，...，第10天早上時發現只有1個桃子了。問第1天摘了多少？
示例
輸出：xxxx
標准答案
num = 1
for i in range(9):
num = (num + 1) * 2
print(num)
# def g(n):
# if n==10:
# return 1
# else:
# return 2*(g(n+1)+1)
# print(g(1))
類型：函數
描述
輸入一個正整數n，把數字n分解成不能再分解因子的乘法，比如：8=222， 10 = 2*5，而不是 8 = 2 * 4 這種可以再分解的。
輸入格式
輸入一個正整數n
輸出格式
輸出包含所有因子的列表
示例
輸入：12
輸出：[2, 2, 3]
標准答案
def defactor(N): # 定義一個函數名稱為defactor，意義是返回N的所有因子
for i in range(2,N): #從2開始試試
if N % i ==0: # 如果試到 i 是 N 的因子的話，就返回i的所有因子和N/i的所有因子 的列表
return defactor(i)+defactor(int(N/i)) # 拼接 列表 + 列表
else: # 如果沒有試到就說明這個N是一個質數，就直接包含它的 列表
return [N] # 返回列表
if __name__ == '__main__':
n = int(input())
print(defactor(n))
類型：函數
描述
輸入一個正整數n，統計從[0,n]之間的最大的10個素數之和。本題保證測試用例至少有10個滿足條件的素數。
例如：輸入31 ，應求得3，5，7，11，13，17，19，23，29，31之和。
本題要求使用自定義函數完成，代碼框架參考如下：
def isprime(n): #判斷素數函數
......
def f(n): #找小於n的素數並求和
......
......
p=int(input())
print(f(p))
示例
輸入：31
輸出：158
標准答案
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
else:
return True
def f(n):
sumPrime,count=0,0
for i in range(n,1,-1):
if isprime(i):
sumPrime = sumPrime + i
count = count + 1
if count == 10:
return sumPrime
num = int(input())
print(f(num))
類型：函數
描述
輸入一個完全由數字字符組成的字符串s，分別統計其中出現的奇數和偶數字符數值之和
如輸入‘123456789’
輸出 oddsum=25,evensum=20
本題需要使用自定義函數完成，建議代碼框架如下：
def f(n):
......
def p(t):
......
def .......
s=input()
print('oddsum={},evensum={}'.format(......))
示例
輸入：123456789
輸出：oddsum=25,evensum=20
標准答案
def f(n): #奇偶函數
if n%2==0:
return 0
return 1
def p(t): #奇數求和
j=0
for i in t:
if f(int(i))==1:
j+=int(i)
return j
def q(t): #偶數求和
j=0
for i in t:
if f(int(i))==0:
j+=int(i)
return j
s=input()
print('oddsum={},evensum={}'.format(p(s),q(s)))
類型：函數
描述
在兩行中分別輸入一個字符串s和整數n，定義一個函數將字符串s循環向右移動n位，n為負數時左移。
若s為空字符串''，則不論n為多少，均輸出空字符串''。
如 s='123456' n=3
輸出結果：456123
代碼框架如下：
def f(s,n):
......
s=input()
n=int(input())
print(f(s,n))
示例
輸入：
123456
2
輸出：
561234
標准答案
def f(s,n):
p=''
if s=='':
return p
t=(len(s)-n)%len(s)
p=s[t:]
p+=s[:t]
return p
s=input()
n=int(input())
print(f(s,n))
'''def f(s,n):
p=''
if s=='':
return p
if n>=0:
t=len(s)-n%len(s)
else:
t=abs(n)%len(s)
p=s[t:]
p+=s[:t]
return p
s=input()
n=int(input())
print(f(s,n))
'''
類型：函數
描述
小明是一個汽車迷，看到什麼汽車馬上就可以說出汽車的生產年份、型號和品牌。定義一個函數，可以輸出汽車的介紹。
例如輸入：
2020 AMG_S65 奔馳
可以輸出：
這是一輛2020年生產，型號是AMG_S65的奔馳牌汽車
要求函數具有以下功能：當用戶只輸入生產年份、型號時，品牌按“寶馬”輸出。
輸入格式
輸入用空格分隔的年、型號和品牌（品牌可能沒有）
輸出格式
這是一輛年生產，型號是的牌汽車（根據用戶輸入進行替換）
示例
輸入：2020 AMG_S65 奔馳
輸出：這是一輛2020年生產，型號是AMG_S65的奔馳牌汽車。
標准答案
# 2020 AMG_S65 奔馳
# 2019 745li
# 2018 760 寶馬
def car(year,model,brand = '寶馬'):
return f'這是一輛{year}年生產，型號是{model}的{brand}牌汽車。'
ls = input().split()
print(car(*ls))
類型：函數
描述
一個不含0的數，如果它能被它的每一位除盡，則它是一個自除數。例如128是一個自除數，因為128能被1、2、8整除。編寫函數selfDivisor(num)判斷num是否為自除數，使用該函數輸出不大於N的所有自除數。
（注意，含有數字0的數不是自除數）
輸入格式
輸入為一行，一個正整數N（N>=1）。
輸出格式
輸出為一行，是不大於N的所有自除數，每個數後面有一個空格。
示例 1
輸入：1
輸出：1
示例 2
輸入：22
輸出：1 2 3 4 5 6 7 8 9 11 12 15 22
標准答案
def selfDivisor(num):
if '0' in str(num):
return False # 包含數字0的不是自除數
for c in str(num): # 對數字num中的每位數字進行遍歷
if num % int(c) != 0: # 測試num的每一位是否是num的因子
return False # 如果存在不能整除的數，則不是自除數
else: # 如果for遍歷順利結束，未遇到return，則執行else子句，返回True
return True
n=int(input())
for num in range(1,n+1): # 注意不大於包括等於n
if selfDivisor(num): # 調用函數，當返回值為True時，該數為自除數，輸出這個數
print(num,end=' ') # 輸出以空格結尾
類型：函數
描述
已知華氏溫度轉換攝氏溫度的計算公式：C=5×(F−32)/9，其中：C表示攝氏溫度，F表示華氏溫度。
編寫函數F2C(f)將華氏溫度轉換為攝氏溫度，讀入兩個華氏溫度值f1和f2，打印范圍在f1~f2內，每次增加兩個華氏溫度刻度的速查表。
注意：如果f1>f2，則直接打印error。
輸入格式
輸入為一行，為兩個不小於32的正整數f1和f2，表示兩個華氏溫度。兩個數之間用逗號隔開，形如f1,f2。
輸出格式
如果f1>f2，輸出error。
如果f1<=f2，則輸出華氏轉攝氏的溫度轉換速查表，速查表可能有多行，每行一個溫度轉換對，形如f1 : c1，其中c1保留小數點兩位。速查表以2華氏度為刻度。
示例1
輸入：86,44
輸出：error
示例 2
輸入：32,32
輸出：32 : 0.00
示例 3
輸入：44,45
輸出：44 : 6.67
示例 4
輸入：44,46
輸出：
44 : 6.67
46 : 7.78
示例 5
輸入：60,73
輸出：
60 : 15.56
62 : 16.67
64 : 17.78
66 : 18.89
68 : 20.00
70 : 21.11
72 : 22.22
標准答案
def F2C(f):
c=5*(f-32)/9
return c
left,right=map(int,input().split(','))
if left>right:
print('error')
else:
for f in range(left,right+1,2):
print("{} : {:.2f}".format(f,F2C(f)))
類型：函數
描述
輸入一個包含多個單詞的英文句子，單詞間以空格分隔，標點符號後跟一個空格。定義一個函數，功能是用指定的符號把單詞連接起來。
輸入格式
第一行輸入一個英文句子
第二行輸入一個符號
輸出格式
用符號連接起來的單詞
示例
輸入：
a string can be split on a delimiter.
-
輸出：
a-string-can-be-split-on-a-delimiter.
標准答案
def split_and_join(line,sign):
return sign.join(line.split())
# 以下代碼請勿改動
if __name__ == '__main__':
line = input()
sign = input()
result = split_and_join(line,sign)
print(result)
類型：函數
描述
定義一個函數來判斷單詞m是否可以由字符串n中出現的字母來組成。
本題保證字符串中出現的字母均為小寫字母，且不考慮n中的字母使用次數
在兩行中分別輸入兩個字符串m,n
如果m,n 滿足條件，則輸出’FOUND‘ ，否則輸出'NOT FOUND'
如果輸入的m包含有除字母外的其他字符，輸出’ERROR‘結束
示例 1
輸入：
word
world
輸出：
FOUND
示例 2
輸入：
1a3e
輸出：
ERROR
示例 3
輸入：
at
bcda
輸出：
NOT FOUND
標准答案
def f(m,n):
for i in m:
if i not in n:
return 'NOT FOUND'
return 'FOUND'
m=input()
if m.isalpha():
n=input()
print(f(m,n))
else:
print('ERROR')
類型：函數
描述
商品價格每天都在變化，作為一個商人，需要低買高賣賺取利潤，通常會根據歷史數據，檢驗策略的收益。
已知有一個商品歷史價格變化列表。其中第 i 個元素是第 i 天該商品的價格。
現在使用的貪心策略是在該過程中要求必須盡可能多的進行獲利的交易，並且每次買入時都要先清倉（全部賣出上一次買入的商品），不能同時進行多筆交易。
定義一個函數，計算你在這種策略下能獲取的最大利潤。
比如價格列表為 [1,3,5,1,8]，利潤最大為11元，
第1天買入，第2天賣出 獲利3-1=2元
第2天買入，第3天賣出 獲利5-3=2元
第4天價格跌落，所以第三天無交易
第4天買入，第5天賣出 獲利8-1=7元
總利潤為 2+2+7=11元
本題的編程模板會幫助你建立一個隨機的價格列表（價格在1-100元的閉區間中），你需要在兩行中各輸入一個整數，第一行輸入一個可交易的總天數（即列表中的價格個數），第二行輸入一個整數做為隨機種子。
輸出時模板會在兩行中分別輸出生成的價格列表以及能獲取的最大利潤。
提示：列表的索引使用方式與字符串相同。
輸入格式
在兩行輸入中各輸入一個整數
輸出格式
生成的價格列表
獲取的最大利潤
示例
輸入：
10
6
輸出：
[74, 11, 63, 98, 34, 5, 1, 19, 85, 76]
171
標准答案
import random
def f(prices):
s=0
for i in range(len(prices)-1): #此處注意不要越界
if prices[i]<prices[i+1]:
s+=prices[i+1]-prices[i]
return s
n=int(input())
random.seed(int(input()))
ls=[]
for i in range(0,n):
ls.append(random.randint(1,100))
print(ls)
print(f(ls))
類型：函數
描述
定義一個函數來判斷單詞m是否可以由字符串n中出現的字母來組成。
本題保證字符串中出現的字母均為小寫字母，n中的字母只能使用一次。
在兩行中分別輸入兩個字符串m,n
如果m,n 滿足條件，則輸出’FOUND‘ ，否則輸出'NOT FOUND'
如果輸入的m包含有除字母外的其他字符，輸出’ERROR‘結束
示例 1
輸入：
word
world
輸出：
FOUND
示例 2
輸入：
1a3e
輸出：
ERROR
示例 3
輸入：
at
bcda
輸出：
NOT FOUND
示例 4
輸入：
hello
heol
輸出：
NOT FOUND
標准答案
def f(m,n):
for i in m:
if n.count(i)>0:
n=n.replace(i,'',1)
else:
return 'NOT FOUND'
return 'FOUND'
m=input()
if m.isalpha():
n=input()
print(f(m,n))
else:
print('ERROR')
類型：函數
描述
素數或稱質數，是指一個大於1的整數，除1和它本身外，不能被其他的正整數所整除。 素數判定方法是： 先用一定的方法枚舉正整數n所有可能的真因子，並驗證每個枚舉的數是否為真因子。若是，則停止枚舉，確定n為合數；若枚舉完也沒發現真因子，可確定n為素數。完成以下函數的定義並按要求完成問題：
輸入輸出
問題1 如果輸入'素數'，再輸入一個正整數n，按從小到大順序輸出不大於n的所有素數。
問題2 如果輸入'回文素數'，再輸入一個正整數n，按從小到大順序輸出小於n的所有回文素數。
問題3 如果輸入'反素數'，再輸入一個正整數n，輸入一個正整數n，按從小到大順序輸出小於n的所有反素數。
問題4 如果輸入'哥德巴赫猜想'，接收一個大於2的偶數，輸出兩個素數，並且兩個素數之和等於原來的偶數，如果有多個不同組合，則全部輸出，格式參考下面的示例。若輸入的數不是大於2的偶數，輸出'Data error!'
如果輸入不是以上字符串，輸出'輸入錯誤'。
示例 1
輸入：
素數
100
輸出：
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
示例2
輸入：
回文素數
200
輸出：
2 3 5 7 11 101 131 151 181 191
示例3
輸入：
反素數
200
輸出：
13 17 31 37 71 73 79 97 107 113 149 157 167 179 199
示例4
輸入：
哥德巴赫猜想
30
輸出：
30=7+23
30=11+19
30=13+17
標准答案
def question_judge(question):
"""接收一個字符串為參數，根據參數判斷問題類型"""
if question == '素數': # 如果輸入”素數“，再輸入一個正整數n，輸出不大於n的所有素數
n = int(input())
output_prime(n) # 輸出素數
elif question == '回文素數':
n = int(input())
palindromic_prime(n) # 輸出回文素數
elif question == '反素數':
n = int(input())
reverse_prime(n) # 輸出反素數
elif question == '哥德巴赫猜想':
n = int(input())
goldbach_conjecture(n)
else:
print('輸入錯誤')
def is_prime(n):
"""判斷素數的函數,接收一個正整數為參數，參數是素數時返回True，否則返回False
減小判定區間，減少循環次數，提升效率"""
if n < 2:
return False # 0、1、負數以及偶數都不是素數
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0: # 能被2到其根號n之間的整數整除的數不是素數
return False
else:
return True # for循環正常結束，未遇到return的數是素數
def output_prime(number):
"""接收一個正整數為參數，遍歷從0到number之間的所有整數
在一行中輸出不大於number的所有素數，函數無返回值"""
for i in range(number + 1): # 遍歷小於n的整數
if is_prime(i): # i為素數時輸出i
print(i, end=' ') # 輸出後不換行，空格分隔輸出
def palindromic(num):
"""接收一個數字為參數，判定其是否為回文數，返回布爾值。"""
if str(num) == str(num)[::-1]:
return True
else:
return False
def palindromic_prime(number):
"""接收一個正整數參數number，遍歷從0到number之間的所有整數，
若某個數是素數，且轉為字符串後是回文字符串，則稱其中回文素數
找出並在同一行中從小到大輸出小於number的所有回文素數，各數字間用一個空格分隔，
函數無返回值"""
for i in range(number): # 遍歷小於n的整數
if palindromic(i) and is_prime(i):
print(i, end=' ') # i為回文素數時輸出i，輸出後不換行
def reverse_num(num):
"""接收一個整數，返回其逆序字符串對應的整數"""
return int(str(num)[::-1])
def reverse_prime(number):
"""接收一個正整數參數，找出並在同一行內輸出所有小於number的反素數，數字間用一個空格分隔。
反素數指某數i及其逆序數都是素數，但數i對應的字符串不是回文字符串
函數無返回值"""
for i in range(number): # 遍歷小於n的整數
if not palindromic(i) and is_prime(i) and is_prime(reverse_num(i)):
print(i, end=' ') # i為回文素數時輸出i，輸出後不換行
def goldbach_conjecture(num):
""" 哥德巴赫猜想, 接收一個不小於4的正整數為參數。
當參數為不小於4的偶數時，將其分解為兩個素數的加和，按小數+數的格式輸出。
有多種組合時全部輸出，但不輸出重復的組合，例如輸出8=3+5，不輸出8=5+3。
參數為奇數或小於4時，輸出'Data error!'
"""
if num % 2 == 0 and num >= 4: # 只判定偶數
for i in range(num // 2+1): # 超過num // 2的組合為重復組合
if is_prime(i) and is_prime(num - i):
print(f"{num}={i}+{num-i}")
else:
print('Data error!')
if __name__ == '__main__':
problems = input()
question_judge(problems)
類型：函數
描述
輸入一個8位數表示的年月日，讀出月份數字並輸出該月有多少天。
輸入格式
輸入一個8位的表示年月日的字符串
輸出格式
該月的天數
示例
輸入：20000219
輸出：29
標准答案
# 輸出**月有多少天
def is_leap(year):
if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
return True
else:
return False
def days_of_month(date_str):
year = int(date_str[:4])
month = int(date_str[4:6])
if month in [1, 3, 5, 7, 8, 10, 12]:
return 31
elif month in [4, 6, 9, 11]:
return 30
elif month == 2 and is_leap(year):
return 29
else:
return 28
if __name__ == '__main__':
date_in = input() # 輸入一個年月日
print(days_of_month(date_in))
