Exercices corrigés sur les tableaux en Python, Java et langage C - TD1-

Un tableau est une structure de données linéaire qui contient une collection séquentielle finie de données homogènes (tous les éléments sont du même type).

Le tableau utilise un index entier pour accéder à un élément spécifique. L'index commence à 0 et va jusqu'à N-1 (où N est la taille du tableau).

Définition — Tableau à une dimension Un tableau est une collection d'éléments stockés dans des emplacements de mémoire contigus. Chaque élément est accessible en O(1) via son indice : tab[i].

Représentation mémoire pour un tableau de 5 entiers :

Index	0	1	2	3	4
Valeur	3	7	4	9	8

Dans les exercices suivants, nous nous concentrerons sur des tableaux à une dimension. Tous les exercices sont résolus en Python, Java et C.

Déclaration et utilisation d'un tableau C

/* Déclaration statique (taille fixe) */
#define TAILLE_MAX 1000
int tab[TAILLE_MAX];

/* Accès aux éléments */
tab[0] = 10;       /* écriture */
int x = tab[0];    /* lecture  */

/* Parcours avec for */
for (int i = 0; i < N; i++)
    printf("%d  ", tab[i]);

Patron commun — Saisie + Parcours Tous les exercices suivent le même schéma :
1. Saisir la taille N du tableau.
2. Remplir le tableau élément par élément (boucle de 0 à N-1).
3. Parcourir le tableau pour calculer ou afficher un résultat.

Exercice 1 — Saisie et affichage d'un tableau

Exercice

Déclarer, remplir et afficher un tableau

Niveau : Débutant

Écrire un programme qui déclare et initialise un tableau, saisit ses N éléments depuis l'utilisateur, puis affiche le tableau.

Solution détaillée

Saisir N — la taille du tableau.
Boucle de remplissage : pour i de 0 à N-1, lire tab[i].
Boucle d'affichage : pour i de 0 à N-1, afficher tab[i].
En Python : utiliser une liste (list) initialisée avec [0]*N.

#include <stdio.h>
#define TAILLE_MAX 1000

int main()
{
    int tab[TAILLE_MAX];
    int i, N;

    /* Saisir la taille N < TAILLE_MAX */
    printf("Saisir le nombre d'éléments : ");
    scanf("%d", &N);

    /* Remplir le tableau */
    for (i = 0; i < N; i++) {
        printf("Élément %d : ", i + 1);
        scanf("%d", &tab[i]);
    }

    /* Afficher le tableau */
    for (i = 0; i < N; i++)
        printf("%d  ", tab[i]);

    return 0;
}

N = int(input("Saisir le nombre d'éléments : "))

# Initialiser la liste avec N zéros
tab = [0] * N

# Remplir la liste
for i in range(N):
    tab[i] = int(input(f"Élément {i + 1} : "))

# Afficher la liste
for i in range(N):
    print(tab[i], end=", ")

# Version Python concise (saisie en une ligne)
# tab = [int(input(f"Élément {i+1} : ")) for i in range(N)]

import java.util.Scanner;

public class TableauAffichage {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);

        System.out.print("Saisir le nombre d'éléments : ");
        int N = clavier.nextInt();

        int[] tab = new int[N];

        // Remplir
        for (int i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        // Afficher
        for (int i = 0; i < N; i++)
            System.out.print(tab[i] + ", ");

        clavier.close();
    }
}

Sortie

3, 7, 4, 9, 8,

Exemple

Entrée

5
3  7  4  9  8

Sortie

3, 7, 4, 9, 8

Explication : On lit 5 entiers et on les stocke dans tab[0]…tab[4], puis on les affiche dans l'ordre.

Contraintes

1 ≤ N ≤ 1000
Les éléments sont des entiers relatifs

Exercice 2 — Afficher les éléments négatifs

Exercice

Filtrer et afficher les éléments négatifs d'un tableau

Niveau : Débutant

Écrire un programme qui saisit un tableau de N entiers et affiche uniquement les éléments négatifs.

Solution détaillée

Après le remplissage, parcourir le tableau.
À chaque case : si tab[i] < 0 → afficher.
En Python : utiliser une compréhension de liste pour filtrer en une ligne.

Python — Compréhension de liste [x for x in tab if x < 0] produit une nouvelle liste ne contenant que les négatifs. C'est idiomatique et très lisible.

#include <stdio.h>
#define TAILLE_MAX 1000

int main()
{
    int tab[TAILLE_MAX];
    int i, N;

    printf("Saisir le nombre d'éléments : ");
    scanf("%d", &N);

    for (i = 0; i < N; i++) {
        printf("Élément %d : ", i + 1);
        scanf("%d", &tab[i]);
    }

    printf("\nÉléments négatifs : ");
    for (i = 0; i < N; i++)
        if (tab[i] < 0)
            printf("%d  ", tab[i]);

    return 0;
}

N = int(input("Saisir le nombre d'éléments : "))
tab = [int(input(f"Élément {i + 1} : ")) for i in range(N)]

print("Éléments négatifs :", end=" ")
for x in tab:
    if x < 0:
        print(x, end=", ")

# Version concise
negatifs = [x for x in tab if x < 0]
print("\n(liste) Négatifs :", negatifs)

import java.util.Scanner;

public class ElementsNegatifs {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);

        System.out.print("Saisir le nombre d'éléments : ");
        int N = clavier.nextInt();
        int[] tab = new int[N];

        for (int i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        System.out.print("\nÉléments négatifs du tableau : ");
        for (int i = 0; i < N; i++)
            if (tab[i] < 0)
                System.out.print(tab[i] + ", ");

        clavier.close();
    }
}

Sortie

Éléments négatifs : -7  -9

Exemple

Entrée

5
3  -7  4  -9  8

Sortie

-7, -9

Explication : Seuls tab[1] = -7 et tab[3] = -9 vérifient la condition < 0.

Exercice 3 — Somme des éléments d'un tableau

Exercice

Calculer la somme de tous les éléments

Niveau : Débutant

Écrire un programme qui saisit un tableau de N entiers et calcule la somme de tous ses éléments.

Solution détaillée

Initialiser somme = 0.
Parcourir le tableau : somme += tab[i] à chaque itération.
En Python : sum(tab) calcule la somme en une seule instruction.

#include <stdio.h>
#define TAILLE_MAX 1000

int main()
{
    int tab[TAILLE_MAX];
    int i, N, somme = 0;

    printf("Saisir le nombre d'éléments : ");
    scanf("%d", &N);

    for (i = 0; i < N; i++) {
        printf("Élément %d : ", i + 1);
        scanf("%d", &tab[i]);
    }

    /* Accumulation */
    for (i = 0; i < N; i++)
        somme += tab[i];

    printf("Somme de tous les éléments = %d\n", somme);
    return 0;
}

N = int(input("Saisir le nombre d'éléments : "))
tab = [int(input(f"Élément {i + 1} : ")) for i in range(N)]

# Méthode boucle
somme = 0
for x in tab:
    somme += x
print(f"Somme de tous les éléments = {somme}")

# Méthode Python native
print(f"(sum) = {sum(tab)}")

import java.util.Scanner;

public class SommeTableau {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);

        System.out.print("Saisir le nombre d'éléments : ");
        int N = clavier.nextInt();
        int[] tab = new int[N];

        for (int i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        int somme = 0;
        for (int i = 0; i < N; i++)
            somme += tab[i];

        System.out.println("Somme de tous les éléments du tableau = " + somme);
        clavier.close();
    }
}

Sortie

Somme de tous les éléments = 31

Exemple

Entrée

5
3  7  4  9  8

Sortie

Somme = 31

Explication : 3 + 7 + 4 + 9 + 8 = 31.

Exercice 4 — Maximum et Minimum d'un tableau

Exercice

Trouver l'élément maximum et l'élément minimum

Niveau : Débutant

Écrire un programme qui saisit un tableau de N entiers et affiche le maximum et le minimum.

Solution détaillée

Algorithme — Recherche du maximum Initialiser max = tab[0] (hypothèse : le premier élément est le maximum). Parcourir de l'indice 1 à N-1 : si tab[i] > max, mettre à jour max = tab[i]. Même logique pour le minimum avec <.

Initialiser max = tab[0] et min = tab[0].
Parcourir à partir de l'indice 1 et mettre à jour si nécessaire.
En Python : max(tab) et min(tab) en O(n).

#include <stdio.h>
#define TAILLE_MAX 1000

int main()
{
    int tab[TAILLE_MAX];
    int i, N, max, min;

    printf("Saisir le nombre d'éléments : ");
    scanf("%d", &N);

    for (i = 0; i < N; i++) {
        printf("Élément %d : ", i + 1);
        scanf("%d", &tab[i]);
    }

    /* Hypothèse initiale : premier élément */
    max = tab[0];
    min = tab[0];

    for (i = 1; i < N; i++) {
        if (tab[i] > max) max = tab[i];
        if (tab[i] < min) min = tab[i];
    }

    printf("Maximum = %d\n", max);
    printf("Minimum = %d\n", min);
    return 0;
}

N = int(input("Saisir le nombre d'éléments : "))
tab = [int(input(f"Élément {i + 1} : ")) for i in range(N)]

# Méthode manuelle
maximum = tab[0]
minimum = tab[0]
for x in tab[1:]:
    if x > maximum: maximum = x
    if x < minimum: minimum = x

print(f"Maximum = {maximum}")
print(f"Minimum = {minimum}")

# Méthode Python native
print(f"(max/min) : max = {max(tab)}, min = {min(tab)}")

import java.util.Scanner;

public class MaxMin {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);

        System.out.print("Saisir le nombre d'éléments : ");
        int N = clavier.nextInt();
        int[] tab = new int[N];

        for (int i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        int max = tab[0], min = tab[0];
        for (int i = 1; i < N; i++) {
            if (tab[i] > max) max = tab[i];
            if (tab[i] < min) min = tab[i];
        }

        System.out.println("Maximum = " + max);
        System.out.println("Minimum = " + min);
        clavier.close();
    }
}

Sortie

Maximum = 9
Minimum = 3

Exemple

Entrée

5
3  7  4  9  8

Sortie

Maximum = 9
Minimum = 3

Explication : Après parcours : max = 9 (à l'indice 3), min = 3 (à l'indice 0).

Exercice 5 — Premier et deuxième plus grand

Exercice

Trouver les deux plus grandes valeurs du tableau

Niveau : Intermédiaire

Écrire un programme qui saisit un tableau de N entiers et trouve le premier et le deuxième plus grand élément.

Solution détaillée

Logique en un seul parcours À chaque élément rencontré, deux cas :
— Si tab[i] > max1 : l'ancien max1 devient max2, et tab[i] devient le nouveau max1.
— Sinon, si tab[i] > max2 et tab[i] < max1 : tab[i] devient le nouveau max2.

Initialiser max1 = max2 = tab[0].
Parcourir le tableau et mettre à jour selon les deux conditions ci-dessus.
En Python : sorted(tab)[-1] et sorted(tab)[-2] — ou trier en O(n log n).

#include <stdio.h>
#define TAILLE_MAX 1000

int main()
{
    int tab[TAILLE_MAX], N, i;
    int max1, max2;

    printf("Saisir le nombre d'éléments : ");
    scanf("%d", &N);

    for (i = 0; i < N; i++) {
        printf("Élément %d : ", i + 1);
        scanf("%d", &tab[i]);
    }

    max1 = max2 = tab[0];

    for (i = 0; i < N; i++) {
        if (tab[i] > max1) {
            max2 = max1;   /* l'ancien 1er devient 2e */
            max1 = tab[i]; /* nouveau 1er */
        } else if (tab[i] > max2 && tab[i] < max1) {
            max2 = tab[i]; /* nouveau 2e */
        }
    }

    printf("Premier plus grand  = %d\n", max1);
    printf("Deuxième plus grand = %d\n", max2);
    return 0;
}

N = int(input("Saisir le nombre d'éléments : "))
tab = [int(input(f"Élément {i + 1} : ")) for i in range(N)]

# Méthode manuelle (un seul parcours)
max1 = max2 = tab[0]
for x in tab:
    if x > max1:
        max2, max1 = max1, x
    elif x > max2 and x < max1:
        max2 = x

print(f"Premier plus grand  = {max1}")
print(f"Deuxième plus grand = {max2}")

# Méthode Python : tri
tri = sorted(set(tab), reverse=True)
print(f"(sorted) 1er={tri[0]}, 2e={tri[1]}")

import java.util.Scanner;

public class DeuxMaximums {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);

        System.out.print("Saisir le nombre d'éléments : ");
        int N = clavier.nextInt();
        int[] tab = new int[N];

        for (int i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        int max1 = tab[0], max2 = tab[0];
        for (int i = 0; i < N; i++) {
            if (tab[i] > max1) {
                max2 = max1;
                max1 = tab[i];
            } else if (tab[i] > max2 && tab[i] < max1) {
                max2 = tab[i];
            }
        }

        System.out.println("Premier plus grand  = " + max1);
        System.out.println("Deuxième plus grand = " + max2);
        clavier.close();
    }
}

Sortie

Premier plus grand  = 9
Deuxième plus grand = 8

Exemple

Entrée

5
3  7  4  9  8

Sortie

Premier plus grand  : 9
Deuxième plus grand : 8

Explication : 9 est le max absolu, 8 est le second — on les trouve en un seul parcours.

Exercice 6 — Compter les éléments pairs et impairs

Exercice

Compter combien d'éléments sont pairs et combien sont impairs

Niveau : Débutant

Écrire un programme qui saisit un tableau de N entiers et affiche le nombre d'éléments pairs et le nombre d'éléments impairs.

Solution détaillée

Initialiser deux compteurs : pair = 0 et impair = 0.
Parcourir : si tab[i] % 2 == 0 → incrémenter pair, sinon impair.
Note : pair + impair == N — on peut donc ne calculer qu'un seul compteur.

Optimisation — un seul compteur Puisque pair + impair = N, il suffit de compter les pairs et calculer impair = N - pair.

#include <stdio.h>
#define TAILLE_MAX 1000

int main()
{
    int tab[TAILLE_MAX];
    int i, N, pair = 0, impair = 0;

    printf("Saisir le nombre d'éléments : ");
    scanf("%d", &N);

    for (i = 0; i < N; i++) {
        printf("Élément %d : ", i + 1);
        scanf("%d", &tab[i]);
    }

    for (i = 0; i < N; i++) {
        if (tab[i] % 2 == 0)
            pair++;
        else
            impair++;
    }

    printf("Total des éléments pairs    : %d\n", pair);
    printf("Total des éléments impairs  : %d\n", impair);
    return 0;
}

N = int(input("Saisir le nombre d'éléments : "))
tab = [int(input(f"Élément {i + 1} : ")) for i in range(N)]

pair   = sum(1 for x in tab if x % 2 == 0)
impair = N - pair

print(f"Total des éléments pairs   : {pair}")
print(f"Total des éléments impairs : {impair}")

import java.util.Scanner;

public class PairsImpairs {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);

        System.out.print("Saisir le nombre d'éléments : ");
        int N = clavier.nextInt();
        int[] tab = new int[N];

        for (int i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        int pair = 0, impair = 0;
        for (int i = 0; i < N; i++) {
            if (tab[i] % 2 == 0) pair++;
            else impair++;
        }

        System.out.println("Total des éléments pairs   : " + pair);
        System.out.println("Total des éléments impairs : " + impair);
        clavier.close();
    }
}

Sortie

Total des éléments pairs   : 2
Total des éléments impairs : 3

Exemple

Entrée

5
3  7  4  9  8

Sortie

Nombre d'éléments pairs   : 2
Nombre d'éléments impairs : 3

Explication : Pairs : 4, 8 → compteur = 2. Impairs : 3, 7, 9 → compteur = 3.

Exercice 7 — Copier un tableau dans un autre

Exercice

Copier tous les éléments d'un tableau source vers un tableau dest

Niveau : Débutant

Écrire un programme qui déclare deux tableaux, remplit le tableau source, copie tous ses éléments dans le tableau dest, puis affiche les deux tableaux.

Solution détaillée

Attention — Copie superficielle en Python En Python, dest = source ne copie PAS le tableau : les deux variables pointent vers le même objet. Modifier dest modifiera aussi source !
Pour une vraie copie, utiliser : dest = source.copy() ou dest = source[:].

Remplir source élément par élément.
Copier : dest[i] = source[i] pour tout i.
Afficher les deux tableaux pour vérification.

#include <stdio.h>
#define TAILLE_MAX 100

int main()
{
    int source[TAILLE_MAX], dest[TAILLE_MAX];
    int i, N;

    printf("Saisir le nombre d'éléments : ");
    scanf("%d", &N);

    /* Remplir source */
    for (i = 0; i < N; i++) {
        printf("Élément %d : ", i + 1);
        scanf("%d", &source[i]);
    }

    /* Copier source → dest */
    for (i = 0; i < N; i++)
        dest[i] = source[i];

    /* Afficher source */
    printf("\nÉléments du tableau source : ");
    for (i = 0; i < N; i++)
        printf("%d  ", source[i]);

    /* Afficher dest */
    printf("\nÉléments du tableau dest   : ");
    for (i = 0; i < N; i++)
        printf("%d  ", dest[i]);

    return 0;
}

N = int(input("Saisir le nombre d'éléments : "))
source = [int(input(f"Élément {i + 1} : ")) for i in range(N)]

# Copie correcte — crée un nouvel objet liste
dest = source.copy()    # équivalent à source[:]

print("\nÉléments du tableau source :", *source, sep=" ")
print("Éléments du tableau dest   :", *dest, sep=" ")

# Preuve que c'est une vraie copie :
dest[0] = 999
print(f"\nAprès dest[0]=999 : source[0]={source[0]}, dest[0]={dest[0]}")
# source[0] est inchangé → vraie copie

import java.util.Scanner;
import java.util.Arrays;

public class CopierTableau {
    public static void main(String[] args) {
        Scanner clavier = new Scanner(System.in);

        System.out.print("Saisir le nombre d'éléments : ");
        int N = clavier.nextInt();
        int[] source = new int[N];
        int[] dest   = new int[N];

        for (int i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            source[i] = clavier.nextInt();
        }

        /* Copie élément par élément */
        for (int i = 0; i < N; i++)
            dest[i] = source[i];

        /* Ou en une ligne : dest = Arrays.copyOf(source, N); */

        System.out.print("\nÉléments du tableau source : ");
        for (int i = 0; i < N; i++) System.out.print(source[i] + ", ");

        System.out.print("\nÉléments du tableau dest   : ");
        for (int i = 0; i < N; i++) System.out.print(dest[i] + ", ");

        clavier.close();
    }
}

Sortie

Éléments du tableau source : 3, 7, 4, 9, 8,
Éléments du tableau dest   : 3, 7, 4, 9, 8,

Exemple

Entrée

5
3  7  4  9  8

Sortie

Tableau source : 3, 7, 4, 9, 8
Tableau dest   : 3, 7, 4, 9, 8

Explication : Chaque élément source[i] est copié vers dest[i]. Les deux tableaux occupent des emplacements mémoire distincts.

Récapitulatif — Opérations essentielles sur les tableaux

Opération	C	Python	Java
Déclaration	`int tab[N];`	`tab = [0]*N`	`int[] tab = new int[N];`
Accès	`tab[i]`	`tab[i]`	`tab[i]`
Taille	`sizeof(tab)/sizeof(tab[0])`	`len(tab)`	`tab.length`
Somme	boucle + accumulateur	`sum(tab)`	boucle + accumulateur
Maximum	boucle comparaison	`max(tab)`	`Arrays.stream(tab).max()`
Tri	`qsort()`	`tab.sort()`	`Arrays.sort(tab)`
Copie	boucle élément par élément	`dest = source.copy()`	`Arrays.copyOf(src, N)`

Sortie

// La sortie apparaîtra ici…

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

Précédent Exercices corrigés sur les boucles en Python, Java et l …

Suivant Exercices corrigés sur les tableaux en Python, Java et …

Exercices corrigés sur les tableaux en Python, Java et langage C - TD1-

Exercice 1 — Saisie et affichage d'un tableau

Déclarer, remplir et afficher un tableau

Exercice 2 — Afficher les éléments négatifs

Filtrer et afficher les éléments négatifs d'un tableau

Exercice 3 — Somme des éléments d'un tableau

Calculer la somme de tous les éléments

Exercice 4 — Maximum et Minimum d'un tableau

Trouver l'élément maximum et l'élément minimum

Exercice 5 — Premier et deuxième plus grand

Trouver les deux plus grandes valeurs du tableau

Exercice 6 — Compter les éléments pairs et impairs

Compter combien d'éléments sont pairs et combien sont impairs

Exercice 7 — Copier un tableau dans un autre

Copier tous les éléments d'un tableau source vers un tableau dest

Récapitulatif — Opérations essentielles sur les tableaux

Discussion (0)

Laisser un commentaire

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

Exercices corrigés sur les tableaux en Python, Java et langage C - TD1-

Exercice 1 — Saisie et affichage d'un tableau

Déclarer, remplir et afficher un tableau

Exercice 2 — Afficher les éléments négatifs

Filtrer et afficher les éléments négatifs d'un tableau

Exercice 3 — Somme des éléments d'un tableau

Calculer la somme de tous les éléments

Exercice 4 — Maximum et Minimum d'un tableau

Trouver l'élément maximum et l'élément minimum

Exercice 5 — Premier et deuxième plus grand

Trouver les deux plus grandes valeurs du tableau

Exercice 6 — Compter les éléments pairs et impairs

Compter combien d'éléments sont pairs et combien sont impairs

Exercice 7 — Copier un tableau dans un autre

Copier tous les éléments d'un tableau source vers un tableau dest

Récapitulatif — Opérations essentielles sur les tableaux

Discussion (0)

Laisser un commentaire