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

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

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
Elément 1 : 3
Elément 2 : 7
Elément 3 : 4
Elément 4 : 9
Elément 5 : 8
Saisir un élément : 5
Saisir une position : 2

Données de sortie

3 5 7 4 9 8

Corrigé

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();

        // intialiser la taille des tableaux avec N
        tab = new int[N + 1];

        // Saisir les éléments du tableau source */
        for (i = 0; i < N; i++) {
            System.out.print("Elé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 et non valide */
        if (pos > N + 1 || pos <= 0) {
            System.out.println("Position invalide! Veuillez saisir une position entre 1 et " + N);
        } else {
            /*
              Faites de la place pour un nouvel élément de tableau en déplaçant les
              éléments juste après la position vers la droite
             */
            for (i = N; i >= pos; i--) {
                tab[i] = tab[i - 1];
            }

            // Insérer un nouvel élément à une position donnée et incrémenter N */
            tab[pos - 1] = num;
            N++;

            // Afficher le tableau après l'opération d'insertion */
            for (i = 0; i < N; i++) {
                System.out.print(tab[i] + " , ");
            }
        }

        // fermer les ressources
        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000 // La taille maximale

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

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

    /* Saisir les éléments du tableau tab */

    for(i=0; i<N; i++)
    {
        printf("Elé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 et non valide */
    if(pos > N+1 || pos $lt;= 0)
    {
        printf("Position invalide! Veuillez saisir une position entre 1 et %d", N);
    }
    else
    {
        /* Faites de la place pour un nouvel élément de tableau en déplaçant les éléments juste après la position vers la droite */
        for(i=N; i>=pos; i--)
        {
            tab[i] = tab[i-1];
        }
        
        /* Insérer un nouvel élément à une position donnée et incrémenter N */
        tab[pos-1] = num;
        N++; 

        /* Afficher le tableau après l'opération d'insertion */
        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 : "))

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

# Saisir les éléments du tableau source
for i in range(N):
    tab[i]=int(input("Saisir l'élement {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 et non valide */
if (pos > N + 1 or pos <= 0):
    print("Position invalide! Veuillez saisir une position entre 1 et " , N)
else:
    #Faites de la place pour un nouvel élément de tableau en déplaçant les
    #éléments juste après la position vers la droite
    for i in range(N,-1,-1):
        tab[i] = tab[i - 1]

    # Insérer un nouvel élément à une position donnée et incrémenter N
    tab[pos - 1] = num
    N+=1

    # Afficher le tableau après l'opération d'insertion */
    for i in range(N):
        print(tab[i] , " , ")

Exercice 2

Créez un programme qui crée et initialise un tableau, puis supprimez 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
Elément 1 : 3
Elément 2 : 7
Elément 3 : 4
Elément 4 : 9
Elément 5 : 8
Saisir la position de l'élément à supprimer : 2

Données de sortie

3 4 9 8

Corrigé

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();

        // intialiser la taille des tableaux avec N
        tab = new int[N + 1];

        // Saisir les éléments du tableau source */
        for (i = 0; i < N; i++) {
            System.out.print("Elé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 {
            // Copier la valeur de l'élément suivant dans l'élément actuel */
            for (i = pos - 1; i < N - 1; i++) {
                tab[i] = tab[i + 1];
            }

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

        // Afficher le tableau après suppression */
        for (i = 0; i < N; i++) {
            System.out.print(tab[i] + " , ");
        }

        // fermer les ressources
        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000 // La taille maximale

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

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

    /* Saisir les éléments du tableau tab */
    for(i=0; i<N; i++)
    {
        printf("Elé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
    {
        /* Copier la valeur de l'élément suivant dans l'élément actuel */
        for(i=pos-1; i<N-1; i++)
        {
            tab[i] = tab[i + 1];
        }

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

    /* Afficher le tableau après suppression */
    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 : "))

# intialiser 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'élement {0} : ".format(i+1)))


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

# Si la position et non valide */
if (pos > N + 1 or pos <= 0):
    print("Position invalide! Veuillez saisir une position entre 1 et " , N)
else:
    #Copier la valeur de l'élément suivant dans l'élément actuel
    for i in range(pos-1, N-1):
        tab[i] = tab[i + 1]

        #Décrémenter N par 1 */
    N-=1
    #Afficher le tableau après suppression */
    for i in range(N):
        print(tab[i] , " , ")

Exercice 3

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
Elément 1 : 3
Elément 2 : 7
Elément 3 : 3
Elément 4 : 9
Elé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

Corrigé

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();

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

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

        for (i = 0; i < N; i++) {
            cpt = 1;
            for (j = 0; j < N; j++) {
                // Si un élément en double est trouvé */
                if ((i != j) && (tab[i] == tab[j])) {
                    cpt++;
                }
            }

            freq[i] = cpt;
        }

        /*
          Afficher la fréquence de chaque élément
         */
        for (i = 0; i < N; i++) {
            if (freq[i] != 0) {
                System.out.print(tab[i] + " se produit " + freq[i] + " fois\n");
            }
        }

        // fermer les ressources
        clavier.close();
    }
}

#include <stdio.h>

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

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

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

        freq[i] = -1;
    }


    for(i=0; i<N; i++)
    {
        cpt = 1;
        for(j=0; j<N; j++)
        {
            /* Si un élément en double est trouvé */
            if((i!=j) && (tab[i]==tab[j]))
            {
                cpt++;
            }
        }

        freq[i] = cpt;
    }

    /*
     * Afficher la fréquence de chaque élément
     */
    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 : "))

# intialiser la taille des tableaux avec N
tab=[0]*(N)
freq=[0]*(N)

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

for i in range(N):
    cpt = 1
    for j in range(N):
        # Si un élément en double est trouvé */
        if((i!=j) and (tab[i]==tab[j])):
            cpt+=1

    freq[i] = cpt

#Afficher la fréquence de chaque élément
for i in range(N):
    if(freq[i] != 0):
        print(tab[i] , " se produit " , freq[i] , " fois")

Exercice 4

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
Elément 1 : 3
Elément 2 : 7
Elément 3 : 3
Elément 4 : 9
Elément 5 : 8

Données de sortie

7 9 8

Corrigé

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();

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

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

        for (i = 0; i < N; i++) {
            cpt = 1;
            for (j = 0; j < N; j++) {
                // Si un élément en double est trouvé */
                if ((i != j) && (tab[i] == tab[j])) {
                    cpt++;
                }
            }

            freq[i] = cpt;
        }

        // afficher tous les éléments uniques du tableau */
        for (i = 0; i < N; i++) {
            if (freq[i] == 1) {
                System.out.println(tab[i] + " , ");
            }
        }

        // fermer les ressources
        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000 // La taille maximale

int main()
{
    int tab[TAILLE_MAX], freq[TAILLE_MAX];
    int N, i, j, count;
 
    /* Saisir la taille actuelle du tableau  <  TAILLE_MAX */
    printf("Saisir le nombre d'éléments : ");
    scanf("%d", &N);

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

        freq[i] = 1;
    }
 
    /* Trouver la fréquence de chaque élément */
    for(i=0; i<N; i++)
    {
        cpt = 1;
        for(j=i+1; j<N; j++)
        {
            /* Si un élément en double est trouvé */
            if((i!=j) && (tab[i]==tab[j]))
            {
                cpt++;

                /* Make sure not to count frequency of same element again */
                freq[j] = 0;*/
            }
        }

        freq[i] = cpt;
    }
 
    /* afficher tous les éléments uniques du tableau */
    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 : "))

# intialiser la taille des tableaux avec N
tab=[0]*(N)
freq=[0]*(N)

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

for i in range(N):
    cpt = 1
    for j in range(N):
        # Si un élément en double est trouvé */
        if((i!=j) and (tab[i]==tab[j])):
            cpt+=1

    freq[i] = cpt

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

Exercice 5

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
Elément 1 : 3
Elément 2 : 7
Elément 3 : 3
Elément 4 : 7
Elément 5 : 8

Données de sortie

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

Corrigé

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();

        // intialiser 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("Elément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        /*
          Trouver tous les éléments en double dans le tableau
         */
        for (i = 0; i < N; i++) {
            for (j = i + 1; j < N; j++) {
                // Si un doublon est trouvé, incrémentez cpt de 1 */
                if (tab[i] == tab[j]) {
                    cpt++;
                    break;
                }
            }
        }

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

        // fermer les ressources
        clavier.close();
    }
}

#include <stdio.h>

#define TAILLE_MAX 1000 // La taille maximale

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

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

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

    /*
     * Trouver tous les éléments en double dans le tableau
     */
    for(i=0; i<N; i++)
    {
        for(j=i+1; j<N; j++)
        {
            /* Si un doublon est trouvé, incrémentez cpt de 1 */
            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 : "))

# intialiser 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'élement {0} : ".format(i+1)))

#Trouver tous les éléments en double dans le tableau
cpt=0
for i in range(N):
    for j in range(i+1,N):
        # Si un doublon est trouvé, incrémentez cpt de 1 */
        if (tab[i] == tab[j]):
            cpt+=1
            break

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

Exercice 6

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
Elément 1 : 3
Elément 2 : 7
Elément 3 : 3
Elément 4 : 9
Elément 5 : 8

Données de sortie

3 7 9 8

Corrigé

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();

        // intialiser 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("Elément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        /*
          Rechercher des éléments en double dans le tableau
         */
        for (i = 0; i < N; i++) {
            for (j = i + 1; j < N; j++) {
                // Si un doublon est trouvé */
                if (tab[i] == tab[j]) {
                    // Supprimer l'élément en double actuel */
                    for (k = j; k < N - 1; k++) {
                        tab[k] = tab[k + 1];
                    }

                    // Décrémenter N après avoir supprimé l'élément en double */
                    N--;

                    // Si un décalage d'éléments se produit, n'incrémentez pas j */
                    j--;
                }
            }
        }

        /*
          Afficher le tableau après avoir supprimé les éléments en double
         */
        for (i = 0; i < N; i++) {
            System.out.print(tab[i] + " , ");
        }

        // fermer les ressources
        clavier.close();
    }
}

#include <stdio.h>

#define TAILLE_MAX 1000 // La taille maximale

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

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

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


    /*
     * Rechercher des éléments en double dans le tableau
     */
    for(i=0; i<N; i++)
    {
        for(j=i+1; j<N; j++)
        {
            /* Si un doublon est trouvé */
            if(tab[i] == tab[j])
            {
                /* Supprimer l'élément en double actuel */
                for(k=j; k<N-1; k++)
                {
                    tab[k] = tab[k + 1];
                }

                /* Décrémenter N après avoir supprimé l'élément en double */
                N--;

                /* Si un décalage d'éléments se produit, n'incrémentez pas j */
                j--;
            }
        }
    }


    /*
     * Afficher le tableau après avoir supprimé les éléments en double
     */
    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 : "))

# intialiser 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'élement {0} : ".format(i+1)))

# Rechercher des éléments en double dans le tableau
for i in range(N):
    for j in range(i+1,N):
        # Si un doublon est trouvé */
        if (tab[i] == tab[j]):
            #Supprimer l'élément en double actuel */
            for k in range(j,N-1):
                tab[k] = tab[k + 1]

            # Décrémenter N après avoir supprimé l'élément en double */
            N-=1

            # Si un décalage d'éléments se produit, n'incrémentez pas j */
            j-=1

#Afficher le tableau après avoir supprimé les éléments en double
for i in range(N):
    print(tab[i] ," , ")

Exercice 7

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
Elément 1 : 3
Elément 2 : 7
Elément 3 : 4
Elément 4 : 9
Elément 5 : 8

Données de sortie

8 9 4 7 3

Corrigé

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 indexAvant;
        int indexArriere;
        int temp; // pour échanger deux éléments

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

        // intialiser 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("Elément " + (i + 1) + " : ");
            tab[i] = clavier.nextInt();
        }

        indexArriere = 0;
        indexAvant = N - 1;
        while (indexArriere < indexAvant) {
            // inverser le dernier élément avec le premier élément */
            temp = tab[indexArriere];
            tab[indexArriere] = tab[indexAvant];
            tab[indexAvant] = temp;

            // incrémenter l'index du premier élément et décrémenter l'index du dernier
            // élément
            indexArriere++;
            indexAvant--;
        }

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

        // fermer les ressources
        clavier.close();
    }
}

#include <stdio.h>
#define TAILLE_MAX 1000 // La taille maximale

int main()
{
    int tab[TAILLE_MAX];
    int N, i;
    int indexAvant;
    int indexArriere;
    int temp; // pour échanger deux éléments

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

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

    indexArriere = 0;
    indexAvant = N - 1;
    while(indexArriere < indexAvant)
    {
        /* inverser le dernier élément avec le premier élément */
        temp = tab[indexArriere];
        tab[indexArriere] = tab[indexAvant];
        tab[indexAvant] = temp;
        
        // incrémenter l'index du premier élément et décrémenter l'index du dernier élément
        indexArriere++;
        indexAvant--;
    }

    // Afficher le tableau inversé
    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 : "))

# intialiser 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'élement {0} : ".format(i+1)))

indexArriere = 0
indexAvant = N - 1
while (indexArriere < indexAvant):
    # inverser le dernier élément avec le premier élément */
    temp = tab[indexArriere]
    tab[indexArriere] = tab[indexAvant]
    tab[indexAvant] = temp

    # incrémenter l'index du premier élément et décrémenter l'index du dernier
    # élément
    indexArriere+=1
    indexAvant-=1

#Afficher le tableau après avoir supprimé les éléments en double
for i in range(N):
    print(tab[i] ,end= " , ")

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

Exercices corrigés en programmation Python, Java et langage C

Sommaire