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

Do you want to read our courses in English? please visit our new website cs-teachers.com Click here

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= " , ")
                                        

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Many people realize their hearts desires late in life. Continue learning, never stop striving and keep your curiosity sharp, and you will never become too old to appreciate life.

0 Commentaire(s)

Pour laisser un commentaire vous devez avoir un compte Inscription, ou Se connecter