Boucles imbriquées

Fait partie de la section Fundamentals du Journey Rust de Coddy — leçon 41 sur 75.

Une boucle imbriquée est simplement une boucle à l'intérieur d'une autre boucle. La boucle interne effectuera toutes ses itérations pour chaque itération de la boucle externe. Une bonne analogie pour cela est une horloge : pour chaque heure (boucle externe), l'aiguille des minutes (boucle interne) doit effectuer son cycle complet de 60 minutes.

Exemple d'une boucle imbriquée :

for x in 0..2 {
    for y in 0..2 {
        println!("{} {}", x, y);
    }
}
// Cela affichera :
// 0 0
// 0 1
// 1 0
// 1 1

La boucle externe (x) s'exécute deux fois, et pour chacune de ces fois, la boucle interne (y) s'exécute deux fois.

Défi

Débutant

Écrivez un programme qui trouve tous les triplets de nombres dont la somme est égale à n en utilisant des nombres de 1 à n - 1. Le programme doit afficher toutes les combinaisons possibles où le premier nombre est inférieur ou égal au deuxième nombre, et le deuxième nombre est inférieur ou égal au troisième nombre (c'est-à-dire, dans un ordre non décroissant). Cela garantit que nous n'avons pas de triplets en double comme "1 2 7" et "2 1 7" qui représentent le même ensemble de nombres.

Par exemple, si n = 10, la sortie doit être :

Parce que :

1 + 1 + 8 = 10
1 + 2 + 7 = 10
1 + 3 + 6 = 10
1 + 4 + 5 = 10
2 + 2 + 6 = 10
2 + 3 + 5 = 10
2 + 4 + 4 = 10
3 + 3 + 4 = 10

Ordre d'affichage : Les triplets doivent être affichés par ordre croissant. Le premier nombre doit itérer du plus petit au plus grand, et pour chaque premier nombre, le deuxième nombre doit itérer du premier nombre jusqu'à la valeur maximale valide, en garantissant a ≤ b ≤ c.

Aide-mémoire

Une boucle imbriquée est une boucle à l'intérieur d'une autre boucle. La boucle interne effectue toutes ses itérations pour chaque itération de la boucle externe.

Structure de base d'une boucle imbriquée :

for x in 0..2 {
    for y in 0..2 {
        println!("{} {}", x, y);
    }
}
// Sortie :
// 0 0
// 0 1
// 1 0
// 1 1

La boucle externe s'exécute complètement et, pour chaque itération de la boucle externe, la boucle interne effectue son cycle complet.

Essayez vous-même

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let n: i32 = input.trim().parse().unwrap();
    // Écrivez votre code ci-dessous

}