Algorithmus on kenji.blog

FizzBuzz

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

Was genau ist eigentlich FizzBuzz?

Hallo!

Heute möchte ich über „FizzBuzz“ schreiben.

Egal, ob du denkst „Ah, das kenne ich!“, oder ob du sagst „Ich habe davon gehört, es aber nicht wirklich verstanden“, bitte bleib einen Moment bei mir. Es dauert nur wenige Minuten, es zu lesen, und vielleicht denkst du danach: „Das ergibt Sinn.“

Stimmt es, dass man „als Programmierer versagt hat, wenn man FizzBuzz nicht schreiben kann“?

FizzBuzz ist kurz gesagt so etwas.

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)

Ja, das ist das berühmte „FizzBuzz-Problem“.

Man betrachtet nacheinander die Zahlen von 1 bis 100,
wenn es ein Vielfaches von 3 ist, gibt man „Fizz“ aus, wenn es ein Vielfaches von 5 ist, „Buzz“,
wenn es ein Vielfaches von beiden ist, gibt man „FizzBuzz“ aus – es ist wirklich sehr einfach.

Und dennoch wird es aus irgendeinem Grund oft als „der minimale Test für einen Programmierer“ behandelt. Es taucht in Vorstellungsgesprächen auf, und in den sozialen Medien sieht man Kommentare wie „Jemand, der nicht einmal FizzBuzz schreiben kann…“.

Aber Moment mal.

Können wir wirklich behaupten, dass „FizzBuzz nicht schreiben können = nicht programmieren können“ bedeutet?

Es geht nicht um das Können, sondern darum, ob man den „Zustand“ dafür hat

Es stimmt, dass FizzBuzz das Verständnis von Syntax und grundlegendem logischem Denken erfordert. Daher ist es nachvollziehbar, dass es zur „Überprüfung der Grundlagen“ verwendet wird.

Aber hier ist der Punkt.

Wenn die Umgebung anders ist, sind auch die Ergebnisse anders.

Zum Beispiel,

Wenn man vor einem Interviewer nervös ist, den man gerade erst kennengelernt hat
Wenn einem plötzlich ein Whiteboard übergeben wird und man keinen Editor zur Hand hat
Wenn einem nicht sofort einfällt: „Warte, was ist noch mal Modulo?“

…Kommt das nicht vor? Wir sind Menschen. Ich denke, das passiert.

Deshalb glaube ich, dass die Frage, „ob man sich in einen Zustand versetzen kann, in dem man FizzBuzz schreiben kann“, eigentlich viel wichtiger ist, als einfach nur „ob man FizzBuzz schreiben kann“.

Die Falle des üblichen Ratschlags „Einfach üben, dann wird alles gut“

Wenn dieses Thema aufkommt, neigen die Leute oft zu dem Ratschlag: „Dann übe jeden Tag!“.

Es ist wahr, dass wiederholte Übung dazu führt, dass man es fließend schreiben kann, und das ist an sich eine gute Sache. Aber wenn wir von der Prämisse ausgehen, dass „man disqualifiziert ist, wenn man FizzBuzz nicht schreiben kann“, kann sich das leicht in bloße Angst verwandeln.

Mit anderen Worten, es neigt dazu, eine Struktur zu schaffen, in der man das Gefühl hat: „Ich habe einen Fehler gemacht = ich bin nutzlos.“

Zum Beispiel, wenn man an einem Tag verschläft, neigt man dann nicht dazu zu denken: „Ich bin faul…“? Aber es könnte einfach sein, dass der Körper in diesem Moment erschöpft war.

Bei FizzBuzz ist es genauso.

Abgesehen davon ist FizzBuzz immer noch eine gute Frage

Trotzdem ist FizzBuzz nichts Schlechtes.

Vielmehr denke ich, dass es eine sehr gut durchdachte Frage ist. Die Regeln sind einfach und es lässt sich leicht erweitern. Wenn man es zum Beispiel so ändert, wird das Denken vertieft.

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)

Dies ist ein Beispiel dafür, dass „man es auch ohne if-elif-else schreiben kann“. Das ist ziemlich smart, oder?

Mit anderen Worten, bei FizzBuzz geht es nicht nur darum, „ob man es geschafft hat“, sondern es dient auch als Einstiegspunkt, um zu sehen, „wie man es schreibt“ und „wie viel man versteht“.

Zusammenfassend

Ich denke, wir sollten der Frage, ob man FizzBuzz programmieren kann oder nicht, zu viel Bedeutung beimessen.

Selbst wenn man es nicht schreiben konnte, könnte es einfach daran liegen, dass „man sich gerade nicht wohlgefühlt hat“, und oft kann man es später tun, wenn man sorgfältig darüber nachdenkt.

Keine Eile, lass uns langsam vorankommen.

Code wird von Menschen geschrieben. Weil wir Menschen sind, vergessen wir manchmal Dinge und sind nervös. Wenn wir das akzeptieren, reicht es meiner Meinung nach aus, wenn wir Stück für Stück vorankommen können.

Lass uns also auch heute wieder ganz entspannt Code schreiben.

Türme von Hanoi

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

Türme von Hanoi

Hallo!

Heute möchte ich Ihnen die “Türme von Hanoi” anhand eines Python-Beispielprogramms erklären.

Was sind die Türme von Hanoi?

Die Türme von Hanoi sind ein Puzzle, das 3 Stäbe und mehrere Scheiben verwendet. Die Scheiben sind unterschiedlich groß und liegen zu Beginn der Größe nach absteigend auf einem Stab. Die Regeln lauten wie folgt:

Es kann immer nur eine Scheibe bewegt werden.
Eine größere Scheibe darf nicht auf eine kleinere Scheibe gelegt werden.

Dieses Puzzle gilt als hervorragendes Lehrmaterial, um rekursives Denken zu erlernen. Rekursion ist eine Methode zur Lösung eines Problems, indem man es in kleinere Probleme derselben Art zerlegt. Bei den Türmen von Hanoi wiederholen wir die Operation, n-1 Scheiben zu bewegen, um n Scheiben zu bewegen.

Lösen wir die Türme von Hanoi mit Python

Unten sehen Sie einen Beispielcode zur Lösung der Türme von 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)

# Beispiel: 3 Scheiben von A nach C bewegen
hanoi(3, 'A', 'C', 'B')

In diesem Code wird die Funktion hanoi rekursiv aufgerufen, und die Schritte zum Bewegen der Scheiben werden angezeigt. Bei 3 Scheiben erhält man beispielsweise die folgende Ausgabe:

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

Auf diese Weise lassen sich komplexe Probleme durch einen rekursiven Ansatz einfach lösen.

Wie lange dauert es, 64 Scheiben zu bewegen?

Die Anzahl der Züge bei den Türmen von Hanoi erfordert mindestens 2^n - 1 mal. Um 64 Scheiben zu bewegen, sind also 2^64 - 1 Züge, etwa 1,84×10^19 Züge erforderlich. Selbst wenn Sie einen Zug pro Sekunde machen könnten, würde es etwa 584,9 Milliarden Jahre dauern. Das ist etwa das 42-fache des Alters des Universums (etwa 13,7 Milliarden Jahre).

Mit zunehmender Anzahl von Scheiben steigt also die Anzahl der erforderlichen Züge exponentiell an. Daher ist es unrealistisch, in der Praxis 64 Scheiben zu bewegen.

Zusammenfassung

Die Türme von Hanoi sind ein perfektes Puzzle, um rekursives Denken zu lernen. Mit Python können Sie die Lösung leicht implementieren. Seien Sie jedoch vorsichtig, da die Anzahl der erforderlichen Züge drastisch ansteigt, wenn die Anzahl der Scheiben zunimmt.

Indem Sie den rekursiven Ansatz verstehen und versuchen, tatsächlich Code zu schreiben, können Sie Ihre Programmierfähigkeiten verbessern. Bitte versuchen Sie sich an der Herausforderung der Türme von Hanoi.

C-Code zur Generierung von Primzahlen

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

Nachfolgend finden Sie einen einfachen C-Code, der Primzahlen innerhalb eines bestimmten Bereichs generiert. In diesem Beispiel zählen wir Primzahlen von 1 bis n auf.

 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("Bitte geben Sie den Maximalwert des Bereichs ein, um Primzahlen zu generieren: ");
 scanf("%d", &n);
 printf("Die Primzahlen von 1 bis %d sind wie folgt:\n", n);
 printPrimes(n);
 return 0;
}

Dieser Code funktioniert wie folgt:

Funktion isPrime: Bestimmt, ob eine gegebene Zahl eine Primzahl ist. Aus Effizienzgründen wird zunächst geprüft, ob sie durch 2 und 3 teilbar ist, und dann in Vielfachen von 6 weitergeprüft.
Funktion printPrimes: Gibt die Primzahlen innerhalb eines bestimmten Bereichs aus. Die 2 wird zuerst ausgegeben, und dann werden nur ungerade Zahlen überprüft.
Funktion main: Fordert den Benutzer auf, den Maximalwert des Bereichs einzugeben, und gibt die Primzahlen innerhalb dieses Bereichs aus.

Wenn Sie diesen Code kompilieren und ausführen, werden die Primzahlen innerhalb des angegebenen Bereichs angezeigt.

Einführung in Mathematica

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

Einführung in Mathematica

Gleichungen lösen

1

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

Ausgabe

1

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

Lösungen von Gleichungen im Bereich der ganzen Zahlen finden

1

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

Ausgabe

1

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

Gleichungssysteme lösen

1

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

Ausgabe

1

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

Ungleichungen lösen

1

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

Ausgabe

1

x < 1 || x > 2

Ableiten

1

D[x^2, x]

Ausgabe

1

2 x

Integrieren

1

Integrate[x^2, x]

Ausgabe

1

x^3/3

Grenzwerte berechnen

1

Limit[1/x, x -> 0]

Ausgabe

1

Infinity

Reihen berechnen

1

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

Ausgabe

1

π^2/6

Matrix erstellen

1

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

Matrixprodukt berechnen

1

m . m

Ausgabe

1

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

Inverse Matrix berechnen

1

Inverse[m]

Ausgabe

1

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

Eigenwerte und Eigenvektoren berechnen

1

Eigensystem[m]

Ausgabe

1

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

Skalarprodukt von Vektoren berechnen

1

{1, 2} . {3, 4}

Ausgabe

1

11

Kreuzprodukt von Vektoren berechnen

1

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

Ausgabe

1

{-3, 6, -3}

Betrag eines Vektors berechnen

1

Norm[{1, 2, 3}]

Ausgabe

1

√14

Winkel von Vektoren berechnen

1

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

Ausgabe

1

ArcCos[11/(√5 √25)]

Projektion von Vektoren berechnen

1

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

Ausgabe

1

{11/5, 22/5}

Rotation von Vektoren berechnen

1

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

Ausgabe

1

{0, 1}

Translation von Vektoren berechnen

1

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

Ausgabe

1

{4, 6}

Skalierung von Vektoren berechnen

1

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

Ausgabe

1

{2, 3}

Reflexion von Vektoren berechnen

1

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

Ausgabe

1

{0, 0}

Zufallszahlen generieren

1

RandomReal[]

Ausgabe

1

0.123456

Zufallszahlen generieren (ganze Zahlen)

1

RandomInteger[]

Ausgabe

1

123456

Zufallszahlen generieren (Bereich angegeben)

1

RandomReal[{1, 10}]

Ausgabe

1

5.6789

Zufallszahlen generieren (ganze Zahlen, Bereich angegeben)

1

RandomInteger[{1, 10}]

Ausgabe

1

5

Zufallszahlen generieren (Verteilung angegeben)

1

RandomVariate[NormalDistribution[0, 1]]

Ausgabe

1

0.123456

Zufallszahlen generieren (Verteilung, Menge angegeben)

1

RandomVariate[NormalDistribution[0, 1], 10]

Ausgabe

1

{0.123456, 0.234567, ..., 0.987654}

Zufallszahlen generieren (Verteilung, Menge, Seed angegeben)

1
2


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

Ausgabe

1

{0.123456, 0.234567, ..., 0.987654}

Funktion auf Array-Elemente anwenden

1
2
3


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

Ausgabe

1

{1, 2, 3}

Funktion mit Lambda-Ausdrücken definieren

1
2


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

Ausgabe

1

9

Funktionen komponieren

1
2
3
4


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

Ausgabe

1

16

Auf vorheriges Berechnungsergebnis verweisen

1

% + 1

Ausgabe

1

17

Reine Funktion

1

(#+3)&[5]

Ausgabe

1

8

Array extrahieren

1
2


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

Ausgabe

1

{2, 4}

Lösung des Problems des Handlungsreisenden mit Mathematica

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

Lösung des Problems des Handlungsreisenden mit Mathematica

Problem

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

Lösung

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

Erstellen Sie eine Matrix mit der Funktion SparseArray. Jedes Element repräsentiert die Entfernung zwischen den Städten in seiner Zeile und Spalte. Das erste Element {1,2}->10 bedeutet beispielsweise, dass die Entfernung zwischen 1 und 2 gleich 10 ist. Das vorletzte Element {9,9} gibt die Größe der Matrix an, und das letzte Element Infinity bedeutet, dass die Weglänge zwischen nicht angegebenen Städten unendlich ist, das heißt, es gibt keinen Weg.

1

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

Mit der Funktion FindShortestTour können Sie das Problem des Handlungsreisenden ganz einfach lösen. {1,2,3,4,5,6,7,8,9} repräsentiert die Stadtnummern. DistanceFunction->(d[[#1,#2]]&) übergibt die Matrix d, die die Entfernung zwischen den Städten darstellt.

Ausgabe

1

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

Die Ausgabe ist die kürzeste Entfernung und die Tourroute zu diesem Zeitpunkt. Die kürzeste Entfernung ist 137, und die Tourroute ist 1→2→5→9→8→7→6→3→4→1. Bei der Konvertierung in die alphabetische ABC-Reihenfolge wird es zu A, B, E, I, H, G, F, C, D.

Aufzählung von Primzahlen in Rust

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

Ich habe ein Programm geschrieben, um Primzahlen in Rust aufzuzählen.

 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);
 }
}