FizzBuzz & Patterns de Boucles

L'art de maîtriser l'algorithmique de base

Utilisez les flèches, cliquez ou glissez pour naviguer

Objectifs de la leçon

1. Savoir implémenter FizzBuzz

Sans erreur d'ordre de conditions

2. Reconnaître les 5 patterns de boucles

Accumuler, chercher, compter, filtrer, min/max

3. Décomposer un nombre en chiffres

Utilisation de modulo (% 10) et Math.floor()

4. Comprendre la conjecture de Collatz

Et l'implémenter en code

Plan du cours

1

Présenter FizzBuzz

L'exercice le plus célèbre de la programmation, utilisé en entretien

2

Le piège de l'ordre des conditions

Tester % 15 AVANT % 3 et % 5

3

Démo live : coder FizzBuzz ensemble

Faire l'erreur d'ordre puis la corriger

4

Les 5 patterns de boucles

Accumuler, chercher, compter, filtrer, min/max

5

Le schéma universel

Montrer que tous suivent le même schéma : initialiser → boucler → résultat

Le célèbre problème FizzBuzz

Les règles :

  • Pour les multiples de 3, afficher "Fizz"
  • Pour les multiples de 5, afficher "Buzz"
  • Pour les multiples de 3 ET 5, afficher "FizzBuzz"
  • Sinon, afficher le nombre lui-même

⚠️ Le piège de l'ordre

Quelle condition vérifier en premier ?

L'erreur classique : l'ordre

❌ Le piège

if (n % 3 === 0) {

console.log("Fizz");

} else if (n % 5 === 0) {

console.log("Buzz");

} else if (n % 15 === 0) {

// Jamais atteint pour 15!

console.log("FizzBuzz");

}

✅ La solution

// Condition la plus restrictive D'ABORD

if (n % 15 === 0) {

console.log("FizzBuzz");

} else if (n % 3 === 0) {

console.log("Fizz");

} else if (n % 5 === 0) {

console.log("Buzz");

}

Point Clé : Toujours tester la condition la plus spécifique en premier !

Les 5 Patterns de Boucles

Les briques de base de tous les programmes

➕

Accumuler

Somme, concaténation

🔍

Chercher

Trouver un élément

🔢

Compter

Combien d'éléments ?

🧹

Filtrer

Garder selon critère

⚖️

Min/Max

Le plus petit/grand

Le schéma universel

Tous ces patterns suivent EXACTEMENT la même logique en 3 étapes :

1️⃣

Initialiser

Créer une variable AVANT la boucle

let total = 0;

2️⃣

Boucler

Mettre à jour PENDANT la boucle

total += i;

3️⃣

Résultat

Utiliser APRÈS la boucle


return total;

1. Pattern : Accumuler

Calculer une somme, concaténer une chaîne, ou multiplier des valeurs.

// Exemple : Somme des éléments d'un tableau

function calculerSomme(nombres) {

// 1️⃣ Initialiser

let total = 0;

// 2️⃣ Boucler

for (let i = 0; i < nombres.length; i++) {

total += nombres[i];

}

// 3️⃣ Résultat

return total;

}

2. Pattern : Chercher

Vérifier si un élément existe ou trouver sa position.

// Exemple : Trouver si un nombre pair existe

function contientPair(nombres) {

// 1️⃣ Initialiser (hypothèse par défaut)

let trouve = false;

// 2️⃣ Boucler

for (let i = 0; i < nombres.length; i++) {

if (nombres[i] % 2 === 0) {

trouve = true;

break; // Optimisation: on peut s'arrêter

}

}

// 3️⃣ Résultat

return trouve;

}

3. Pattern : Compter

Déterminer combien d'éléments respectent une condition.

// Exemple : Compter le nombre de majuscules

function compterMajuscules(texte) {

// 1️⃣ Initialiser

let compteur = 0;

// 2️⃣ Boucler

for (let i = 0; i < texte.length; i++) {

if (texte[i] >= 'A' && texte[i] <= 'Z') {

compteur++;

}

}

// 3️⃣ Résultat

return compteur;

}

4. Pattern : Filtrer

Construire une nouvelle liste en gardant seulement certains éléments.

// Exemple : Garder uniquement les nombres positifs

function garderPositifs(nombres) {

// 1️⃣ Initialiser (tableau vide)

let resultats = [];

// 2️⃣ Boucler

for (let i = 0; i < nombres.length; i++) {

if (nombres[i] > 0) {

resultats.push(nombres[i]);

}

}

// 3️⃣ Résultat

return resultats;

}

5. Pattern : Min/Max

Trouver le plus grand ou le plus petit élément d'une série.

// Exemple : Trouver le plus grand nombre

function trouverMax(nombres) {

// 1️⃣ Initialiser AVEC LE PREMIER ÉLÉMENT

let max = nombres[0];

// 2️⃣ Boucler (on peut commencer à 1)

for (let i = 1; i < nombres.length; i++) {

if (nombres[i] > max) {

max = nombres[i]; // Nouveau record !

}

}

// 3️⃣ Résultat

return max;

}

⚠️ Pièges d'initialisation (Étape 1)

Pattern Accumuler

Pour une somme (+) : let sum = 0;

Pour un produit (*) : let prod = 1; (0 annulerait tout !)

Pattern Min/Max

Ne jamais initialiser avec 0 !

Si on cherche le max de [-10, -5, -20], si max = 0 au départ, le résultat sera 0 (faux !)

Toujours initialiser avec le premier élément : let max = array[0];

Décomposer un nombre en chiffres

Comment récupérer chaque chiffre d'un nombre (ex: 456) ?

1. Récupérer le dernier chiffre

On utilise le modulo 10 (% 10)

456 % 10 // Résultat : 6

2. Enlever le dernier chiffre

On divise par 10 et on arrondit vers le bas

Math.floor(456 / 10) // Résultat : 45

while (n > 0) {
  let chiffre = n % 10;
  // faire quelque chose avec le chiffre
  n = Math.floor(n / 10);
}

La Conjecture de Collatz

Aussi appelée "Suite de Syracuse"

La règle est simple :

  • On prend un nombre entier positif n
  • Si n est pair, on le divise par 2 : n = n / 2
  • Si n est impair, on le multiplie par 3 et on ajoute 1 : n = n * 3 + 1
  • On répète l'opération tant que n > 1

La conjecture dit que, quel que soit le nombre de départ, on finit TOUJOURS par arriver à 1 !

À retenir !

🎯 FizzBuzz : L'ordre compte ! Du plus spécifique au plus général.

🔄 Boucles : Initialiser → Boucler → Résultat. C'est universel.

⚠️ Initialisation : Attention aux Min/Max et aux Produits (*).

Place au code ! 🚀