TP3 - Correction

TP 3 : Algorithmique et programmation 2 S3 24/10/2022
S. QASSIMI MIPC
Exercice 1 :
Écrire un programme qui lit deux tableaux A et B et leurs dimensions N et M au clavier et

qui ajoute les éléments de B à la fin de A. Utiliser le formalisme pointeur à chaque fois que
cela est possible.
#include <stdio.h>
main()
{
/* Déclarations */
int A[100], B[50]; /* tableaux */
int N, M; /* dimensions des tableaux */
int I; /* indice courant */
/* Saisie des données */

printf("Dimension du tableau A (max.50) : ");
scanf("%d", &N );
for (I=0; I<N; I++)
{
printf("Elément %d : ", I);
scanf("%d", A+I);
}
printf("Dimension du tableau B (max.50) : ");
scanf("%d", &M );
for (I=0; I<M; I++)
{
printf("Elément %d : ", I);
scanf("%d", B+I);
}
/* Affichage des tableaux */
printf("Tableau donné A :\n");
for (I=0; I<N; I++)
printf("%d ", *(A+I));
printf("\n");
printf("Tableau donné B :\n");
for (I=0; I<M; I++)
printf("%d ", *(B+I));
printf("\n");
/* Copie de B à la fin de A */
for (I=0; I<M; I++)
*(A+N+I) = *(B+I);
/* Nouvelle dimension de A */
N += M;
/* Edition du résultat */
printf("Tableau résultat A :\n");
for (I=0; I<N; I++)
printf("%d ", *(A+I));
printf("\n");
return 0;
}
Exercice 2 :
Écrire un programme qui lit un entier X et un tableau A du type int au clavier et élimine
toutes les occurrences de X dans A en tassant les éléments restants. Le programme utilisera
les pointeurs P1 et P2 pour parcourir le tableau
#include <stdio.h>
main()
{
/* Déclarations */
int A[50]; /* tableau donné */
int N; /* dimension du tableau */
int X; /* valeur à éliminer */
int *P1, *P2; /* pointeurs d'aide */

printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
for (P1=A; P1<A+N; P1++)
{
printf("Elément %d : ", P1-A);
scanf("%d", P1);
}
printf("Introduire l'élément X à éliminer du tableau : ");
scanf("%d", &X );
/* Affichage du tableau */
for (P1=A; P1<A+N; P1++)
printf("%d ", *P1);
printf("\n");
/* Effacer toutes les occurrences de X et comprimer : */
/* Copier tous les éléments de P1 vers P2 et augmenter */
/* P2 pour tous les éléments différents de X. */
for (P1=P2=A; P1<A+N; P1++)
{
*P2 = *P1;
if (*P2 != X)
P2++;
}
/* Nouvelle dimension de A */
N = P2-A;
for (P1=A; P1<A+N; P1++)
printf("%d ", *P1);
printf("\n");
return 0;
}
Exercice 3 :
Ecrire un programme qui range les éléments d'un tableau A du type int dans l'ordre inverse.
Le programme utilisera des pointeurs P1 et P2 et une variable numérique AIDE pour la
permutation des éléments.
#include <stdio.h>
main()
{
/* Déclarations */
int A[50]; /* tableau donné */
int N; /* dimension du tableau */
int AIDE; /* pour la permutation */
int *P1, *P2; /* pointeurs d'aide */
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
for (P1=A; P1<A+N; P1++)
{
printf("Elément %d : ", P1-A);
scanf("%d", P1);
}
/* Affichage du tableau */
for (P1=A; P1<A+N; P1++)
printf("%d ", *P1);
printf("\n");
/* Inverser la tableau */
for (P1=A,P2=A+(N-1); P1<P2; P1++,P2--)
{
AIDE = *P1;
*P1 = *P2;
*P2 = AIDE;
}
for (P1=A; P1<A+N; P1++)
printf("%d ", *P1);
printf("\n");
return 0;
}
Exercice 4 :
Ecrire un programme qui lit une matrice A de dimensions N et M au clavier et affiche les
données suivantes en utilisant le formalisme pointeur à chaque fois que cela est possible :
a) la matrice A
b) la transposée de A
#include <stdio.h>
main()
{
/* Déclarations */
int A[50][50]; /* matrice */
int N, M; /* dimensions de la matrice */
int I, J; /* indices courants */
printf("Nombre de lignes (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &M );
/* Lecture de la matrice au clavier */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
printf("Elément[%d][%d] : ",I,J);
scanf("%d", (int *)A+I*50+J);
}
/* a) Affichage de la matrice */
printf("Matrice donnée :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", *((int *)A+I*50+J));
printf("\n");
}
/* b) Affichage de la transposée de A */
printf("Matrice transposée :\n");
for (J=0; J<M; J++)
{
for (I=0; I<N; I++)
printf("%7d ", *((int *)A+I*50+J));
printf("\n");
}
printf("\n");
return 0;
}
Exercice 5 :
Ecrire un programme qui lit une chaîne de caractères CH et détermine la longueur de la

chaîne à l'aide d'un pointeur P.
#include <stdio.h>
main()
{
/* Déclarations */
char CH[101]; /* chaîne donnée */
char *P; /* pointeur d'aide */

printf("Entrez une ligne de texte (max.100 caractères) :\n");
gets(CH);
/* Placer P à la fin de la chaîne */
for (P=CH; *P; P++)
;
/* Affichage du résultat */
printf("La chaîne \"%s\" est formée de %d caractères.\n",
CH, P-CH);
return 0;
}
Exercice 6 :
Ecrire un programme qui lit un caractère C et une chaîne de caractères CH au clavier. Ensuite
toutes les occurrences de C dans CH seront éliminées. Le reste des caractères dans CH sera
tassé à l'aide d'un pointeur et de la fonction strcpy.
#include <stdio.h>
#include <string.h>
main()
{
/* Déclarations */
char CH[101]; /* chaîne donnée */
char C; /* lettre à éliminer */
char *P; /* pointeur d'aide dans CH */

printf("Entrez une ligne de texte (max.100 caractères) :\n");
gets(CH);
printf("Entrez le caractère à éliminer (suivi de Enter) : ");
C=getchar();
/* Comprimer la chaîne à l'aide de strcpy */
P=CH;
while (*P)
{
if (*P==C)
strcpy(P, P+1);
else P++;
}
/* Affichage du résultat */
printf("Chaîne résultat : \"%s\"\n", CH);
return 0;
}
Exercice 7 :
Ecrire un programme qui lit 5 mots d'une longueur maximale de 50 caractères et les
mémorise dans un tableau de chaînes de caractères TABCH. Inverser l'ordre des caractères à
l'intérieur des 5 mots à l'aide de deux pointeurs P1 et P2. Afficher les mots.
#include <stdio.h>
main()
{
/* Déclarations */
char TABCH[5][51];/* tableau de chaînes de caractères */
char AIDE; /* pour la permutation des caractères */
char *P1, *P2; /* pointeurs d'aide */
int I; /* indice courant */
/* TABCH+I est l'adresse de la I-ième chaîne du tableau */

/* Il vaut mieux convertir TABCH+I en pointeur sur char */
printf("Entrez 5 mots :\n");
for (I=0; I<5; I++)
{
printf("Mot %d (max.50 caractères) : ", I);
gets((char *)(TABCH+I));
}
/* Inverser l'ordre des caractères à l'intérieur des mots */

for (I=0; I<5; I++)
{
P1 = P2 = (char *)(TABCH+I);
/* Placer P2 à la fin de la chaîne */
while (*P2)
P2++;
P2--; /* sinon '\0' est placé au début de la chaîne */
while (P1<P2)
{
AIDE = *P1;
*P1 = *P2;
*P2 = AIDE;
P1++;
P2--;
}
}
/* Affichage des mots inversés */

for (I=0; I<5; I++)
puts((char *)(TABCH+I));
return 0;
}
Exercice 8 :
Nous voulons construire un tableau représenté initialement par un pointeur *tableau de type
int et initialisé à NULL.
Ce tableau aura une dimension qui aura comme dimension un nombre (saisi à l’exécution)
A l’aide de la fonction malloc, on vous demande de réserver un emplacement mémoire pour
ce tableau et saisir ces éléments.
Afficher les éléments du tableau et libérer la mémoire
int main() {
int nombre = 0;
int *tableau = NULL;
int x = 0;
printf ("Veuillez entrer la taille du tableau : ");
scanf ("%d", &nombre);
tableau = malloc(sizeof(int) * nombre);
for (x = 0; x <nombre; x++) {
printf ("Veuillez entrer un nombre : ");
scanf ("%d", &tableau[x]);
}
for (x = 0; x < nombre; ++x) {
printf ("Nombre %d : %d\n", (x + 1), tableau[x]);
}
free(tableau);
return 0;
}

TP3 - Correction

Transféré par

Droits d'auteur :

Formats disponibles

TP3 - Correction

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TP3 - Correction

Transféré par

Droits d'auteur :

Formats disponibles

TP 3 : Algorithmique et programmation 2 S3 24/10/2022

Écrire un programme qui lit deux tableaux A et B et leurs dimensions N et M au clavier et

/* Saisie des données */

/* Saisie des données */

Ecrire un programme qui lit une chaîne de caractères CH et détermine la longueur de la

/* Saisie des données */

/* Saisie des données */

/* TABCH+I est l'adresse de la I-ième chaîne du tableau */

/* Inverser l'ordre des caractères à l'intérieur des mots */

/* Affichage des mots inversés */

Vous aimerez peut-être aussi

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.