Exercices corrigés sur les boucles en Python, Java et langage C

En programmation, une boucle est une séquence d'instructions qui se répète jusqu'à ce qu'une certaine condition soit atteinte. Les boucles permettent d'automatiser des tâches répétitives sans réécrire le même code.

Types de boucles Il existe trois types principaux de boucles :
— for : utilisée quand le nombre d'itérations est connu à l'avance.
— while : répète tant qu'une condition est vraie (vérification avant chaque itération).
— do-while (C/Java) : comme while, mais la condition est vérifiée après la première exécution (au moins une itération garantie).

Syntaxe des trois boucles C

/* Boucle for */
for (initialisation; condition; incrément) {
    /* instructions */
}

/* Boucle while */
while (condition) {
    /* instructions */
}

/* Boucle do-while */
do {
    /* instructions */
} while (condition);

Conseil avant de commencer Pour chaque exercice, identifiez d'abord : le point de départ, la condition d'arrêt et la mise à jour du compteur. Ce sont les trois éléments fondamentaux de toute boucle.

Exercice 1 — Nombres naturels de 1 à n

Exercice

Afficher tous les naturels de 1 à n

Niveau : Débutant

Écrire un programme qui lit un entier n et affiche tous les nombres naturels de 1 à n en utilisant une boucle for puis une boucle while.

Solution détaillée

for : initialiser i = 1, condition i <= n, incrémenter i++.
while : même logique — initialiser i avant la boucle, incrémenter à l'intérieur.

Version avec for

#include <stdio.h>

int main()
{
    int i, n;
    printf("Saisir n : ");
    scanf("%d", &n);

    printf("Nombres naturels de 1 à %d :\n", n);

    /* --- Version for --- */
    for (i = 1; i <= n; i++)
        printf("%d  ", i);

    printf("\n");

    /* --- Version while --- */
    i = 1;
    while (i <= n) {
        printf("%d  ", i);
        i++;
    }

    return 0;
}

n = int(input("Saisir n : "))
print(f"Nombres naturels de 1 à {n} :")

# --- Version for ---
for i in range(1, n + 1):
    print(i, end="  ")

print()

# --- Version while ---
i = 1
while i <= n:
    print(i, end="  ")
    i += 1

import java.util.Scanner;

public class NombresNaturels {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir n : ");
        int n = clavier.nextInt();

        System.out.println("Nombres naturels de 1 à " + n + " :");

        // --- Version for ---
        for (int i = 1; i <= n; i++)
            System.out.print(i + "  ");

        System.out.println();

        // --- Version while ---
        int i = 1;
        while (i <= n) {
            System.out.print(i + "  ");
            i++;
        }
        clavier.close();
    }
}

Sortie

Nombres naturels de 1 à 5 :
1  2  3  4  5

Exemple

Entrée

Sortie

1  2  3  4  5

Explication : La boucle parcourt i de 1 à 5 inclus et affiche chaque valeur.

Contraintes

1 ≤ n ≤ 10⁶

Exercice 2 — Nombres naturels en sens inverse (n → 1)

Exercice

Afficher les entiers de n jusqu'à 1 (décroissant)

Niveau : Débutant

Écrire un programme qui lit n et affiche tous les entiers de n à 1 par ordre décroissant.

Solution détaillée

Initialiser i = n, condition i >= 1, décrémenter i--.
En Python, utiliser range(n, 0, -1) — le troisième argument est le pas (négatif ici).

#include <stdio.h>

int main()
{
    int i, n;
    printf("Saisir n : ");
    scanf("%d", &n);

    for (i = n; i >= 1; i--)
        printf("%d  ", i);

    return 0;
}

n = int(input("Saisir n : "))

for i in range(n, 0, -1):   # pas = -1 → décroissant
    print(i, end="  ")

import java.util.Scanner;

public class InverseNaturels {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir n : ");
        int n = clavier.nextInt();

        for (int i = n; i >= 1; i--)
            System.out.print(i + "  ");

        clavier.close();
    }
}

Sortie

5  4  3  2  1

Exemple

Entrée

Sortie

5  4  3  2  1

Explication : La boucle part de n=5 et décrémente jusqu'à 1.

Exercice 3 — Nombres pairs de 1 à n

Exercice

Afficher tous les nombres pairs entre 1 et n

Niveau : Débutant

Écrire un programme qui lit n et affiche tous les nombres pairs compris entre 1 et n.

Solution détaillée

Méthode 1 : parcourir de 1 à n et tester i % 2 == 0.
Méthode 2 (plus efficace) : démarrer à 2 et incrémenter de 2 en 2 → i += 2 ou range(2, n+1, 2). Cette approche évite les tests inutiles.

Optimisation — pas de 2 Partir de 2 avec un pas de +2 est deux fois plus rapide que parcourir tous les entiers et tester la parité. Pour de très grandes valeurs de n, cette optimisation est significative.

#include <stdio.h>

int main()
{
    int i, n;
    printf("Saisir n : ");
    scanf("%d", &n);

    printf("Nombres pairs de 1 à %d :\n", n);

    /* Méthode optimisée : pas de 2 */
    for (i = 2; i <= n; i += 2)
        printf("%d  ", i);

    return 0;
}

n = int(input("Saisir n : "))
print(f"Nombres pairs de 1 à {n} :")

# Méthode optimisée : range avec pas 2
for i in range(2, n + 1, 2):
    print(i, end="  ")

import java.util.Scanner;

public class NombresPairs {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir n : ");
        int n = clavier.nextInt();

        System.out.println("Nombres pairs de 1 à " + n + " :");
        for (int i = 2; i <= n; i += 2)
            System.out.print(i + "  ");

        clavier.close();
    }
}

Sortie

Nombres pairs de 1 à 11 :
2  4  6  8  10

Exemple

Entrée

Sortie

2  4  6  8  10

Explication : On parcourt 2, 4, 6, 8, 10 — tous ≤ 11.

Exercice 4 — Nombres impairs de 1 à n

Exercice

Afficher tous les nombres impairs entre 1 et n

Niveau : Débutant

Écrire un programme qui lit n et affiche tous les nombres impairs compris entre 1 et n.

Solution détaillée

Démarrer à 1 (premier impair) avec un pas de +2.
Condition : i % 2 != 0, ou mieux, utiliser directement range(1, n+1, 2).

#include <stdio.h>

int main()
{
    int i, n;
    printf("Saisir n : ");
    scanf("%d", &n);

    printf("Nombres impairs de 1 à %d :\n", n);

    for (i = 1; i <= n; i += 2)
        printf("%d  ", i);

    return 0;
}

n = int(input("Saisir n : "))
print(f"Nombres impairs de 1 à {n} :")

for i in range(1, n + 1, 2):
    print(i, end="  ")

import java.util.Scanner;

public class NombresImpairs {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir n : ");
        int n = clavier.nextInt();

        System.out.println("Nombres impairs de 1 à " + n + " :");
        for (int i = 1; i <= n; i += 2)
            System.out.print(i + "  ");

        clavier.close();
    }
}

Sortie

Nombres impairs de 1 à 11 :
1  3  5  7  9  11

Exemple

Entrée

Sortie

1  3  5  7  9  11

Exercice 5 — Somme des n premiers entiers

Exercice

Calculer la somme 1 + 2 + ... + n

Niveau : Débutant

Écrire un programme qui lit n et calcule la somme de tous les entiers de 1 à n.

Solution détaillée

Initialiser un accumulateur somme = 0 avant la boucle.
À chaque itération, ajouter i à somme : somme += i.
Afficher somme après la boucle.

Formule de Gauss La somme des n premiers entiers est : $$\sum_{i=1}^{n} i = \frac{n(n+1)}{2}$$ Vérification : pour n = 30, somme = 30×31/2 = 465. Cette formule permet d'éviter la boucle et de calculer le résultat en O(1).

#include <stdio.h>

int main()
{
    int i, n, somme = 0;
    printf("Saisir n : ");
    scanf("%d", &n);

    /* Méthode boucle */
    for (i = 1; i <= n; i++)
        somme += i;

    printf("Somme de %d nombres = %d\n", n, somme);

    /* Méthode formule de Gauss */
    printf("(Gauss) Somme = %d\n", n * (n + 1) / 2);

    return 0;
}

n = int(input("Saisir n : "))

# Méthode boucle
somme = 0
for i in range(1, n + 1):
    somme += i

print(f"Somme de {n} nombres = {somme}")

# Méthode formule de Gauss
print(f"(Gauss) Somme = {n * (n + 1) // 2}")

# Méthode Python native
print(f"(sum) Somme = {sum(range(1, n + 1))}")

import java.util.Scanner;

public class SommeNaturels {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir n : ");
        int n = clavier.nextInt();

        int somme = 0;
        for (int i = 1; i <= n; i++)
            somme += i;

        System.out.println("Somme de " + n + " nombres = " + somme);
        System.out.println("(Gauss) Somme = " + (n * (n + 1) / 2));
        clavier.close();
    }
}

Sortie

Somme de 30 nombres = 465

Exemple

Entrée

Sortie

Somme de 30 nombres = 465

Explication : 1+2+…+30 = 30×31/2 = 465.

Exercice 6 — Somme des nombres pairs de 1 à n

Exercice

Calculer la somme des nombres pairs entre 1 et n

Niveau : Débutant

Écrire un programme qui lit n et calcule la somme de tous les nombres pairs entre 1 et n.

Solution détaillée

Démarrer à i = 2, incrémenter de 2 : on ne visite que les pairs.
Accumuler avec somme += i.

#include <stdio.h>

int main()
{
    int i, n, somme = 0;
    printf("Saisir n : ");
    scanf("%d", &n);

    for (i = 2; i <= n; i += 2)
        somme += i;

    printf("Somme des pairs de 1 à %d = %d\n", n, somme);
    return 0;
}

# Fournir les données d'entrée
n = int(input("Saisir un nombre : "))
print("les nombres impairs de 1 à {0} ".format(n))

somme = 0
for i in range(2, n+1, 2):
    somme += i

print("la somme des nombres pairs de 1 à {0} nombres = {1}".format(n, somme))

import java.util.Scanner;

public class SommePairs {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir n : ");
        int n = clavier.nextInt();

        int somme = 0;
        for (int i = 2; i <= n; i += 2)
            somme += i;

        System.out.println("Somme des pairs de 1 à " + n + " = " + somme);
        clavier.close();
    }
}

Sortie

Somme des pairs de 1 à 13 = 42

Exemple

Entrée

Sortie

Somme des pairs de 1 à 13 = 42

Explication : 2+4+6+8+10+12 = 42.

Exercice 7 — Table de multiplication

Exercice

Afficher la table de multiplication d'un nombre

Niveau : Débutant

Écrire un programme qui lit un nombre n et affiche sa table de multiplication de 1 à 10.

Solution détaillée

Boucler i de 1 à 10.
Afficher à chaque tour : n * i * = n*i.

#include <stdio.h>

int main()
{
    int i, n;
    printf("Saisir un nombre : ");
    scanf("%d", &n);

    for (i = 1; i <= 10; i++)
        printf("%d * %d = %d\n", n, i, n * i);

    return 0;
}

n = int(input("Saisir un nombre : "))

for i in range(1, 11):
    print(f"{n} * {i} = {n * i}")

import java.util.Scanner;

public class TableMultiplication {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int n = clavier.nextInt();

        for (int i = 1; i <= 10; i++)
            System.out.println(n + " * " + i + " = " + (n * i));

        clavier.close();
    }
}

Sortie (n = 9)

9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
...
9 * 10 = 90

Exemple

Entrée

Sortie

9 * 1 = 9
9 * 2 = 18
...
9 * 10 = 90

Exercice 8 — Compter les chiffres d'un entier

Exercice

Trouver le nombre de chiffres d'un entier

Niveau : Débutant

Écrire un programme qui lit un entier et affiche le nombre de chiffres qui le composent.

Solution détaillée

Répéter : diviser le nombre par 10 et incrémenter un compteur, jusqu'à ce que le nombre soit 0.
Chaque division par 10 supprime le dernier chiffre → le compteur compte le nombre de divisions nécessaires.
Alternative Python : len(str(num)) — convertir en chaîne et mesurer sa longueur.

Astuce mathématique Le nombre de chiffres d'un entier positif n est égal à ⌊log₁₀(n)⌋ + 1. Par exemple : log₁₀(2020) ≈ 3.30 → ⌊3.30⌋ + 1 = 4.

#include <stdio.h>

int main()
{
    int num, compteur = 0;
    printf("Saisir un nombre : ");
    scanf("%d", &num);

    while (num != 0) {
        compteur++;
        num /= 10;   /* supprime le dernier chiffre */
    }

    printf("Nombre de chiffres : %d\n", compteur);
    return 0;
}

num = int(input("Saisir un nombre : "))

# Méthode boucle
compteur = 0
n = num
while n != 0:
    compteur += 1
    n //= 10

print(f"Nombre de chiffres : {compteur}")

# Méthode Python native
print(f"(len) Nombre de chiffres : {len(str(num))}")

import java.util.Scanner;

public class CompterChiffres {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int num = clavier.nextInt();

        int compteur = 0;
        int n = num;
        while (n != 0) {
            compteur++;
            n /= 10;
        }

        System.out.println("Nombre de chiffres : " + compteur);
        clavier.close();
    }
}

Sortie

Nombre de chiffres : 4

Exemple

Entrée

Sortie

Nombre de chiffres : 4

Explication : 2020 → 202 → 20 → 2 → 0 : 4 divisions → 4 chiffres.

Exercice 9 — Premier et dernier chiffre d'un nombre

Exercice

Extraire le premier et le dernier chiffre

Niveau : Débutant

Écrire un programme qui lit un entier et affiche son premier chiffre (le plus à gauche) et son dernier chiffre (le plus à droite).

Solution détaillée

Dernier chiffre : n % 10 — le reste de la division par 10.
Premier chiffre : diviser successivement par 10 jusqu'à obtenir un nombre à un seul chiffre.
Alternative Python : convertir en chaîne → str(n)[0] et str(n)[-1].

#include <stdio.h>

int main()
{
    int n, premier, dernier;
    printf("Saisir un nombre : ");
    scanf("%d", &n);

    dernier = n % 10;

    premier = n;
    while (premier >= 10)
        premier /= 10;

    printf("Premier chiffre = %d\n", premier);
    printf("Dernier chiffre = %d\n", dernier);
    return 0;
}

n = int(input("Saisir un nombre : "))

# Méthode arithmétique
dernier = n % 10
premier = n
while premier >= 10:
    premier //= 10

print(f"Premier chiffre = {premier}")
print(f"Dernier chiffre = {dernier}")

# Méthode chaîne (Python)
s = str(n)
print(f"(str) Premier = {s[0]}, Dernier = {s[-1]}")

import java.util.Scanner;

public class PremierDernier {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int n = clavier.nextInt();

        int dernier = n % 10;
        int premier = n;
        while (premier >= 10)
            premier /= 10;

        System.out.println("Premier chiffre = " + premier);
        System.out.println("Dernier chiffre = " + dernier);
        clavier.close();
    }
}

Sortie

Premier chiffre = 1
Dernier chiffre = 7

Exemple

Entrée

Sortie

Premier chiffre = 1
Dernier chiffre = 7

Explication : 1987 % 10 = 7 (dernier) ; 1987 → 198 → 19 → 1 (premier).

Exercice 10 — Échanger le premier et le dernier chiffre

Exercice

Permuter le premier et le dernier chiffre d'un entier

Niveau : Intermédiaire

Écrire un programme qui lit un entier et affiche le nombre obtenu en échangeant son premier et son dernier chiffre.

Exemple : 1987 → 7981

Solution détaillée

Extraire dernier = n % 10 et premier via log10.
Construire le nouveau nombre : remplacer le premier chiffre par dernier et le dernier par premier.
Méthode Python simplifiée : convertir en liste de caractères, permuter les indices [0] et [-1], reconvertir en entier.

#include <stdio.h>
#include <math.h>

int main()
{
    int num, echanger, dernier, premier, chiffres;

    printf("Saisir un nombre : ");
    scanf("%d", &num);

    dernier  = num % 10;
    chiffres = (int)log10(num);
    premier  = (int)(num / pow(10, chiffres));

    echanger  = dernier;
    echanger *= (int)pow(10, chiffres);
    echanger += num % ((int)pow(10, chiffres));
    echanger -= dernier;
    echanger += premier;

    printf("Nombre original : %d\n", num);
    printf("Après l'échange : %d\n", echanger);
    return 0;
}

import math

# Fournir les données d'entrée
num = int(input("Saisir un nombre : "))
# print("les nombres impairs de 1 à {0} ".format(n))
dernier = num % 10

# Trouver le nombre total de chiffres - 1 */
chiffres = int(math.log10(num))

# Premier chiffre */
premier = int(num / pow(10, chiffres))

echanger = dernier
echanger *= int(pow(10, chiffres))
echanger += num % (int(pow(10, chiffres)))
echanger -= dernier
echanger += premier

print("Nombre original : ", num)
print("Après l'echange : ", echanger)

import java.util.Scanner;

public class EchangerChiffres {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int num = clavier.nextInt();

        // Méthode via chaîne de caractères
        char[] c = String.valueOf(num).toCharArray();
        char tmp = c[0]; c[0] = c[c.length - 1]; c[c.length - 1] = tmp;
        int echanger = Integer.parseInt(new String(c));

        System.out.println("Nombre original : " + num);
        System.out.println("Après l'échange : " + echanger);
        clavier.close();
    }
}

Sortie

Nombre original  : 1987
Après l'échange  : 7981

Exemple

Entrée

Sortie

Après l'échange : 7981

Explication : Premier chiffre = 1, dernier = 7 → on échange → 7981.

Exercice 11 — Somme des chiffres d'un nombre

Exercice

Calculer la somme des chiffres d'un entier

Niveau : Débutant

Écrire un programme qui lit un entier et calcule la somme de ses chiffres.

Exemple : 1987 → 1 + 9 + 8 + 7 = 25

Solution détaillée

Extraire le dernier chiffre avec num % 10 et l'ajouter à somme.
Supprimer le dernier chiffre avec num /= 10.
Répéter jusqu'à num == 0.

#include <stdio.h>

int main()
{
    int num, somme = 0;
    printf("Saisir un nombre : ");
    scanf("%d", &num);

    while (num != 0) {
        somme += num % 10;   /* ajouter le dernier chiffre */
        num   /= 10;         /* supprimer le dernier chiffre */
    }

    printf("Somme des chiffres = %d\n", somme);
    return 0;
}

num = int(input("Saisir un nombre : "))

# Méthode arithmétique
somme = 0
n = num
while n != 0:
    somme += n % 10
    n //= 10

print(f"Somme des chiffres = {somme}")

# Méthode Python concise
print(f"(sum) Somme = {sum(int(c) for c in str(num))}")

import java.util.Scanner;

public class SommeChiffres {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int num = clavier.nextInt();

        int somme = 0, n = num;
        while (n != 0) {
            somme += n % 10;
            n /= 10;
        }

        System.out.println("Somme des chiffres = " + somme);
        clavier.close();
    }
}

Sortie

Somme des chiffres = 25

Exemple

Entrée

Sortie

Somme des chiffres = 25

Explication : 1 + 9 + 8 + 7 = 25.

Exercice 12 — Nombre palindrome

Exercice

Vérifier si un nombre est palindrome

Niveau : Intermédiaire

Écrire un programme qui vérifie si un entier est un palindrome, c'est-à-dire qu'il se lit de la même façon de gauche à droite et de droite à gauche.

Exemple : 1221 → palindrome | 1987 → non palindrome

Solution détaillée

Définition — Palindrome Un nombre est palindrome si son inverse (ses chiffres écrits en sens contraire) est égal à lui-même. Méthode : calculer le nombre inversé, puis comparer avec l'original.

Copier l'original dans num.
Construire inverse : à chaque étape, inverse = inverse * 10 + (n % 10).
Si inverse == num → palindrome.

#include <stdio.h>

int main()
{
    int n, num, inverse = 0;
    printf("Saisir un nombre : ");
    scanf("%d", &n);

    num = n;
    while (n != 0) {
        inverse = (inverse * 10) + (n % 10);
        n /= 10;
    }

    if (inverse == num)
        printf("%d est palindrome.\n", num);
    else
        printf("%d n'est pas palindrome.\n", num);

    return 0;
}

import math

# Fournir les données d'entrée
n = int(input("Saisir un nombre : "))

# copier la valeur d'origine */
num = n
inverse = 0
# Trouver l'inverse de n et stocker dans inverse */
while(n != 0):
    inverse = (inverse * 10) + (n % 10)
    n //= 10

# Vérifiez si l'inverse est égal à «num» ou non */
if(inverse == num):
    print(num, " est palindrome.")
else:
    print(num, " n'est pas palindrome.")

import java.util.Scanner;

public class Palindrome {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int n = clavier.nextInt();

        int num = n, inverse = 0;
        while (n != 0) {
            inverse = (inverse * 10) + (n % 10);
            n /= 10;
        }

        if (inverse == num)
            System.out.println(num + " est palindrome.");
        else
            System.out.println(num + " n'est pas palindrome.");

        clavier.close();
    }
}

Sortie

1221 est palindrome.

Exemple 1

Entrée

Sortie

1221 est palindrome.

Exemple 2

Entrée

Sortie

1987 n'est pas palindrome.

Exercice 13 — Fréquence des chiffres

Exercice

Compter la fréquence d'apparition de chaque chiffre (0–9)

Niveau : Intermédiaire

Écrire un programme qui lit un entier et affiche le nombre d'occurrences de chaque chiffre de 0 à 9.

Solution détaillée

Créer un tableau freq[10] initialisé à 0 pour stocker la fréquence de chaque chiffre.
À chaque itération : dernierChiffre = n % 10, incrémenter freq[dernierChiffre], puis n /= 10.
Afficher tout le tableau.

#include <stdio.h>
#define BASE 10

int main()
{
    int num, n, i, dernierChiffre;
    int freq[BASE] = {0};   /* initialiser à zéro */

    printf("Saisir un nombre : ");
    scanf("%d", &num);

    n = num;
    while (n != 0) {
        dernierChiffre = n % 10;
        freq[dernierChiffre]++;
        n /= 10;
    }

    for (i = 0; i < BASE; i++)
        printf("Fréquence de %d = %d\n", i, freq[i]);

    return 0;
}

num = int(input("Saisir un nombre : "))

# Méthode arithmétique
freq = [0] * 10
n = num
while n != 0:
    freq[n % 10] += 1
    n //= 10

for i in range(10):
    print(f"Fréquence de {i} = {freq[i]}")

import java.util.Scanner;

public class FrequenceChiffres {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int num = clavier.nextInt();

        int[] freq = new int[10];
        int n = num;
        while (n != 0) {
            freq[n % 10]++;
            n /= 10;
        }

        for (int i = 0; i < 10; i++)
            System.out.println("Fréquence de " + i + " = " + freq[i]);

        clavier.close();
    }
}

Sortie (1122344)

Fréquence de 0 = 0
Fréquence de 1 = 2
Fréquence de 2 = 2
Fréquence de 3 = 1
Fréquence de 4 = 2
...

Exemple

Entrée

Sortie

Fréquence de 1 = 2
Fréquence de 2 = 2
Fréquence de 3 = 1
Fréquence de 4 = 2

Exercice 15 — Facteurs (diviseurs) d'un nombre

Exercice

Trouver tous les diviseurs d'un entier

Niveau : Débutant

Écrire un programme qui lit un entier n et affiche tous ses diviseurs (nombres qui le divisent sans reste).

Solution détaillée

Parcourir i de 1 à num.
Si num % i == 0, alors i est un diviseur.
Optimisation : on peut s'arrêter à √num et ajouter le diviseur complémentaire, réduisant la complexité de O(n) à O(√n).

#include <stdio.h>

int main()
{
    int i, num;
    printf("Saisir un nombre : ");
    scanf("%d", &num);

    printf("Les facteurs de %d sont : ", num);
    for (i = 1; i <= num; i++)
        if (num % i == 0)
            printf("%d  ", i);

    printf("\n");
    return 0;
}

import math

# Fournir les données d'entrée
num = int(input("Saisir un nombre : "))

print("Les facteurs de {0} sont : ".format(num))
for i in range(1, num+1):
    # Si num est exactement divisible par i alors i est un facteur de num
    if (num % i == 0):
        print(i, end="   ")

import java.util.Scanner;

public class Facteurs {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int num = clavier.nextInt();

        System.out.print("Les facteurs de " + num + " sont : ");
        for (int i = 1; i <= num; i++)
            if (num % i == 0)
                System.out.print(i + "  ");

        clavier.close();
    }
}

Sortie

Les facteurs de 20 sont : 1  2  4  5  10  20

Exemple

Entrée

Sortie

1  2  4  5  10  20

Exercice 16 — Factorielle

Exercice

Calculer n! (factorielle de n)

Niveau : Débutant

Écrire un programme qui lit un entier n et calcule sa factorielle n! = 1 × 2 × … × n.

Solution détaillée

Définition — Factorielle $$n! = \prod_{i=1}^{n} i = 1 \times 2 \times 3 \times \cdots \times n$$ Convention : 0! = 1.
Attention aux dépassements : 13! dépasse déjà la capacité d'un int en C/Java → utiliser long.

Dépassement d'entier En C, un int (32 bits) peut contenir jusqu'à ~2 milliards. Or 13! = 6 227 020 800 > 2³¹. Utiliser unsigned long long en C ou long en Java pour n ≤ 20. En Python, les entiers sont de taille arbitraire — pas de problème.

#include <stdio.h>

int main()
{
    int i, num;
    unsigned long long fact = 1;

    printf("Saisir un nombre : ");
    scanf("%d", &num);

    for (i = 1; i <= num; i++)
        fact *= i;

    printf("Factorielle de %d = %llu\n", num, fact);
    return 0;
}

import math

num = int(input("Saisir un nombre : "))

# Méthode boucle
fact = 1
for i in range(2, num + 1):
    fact *= i

print(f"Factorielle de {num} = {fact}")

# Méthode Python native
print(f"(math) Factorielle = {math.factorial(num)}")

import java.util.Scanner;

public class Factorielle {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int num = clavier.nextInt();

        long fact = 1;
        for (int i = 1; i <= num; i++)
            fact *= i;

        System.out.println("Factorielle de " + num + " = " + fact);
        clavier.close();
    }
}

Sortie

Factorielle de 5 = 120

Exemple

Entrée

Sortie

Factorielle de 5 = 120

Explication : 5! = 1×2×3×4×5 = 120.

Exercice 17 — PGCD de deux nombres

Exercice

Calculer le Plus Grand Commun Diviseur

Niveau : Intermédiaire

Écrire un programme qui lit deux entiers et affiche leur PGCD (Plus Grand Commun Diviseur).

Solution détaillée

Algorithme d'Euclide (méthode optimale) L'algorithme d'Euclide calcule le PGCD en O(log min(a,b)) :
pgcd(a, b) = pgcd(b, a % b) jusqu'à ce que b = 0. Bien plus efficace que la méthode par itération présentée ici.

#include <stdio.h>

int main()
{
    int num1, num2, min, pgcd = 1;
    printf("Saisir deux nombres : ");
    scanf("%d %d", &num1, &num2);

    /* Méthode par itération */
    min = (num1 < num2) ? num1 : num2;
    for (int i = 1; i <= min; i++)
        if (num1 % i == 0 && num2 % i == 0)
            pgcd = i;

    printf("PGCD de %d et %d = %d\n", num1, num2, pgcd);

    /* Méthode Euclide */
    int a = num1, b = num2;
    while (b != 0) { int r = a % b; a = b; b = r; }
    printf("(Euclide) PGCD = %d\n", a);

    return 0;
}

import math

num1 = int(input("Saisir nombre 1 : "))
num2 = int(input("Saisir nombre 2 : "))

# Méthode Euclide
a, b = num1, num2
while b:
    a, b = b, a % b
print(f"PGCD de {num1} et {num2} = {a}")

# Méthode Python native
print(f"(math) PGCD = {math.gcd(num1, num2)}")

import java.util.Scanner;

public class PGCD {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir nombre 1 : ");
        int num1 = clavier.nextInt();
        System.out.print("Saisir nombre 2 : ");
        int num2 = clavier.nextInt();

        // Algorithme d'Euclide
        int a = num1, b = num2;
        while (b != 0) { int r = a % b; a = b; b = r; }

        System.out.println("PGCD de " + num1 + " et " + num2 + " = " + a);
        clavier.close();
    }
}

Sortie

PGCD de 35 et 60 = 5

Exemple

Entrée

35
60

Sortie

PGCD de 35 et 60 = 5

Explication : Les diviseurs communs de 35 et 60 sont 1 et 5 → PGCD = 5.

Exercice 18 — Nombre premier

Exercice

Vérifier si un nombre est premier

Niveau : Intermédiaire

Écrire un programme qui lit un entier et détermine s'il est premier (divisible uniquement par 1 et lui-même).

Solution détaillée

Définition — Nombre premier Un entier n > 1 est premier s'il n'est divisible que par 1 et lui-même. Il suffit de tester les diviseurs de 2 à n/2 (ou mieux, jusqu'à √n).

Initialiser un drapeau estPremier = true.
Tester les diviseurs de 2 à num/2. Dès qu'un diviseur est trouvé → estPremier = false et break.
Optimisation : tester jusqu'à √num suffit, car si i divise num et i > √num, alors num/i < √num aurait déjà été trouvé.

#include <stdio.h>
#include <math.h>

int main()
{
    int i, num, estPremier = 1;
    printf("Saisir un nombre : ");
    scanf("%d", &num);

    if (num <= 1) estPremier = 0;

    /* Optimisation : tester jusqu'à √num */
    for (i = 2; i <= (int)sqrt(num); i++) {
        if (num % i == 0) {
            estPremier = 0;
            break;
        }
    }

    if (estPremier)
        printf("%d est premier\n", num);
    else
        printf("%d n'est pas premier\n", num);

    return 0;
}

# Fournir les données d'entrée
num = int(input("Saisir un nombre : "))

# Trouver tous les facteurs premiers */
for i in range(2, num + 1):
    # Vérifiez 'i'est un facteur de num */
    if (num % i == 0):
        # Vérifier si 'i' est premier */
        estPremier = True
        for j in range(2, i//2):
            if (i % j == 0):
                estPremier = False
                break

        # Si 'i' est un nombre premier et est un facteur de num */
        if (estPremier == 1):
            print(i, "   ")

import java.util.Scanner;

public class NombrePremier {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int num = clavier.nextInt();

        boolean estPremier = num > 1;
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) { estPremier = false; break; }
        }

        System.out.println(num + (estPremier ? " est premier" : " n'est pas premier"));
        clavier.close();
    }
}

Sortie

13 est premier

Exemple

Entrée

Sortie

13 est premier

Explication : √13 ≈ 3.6 → on teste 2 et 3. 13 n'est divisible ni par 2 ni par 3 → premier.

Exercice 20 — Nombre d'Armstrong

Exercice

Vérifier si un nombre est un nombre d'Armstrong

Niveau : Intermédiaire

Écrire un programme qui vérifie si un entier est un nombre d'Armstrong.

Définition — Nombre d'Armstrong Un nombre à n chiffres est un nombre d'Armstrong si la somme de chacun de ses chiffres élevé à la puissance n est égale au nombre lui-même. $$371 = 3^3 + 7^3 + 1^3 = 27 + 343 + 1 = 371 \checkmark$$

Solution détaillée

Calculer le nombre de chiffres : chiffres = floor(log10(num)) + 1.
Pour chaque chiffre extrait avec % 10, calculer chiffre^n et l'ajouter à somme.
Si somme == num → Armstrong.

#include <stdio.h>
#include <math.h>

int main()
{
    int num, copie, chiffres, somme = 0, d;
    printf("Saisir un nombre : ");
    scanf("%d", &num);

    copie   = num;
    chiffres = (int)log10(num) + 1;

    int n = num;
    while (n > 0) {
        d     = n % 10;
        somme += (int)round(pow(d, chiffres));
        n    /= 10;
    }

    if (somme == copie)
        printf("%d est un nombre d'Armstrong\n", copie);
    else
        printf("%d n'est pas un nombre d'Armstrong\n", copie);

    return 0;
}

import math

# Fournir les données d'entrée
num = int(input("Saisir un nombre : "))

somme = 0

# Copiez la valeur de num pour le traitement */
copie = num

# Trouver le nombre total de chiffres de num */
chiffres = int(math.log10(num)) + 1

# Calculer la somme de la puissance des chiffres */
while (num > 0):
    # Extraire le dernier chiffre */
    dernierchiffre = num % 10

    # Calculer la somme de la puissance du dernier chiffre */
    somme = somme + (pow(dernierchiffre, chiffres))

    # Supprimer le dernier chiffre */
    num = num // 10

# Vérifiez le numéro Armstrong */
if (copie == somme):
    print(copie, " est un nombre Armstrong")
else:
    print(copie, " n'est pas un nombre Armstrong")

import java.util.Scanner;

public class Armstrong {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir un nombre : ");
        int num = clavier.nextInt();

        int chiffres = String.valueOf(num).length();
        int somme = 0, n = num;
        while (n > 0) {
            int d = n % 10;
            somme += (int) Math.pow(d, chiffres);
            n /= 10;
        }

        System.out.println(num + (somme == num ? " est" : " n'est pas")
                           + " un nombre d'Armstrong");
        clavier.close();
    }
}

Sortie

371 est un nombre d'Armstrong

Exemple

Entrée

Sortie

371 est un nombre d'Armstrong

Explication : 3³ + 7³ + 1³ = 27 + 343 + 1 = 371.

Exercice 23 — Suite de Fibonacci

Exercice

Afficher les n premiers termes de la suite de Fibonacci

Niveau : Intermédiaire

Écrire un programme qui lit n et affiche les n premiers termes de la suite de Fibonacci.

Définition — Suite de Fibonacci La suite de Fibonacci est définie par : $$F_0 = 0,\quad F_1 = 1,\quad F_n = F_{n-1} + F_{n-2} \quad (n \geq 2)$$ Les premiers termes : 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

Solution détaillée

Initialiser a = 0, b = 1.
À chaque itération : afficher a, puis calculer le terme suivant c = a + b, décaler : a = b; b = c.

#include <stdio.h>

int main()
{
    int n, a = 0, b = 1, c;
    printf("Saisir le nombre de termes : ");
    scanf("%d", &n);

    printf("Termes de Fibonacci : ");
    for (int i = 0; i < n; i++) {
        printf("%d  ", a);
        c = a + b;
        a = b;
        b = c;
    }
    printf("\n");
    return 0;
}

n = int(input("Saisir le nombre de termes : "))

a, b = 0, 1
print("Termes de Fibonacci : ", end="")
for _ in range(n):
    print(a, end="  ")
    a, b = b, a + b   # affectation simultanée — très Pythonique
print()

import java.util.Scanner;

public class Fibonacci {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);
        System.out.print("Saisir le nombre de termes : ");
        int n = clavier.nextInt();

        int a = 0, b = 1;
        System.out.print("Termes de Fibonacci : ");
        for (int i = 0; i < n; i++) {
            System.out.print(a + "  ");
            int c = a + b;
            a = b;
            b = c;
        }
        clavier.close();
    }
}

Sortie

Termes de Fibonacci : 0  1  1  2  3  5  8

Exemple

Entrée

Sortie

0  1  1  2  3  5  8

Explication : F₀=0, F₁=1, F₂=1, F₃=2, F₄=3, F₅=5, F₆=8.

Récapitulatif — Structures de boucles comparées

Boucle	C / Java	Python	Cas d'usage typique
for	`for(i=0; i<n; i++)`	`for i in range(n)`	Nombre d'itérations connu
while	`while(cond)`	`while cond:`	Condition inconnue à l'avance
do-while	`do { } while(cond);`	N/A (simulé avec while)	Exécuter au moins une fois
break	`break;`	`break`	Sortir de la boucle immédiatement
continue	`continue;`	`continue`	Passer à l'itération suivante

Sortie

// La sortie apparaîtra ici…

Prêt · Ctrl+Entrée pour exécuter

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

Exercices corrigés sur les boucles en Python, Java et langage C

Exercice 1 — Nombres naturels de 1 à n

Afficher tous les naturels de 1 à n

Exercice 2 — Nombres naturels en sens inverse (n → 1)

Afficher les entiers de n jusqu'à 1 (décroissant)

Exercice 3 — Nombres pairs de 1 à n

Afficher tous les nombres pairs entre 1 et n

Exercice 4 — Nombres impairs de 1 à n

Afficher tous les nombres impairs entre 1 et n

Exercice 5 — Somme des n premiers entiers

Calculer la somme 1 + 2 + ... + n

Exercice 6 — Somme des nombres pairs de 1 à n

Calculer la somme des nombres pairs entre 1 et n

Exercice 7 — Table de multiplication

Afficher la table de multiplication d'un nombre

Exercice 8 — Compter les chiffres d'un entier

Trouver le nombre de chiffres d'un entier

Exercice 9 — Premier et dernier chiffre d'un nombre

Extraire le premier et le dernier chiffre

Exercice 10 — Échanger le premier et le dernier chiffre

Permuter le premier et le dernier chiffre d'un entier

Exercice 11 — Somme des chiffres d'un nombre

Calculer la somme des chiffres d'un entier

Exercice 12 — Nombre palindrome

Vérifier si un nombre est palindrome

Exercice 13 — Fréquence des chiffres

Compter la fréquence d'apparition de chaque chiffre (0–9)

Exercice 15 — Facteurs (diviseurs) d'un nombre

Trouver tous les diviseurs d'un entier

Exercice 16 — Factorielle

Calculer n! (factorielle de n)

Exercice 17 — PGCD de deux nombres

Calculer le Plus Grand Commun Diviseur

Exercice 18 — Nombre premier

Vérifier si un nombre est premier

Exercice 20 — Nombre d'Armstrong

Vérifier si un nombre est un nombre d'Armstrong

Exercice 23 — Suite de Fibonacci

Afficher les n premiers termes de la suite de Fibonacci

Récapitulatif — Structures de boucles comparées

Discussion (0)

Laisser un commentaire