Algorithm on kenji.blog

Collatz Conjecture

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

Is it true that “any number eventually becomes 1”? ── Playing with the Collatz Conjecture

Hello! I’m kenji.

Suddenly, but if you hear “a rule where any number eventually becomes 1”, isn’t it a bit mysterious?

For example, 19, or 87, or even 1000000. If you tweak the numbers according to appropriate rules, for some reason it converges to “1” at the end.

Such a dream-like story is the Collatz Conjecture.

What is the Collatz Conjecture anyway?

First, let me introduce the rules.

Start: Choose any positive integer
Operation:
- If it is even → Halve it (n → n / 2)
- If it is odd → Triple it and add 1 (n → 3n + 1)

If you repeat this forever, the conjecture says that any number will eventually reach 1.

For example, starting from 6:

1

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

It properly became “1”. Welcome back!

Let’s do it in code: Collatz in Python

Now, in times like this, it’s faster to try it in code! Let’s output the “Collatz sequence” in 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

# Example: Starting from 19
print(collatz(19))

When you execute it:

1

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

It splendidly reaches 1. Even though it takes quite a detour, it firmly reaches the goal at the end!

By the way, even if you start from 29, it reaches 1 in the same way.

1

print(collatz(29))

When you execute it:

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]

Surprisingly, it takes 111 steps!

Moreover, there are scenes where it balloons to over 9000 along the way. It’s a pattern that takes a huge detour before reaching the goal.

So, what’s amazing about it in the end?

What’s amazing about this conjecture is,

Even though it hasn’t been proven, it seems to become 1 no matter what number you use

That’s the point.

Eh? Then, what about 1 trillion, or 10 quadrillion…?

If you thought that, you are sharp. Actually, it has been verified up to about “2 to the 68th power” using computers, and all have reached 1. Unbelievable…

But, it hasn’t been theoretically proven that “it always happens”. This is what they call an “unsolved problem” in the world of mathematics.

Who is Mr. Collatz?

So, reading this far, you might wonder “who is Collatz anyway?”. Let me introduce him properly!

Name: Lothar Collatz
Nationality: Germany
Year of birth: 1910 - 1990
Title: Mathematician (Active in the fields of functional analysis and number theory)

He proposed this conjecture in 1937, and since then, for over 80 years, no one has been able to prove or disprove it.

By the way, this problem is so simple yet so deep that even Paul Erdős (a super famous mathematician) is said to have said this:

“Mathematics may not be ready for such problems.”

In other words, the theory that human mathematics hasn’t caught up with this mystery yet…

No “complex math formulas” are necessary

The good thing about the Collatz Conjecture is that anyone can play with it.

You can do it if you have paper and pen. If you write code in Python, you can test it automatically. And yet, cutting-edge mathematicians are seriously challenging it.

Doesn’t it make you excited?

Bonus: Code to test it all at once

I’ll also include code to test various numbers all at once.

1
2
3


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

This outputs the Collatz sequences from “1 to 20” all at once.

Conclusion: This world is indeed mysterious

So, that’s the Collatz Conjecture.

Even though it’s super simple
No one can prove it
It’s a huge problem in the math community

It’s an existence like a cluster of mysteries.

Even programming beginners can try it, so please definitely play with it~!

FizzBuzz

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

What exactly is FizzBuzz, anyway?

Hello!

Today, I’d like to write about “FizzBuzz”.

Whether you’re thinking, “Ah, I know that one!” or “I’ve heard of it, but don’t really get it,” please stick with me for a bit. It takes just a few minutes to read, and you might just have an “aha” moment.

Is it true that “you’re disqualified as a programmer if you can’t write FizzBuzz”?

Roughly speaking, FizzBuzz looks like this.

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)

Yes, this is the famous “FizzBuzz problem.”

You go through the numbers from 1 to 100 in order,
if it’s a multiple of 3, print “Fizz”, if it’s a multiple of 5, print “Buzz”,
and if it’s a multiple of both, print “FizzBuzz.” It’s extremely simple.

And yet, for some reason, it’s often treated like a “minimum test for programmers.” It comes up in interviews, and on social media you’ll occasionally see people flexing with comments like, “If you can’t even write FizzBuzz…”

But wait a minute.

Can we really definitively say, “Couldn’t write FizzBuzz = can’t program”?

It’s not about whether you can do it, but whether you’re in a “state” to do it

It’s true that FizzBuzz requires an understanding of syntax and basic logical thinking. So it makes sense that it’s used to “check the basics.”

But, hear me out.

If the environment is different, the results will be different.

For example,

When you’re nervous in front of an interviewer you’ve just met
When you’re suddenly handed a whiteboard and don’t have an editor at hand
When you suddenly draw a blank and think, “Wait, what’s modulo again?”

…Doesn’t that happen? We’re human, after all. I think it does.

Therefore, rather than “whether you can write FizzBuzz,” I think what’s actually more important is “whether you can get yourself into a state where you can write FizzBuzz.”

The pitfall of the common advice to “just train and you’ll be fine”

When this topic comes up, the advice “so practice every day!” tends to appear.

It’s true that repeated practice will enable you to write it smoothly, and that in itself is a good thing. But if you stand on the premise that “you’re disqualified if you can’t write FizzBuzz,” it can turn into pure fear.

In other words, it tends to create a structure where you feel, “I made a mistake = I’m useless.”

For example, on days when you oversleep, don’t you tend to think, “I’m lazy…”? But it might just be that your body was accidentally tired.

The same goes for FizzBuzz.

That being said, FizzBuzz is still a good question

That being said, there’s nothing wrong with FizzBuzz.

Rather, I think it’s a very well-made question. The rules are simple, and it’s easy to expand. For example, if you change it like this, it deepens your thinking even more.

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)

This is an example showing that “you don’t have to use if-elif-else to write it.” It’s a bit smart, isn’t it?

In other words, FizzBuzz doesn’t just show “whether you could do it,” but also serves as an entry point to see “how you write it” and “how deeply you understand it.”

In conclusion

I don’t think you need to attach excessive meaning to whether you can do FizzBuzz or not.

Even if you couldn’t write it, it might simply mean “you were just a little off your game,” and often you can do it if you think about it carefully later.

Let’s not rush and proceed slowly.

Code is written by humans. Because we’re human, there are times when we forget things or get nervous. I think it’s enough if we can accept that and move forward little by little.

Well then, let’s take it easy and write some code today too.

Tower of Hanoi

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

Tower of Hanoi

Hello!

Today, I would like to explain the “Tower of Hanoi” along with a Python sample program.

What is the Tower of Hanoi?

The Tower of Hanoi is a puzzle using three rods and multiple disks. The disks vary in size and are initially stacked on one rod in decreasing order of size. The rules are as follows:

Only one disk can be moved at a time.
A larger disk cannot be placed on top of a smaller disk.

This puzzle is considered an excellent teaching material for learning recursive thinking. Recursion is a method of solving a problem by breaking it down into smaller problems of the same type. In the Tower of Hanoi, to move n disks, the operation of moving n-1 disks is repeated.

Let’s Solve the Tower of Hanoi in Python

Below is a sample code to solve the Tower of Hanoi in 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)

# Example: Move 3 disks from A to C
hanoi(3, 'A', 'C', 'B')

In this code, the hanoi function is called recursively, and the steps to move the disks are printed. For example, in the case of 3 disks, you will get the following output:

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

In this way, by using a recursive approach, even complex problems can be solved simply.

How Long Does It Take to Move 64 Disks?

The minimum number of moves for the Tower of Hanoi is 2^n - 1. This means that to move 64 disks, it requires 2^64 - 1 moves, or approximately 1.84 × 10^19 moves. Even if you could make one move per second, it would take about 584.9 billion years. This is roughly 42 times the age of the universe (about 13.7 billion years).

Thus, as the number of disks increases, the required number of moves increases exponentially. Therefore, it is not realistic to actually move 64 disks.

Conclusion

The Tower of Hanoi is a perfect puzzle for learning recursive thinking. Using Python, you can easily implement its solution. However, care must be taken as the required number of moves increases sharply as the number of disks increases.

By understanding the recursive approach and actually writing the code, you can improve your programming skills. By all means, give the Tower of Hanoi a try.

C Language Code to Generate Prime Numbers

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

Here is a simple C language code that generates prime numbers within a specified range. In this example, it enumerates prime numbers from 1 to 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("Please enter the maximum value of the range to generate prime numbers: ");
 scanf("%d", &n);
 printf("The prime numbers from 1 to %d are as follows:\n", n);
 printPrimes(n);
 return 0;
}

This code works as follows:

isPrime function: Determines whether a given number is a prime number. For efficiency, it first checks if it is divisible by 2 or 3, and then proceeds to check using steps of 6.
printPrimes function: Outputs the prime numbers within the specified range. It outputs 2 first, and then checks only odd numbers.
main function: Prompts the user to input the maximum value of the range and outputs the prime numbers within that range.

When you compile and run this code, it will display the prime numbers within the specified range.

Introduction to Mathematica

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

Introduction to Mathematica

Solve an equation

1

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

Output

1

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

Solve an equation within integers

1

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

Output

1

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

Solve simultaneous equations

1

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

Output

1

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

Solve an inequality

1

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

Output

1

x < 1 || x > 2

Differentiate

1

D[x^2, x]

Output

1

2 x

Integrate

1

Integrate[x^2, x]

Output

1

x^3/3

Find a limit

1

Limit[1/x, x -> 0]

Output

1

Infinity

Find a series

1

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

Output

1

π^2/6

Create a matrix

1

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

Find the product of matrices

1

m . m

Output

1

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

Find the inverse matrix

1

Inverse[m]

Output

1

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

Find eigenvalues and eigenvectors

1

Eigensystem[m]

Output

1

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

Find the inner product of vectors

1

{1, 2} . {3, 4}

Output

1

11

Find the cross product of vectors

1

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

Output

1

{-3, 6, -3}

Find the magnitude of a vector

1

Norm[{1, 2, 3}]

Output

1

√14

Find the angle between vectors

1

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

Output

1

ArcCos[11/(√5 √25)]

Find the projection of a vector

1

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

Output

1

{11/5, 22/5}

Find the rotation of a vector

1

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

Output

1

{0, 1}

Find the translation of a vector

1

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

Output

1

{4, 6}

Find the scaling of a vector

1

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

Output

1

{2, 3}

Find the reflection of a vector

1

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

Output

1

{0, 0}

Generate random numbers

1

RandomReal[]

Output

1

0.123456

Generate random numbers (integers)

1

RandomInteger[]

Output

1

123456

Generate random numbers (range specified)

1

RandomReal[{1, 10}]

Output

1

5.6789

Generate random numbers (integers, range specified)

1

RandomInteger[{1, 10}]

Output

1

5

Generate random numbers (distribution specified)

1

RandomVariate[NormalDistribution[0, 1]]

Output

1

0.123456

Generate random numbers (distribution specified, number specified)

1

RandomVariate[NormalDistribution[0, 1], 10]

Output

1

{0.123456, 0.234567, ..., 0.987654}

Generate random numbers (distribution specified, number specified, seed specified)

1
2


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

Output

1

{0.123456, 0.234567, ..., 0.987654}

Apply a function to array elements

1
2
3


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

Output

1

{1, 2, 3}

Define a function using lambda expressions

1
2


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

Output

1

9

Compose functions

1
2
3
4


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

Output

1

16

Reference the previous calculation result

1

% + 1

Output

1

17

Pure functions

1

(#+3)&[5]

Output

1

8

Extract from an array

1
2


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

Output

1

{2, 4}

Solving the Traveling Salesperson Problem with Mathematica

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

Solving the Traveling Salesperson Problem with Mathematica

Problem

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

Solution

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];

We create a matrix using the SparseArray function. Each element represents the distance between cities at the row and column of that element. For example, the first element {1,2}->10 means the distance between 1 and 2 is 10. The second to last element {9,9} indicates the size of the matrix, and the final element Infinity means the length of paths between unspecified cities is infinite, meaning there is no path.

1

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

You can easily solve the traveling salesperson problem with the FindShortestTour function. {1,2,3,4,5,6,7,8,9} represents the city numbers. DistanceFunction->(d[[#1,#2]]&) passes the matrix d which represents the distance between cities.

Output

1

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

The output gives the shortest distance and the tour route for it. The shortest distance is 137, and the route is 1→2→5→9→8→7→6→3→4→1. Converting this to ABC order gives A, B, E, I, H, G, F, C, D.

Enumerate Prime Numbers in Rust

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

I wrote a program to enumerate prime numbers in 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);
 }
}

Algorithm on kenji.blog

Collatz Conjecture

Is it true that “any number eventually becomes 1”? ── Playing with the Collatz Conjecture

What is the Collatz Conjecture anyway?

Let’s do it in code: Collatz in Python

So, what’s amazing about it in the end?

Who is Mr. Collatz?

No “complex math formulas” are necessary

Bonus: Code to test it all at once

Conclusion: This world is indeed mysterious

Recommended Links (For interested people)

FizzBuzz

What exactly is FizzBuzz, anyway?

Is it true that “you’re disqualified as a programmer if you can’t write FizzBuzz”?

It’s not about whether you can do it, but whether you’re in a “state” to do it

The pitfall of the common advice to “just train and you’ll be fine”

That being said, FizzBuzz is still a good question

In conclusion

Tower of Hanoi

Tower of Hanoi

What is the Tower of Hanoi?

Let’s Solve the Tower of Hanoi in Python

How Long Does It Take to Move 64 Disks?

Conclusion

C Language Code to Generate Prime Numbers

Introduction to Mathematica

Introduction to Mathematica

Solve an equation

Solve an equation within integers

Solve simultaneous equations

Solve an inequality

Differentiate

Integrate

Find a limit

Find a series

Create a matrix

Find the product of matrices

Find the inverse matrix

Find eigenvalues and eigenvectors

Find the inner product of vectors

Find the cross product of vectors

Find the magnitude of a vector

Find the angle between vectors

Find the projection of a vector

Find the rotation of a vector

Find the translation of a vector

Find the scaling of a vector

Find the reflection of a vector

Generate random numbers

Generate random numbers (integers)

Generate random numbers (range specified)

Generate random numbers (integers, range specified)

Generate random numbers (distribution specified)

Generate random numbers (distribution specified, number specified)

Generate random numbers (distribution specified, number specified, seed specified)

Apply a function to array elements

Define a function using lambda expressions

Compose functions

Reference the previous calculation result

Pure functions

Extract from an array

Solving the Traveling Salesperson Problem with Mathematica

Solving the Traveling Salesperson Problem with Mathematica

Problem

Solution

Output

Enumerate Prime Numbers in Rust