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

Exercices corrigés sur les tableaux

Définition

Un tableau est une collection d'éléments stockés dans des emplacements de mémoire continus.

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

Dans les exercices suivants, nous essaierons de vous montrer comment faire face à certains problèmes difficiles pour manipuler les tableaux.

Tous les exercices sont résolus en utilisant Python, Java et C.

Exercice 1

Insertion d'un élément dans un tableau

Créez un programme qui crée et initialise un tableau, puis insère un élément à la position spécifiée dans ce tableau (de 0 à N-1).

Pour insérer un nouvel élément dans le tableau, déplacez les éléments de la position d'insertion donnée vers une position vers la droite.

Exemple :

Données d'entrée

Saisir le nombre d'éléments : 5
Élément 1 : 3
Élément 2 : 7
Élément 3 : 4
Élément 4 : 9
Élément 5 : 8
Saisir un élément : 5
Saisir une position : 2

Données de sortie

3 5 7 4 9 8

Solutions - Insertion d'un élément

import java.util.Scanner;

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

        int tab[];
        int i, N, num, pos;

        // Saisir la taille actuelle du tableau
        System.out.print("Saisir le nombre d'éléments : ");
        N = clavier.nextInt();

        // initialiser la taille des tableaux avec N+1 pour faire de la place
        tab = new int[N + 1];

        // Saisir les éléments du tableau source
        for (i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        // Saisir un élément et sa position d'insertion
        System.out.print("Saisir un élément : ");
        num = clavier.nextInt();
        System.out.print("Saisir une position : ");
        pos = clavier.nextInt();

        // Si la position est non valide
        if (pos > N + 1 || pos <= 0) {
            System.out.println("Position invalide! Veuillez saisir une position entre 1 et " + N);
        } else {
            // Faire de la place pour un nouvel élément
            for (i = N; i >= pos; i--) {
                tab[i] = tab[i - 1];
            }

            // Insérer le nouvel élément
            tab[pos - 1] = num;
            N++;

            // Afficher le résultat
            for (i = 0; i < N; i++) {
                System.out.print(tab[i] + " , ");
            }
        }

        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000

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

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

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

    /* Saisir un élément et sa position d'insertion */
    printf("Saisir un élément : ");
    scanf("%d", &num);
    printf("Saisir une position : ");
    scanf("%d", &pos);

    /* Si la position est non valide */
    if(pos > N+1 || pos <= 0)
    {
        printf("Position invalide! Veuillez saisir une position entre 1 et %d", N);
    }
    else
    {
        /* Faire de la place pour un nouvel élément */
        for(i=N; i>=pos; i--)
        {
            tab[i] = tab[i-1];
        }
        
        /* Insérer le nouvel élément */
        tab[pos-1] = num;
        N++; 

        /* Afficher le résultat */
        for(i=0; i<N; i++)
        {
            printf("%d\t", tab[i]);
        }
    }

    return 0;
}

# Saisir la taille actuelle du tableau
N = int(input("Saisir le nombre d'éléments : "))

# initialiser la taille des tableaux avec N+1
tab = [0] * (N + 1)

# Saisir les éléments du tableau source
for i in range(N):
    tab[i] = int(input("Saisir l'élément {0} : ".format(i+1)))

# Saisir un élément et sa position d'insertion
num = int(input("Saisir un élément : "))
pos = int(input("Saisir une position : "))

# Si la position est non valide
if pos > N + 1 or pos <= 0:
    print("Position invalide! Veuillez saisir une position entre 1 et", N)
else:
    # Faire de la place pour un nouvel élément
    for i in range(N, pos-1, -1):
        tab[i] = tab[i - 1]

    # Insérer le nouvel élément
    tab[pos - 1] = num
    N += 1

    # Afficher le résultat
    for i in range(N):
        print(tab[i], end=" , ")
    print()

Exercice 2

Suppression d'un élément dans un tableau

Créez un programme qui crée et initialise un tableau, puis supprime un élément de ce tableau à la position spécifiée (de 0 à N-1).

Pour supprimer un élément du tableau, déplacez les éléments juste après la position donnée vers une position à gauche et réduisez la taille du tableau.

Exemple :

Données d'entrée

Saisir le nombre d'éléments : 5
Élément 1 : 3
Élément 2 : 7
Élément 3 : 4
Élément 4 : 9
Élément 5 : 8
Saisir la position de l'élément à supprimer : 2

Données de sortie

3 4 9 8

Solutions - Suppression d'un élément

import java.util.Scanner;

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

        int tab[];
        int i, N, pos;

        // Saisir la taille actuelle du tableau
        System.out.print("Saisir le nombre d'éléments : ");
        N = clavier.nextInt();

        // initialiser la taille des tableaux avec N
        tab = new int[N];

        // Saisir les éléments du tableau source
        for (i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        // Position de l'élément à supprimer
        System.out.print("Saisir la position de l'élément à supprimer : ");
        pos = clavier.nextInt();

        // Position de suppression non valide
        if (pos < 0 || pos > N) {
            System.out.println("Position invalide! Veuillez saisir une position entre 1 et " + N);
        } else {
            // Décaler les éléments vers la gauche
            for (i = pos - 1; i < N - 1; i++) {
                tab[i] = tab[i + 1];
            }

            // Décrémenter N
            N--;
        }

        // Afficher le résultat
        for (i = 0; i < N; i++) {
            System.out.print(tab[i] + " , ");
        }

        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000

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

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

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

    /* Position de l'élément à supprimer */
    printf("Saisir la position de l'élément à supprimer : ");
    scanf("%d", &pos);

    /* Position de suppression non valide */
    if(pos < 0 || pos > N)
    {
        printf("Position invalide! Veuillez saisir une position entre 1 et %d", N);
    }
    else
    {
        /* Décaler les éléments vers la gauche */
        for(i=pos-1; i<N-1; i++)
        {
            tab[i] = tab[i + 1];
        }

        /* Décrémenter N */
        N--;
    }

    /* Afficher le résultat */
    for(i=0; i<N; i++)
    {
        printf("%d\t", tab[i]);
    }

    return 0;
}

# Saisir la taille actuelle du tableau
N = int(input("Saisir le nombre d'éléments : "))

# initialiser la taille des tableaux avec N
tab = [0] * N

# Saisir les éléments du tableau source
for i in range(N):
    tab[i] = int(input("Saisir l'élément {0} : ".format(i+1)))

# Position de l'élément à supprimer
pos = int(input("Saisir la position de l'élément à supprimer : "))

# Si la position est non valide
if pos > N or pos <= 0:
    print("Position invalide! Veuillez saisir une position entre 1 et", N)
else:
    # Décaler les éléments vers la gauche
    for i in range(pos-1, N-1):
        tab[i] = tab[i + 1]

    # Décrémenter N
    N -= 1
    # Afficher le résultat
    for i in range(N):
        print(tab[i], end=" , ")
    print()

Exercice 3

Fréquence des éléments d'un tableau

Créez un programme qui crée et initialise un tableau, puis trouve la fréquence de chaque élément de ce tableau.

Exemple :

Données d'entrée

Saisir le nombre d'éléments : 5
Élément 1 : 3
Élément 2 : 7
Élément 3 : 3
Élément 4 : 9
Élément 5 : 8

Données de sortie

3 se produit 2 fois
7 se produit 1 fois
3 se produit 2 fois
9 se produit 1 fois
8 se produit 1 fois

Solutions - Fréquence des éléments

import java.util.Scanner;

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

        int tab[], freq[];
        int N, i, j, cpt;

        // Saisir la taille actuelle du tableau
        System.out.print("Saisir le nombre d'éléments : ");
        N = clavier.nextInt();

        // initialiser la taille des tableaux
        tab = new int[N];
        freq = new int[N];

        // Saisir les éléments du tableau source
        for (i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
            freq[i] = 1;
        }

        // Calculer les fréquences
        for (i = 0; i < N; i++) {
            cpt = 1;
            for (j = 0; j < N; j++) {
                if ((i != j) && (tab[i] == tab[j])) {
                    cpt++;
                }
            }
            freq[i] = cpt;
        }

        // Afficher les fréquences
        for (i = 0; i < N; i++) {
            if (freq[i] != 0) {
                System.out.println(tab[i] + " se produit " + freq[i] + " fois");
            }
        }

        clavier.close();
    }
}

#include <stdio.h>

int main()
{
    int tab[100], freq[100];
    int N, i, j, cpt;

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

    /* Saisir les éléments du tableau */
    for(i=0; i<N; i++)
    {
        printf("Élément %d : ", i+1);
        scanf("%d", &tab[i]);
        freq[i] = -1;
    }

    /* Calculer les fréquences */
    for(i=0; i<N; i++)
    {
        cpt = 1;
        for(j=0; j<N; j++)
        {
            if((i!=j) && (tab[i]==tab[j]))
            {
                cpt++;
            }
        }
        freq[i] = cpt;
    }

    /* Afficher les fréquences */
    for(i=0; i<N; i++)
    {
        if(freq[i] != 0)
        {
            printf("%d se produit %d fois\n", tab[i], freq[i]);
        }
    }

    return 0;
}

# Saisir la taille actuelle du tableau
N = int(input("Saisir le nombre d'éléments : "))

# initialiser les tableaux
tab = [0] * N
freq = [0] * N

# Saisir les éléments du tableau source
for i in range(N):
    tab[i] = int(input("Saisir l'élément {0} : ".format(i+1)))
    freq[i] = -1

# Calculer les fréquences
for i in range(N):
    cpt = 1
    for j in range(N):
        if (i != j) and (tab[i] == tab[j]):
            cpt += 1
    freq[i] = cpt

# Afficher les fréquences
for i in range(N):
    if freq[i] != 0:
        print(tab[i], "se produit", freq[i], "fois")

Exercice 4

Éléments uniques d'un tableau

Créez un programme qui crée et initialise un tableau, puis affichez tous les éléments uniques de ce tableau.

Idée : utiliser un tableau de fréquences.

Exemple :

Données d'entrée

Saisir le nombre d'éléments : 5
Élément 1 : 3
Élément 2 : 7
Élément 3 : 3
Élément 4 : 9
Élément 5 : 8

Données de sortie

7 9 8

Solutions - Éléments uniques

import java.util.Scanner;

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

        int tab[], freq[];
        int N, i, j, cpt;

        // Saisir la taille actuelle du tableau
        System.out.print("Saisir le nombre d'éléments : ");
        N = clavier.nextInt();

        // initialiser la taille des tableaux
        tab = new int[N];
        freq = new int[N];

        // Saisir les éléments du tableau source
        for (i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
            freq[i] = 1;
        }

        // Calculer les fréquences
        for (i = 0; i < N; i++) {
            cpt = 1;
            for (j = 0; j < N; j++) {
                if ((i != j) && (tab[i] == tab[j])) {
                    cpt++;
                }
            }
            freq[i] = cpt;
        }

        // Afficher les éléments uniques
        for (i = 0; i < N; i++) {
            if (freq[i] == 1) {
                System.out.print(tab[i] + " , ");
            }
        }

        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000

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

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

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

    /* Calculer les fréquences */
    for(i=0; i<N; i++)
    {
        cpt = 1;
        for(j=i+1; j<N; j++)
        {
            if(tab[i] == tab[j])
            {
                cpt++;
                freq[j] = 0;
            }
        }
        freq[i] = cpt;
    }

    /* Afficher les éléments uniques */
    for(i=0; i<N; i++)
    {
        if(freq[i] == 1)
        {
            printf("%d ", tab[i]);
        }
    }

    return 0;
}

# Saisir la taille actuelle du tableau
N = int(input("Saisir le nombre d'éléments : "))

# initialiser les tableaux
tab = [0] * N
freq = [0] * N

# Saisir les éléments du tableau source
for i in range(N):
    tab[i] = int(input("Saisir l'élément {0} : ".format(i+1)))
    freq[i] = -1

# Calculer les fréquences
for i in range(N):
    cpt = 1
    for j in range(N):
        if (i != j) and (tab[i] == tab[j]):
            cpt += 1
    freq[i] = cpt

# Afficher les éléments uniques
for i in range(N):
    if freq[i] == 1:
        print(tab[i], end=" - ")
print()

Exercice 5

Compter les éléments en double

Créez un programme qui crée et initialise un tableau, puis comptez les éléments en double dans ce tableau.

Exemple :

Données d'entrée

Saisir le nombre d'éléments : 5
Élément 1 : 3
Élément 2 : 7
Élément 3 : 3
Élément 4 : 7
Élément 5 : 8

Données de sortie

Nombre total d'éléments en double trouvés dans le tableau = 2

Solutions - Compter les doublons

import java.util.Scanner;

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

        int tab[];
        int N, i, j, cpt = 0;

        // Saisir la taille actuelle du tableau
        System.out.print("Saisir le nombre d'éléments : ");
        N = clavier.nextInt();

        // initialiser la taille des tableaux
        tab = new int[N];

        // Saisir les éléments du tableau source
        for (i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        // Compter les doublons
        for (i = 0; i < N; i++) {
            for (j = i + 1; j < N; j++) {
                if (tab[i] == tab[j]) {
                    cpt++;
                    break;
                }
            }
        }

        System.out.println("Nombre total d'éléments en double trouvés dans le tableau = " + cpt);

        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000

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

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

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

    /* Compter les doublons */
    for(i=0; i<N; i++)
    {
        for(j=i+1; j<N; j++)
        {
            if(tab[i] == tab[j])
            {
                cpt++;
                break;
            }
        }
    }

    printf("\nNombre total d'éléments en double trouvés dans le tableau = %d", cpt);

    return 0;
}

# Saisir la taille actuelle du tableau
N = int(input("Saisir le nombre d'éléments : "))

# initialiser le tableau
tab = [0] * N

# Saisir les éléments du tableau source
for i in range(N):
    tab[i] = int(input("Saisir l'élément {0} : ".format(i+1)))

# Compter les doublons
cpt = 0
for i in range(N):
    for j in range(i+1, N):
        if tab[i] == tab[j]:
            cpt += 1
            break

print("Nombre total d'éléments en double trouvés dans le tableau =", cpt)

Exercice 6

Supprimer les éléments en double

Créez un programme qui crée et initialise un tableau, puis supprimez les éléments en double dans ce tableau.

Exemple :

Données d'entrée

Saisir le nombre d'éléments : 5
Élément 1 : 3
Élément 2 : 7
Élément 3 : 3
Élément 4 : 9
Élément 5 : 8

Données de sortie

3 7 9 8

Solutions - Supprimer les doublons

import java.util.Scanner;

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

        int tab[];
        int N, i, j, k;

        // Saisir la taille actuelle du tableau
        System.out.print("Saisir le nombre d'éléments : ");
        N = clavier.nextInt();

        // initialiser la taille des tableaux
        tab = new int[N];

        // Saisir les éléments du tableau source
        for (i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        // Supprimer les doublons
        for (i = 0; i < N; i++) {
            for (j = i + 1; j < N; j++) {
                if (tab[i] == tab[j]) {
                    for (k = j; k < N - 1; k++) {
                        tab[k] = tab[k + 1];
                    }
                    N--;
                    j--;
                }
            }
        }

        // Afficher le résultat
        for (i = 0; i < N; i++) {
            System.out.print(tab[i] + " , ");
        }

        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000

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

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

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

    /* Supprimer les doublons */
    for(i=0; i<N; i++)
    {
        for(j=i+1; j<N; j++)
        {
            if(tab[i] == tab[j])
            {
                for(k=j; k<N-1; k++)
                {
                    tab[k] = tab[k + 1];
                }
                N--;
                j--;
            }
        }
    }

    /* Afficher le résultat */
    for(i=0; i<N; i++)
    {
        printf("%d\t", tab[i]);
    }

    return 0;
}

# Saisir la taille actuelle du tableau
N = int(input("Saisir le nombre d'éléments : "))

# initialiser le tableau
tab = [0] * N

# Saisir les éléments du tableau source
for i in range(N):
    tab[i] = int(input("Saisir l'élément {0} : ".format(i+1)))

# Supprimer les doublons
i = 0
while i < N:
    j = i + 1
    while j < N:
        if tab[i] == tab[j]:
            for k in range(j, N-1):
                tab[k] = tab[k + 1]
            N -= 1
        else:
            j += 1
    i += 1

# Afficher le résultat
for i in range(N):
    print(tab[i], end=" , ")
print()

Exercice 7

Inverser un tableau sans tableau supplémentaire

Créez un programme qui crée et initialise un tableau, puis inversez ce tableau sans utiliser un tableau supplémentaire.

Exemple :

Données d'entrée

Saisir le nombre d'éléments : 5
Élément 1 : 3
Élément 2 : 7
Élément 3 : 4
Élément 4 : 9
Élément 5 : 8

Données de sortie

8 9 4 7 3

Solutions - Inverser un tableau

import java.util.Scanner;

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

        int tab[];
        int N, i;
        int debut, fin;
        int temp;

        // Saisir la taille actuelle du tableau
        System.out.print("Saisir le nombre d'éléments : ");
        N = clavier.nextInt();

        // initialiser la taille des tableaux
        tab = new int[N];

        // Saisir les éléments du tableau source
        for (i = 0; i < N; i++) {
            System.out.print("Élément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        // Inverser le tableau
        debut = 0;
        fin = N - 1;
        while (debut < fin) {
            temp = tab[debut];
            tab[debut] = tab[fin];
            tab[fin] = temp;
            debut++;
            fin--;
        }

        // Afficher le résultat
        for (i = 0; i < N; i++) {
            System.out.print(tab[i] + " , ");
        }

        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000

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

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

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

    /* Inverser le tableau */
    debut = 0;
    fin = N - 1;
    while(debut < fin)
    {
        temp = tab[debut];
        tab[debut] = tab[fin];
        tab[fin] = temp;
        debut++;
        fin--;
    }

    /* Afficher le résultat */
    for(i=0; i<N; i++)
    {
        printf("%d\t", tab[i]);
    }

    return 0;
}

# Saisir la taille actuelle du tableau
N = int(input("Saisir le nombre d'éléments : "))

# initialiser le tableau
tab = [0] * N

# Saisir les éléments du tableau source
for i in range(N):
    tab[i] = int(input("Saisir l'élément {0} : ".format(i+1)))

# Inverser le tableau
debut = 0
fin = N - 1
while debut < fin:
    temp = tab[debut]
    tab[debut] = tab[fin]
    tab[fin] = temp
    debut += 1
    fin -= 1

# Afficher le résultat
for i in range(N):
    print(tab[i], end=" , ")
print()

Points clés à retenir

Un tableau est une structure de données linéaire avec des indices commençant à 0.
L'insertion d'un élément nécessite de décaler les éléments vers la droite.
La suppression d'un élément nécessite de décaler les éléments vers la gauche.
Pour trouver des doublons, on utilise des boucles imbriquées ou un tableau de fréquences.
L'inversion d'un tableau peut se faire en échangeant les éléments symétriques.

Sortie

// La sortie apparaîtra ici…

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

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

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

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