07函數 1. 判斷素數函數 類型：函數 描述 寫一個函數isPrime(n ...
07函數
1. 判斷素數函數
類型：函數
描述
寫一個函數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=' ') #在同一行內輸出結果，不換行，中間用空格分隔
2. 二分法求平方根
類型：函數
描述
設計一個用二分法計算一個大於或等於 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('請輸入一個非負數！')
3. 二分法求平方根B
類型：函數
描述
設計一個用二分法計算一個大於或等於 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()計算平方根
4. 計算ID號
類型：函數
描述
我的微信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)
5. 迴文素數
類型：函數
描述
迴文素數是指一個數既是素數又是迴文數。例如，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)
6. 反素數
類型：函數
描述
反素數(逆向拼寫的素數)是指一個將其逆向拼寫後也是一個素數的非迴文數。
例如：
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)
7. 哥德巴赫猜想
類型：函數
描述
數學領域著名的“哥德巴赫猜想”的大致意思是：任何一個大於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!')
'''
8. 侯先生爬樓梯
類型：函數
描述
侯先生每天都會爬樓梯鍛煉身體，他爬樓梯的上跨步長有且僅有兩種，或者一次上跨一級，或者一次上跨兩級。
有一天侯先生想弄明白一個很難的問題：從最下麵的平臺開始到頂端的第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))
9. 自定義冪函數
類型：函數
描述
定義一個函數實現整數的冪運算，用以計算 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))
10. 累加函數
類型：函數
描述
編寫一個函數實現從 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())))
11. 漢諾塔
類型：函數
描述
漢諾塔：漢諾塔（又稱河內塔）問題是源於印度一個古老傳說的益智玩具。大梵天創造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞著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) # 調用遞歸函數移動圓盤
12. 特殊的數字
類型：函數
描述
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())
13. 模塊化編程測試
類型：函數
描述
調用附件中的函數進行四則運算
輸入格式
兩個整數
輸出格式
和
示例
輸入：3 4
輸出：7
標準答案
import cal
a,b = map(int,input().split())
print(cal.add(a,b))
14. 猴子吃桃
類型：函數
描述
猴子第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))
15. 分解質因數
類型：函數
描述
輸入一個正整數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))
16. 素數求和
類型：函數
描述
輸入一個正整數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))
17. 奇偶求和
類型：函數
描述
輸入一個完全由數字字元組成的字元串s，分別統計其中出現的奇數和偶數
