1、實作一個數字的反轉，比如輸入12345，輸出54321
num = 12345
num_str = str(num)
reversed_num_str = num_str[::-1]
reversed_num = int(reversed_num_str)
print(reversed_num) # 輸出 54321
- 代碼解析：首先将輸入的數字轉換為字元串，然後使用切片操作将字元串反轉，最後再将反轉後的字元串轉換回數字類型。
2、統計在一個隊列中的數字，有多少個正數，多少個負數，如[1,3,5,7,0,-1,-9,-4,-5,8]
nums = [1, 3, 5, 7, 0, -1, -9, -4, -5, 8]
positive_count = 0
negative_count = 0
for num in nums:
if num > 0:
positive_count += 1
elif num < 0:
negative_count += 1
print(f"正數數量：{positive_count}，負數數量：{negative_count}")
- 代碼解析：首先定義了一個數字清單 nums，然後用變量 positive_count和negative_count 分别記錄其中的正數和負數數量。循環周遊這個清單，對于每個數字，如果它是正數則正數數量加一，否則如果是負數則負數數量加一。最後輸出正數和負數數量的統計結果。
3、一個數的階乘運算，求結果，如求5的階乘結果。
n = 5 # 求 5 的階乘
factorial = 1 # 階乘的初始值為 1
for i in range(1, n+1):
factorial *= i # 依次乘以 1, 2, 3, ..., n
print(factorial) # 輸出 120
- 代碼解析：首先定義了待求階乘的數 n，然後将階乘的初始值設為 1。在循環中，使用 range(1, n+1) 來周遊 1 到 n 這n個數的值。對于每個數，用 factorial 依次乘以它，最終得到的結果即為階乘。最後輸出結果
4、1加到N的階層之和,比如N=4, result = (1! + 2! + 3! + 4!)
n = 4
factorial_sum = 0 # 1到N的階層之和
result = 0 # 最終的結果
# 循環計算1到N的階層之和
for i in range(1, n+1):
factorial = 1 # 用來記錄i的階層
for j in range(1, i+1):
factorial *= j
factorial_sum += factorial
# 累加到結果中
result += factorial_sum
print(result) # 輸出 33
- 代碼解析：首先定義了待求解的數 n 和計算 1 到 N 的階層之和的變量 factorial_sum。在循環中，使用兩層嵌套循環來計算 i 的階層，然後把所有階層求和得到 factorial_sum。最後将 factorial_sum 加入到最終結果 result 中。最後輸出結果。
5、求出1000以内的完全數
for n in range(2, 1001):
factors = [] # 用來存儲n的因子
for i in range(1, n):
if n % i == 0:
factors.append(i) # 将i加入到n的因子清單中
if sum(factors) == n:
print(n)
- 代碼解析：外層循環 for n in range(2, 1001) 周遊所有可能的完全數，即從2到1000。在内層循環 for i in range(1, n) 中，使用 n % i == 0 來判斷i是否是n的因子，如果是則将它加入到因子清單 factors 中。在循環結束後，使用 sum(factors) == n 來判斷所有因子的和是否等于n，如果是則說明n是完全數，輸出它的值即可。
- 完全數是指除自身外所有因子之和等于自身的數。其中最經典的兩個完全數是6和28，它們的因子分别是1, 2, 3和1, 2, 4, 7, 14。
6、求出1000以内的水仙花數
for n in range(100, 1000):
# 将 n 的每一位取出來，計算它們的立方和
digits = [int(d) for d in str(n)]
digit_cubes_sum = sum(d ** 3 for d in digits)
# 如果立方和等于 n，則說明這是一個水仙花數
if digit_cubes_sum == n:
print(n)
- 代碼解析：外層循環 for n in range(100, 1000) 周遊所有三位數，内層使用了清單推導式和 sum() 函數來計算 n 的每個數字的立方和。在判斷時，如果立方和等于 n，說明 n 是一個水仙花數，将它輸出即可。
- 水仙花數是指一個 n 位數（n≥3）它的每個位上的數字的 n 次幂之和等于它本身。比如 153 就是一個水仙花數，因為 1^3 + 5^3+ 3^3 = 153.
7、求出1000以内的回文數
for n in range(100, 1000):
# 将 n 轉換為字元串，并将字元串反轉後再轉成數字
reversed_n = int(str(n)[::-1])
# 如果翻轉後的數等于 n，則說明 n 是一個回文數
if reversed_n == n:
print(n)
- 代碼解析：外層循環 for n in range(100, 1000) 周遊所有三位數，将每個數字轉換成字元串，然後使用字元串切片 [::-1] 反轉它，并将反轉後的字元串轉回數字。在判斷時，如果反轉後的數等于 n，則說明 n 是一個回文數，将它輸出即可。
- 回文數是指一個數字從左往右和從右往左讀都是一樣的，比如 121、1221。
8、實作一個數字的斐波那契數列
# 方式一：循環實作
def fib(n):
a, b = 0, 1
for i in range(n):
a, b = b, a + b
return a
# 測試代碼
n = 10
print([fib(i) for i in range(n)]) # 輸出結果為 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
# 方式二：遞歸實作
def fib(n):
if n <= 1:
return n
else:
return fib(n-1) + fib(n-2)
# 測試代碼
n = 10
print([fib(i) for i in range(n)]) # 輸出結果為 [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
- 代碼解析：
- **方式一（循環實作）：初始化 a 和 b 為 0 和 1，然後使用 **for 循環周遊 0 到 n-1，每次将 a 和 b 的值更新為 b 和 a+b，最後傳回 a。
- **方式二（遞歸實作）：首先判斷 n 的值是否小于等于 1，如果是，則直接傳回 n。否則，遞歸調用 **fib(n-1) 和 fib(n-2) 并傳回它們的和。
- 斐波那契數列是指從 0 和 1 開始，後續每個數都等于前兩個數之和的數列。其數值為：1、1、2、3、5、8、13、21、34……在數學上，這一數列以如下遞推的方法定義：F(0)=1，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）
9、統計清單1~9999中包含3的元素的總個數
import re
# 方式一：循環實作
count = 0
# 周遊 1~9999 中的每個數字，将數字轉換成字元串并查找其中是否包含字元 3
for i in range(1, 10000):
if '3' in str(i):
count += 1
print(count) # 輸出結果為 3439
# 方式二：循環+正則比對實作
theList = list(filter(lambda x: re.match('(.*?)3(.*?)',str(x)) ,a))
print(f"清單[1~9999]中包含3的元素總個數為:{len(theList)}") # 輸出結果為 3439
代碼解析：
- 方式一（循環）：使用 for 循環周遊 1~9999 中的每個數字，并将每個數字轉換成字元串，然後查找其中是否包含字元 3。如果包含，則将計數器加 1。最後，計數器的值就是包含數字 3 的元素的個數
- 方式二（循環+正則比對）： re.match() 函數用于檢查清單 a 中的每個元素是否包含數字3。正規表達式 (.*?)3(.*?) 比對任何包含數字3的字元串，無論它在字元串中的位置如何。 filter() 函數用于建立一個新清單，其中僅包含與正規表達式比對的 a 中的元素。 lambda 函數用于定義一個簡單的函數，它接受一個參數 x ，并且如果 re.match('(.*?)3(.*?)',str(x)) 傳回一個比對對象（即如果 x 包含數字3），則傳回 True ，否則傳回 False 。 結果清單被指派給變量 theList 。 - len() 函數用于計算 theList 的長度，這給出了在範圍[1, 9999]中包含數字3的元素的總數。
10、寫一個冒泡排序的算法程式
def bubble_sort(arr):
n = len(arr)
# 周遊 n 次
for i in range(n):
# 第 i 次周遊，找出未排序部分的最大元素并将其放到末尾
for j in range(n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
# 測試代碼
arr = [5, 2, 8, 4, 1]
bubble_sort(arr)
print(arr) # 輸出結果為 [1, 2, 4, 5, 8]
- 代碼解析： bubble_sort() 函數接收一個清單 arr，并将其進行冒泡排序。具體實作時，使用兩個嵌套的循環對清單中的所有元素進行比較，如果相鄰兩個元素的順序相反，則交換它們的順序，直到整個清單都排好序。 **先定義了一個清單 **arr，然後調用 bubble_sort(arr) 對其進行冒泡排序，并輸出排序後的結果。
- 冒泡排序是一種基本的排序算法，也是最簡單的一種排序算法之一。它的基本思想是：通過重複交換相鄰的兩個元素來實作排序。具體來說，冒泡排序的過程如下： 從清單的第一個元素開始，依次比較相鄰的兩個元素，如果第一個元素大于第二個元素，則交換它們的位置； 繼續比較第二個元素和第三個元素，如果第二個元素大于第三個元素，則交換它們的位置； 重複上述步驟，直到比較到清單的最後一個元素； 重複上述步驟，直到清單中的所有元素都按照從小到大的順序排列為止。
11、用python實作二分法排序
def binary_search(arr, target):
low, high = 0, len(arr) - 1
while low <= high:
mid = (low + high) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
low = mid + 1
else:
high = mid - 1
return -1
# 測試代碼
arr = [1, 3, 4, 6, 8, 9, 11, 12, 13, 16]
target = 9
pos = binary_search(arr, target)
if pos == -1:
print("元素不在清單中")
else:
print("元素在清單中的下标為：", pos)
- 代碼解析： binary_search() 函數接收一個有序清單 arr 和一個待查找的元素 target，并傳回該元素在清單中的下标（從 0 開始計數）；如果該元素不在清單中，則傳回 -1。二分查找算法通過不斷地将待查找部分縮小一半來實作查找 **有序清單 **arr 和一個待查找的元素 target，然後調用 binary_search(arr, target) 函數查找該元素在清單中的下标，并輸出結果。
- 二分查找，也叫二分查找、折半查找，是一種在有序數組中查找某一特定元素的搜尋算法。二分查找每次将查找區間減半，直到找到目标元素，或者确定目标元素不存在于數組中。具體來說，二分查找的基本步驟如下： 首先，令左側下标 low 等于數組的第一個元素下标，右側下标 high 等于數組的最後一個元素下标，計算中間下标 mid； 比較中間下标的值與目标值的大小關系。若相等，則傳回中間下标；若小于目标值，則目标值在中間下标的右側，将 low 置為 mid + 1；否則目标值在中間下标的左側，将 high 置為 mid - 1； 重複上述步驟，直到 low 大于 high，表示查找區間為空，傳回 -1。
12、寫一個快排的算法程式
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2] # 選擇中間的元素作為基準值
left = [x for x in arr if x < pivot] # 小于基準值的放在左邊
mid = [x for x in arr if x == pivot] # 等于基準值的放在中間
right = [x for x in arr if x > pivot] # 大于基準值的放在右邊
return quick_sort(left) + mid + quick_sort(right)
# 測試代碼
arr = [5, 2, 8, 4, 1]
arr_sorted = quick_sort(arr)
print(arr_sorted) # 輸出結果為 [1, 2, 4, 5, 8]
- 代碼解析： quick_sort() 函數接收一個清單 arr，并傳回排序後的新清單。具體實作時，先選擇清單中間的元素作為基準值 pivot，然後将清單分成三部分：小于基準值的放在左邊，等于基準值的放在中間，大于基準值的放在右邊。然後遞歸地對左、右兩個子清單進行排序。 **先定義了一個清單 **arr，然後調用 quick_sort(arr) 将其進行快速排序，并輸出排序後的結果。
- 快速排序（Quick Sort）是一種常用的排序算法，屬于交換排序的一種。其基本思想是：標明一個基準值，将清單分成兩個子清單，小于基準值的放在左邊，大于或等于基準值的放在右邊，然後遞歸地對左、右兩個子清單進行排序，最終将整個清單排序。具體來說，快速排序算法的基本步驟如下： 确定基準值：選取一個基準值，在清單中選擇一個元素作為基準值。 分割：将清單按照基準值進行分割，小于基準值的放在左邊，大于或等于基準值的放在右邊。分割後，将清單分成了兩個部分，左邊部分的所有元素都小于基準值，右邊部分的所有元素都大于或等于基準值。 遞歸：對左、右兩個子清單分别進行快速排序的遞歸操作，直到排序完成。
![參加殿試的劉墨林，為何敢頂撞隆科多？這是雍正出的“面試題”！[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)