金阳光测试算法专题——精选小算法汇总
[本文出自天外歸云的博客園]
本文是對金陽光測試算法專題中一些小算法的精選匯總，利于思考與收獲。
注意：原版是用java解，以下題目部分使用python解（python3），對于題目中描述不清楚的地方做了改進，部分題目的解法是我自己思考后寫出的，可能與原版不一樣。
算法1：兔子問題（斐波那契數列）
問題描述：有一對兔子，從出生后第3個月起每個月都生一對兔子。如此輪回。假如兔子都不死，問每個月的兔子總數為多少對？
代碼如下：
def create_rabbits(month,final_month):
count = 1
for sub_month in range(month,final_month+1):
if sub_month-month >= 3:
count += create_rabbits(sub_month,final_month+1)
return count
def calc_rabbits(final_month):
count = 1
for month in range(1,final_month+1):
if month >= 3:
count += create_rabbits(month,final_month+1)
return count
#一對兔子，從出生后第3個月起每個月都生一對兔子。如此輪回。
#假如兔子都不死，問每個月的兔子總數為多少？
if __name__ == '__main__':
for month in range(1,10):
count = calc_rabbits(month)
print(count)
算法2：素數問題
問題描述：判斷101-200之間有多少素數，并輸出所有素數。
代碼如下：
def is_prime(num,flag=0):
for i in range(num):
if num%(i+1)==0:
flag +=1
if flag == 2:
return True
else:
return False
#判斷101-200之間有多少素數，并輸出所有素數。
if __name__ == '__main__':
count = 0
for num in range(101,201):
if is_prime(num):
count += 1
print(num)
print("共有"+str(count)+"個質數")
算法3：水仙花數問題
問題描述：打印三位數中的水仙花數。所謂水仙花數，就是指一個三位以上的數，并且該數各位數字立方和等于該數本身。
代碼如下：
import math
def is_narcissus_number(number):
str_number = str(number)
_sum = 0
for i in range(len(str_number)):
_sum += pow(int(str_number[i]),3)
if _sum == number:
return True
else:
return False
#打印三位數中的水仙花數。
#所謂水仙花數，就是指一個三位以上的數，并且該數各位數字立方和等于該數本身。
if __name__ == '__main__':
for num in range(1,1000):
if is_narcissus_number(num):
print(str(num)+"是水仙花數")
算法4：條件運算符問題
問題描述：利用條件運算符的嵌套完成。學習成績大于等于90分的同學用A表示，60-89分的用B表示，60以下用C表示。
特殊說明：
1. 條件運算符，也叫三元運算符，不是if語句（python里并沒有條件運算符，所以本題用java解）；
2. 原文中提到要考察輸入帶小數點的數字強制轉換為整型，有直接丟棄小數點后面的部分和四舍五入兩種方法。
代碼如下：
public class Test {
public static String locate_score(float number){
int score = 0;
score = (int)number;//舍棄小數點后面的部分
score = Math.round(number);//四舍五入
return score >= 90 ? "A" : number >= 60 ? "B" : "C";
}
public static void main (String[] args)
{
System.out.println(locate_score(59.5f));
}
}
算法5、6：最大公約數和最小公倍數問題
問題描述：求兩個數的最小公倍數和最大公約數。
代碼如下：
#最大公約數：greatest common divisor
def find_gcd(num1,num2):
if num1>num2:
max = num1
else:
max = num2
gcd = 1
for num in range(1,max):
limit1 = (num1%num==0)
limit2 = (num2%num==0)
limit3 = num>=gcd
if limit1 and limit2 and limit3:
gcd = num
return gcd
#最小公倍數：greatest common multiple
def find_gcm(num1,num2):
gcm = num1*num2
for num in range(1,gcm+1):
limit1 = (num%num1==0)
limit2 = (num%num2==0)
limit3 = num<=gcm
if limit1 and limit2 and limit3:
gcm = num
return gcm
if __name__ == '__main__':
num1 = 28
num2 = 98
print(str(num1)+"和"+str(num2)+"的最大公約數是："+str(find_gcd(num1,num2)))
print(str(num1)+"和"+str(num2)+"的最小公倍數是："+str(find_gcm(num1,num2)))
上面的解法是常規解法，比較快的求解方法參照原版如下：
#最大公約數：greatest common divisor
def find_gcd(num1,num2):
#確保num1是較大的
if num1<num2:
temp = num1
num1 = num2
num2 = temp
if num1%num2 == 0:
return num2
else:
return find_gcd(num2,num1%num2)
#最小公倍數：greatest common multiple
def find_gcm(num1,num2):
return int(num1*num2/find_gcd(num1,num2))
兩數最大公約數的較快求法：兩數相除（“大的”除以“小的”），余數為0則“小的”為最大公約數；若余數不為0，則將“小的”和余數相除。循環以上步驟直到兩數相除余數為0時，最大公約數為“小的”那個數。
兩數最小公倍數的較快求法：根據最小公倍數與最大公約數的關系公式求解。
算法7：快速排序
描述：快速排序就是用分治思想來進行的一種排序，把數組中每一個元素都作為一次待排序對象，每次排序都會將該元素確定到它最終的位置，左邊的子數組中的元素值都比它小，右邊的子數組中的元素值都比它大。
輸入：一個數組。
排序過程：對數組中最左側的元素進行排序，排序后該元素在數組中“左側的元素值都是比它小的，右側的元素值都是比它大的”。
遞歸過程：每次排序后，將排好序的元素左側的部分和右側的部分作為兩個子數組再次輸入進行排序。
代碼如下：
def qucik_sort(_array,left,right):
_left = left
_right = right
#如果數組長度大于等于1
if _left <= _right:
#選擇最左側的元素為待排序元素
key = _array[_left]
#當待排序數組左邊界和右邊界不一致時
while _left != _right:
#從右側開始遍歷元素移動“_right”直到找到比待排序元素小的元素所在位置“_right”
while (_right > _left) and (_array[_right] >= key):
_right -= 1
#把比待排序元素小的元素放到位置“_left”
_array[_left] = _array[_right]
#從左側開始遍歷元素移動“_left”直到找到比待排序元素大的元素所在位置“_left”
while (_left < _right) and (_array[_left] <= key):
_left += 1
#把比待排序元素大的元素放到位置“_right”
_array[_right] = _array[_left]
#把待排序元素放到“_left”和“_right”相遇時的位置
_array[_left] = key
#打印一下本次排序后的數組
print(_array)
#對待排序元素左側的元素進行排序
qucik_sort(_array,left,_left-1)
#對待排序元素右側的元素進行排序
qucik_sort(_array,_right+1,right)
#排序結束后返回數組
return _array
if __name__ == '__main__':
_array = [60,2,34,22,65,6,77,99,44,2,4,3,88]
print("排序前的數組："+str(_array))
print("排序后的數組："+str(qucik_sort(_array,0,len(_array)-1)))
算法8：冒泡排序
描述：冒泡排序就是對于一個數組中的每一位元素都作為一個起點索引，將起點索引之后的元素進行兩兩交換，直到把最大的移到最后面。也就是說，每一次排序都會把待排序數組中最大的元素值以冒泡的方式轉移到數組的末尾。
輸入：一個數組。
外層循環過程：第一次排序結束是第一個數到數組倒數第二位，第二次排序結束是第一個數到數組倒數第三位……逆序的for循環。
內層循環過程：遍歷數組，兩兩比較交換，最大的排到最后。
代碼如下：
def bubble_sort(_array):
for i in range(len(_array))[::-1]:
for j in range(i):
if _array[j] > _array[j+1]:
_array[j], _array[j+1] = _array[j+ 1], _array[j]
return _array
if __name__ == '__main__':
_array = [60, 2, 34, 22, 65, 7, 4, 99, 44, 2, 4, 3, 88]
print(bubble_sort(_array))
算法9：簡單排序（又稱：選擇排序、簡單選擇排序）
描述：簡單選擇排序就是把每一個元素都作為一次待排序對象，將數組中待排序對象之后的元素共同作為一個子數組，選出子數組中最小的元素并與待排序對象進行交換。
輸入：一個數組。
外層循環：對于數組中每位元素都做為一次待排序對象。
內層循環：選出當前數組中最小的元素并與待排序對象的值交換。
代碼如下：
def select_sort(_array):
for index in range(len(_array)):
_key = _array[index]
_key_index = index
for each_index in range(len(_array[index:])):
if _array[each_index+index] < _key:
_key = _array[each_index+index]
_key_index = each_index+index
_array[index],_array[_key_index] = _array[_key_index],_array[index]
return _array
if __name__ == '__main__':
_array = [60,298,34,22,65,7,4,99,44,2,4,3,88]
print(select_sort(_array))
總結
以上是生活随笔為你收集整理的金阳光测试算法专题——精选小算法汇总的全部內容，希望文章能夠幫你解決所遇到的問題。
