演算法 on kenji.blog

FizzBuzz

Fri, 18 Apr 2025 00:58:11 +0900

FizzBuzz 到底是什麼？

大家好！

今天我想寫寫關於「FizzBuzz」的事。

無論你是覺得「啊，那個我知道！」的人，還是「好像聽過，但不太清楚」的人，請稍微陪我一下。幾分鐘就能讀完，或許你會覺得「原來如此」。

「不會寫 FizzBuzz 就不夠格當程式設計師」是真的嗎？

簡單來說，FizzBuzz 大概是這樣的東西。

1
2
3
4
5
6
7
8
9


for i in range(1, 101):
 if i % 15 == 0:
 print("FizzBuzz")
 elif i % 3 == 0:
 print("Fizz")
 elif i % 5 == 0:
 print("Buzz")
 else:
 print(i)

沒錯，這就是著名的「FizzBuzz 問題」。

依序查看 1 到 100 的數字，
如果是 3 的倍數就顯示「Fizz」，如果是 5 的倍數就顯示「Buzz」，
如果是兩者的倍數就顯示「FizzBuzz」，非常簡單。

儘管如此，不知為何它常常被當作「程式設計師的最低測試」來對待。面試時會出現，社群網路上也時常看到「連 FizzBuzz 都不會寫的人…」這種高高在上的發言。

不過，請等一下。

真的能斷言「不會寫 FizzBuzz = 不會寫程式」嗎？

不是會不會，而是有沒有會的「狀態」

的確，FizzBuzz 要求對語法的理解和基本的邏輯思考能力。所以用來「確認基礎」是可以理解的。

但是。

環境不同，結果也會不同。

例如，

在初次見面的面試官面前感到緊張時
突然被交給一塊白板，手邊沒有編輯器時
突然想不起「咦，modulo 是什麼來著？」時

……這些情況，難道沒有嗎？畢竟是人類，我想是有的。

所以，與其說「能不能寫出 FizzBuzz」，不如說「能不能讓自己處於能寫出 FizzBuzz 的狀態」，其實才是更重要的。

常見的「多練習就好」建議的陷阱

一談到這個話題，很容易就會出現「所以要每天練習！」這樣的建議。

的確，透過反覆練習就能寫得很流暢，這是事實，本身也是好事。但是，如果站在「不會寫 FizzBuzz 就不及格」的前提下，它有時就會變成單純的恐懼。

也就是說，很容易形成「犯錯了 = 自己很沒用」的感覺。

例如，早上睡過頭的那天，是不是很容易覺得「自己是個懶惰的人…」？但那可能只是身體剛好累了而已。

FizzBuzz 也是一樣的。

雖然這麼說，FizzBuzz 仍是個好問題

儘管如此，並不是說 FizzBuzz 不好。

相反地，我覺得這是一個非常好的問題。規則簡單，也很容易擴充。例如，試著像這樣改變一下，思考就會變得更深。

1
2
3
4
5
6
7


for i in range(1, 101):
 output = ""
 if i % 3 == 0:
 output += "Fizz"
 if i % 5 == 0:
 output += "Buzz"
 print(output or i)

這是一個「不用 if-elif-else 也能寫出來」的例子。感覺有點聰明吧。

也就是說，FizzBuzz 不僅僅是「做不做得到」，它也能成為觀察「如何寫」以及「理解到什麼程度」的入口。

總而言之

我覺得不必對能不能寫出 FizzBuzz 賦予太多過度的意義。

就算寫不出來，那也可能只是「現在狀態不太好」，而且事後仔細想想能寫出來的情況也很多。

不用著急，慢慢前進吧。

程式碼是人類寫的。既然是人類，就有忘記的時候，也有緊張的時候。一邊接受這些，一邊慢慢前進，我想這樣就足夠了。

那麼，今天也輕鬆地寫程式碼吧。

漢諾塔

Thu, 17 Apr 2025 22:23:14 +0900

漢諾塔

你好！

今天，我想透過一個 Python 範例程式來解釋「漢諾塔」。

什麼是漢諾塔？

漢諾塔是一個使用 3 根柱子和多個圓盤的謎題。圓盤的大小各不相同，最初它們按從大到小的順序堆疊在一根柱子上。規則如下：

每次只能移動一個圓盤。
較大的圓盤不能放在較小的圓盤上。

這個謎題被認為是學習遞迴思考的最佳教材。遞迴是一種透過將問題分解成相同類型的更小問題來解決問題的方法。在漢諾塔中，為了移動 n 個圓盤，我們重複移動 n-1 個圓盤的操作。

用 Python 解決漢諾塔

以下是用 Python 解決漢諾塔的範例程式碼。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def hanoi(n, source, target, auxiliary):
 if n == 1:
 print(f"Move disk 1 from {source} to {target}")
 return
 hanoi(n - 1, source, auxiliary, target)
 print(f"Move disk {n} from {source} to {target}")
 hanoi(n - 1, auxiliary, target, source)

# 範例：將 3 個圓盤從 A 移動到 C
hanoi(3, 'A', 'C', 'B')

在這個程式碼中，hanoi 函數被遞迴呼叫，並顯示移動圓盤的步驟。例如，在 3 個圓盤的情況下，可以獲得以下輸出：

1
2
3
4
5
6
7


Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C

透過這種方式，使用遞迴方法，可以簡單地解決複雜的問題。

移動 64 個圓盤需要多長時間？

漢諾塔的移動次數最少需要 2^n - 1 次。也就是說，要移動 64 個圓盤，需要 2^64 - 1 次，約 1.84×10^19 次移動。即使 1 秒移動 1 次，也需要大約 5849 億年。這大約是宇宙年齡（約 137 億年）的 42 倍。

因此，隨著圓盤數量的增加，所需的移動次數呈指數級增長。所以，在現實中移動 64 個圓盤是不切實際的。

總結

漢諾塔是學習遞迴思考的最佳謎題。使用 Python，您可以輕鬆實現其解決方案。然而，請注意，隨著圓盤數量的增加，所需的移動次數會急劇增加。

了解遞迴方法並嘗試實際編寫程式碼，可以幫助您提高程式設計技能。請務必挑戰一下漢諾塔。

生成質數的C語言程式碼

Sat, 24 Aug 2024 09:38:10 +0900

以下是一個簡單的C語言程式碼，用於生成指定範圍內的質數。在這個例子中，我們列舉從1到n的質數。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("請輸入生成質數範圍的最大值: ");
 scanf("%d", &n);
 printf("1到%d之間的質數如下:\n", n);
 printPrimes(n);
 return 0;
}

這段程式碼的運作方式如下：

isPrime函數：判斷給定的數字是否為質數。為了提高效率，首先檢查是否能被2和3整除，然後再以6的倍數進行檢查。
printPrimes函數：輸出指定範圍內的質數。首先輸出2，然後只檢查奇數。
main函數：讓使用者輸入範圍的最大值，並輸出該範圍內的質數。

編譯並執行此程式碼後，將會顯示指定範圍內的質數。

Mathematica 入門

Thu, 25 Jul 2024 01:36:19 +0900

Mathematica 入門

解方程式

1

Solve[x^2 - 3 x + 2 == 0, x]

輸出

1

{{x -> 1}, {x -> 2}}

在整數範圍內求方程式的解

1

Solve[x^2 - 3 x + 2 == 0 && 0 <= x <= 2, x, Integers]

輸出

1

{{x -> 1}, {x -> 2}}

解聯立方程式

1

Solve[{x + y == 3, x - y == 1}, {x, y}]

輸出

1

{{x -> 2, y -> 1}}

解不等式

1

Reduce[x^2 - 3 x + 2 > 0, x]

輸出

1

x < 1 || x > 2

微分

1

D[x^2, x]

輸出

1

2 x

積分

1

Integrate[x^2, x]

輸出

1

x^3/3

求極限

1

Limit[1/x, x -> 0]

輸出

1

Infinity

求級數

1

Sum[1/n^2, {n, 1, Infinity}]

輸出

1

π^2/6

建立矩陣

1

m = {{1, 2}, {3, 4}}

求矩陣乘積

1

m . m

輸出

1

{{7, 10}, {15, 22}}

求反矩陣

1

Inverse[m]

輸出

1

{{-2, 1}, {1.5, -0.5}}

求特徵值與特徵向量

1

Eigensystem[m]

輸出

1

{{5, 0}, {{1, 1}, {1, -1}}}

求向量內積

1

{1, 2} . {3, 4}

輸出

1

11

求向量外積

1

Cross[{1, 2, 3}, {4, 5, 6}]

輸出

1

{-3, 6, -3}

求向量的大小

1

Norm[{1, 2, 3}]

輸出

1

√14

求向量的角度

1

ArcCos[{1, 2} . {3, 4}/(Norm[{1, 2}] Norm[{3, 4}])]

輸出

1

ArcCos[11/(√5 √25)]

求向量的投影

1

{1, 2} . {3, 4}/Norm[{3, 4}] {3, 4}/Norm[{3, 4}]

輸出

1

{11/5, 22/5}

求向量的旋轉

1

RotationMatrix[π/2].{1, 0}

輸出

1

{0, 1}

求向量的平移

1

TranslationTransform[{1, 2}][{3, 4}]

輸出

1

{4, 6}

求向量的縮放

1

ScalingTransform[{2, 3}][{1, 1}]

輸出

1

{2, 3}

求向量的反射

1

ReflectionTransform[{1, 1}][{1, 1}]

輸出

1

{0, 0}

產生亂數

1

RandomReal[]

輸出

1

0.123456

產生亂數（整數）

1

RandomInteger[]

輸出

1

123456

產生亂數（指定範圍）

1

RandomReal[{1, 10}]

輸出

1

5.6789

產生亂數（整數、指定範圍）

1

RandomInteger[{1, 10}]

輸出

1

5

產生亂數（指定分佈）

1

RandomVariate[NormalDistribution[0, 1]]

輸出

1

0.123456

產生亂數（指定分佈、指定數量）

1

RandomVariate[NormalDistribution[0, 1], 10]

輸出

1

{0.123456, 0.234567, ..., 0.987654}

產生亂數（指定分佈、指定數量、指定種子）

1
2


SeedRandom[12345]
RandomVariate[NormalDistribution[0, 1], 10]

輸出

1

{0.123456, 0.234567, ..., 0.987654}

將函數套用至陣列元素

1
2
3


Map[Sqrt, {1, 4, 9}]
Sqrt /@ {1, 4, 9}
Map[#^(1/2)&, {1, 4, 9}]

輸出

1

{1, 2, 3}

使用 Lambda 運算式定義函數

1
2


f = Function[x, x^2]
f[3]

輸出

1

9

合成函數

1
2
3
4


f = Function[x, x^2]
g = Function[x, x + 1]
h = Function[x, f[g[x]]]
h[3]

輸出

1

16

參考前一次的計算結果

1

% + 1

輸出

1

17

純函數

1

(#+3)&[5]

輸出

1

8

擷取陣列

1
2


Select[{1, 2, 3, 4, 5}, EvenQ]
Select[{1, 2, 3, 4, 5}, Mod[#,2]==0&]

輸出

1

{2, 4}

使用 Mathematica 解決旅行推銷員問題

Wed, 12 Oct 2022 19:05:58 +0900

使用 Mathematica 解決旅行推銷員問題

問題

電車でこんな広告を見かけました😁📸 pic.twitter.com/iXEgvtXrpL
— 早稲田大学早水桃子研究室 (@hayamizu_lab) October 11, 2022

解法

1

d=SparseArray[{{1,2}->10,{2,1}->10,{1,5}->15,{5,1}->15,{1,4}->12,{4,1}->12,{1,3}->20,{3,1}->20,{2,5}->10,{5,2}->10,{3,4}->10,{4,3}->10,{3,8}->30,{8,3}->30,{3,7}->20,{7,3}->20,{3,6}->25,{6,3}->25,{4,5}->15,{5,4}->15,{4,8}->20,{8,4}->20,{5,9}->18,{9,5}->18,{5,8}->15,{8,5}->15,{6,7}->5,{7,6}->5,{7,8}->35,{8,7}->35,{8,9}->12,{9,8}->12},{9,9},Infinity];

使用 SparseArray 函數建立矩陣。每個元素代表該元素的行與列對應城市之間的距離。例如，第一個元素 {1,2}->10 表示 1 和 2 之間的距離是 10。倒數第二個元素 {9,9} 表示矩陣的大小，最後一個元素 Infinity 表示未指定城市之間的道路長度無限大。也就是說，意味著沒有道路。

1

{len,tour}=FindShortestTour[{1,2,3,4,5,6,7,8,9},DistanceFunction->(d[[#1,#2]]&)]

透過 FindShortestTour 函數，可以輕鬆解決旅行推銷員問題。{1,2,3,4,5,6,7,8,9} 代表城市編號。DistanceFunction->(d[[#1,#2]]&) 傳遞了代表城市之間距離的矩陣 d。

輸出

1

{137, {1, 2, 5, 9, 8, 7, 6, 3, 4}}

輸出為最短距離及當時的巡迴路線。最短距離為 137，巡迴路線為 1→2→5→9→8→7→6→3→4→1。按照 ABC 順序轉換後，將變為 A, B, E, I, H, G, F, C, D。

在 Rust 中列舉質數

Fri, 09 Sep 2022 07:08:49 +0900

我寫了一個在 Rust 中列舉質數的程式。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}