Algorithme on kenji.blog

FizzBuzz

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

Au fait, qu’est-ce que FizzBuzz ?

Bonjour !

Aujourd’hui, j’aimerais parler de « FizzBuzz ».

Que vous soyez de ceux qui se disent « Ah, je connais ça ! » ou de ceux qui disent « J’en ai entendu parler, mais je ne comprends pas vraiment », restez avec moi un instant. Cela ne prend que quelques minutes à lire, et peut-être vous direz-vous : « C’est logique ».

Est-il vrai que « si vous ne pouvez pas écrire FizzBuzz, vous êtes un mauvais programmeur » ?

FizzBuzz, pour faire simple, c’est ça.

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)

Oui, c’est le fameux « Problème FizzBuzz ».

Vous regardez les nombres de 1 à 100 dans l’ordre,
si c’est un multiple de 3, vous affichez « Fizz », si c’est un multiple de 5, vous affichez « Buzz »,
si c’est un multiple des deux, vous affichez « FizzBuzz » – c’est extrêmement simple.

Et pourtant, pour une raison quelconque, c’est souvent traité comme « le test minimum pour un programmeur ». Il apparaît lors des entretiens, et sur les réseaux sociaux, vous verrez des commentaires du genre « Quelqu’un qui ne peut même pas écrire FizzBuzz… ».

Mais, attendez une minute.

Pouvons-nous vraiment affirmer que « ne pas savoir écrire FizzBuzz = ne pas savoir programmer » ?

Il ne s’agit pas de savoir si on peut le faire, mais si on a l’« état » pour le faire

Il est vrai que FizzBuzz exige une compréhension de la syntaxe et de la pensée logique de base. Il est donc logique qu’il soit utilisé pour « vérifier les bases ».

Mais, voilà.

Si l’environnement est différent, les résultats seront différents.

Par exemple,

Quand vous êtes nerveux devant un recruteur que vous venez de rencontrer
Quand on vous tend soudainement un tableau blanc et que vous n’avez pas d’éditeur sous la main
Quand vous n’arrivez pas à vous souvenir immédiatement de « Au fait, c’est quoi le modulo ? »

…Cela n’arrive-t-il pas ? Nous sommes humains. Je pense que cela arrive.

Par conséquent, plutôt que de dire « pouvez-vous écrire FizzBuzz », je pense qu’il est en fait beaucoup plus important de se demander « pouvez-vous vous mettre dans un état où vous pouvez écrire FizzBuzz ».

Le piège du conseil habituel « Il suffit de s’entraîner et tout ira bien »

Quand ce sujet est abordé, le conseil « Alors entraîne-toi tous les jours ! » a tendance à surgir.

Il est vrai qu’une pratique répétée vous permettra de l’écrire couramment, et c’est en soi une bonne chose. Mais si nous partons du principe que « si vous ne pouvez pas écrire FizzBuzz, vous êtes disqualifié », cela peut facilement se transformer en simple peur.

En d’autres termes, cela tend à créer une structure où vous ressentez que « j’ai fait une erreur = je suis inutile ».

Par exemple, le jour où vous vous réveillez tard, n’avez-vous pas tendance à penser « Je suis un paresseux… » ? Mais il se peut simplement que votre corps ait été fatigué à ce moment-là.

FizzBuzz, c’est la même chose.

Cela dit, FizzBuzz reste une bonne question

Cela dit, FizzBuzz n’est pas une mauvaise chose.

Au contraire, je pense que c’est une question très bien conçue. Les règles sont simples et il est facile de la développer. Par exemple, si vous la modifiez de cette façon, votre réflexion s’approfondira.

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)

C’est un exemple qui montre que « vous pouvez l’écrire même sans if-elif-else ». C’est plutôt astucieux, n’est-ce pas ?

En d’autres termes, FizzBuzz ne consiste pas seulement à savoir « si vous avez réussi à le faire », mais sert également de point d’entrée pour voir « comment vous l’écrivez » et « jusqu’à quel point vous comprenez ».

En résumé

Je pense que nous ne devrions pas accorder trop d’importance au fait de savoir si vous pouvez ou non faire FizzBuzz.

Même si vous n’avez pas réussi à l’écrire, c’est peut-être simplement que « vous ne vous sentiez pas bien sur le moment », et souvent, vous y parviendrez si vous y réfléchissez attentivement plus tard.

Ne vous précipitez pas, avançons lentement.

Le code est écrit par des humains. En tant qu’humains, il nous arrive d’oublier des choses et d’être nerveux. En acceptant cela, je pense qu’il suffit de pouvoir avancer petit à petit.

Alors, écrivons du code de manière détendue aujourd’hui aussi.

Tour de Hanoï

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

Tour de Hanoï

Bonjour !

Aujourd’hui, j’aimerais vous expliquer la “Tour de Hanoï”, à l’aide d’un exemple de programme en Python.

Qu’est-ce que la Tour de Hanoï ?

La Tour de Hanoï est un puzzle qui utilise 3 tiges et plusieurs disques. Les disques sont de tailles différentes et, au début, ils sont empilés sur une tige par ordre décroissant de taille. Les règles sont les suivantes :

Un seul disque peut être déplacé à la fois.
Un grand disque ne peut pas être placé sur un petit disque.

Ce puzzle est considéré comme un excellent matériel pédagogique pour apprendre la pensée récursive. La récursivité est une méthode de résolution d’un problème en le décomposant en problèmes plus petits du même type. Dans la Tour de Hanoï, pour déplacer n disques, nous répétons l’opération de déplacement de n-1 disques.

Résolvons la Tour de Hanoï avec Python

Voici un exemple de code pour résoudre la Tour de Hanoï en 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)

# Exemple : Déplacer 3 disques de A vers C
hanoi(3, 'A', 'C', 'B')

Dans ce code, la fonction hanoi est appelée de manière récursive, et les étapes pour déplacer les disques sont affichées. Par exemple, dans le cas de 3 disques, on obtient le résultat suivant :

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

De cette façon, en utilisant une approche récursive, les problèmes complexes peuvent être résolus simplement.

Combien de temps faut-il pour déplacer 64 disques ?

Le nombre de mouvements dans la Tour de Hanoï nécessite un minimum de 2^n - 1 fois. En d’autres termes, pour déplacer 64 disques, 2^64 - 1 mouvements, soit environ 1,84×10^19 mouvements sont nécessaires. Même si vous pouviez effectuer un mouvement par seconde, cela prendrait environ 584,9 milliards d’années. C’est environ 42 fois l’âge de l’univers (environ 13,7 milliards d’années).

Ainsi, au fur et à mesure que le nombre de disques augmente, le nombre de mouvements nécessaires augmente de manière exponentielle. Par conséquent, déplacer 64 disques dans la pratique n’est pas réaliste.

Résumé

La Tour de Hanoï est un puzzle parfait pour apprendre la pensée récursive. Avec Python, vous pouvez facilement implémenter sa solution. Cependant, soyez prudent, car au fur et à mesure que le nombre de disques augmente, le nombre de mouvements nécessaires augmente considérablement.

En comprenant l’approche récursive et en essayant d’écrire du code, vous pouvez améliorer vos compétences en programmation. N’hésitez pas à relever le défi de la Tour de Hanoï.

Code C pour générer des nombres premiers

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

Voici un code C simple qui génère des nombres premiers dans une plage spécifiée. Dans cet exemple, nous énumérons les nombres premiers de 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("Veuillez entrer la valeur maximale de la plage pour générer des nombres premiers : ");
 scanf("%d", &n);
 printf("Les nombres premiers de 1 à %d sont les suivants :\n", n);
 printPrimes(n);
 return 0;
}

Ce code fonctionne de la manière suivante :

Fonction isPrime : Détermine si un nombre donné est premier. Par souci d’efficacité, on vérifie d’abord s’il est divisible par 2 et 3, puis on procède à la vérification par multiples de 6.
Fonction printPrimes : Produit les nombres premiers dans une plage spécifiée. Le 2 est affiché en premier, puis seuls les nombres impairs sont vérifiés.
Fonction main : Demande à l’utilisateur de saisir la valeur maximale de la plage et affiche les nombres premiers dans cette plage.

Si vous compilez et exécutez ce code, les nombres premiers dans la plage spécifiée seront affichés.

Introduction à Mathematica

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

Introduction à Mathematica

Résoudre des équations

1

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

Sortie

1

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

Trouver les solutions d’une équation dans les entiers

1

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

Sortie

1

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

Résoudre un système d’équations

1

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

Sortie

1

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

Résoudre des inéquations

1

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

Sortie

1

x < 1 || x > 2

Dériver

1

D[x^2, x]

Sortie

1

2 x

Intégrer

1

Integrate[x^2, x]

Sortie

1

x^3/3

Calculer une limite

1

Limit[1/x, x -> 0]

Sortie

1

Infinity

Calculer une série

1

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

Sortie

1

π^2/6

Créer une matrice

1

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

Calculer le produit de matrices

1

m . m

Sortie

1

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

Calculer la matrice inverse

1

Inverse[m]

Sortie

1

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

Calculer les valeurs propres et les vecteurs propres

1

Eigensystem[m]

Sortie

1

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

Calculer le produit scalaire de vecteurs

1

{1, 2} . {3, 4}

Sortie

1

11

Calculer le produit vectoriel

1

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

Sortie

1

{-3, 6, -3}

Calculer la norme d’un vecteur

1

Norm[{1, 2, 3}]

Sortie

1

√14

Calculer l’angle entre des vecteurs

1

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

Sortie

1

ArcCos[11/(√5 √25)]

Calculer la projection d’un vecteur

1

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

Sortie

1

{11/5, 22/5}

Calculer la rotation d’un vecteur

1

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

Sortie

1

{0, 1}

Calculer la translation d’un vecteur

1

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

Sortie

1

{4, 6}

Calculer la mise à l’échelle d’un vecteur

1

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

Sortie

1

{2, 3}

Calculer la réflexion d’un vecteur

1

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

Sortie

1

{0, 0}

Générer des nombres aléatoires

1

RandomReal[]

Sortie

1

0.123456

Générer des nombres aléatoires (entiers)

1

RandomInteger[]

Sortie

1

123456

Générer des nombres aléatoires (plage spécifiée)

1

RandomReal[{1, 10}]

Sortie

1

5.6789

Générer des nombres aléatoires (entiers, plage spécifiée)

1

RandomInteger[{1, 10}]

Sortie

1

5

Générer des nombres aléatoires (distribution spécifiée)

1

RandomVariate[NormalDistribution[0, 1]]

Sortie

1

0.123456

Générer des nombres aléatoires (distribution, quantité spécifiées)

1

RandomVariate[NormalDistribution[0, 1], 10]

Sortie

1

{0.123456, 0.234567, ..., 0.987654}

Générer des nombres aléatoires (distribution, quantité, graine spécifiées)

1
2


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

Sortie

1

{0.123456, 0.234567, ..., 0.987654}

Appliquer une fonction aux éléments d’un tableau

1
2
3


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

Sortie

1

{1, 2, 3}

Définir une fonction avec des expressions lambda

1
2


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

Sortie

1

9

Composer des fonctions

1
2
3
4


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

Sortie

1

16

Faire référence au résultat du calcul précédent

1

% + 1

Sortie

1

17

Fonction pure

1

(#+3)&[5]

Sortie

1

8

Extraction de tableau

1
2


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

Sortie

1

{2, 4}

Résoudre le problème du voyageur de commerce avec Mathematica

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

Résoudre le problème du voyageur de commerce avec Mathematica

Problème

電車でこんな広告を見かけました😁📸 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];

Créez une matrice à l’aide de la fonction SparseArray. Chaque élément représente la distance entre les villes à sa ligne et sa colonne. Par exemple, le premier élément {1,2}->10 signifie que la distance entre 1 et 2 est de 10. L’avant-dernier élément {9,9} indique la taille de la matrice, et le dernier élément Infinity signifie que la longueur du chemin entre les villes non spécifiées est infinie, c’est-à-dire qu’il n’y a pas de chemin.

1

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

Avec la fonction FindShortestTour, vous pouvez facilement résoudre le problème du voyageur de commerce. {1,2,3,4,5,6,7,8,9} représente les numéros de ville. DistanceFunction->(d[[#1,#2]]&) transmet la matrice d qui représente la distance entre les villes.

Sortie

1

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

La sortie correspond à la distance la plus courte et à l’itinéraire de visite à ce moment-là. La distance la plus courte est 137 et l’itinéraire de la visite est 1→2→5→9→8→7→6→3→4→1. En le convertissant dans l’ordre alphabétique ABC, il devient A, B, E, I, H, G, F, C, D.

Énumération des nombres premiers en Rust

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

J’ai écrit un programme pour énumérer les nombres premiers en 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);
 }
}