算法 on kenji.blog

考拉兹猜想

Tue, 15 Jul 2025 18:03:03 +0900

“任何数字最终都会变成1”是真的吗？——玩转考拉兹猜想

大家好！我是kenji。

突然问一下，如果你听说“任何数字最终都会变成1的规则”，会不会觉得有些不可思议？

比如19，或者87，甚至1000000也是如此。按照特定的规则去处理数字，不知为何最后都会收敛到“1”。

像梦一样的故事，这就是 考拉兹猜想（Collatz Conjecture）。

考拉兹猜想究竟是什么？

首先介绍一下规则。

起点：选择任意一个 正整数
操作：
- 如果是偶数 → 减半（n → n / 2）
- 如果是奇数 → 乘以3再加1（n → 3n + 1）

一直重复这个过程，猜想认为 任何数字最终都会到达1。

比如，从 6 开始：

1

6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1

确实变成了“1”。欢迎回来！

用代码试试看：用Python写考拉兹猜想

好了，这种时候写代码测试最快！让我们用Python输出一下“考拉兹数列”。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def collatz(n):
 steps = [n]
 while n != 1:
 if n % 2 == 0:
 n = n // 2
 else:
 n = 3 * n + 1
 steps.append(n)
 return steps

# 例子：从19开始
print(collatz(19))

运行结果：

1

[19, 58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]

完美到达了1。虽然绕了不少远路，但最后还是顺利冲过终点！

顺便说一下，即使从 27 开始，也同样会到达1。

1

print(collatz(27))

运行结果：

1
2
3
4
5
6
7
8


[27, 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242,
121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350,
175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167,
502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479,
1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911,
2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732,
866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35,
106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]

竟然花了111步！

而且，中途还有膨胀到9000以上的阶段。这真是绕了天大的远路才到达终点的模式啊。

那么，到底哪里厉害呢？

这个猜想的厉害之处在于，

虽然还没有被证明，但似乎不管用什么数字来算都会变成1

这一点。

诶？那1兆呢，1京呢……？

能想到这点的你很敏锐。实际上，用计算机已经验证到了“2的68次方”左右， 全部都到达了1。难以置信……。

但是，“全部都会这样”并没有在理论上被证明。这就是数学世界里的“未解决问题”。

考拉兹是谁？

读到这里，你肯定会想“考拉兹到底是谁？”吧。下面就好好介绍一下！

姓名：洛塔尔·考拉兹（Lothar Collatz）
国籍：德国
生卒年：1910年〜1990年
头衔：数学家（活跃于泛函分析和数论领域）

他在1937年提出了这个猜想，此后，在长达80多年的时间里，谁也没能证明，也没能推翻。

顺便一提，这个问题虽然如此简单，却又无比深奥，以至于连保罗·埃尔德什（超著名的数学家）都这样说过：

“数学还没有成熟到足以解决考拉兹猜想。”

也就是说，人类的数学水平可能还没赶上这个谜团……。

不需要“复杂的公式”

考拉兹猜想的美妙之处在于，任何人都能玩。

只要有纸和笔就能算。用Python写几行代码，就能自动测试。不仅如此，最顶尖的数学家们也在认真挑战它。

怎么样，是不是让人热血沸腾？

彩蛋：一次性测试的代码

这里也附上可以一次性测试多个数字的代码。

1
2
3


for n in range(1, 21):
 steps = collatz(n)
 print(f"{n}: {steps}（步数: {len(steps)-1}）")

这能一口气输出“1～20”的考拉兹数列。

结论：这个世界，果然很不可思议

这就是考拉兹猜想。

明明极其简单
却没人能证明
在数学界是个大难题

它就像是一个不可思议的集合体。

即使是编程初学者也能尝试，请务必玩玩看哦〜！

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根柱子和多个圆盘的益智游戏。圆盘大小不一，最初按照从大到小的顺序堆叠在一根柱子上。规则如下：

每次只能移动1个圆盘。
较小的圆盘上不能放置较大的圆盘。

这个益智游戏被认为是学习递归思维的最佳教材。递归是一种将某个问题分解为同类型的较小问题来解决的方法。在汉诺塔中，为了移动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 次移动。即使每秒移动一次，大约也需要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);
 }
}

算法 on kenji.blog

考拉兹猜想

“任何数字最终都会变成1”是真的吗？——玩转考拉兹猜想

考拉兹猜想究竟是什么？

用代码试试看：用Python写考拉兹猜想

那么，到底哪里厉害呢？

考拉兹是谁？

不需要“复杂的公式”

彩蛋：一次性测试的代码

结论：这个世界，果然很不可思议

推荐链接（面向感兴趣的人）

FizzBuzz

FizzBuzz到底是什么？

“写不出FizzBuzz就不配当程序员”是真的吗？

重要的不是会不会，而是有没有处于能做到的“状态”

常见的“只要训练就行”这种建议的陷阱

话虽如此，FizzBuzz确实是个好问题

所以说

汉诺塔

汉诺塔

什么是汉诺塔？

让我们用Python来解汉诺塔

移动64个圆盘需要多长时间？

总结

生成素数的C语言代码

Mathematica入门

Mathematica入门

解方程

在整数范围内求方程的解

解方程组

解不等式

微分

积分

求极限

求级数

创建矩阵

求矩阵乘积

求逆矩阵

求特征值与特征向量

求向量的点积

求向量的叉积

求向量的模（大小）

求向量的夹角

求向量的投影

求向量的旋转

求向量的平移

求向量的缩放

求向量的反转（反射）

生成随机数

生成随机数（整数）

生成随机数（指定范围）

生成随机数（整数、指定范围）

生成随机数（指定分布）

生成随机数（指定分布、指定数量）

生成随机数（指定分布、指定数量、指定种子）

对数组元素应用函数

使用Lambda表达式定义函数

复合函数

引用上一次的计算结果

纯函数

数组提取

用 Mathematica 解决旅行商问题

用 Mathematica 解决旅行商问题

问题

解法

输出

在 Rust 中枚举素数