TP1 de programmation C S4

Bonjour / Bonsoir chers membres,

Voila le code source du 1er TP de programmation C pour ce semestre bon le code est simple, bien commenter, les fonctions sont si simple a comprendre mais ça empêche d'en discuter si vous rencontrez des difficulté ....

juste je doit motionner que si les barre des encadrement des tableaux et tout; s'il s'affiche bizarrement enlever les et remplacer les par leur code ASCII que vous pouvez retrouver ICI

Donc sans tarder voila le code C:

Code:: /*
Name: Manipulation generale d'un tableau d'entiers.
Author : Boukhris Chouaib.
Date: 28/02/10 16:15.
Derniere Mise a Jour : 04/03/10 21:02.
Description: Il fait beaucoup de chose XD ^_^ .
Licence : Copyleft OpenSource.
*/

#include
#include

/*====================================================================================================*/
/* Procedure de saisie d'un Tableau d'entiers */

void Saisie(int *Tab, int *N)
{
int i;

printf("\\n\\t\\tSaisie des valeurs de votre tableau \\"T\\" : \\n");
for(i=0; i<*N; i++)
{
printf("\\tT[%d] : ", i+1);
scanf("%d", (Tab+i));
}

}
/*===================================================================================================*/

/* Procedure d'affichage d'un Tableau d'entiers */

void Affichage(int *Tab, int *N)
{
int i;

printf("\\n\\t\\t╭──────────────────────────────────╮\\n");
printf("\\t\\t│ Le tableau d'Entier │\\n");
printf("\\t\\t├───────┬──────────────────────────┤\\n");
printf("\\t\\t│ T[N°] │ Nombre │\\n");
printf("\\t\\t├───────┼──────────────────────────┤\\n");

for(i=0; i<*N; i++)
{
printf("\\t\\t│ T[%2d] │ %5d │\\n", i+1, *(Tab+i));
}

printf("\\t\\t╰───────┴──────────────────────────╯");

}
/*====================================================================================================*/

/* Procedure qui affiche tout les nombres qui se termine par 8 */

void Affich_T8(int *Tab, int *N)
{
int i;

printf("\\t\\t╭────────────────────────────────────────────────╮\\n");
printf("\\t\\t│ Les nombres qui se termine par 8 │\\n");
printf("\\t\\t├───────────────────┬────────────────────────────┤\\n");
printf("\\t\\t│ Emplacement T[N°] │ Nombre │\\n");
printf("\\t\\t├───────────────────┼────────────────────────────┤\\n");
for(i=0; i<*N; i++)
{
/* Si le reste de la division = 8 donc le nobre se termine par 8 ^_^ */
if( *(Tab+i)%10 == 8)
printf("\\t\\t│ T[%2d] │ %5d │\\n", i+1, *(Tab+i));
}

printf("\\t\\t╰───────────────────┴────────────────────────────╯");

}
/*===================================================================================================*/

/* Procedure qui cherche les multiples de 3 puis les affiche en un seul parcour du tableau */

void Multip_3(int *Tab, int *N)
{
int i, nbr=0;
int *Aux= malloc(sizeof(int)*(*N));

for(i=0; i<*N; i++)
{
/* Si le reste de la division par 3 et nul donc le nombre est n multiple de 3 ^_^ */
if( *(Tab+i)%3 == 0)
{
*(Aux+nbr)=*(Tab+i);
nbr++;
}
}
printf("\\n\\t\\tNombre des multiples dans le tableau : %d", nbr);
Affichage(Aux,&nbr);
free(Aux);
}
/*===================================================================================================*/

/* Procedure qui Affiche tout les nombres composer de 3 chifres */

void Nombre_3x(int *Tab, int *N)
{
int i;

printf("\\t\\t╭─────────────────────────────────────────────────╮\\n");
printf("\\t\\t│ Les nombres composer de 3 chifres │\\n");
printf("\\t\\t├───────────────────┬─────────────────────────────┤\\n");
printf("\\t\\t│ Emplacement T[N°] │ Nombre │\\n");
printf("\\t\\t├───────────────────┼─────────────────────────────┤\\n");

for(i=0; i<*N; i++)
{
if( *(Tab+i)>99 && *(Tab+i)<1000)
printf("\\t\\t│ T[%2d] │ %5d │\\n", i+1, *(Tab+i));
}
printf("\\t\\t╰───────────────────┴─────────────────────────────╯");

}
/*====================================================================================================*/

/* Fonction qui cherche un nombre fourni par l'utilisateur dans le tableau */

int Chercher(int *Tab, int *N)
{
int Nbr;
int i;

printf("Donnez le nobre a chercher dans le tableau :");
scanf("%d", &Nbr);

for(i=0; i<*N; i++)
{
if( *(Tab+i)== Nbr)
return(i);

/* Si on a parcouru tout le tableaux sans trouver le nombre recercher */
if (i == *N-1)
return(-1);

}
}
/*====================================================================================================*/

/* Fonction qui renvoie le Maximum du tableau */

int Max(int *Tab, int *N)
{
int i;
int max= *Tab;

for(i=1; i<*N; i++)
{
if(max < *(Tab+i))
max = *(Tab+i);
}

return (max);
}
/*===================================================================================================*/

/*fonction qui renvoie la derniere position du min*/

int P_Min(int *Tab, int *N)
{
int i;
int pos_min, min = *Tab;

for(i=0; i<*N; i++)
{
if(*(Tab+i) <= min)
{
min=*(Tab+i);
pos_min=i;
}
}

return (pos_min);
}
/*===================================================================================================*/

/* Procedure qui determine si tout les nombre du tableau sans compri entre X & Y */

void Interval(int *Tab, int *N)
{
int X, Y;
int min, max;

min = P_Min(Tab, N);
max = Max(Tab, N);

printf("Donnez l'interval a verifier : ");
scanf("%d %d", &X, &Y);

if( (*(Tab+min) >= X) && (max <= Y) )
printf("\\n\\t\\t\\" Vrai \\" : Tout les nombres sont compris dans l'intervale [%d, %d]", X, Y);
else
printf("\\n\\t\\tLes nombre du Tableu ne sont pas compris dans l'intervale [%d, %d]", X, Y);

getchar();
}
/*====================================================================================================*/

/* Fonction qui inverse le tableau sur place */

void Inverse(int *Tab, int *N)
{
int i;
int j = *N-1, Aux;

for(i=0; i<(*N/2); i++)
{
Aux = *(Tab+i);
*(Tab+i) = *(Tab+j-i);
*(Tab+j-i) = Aux;
}
}
/*====================================================================================================*/

/* Procedure qui decale le tableu a gauche d'un element d'une façon cerculaire */
void Decal(int *Tab, int *N, int j)
{
int i;
int aux = *Tab;

for(i=j+1; i<*N; i++)
{
*(Tab+i-1) = *(Tab+i);
}

*(Tab+*N-1) = aux;

}
/*===================================================================================================*/

/* Procedure qui supprime tout les nombres paires */

void P_Suppr(int *Tab, int *N)
{
int i;

for(i=0; i<*N; i++)
{
if( *(Tab+i)%2 == 0)
{
/* on decale le tableau d'un pas à gauche puis en suprime une cas de la droite */
Decal( Tab, N, i);
*N = *N-1;
}

}
}
/*===================================================================================================*/

/* Tri du tableu */
void TriShell(int *Tab,int *N)
{
int n, i, j, valeur;

n=0;

while(n<*N)
{
n=3*n+1;
}

while(n!=0)
{
n=n/3;
for (i=n;i<*N;i++)
{
valeur=*(Tab+i);
j=i;

while((j>(n-1)) && ( *(Tab+j-n)>valeur))
{
*(Tab+j)=*(Tab+j-n);
j=j-n;
}
*(Tab+j)=valeur;
}
}
}
/*===================================================================================================*/

/* Procedure qui renvoie l'inverse d'un nombre passer en param */
int Riverse(int *Var)
{
int res= 0;
int aux, tempo=*Var;

while(tempo != 0)
{
aux = tempo%10;
tempo/= 10;
res = res*10+aux;
}
return (res);

}
/*==============================================================================================================*/

/* Fonction qui Cherche tout les palindrome sur un tableau */

void Palindrome(int *Tab, int *N)
{
int i;
int Aux;

printf("\\t\\t╭────────────────────────────────────────────────╮\\n");
printf("\\t\\t│ Les nombres Plindrome du tableau │\\n");
printf("\\t\\t├───────────────────┬────────────────────────────┤\\n");
printf("\\t\\t│ Emplacement T[N°] │ Nombre │\\n");
printf("\\t\\t├───────────────────┼────────────────────────────┤\\n");
for(i=0; i<*N; i++)
{
/* En recupere le nombre inverse */
Aux=Riverse((Tab+i));

if(Aux == *(Tab+i))
printf("\\t\\t│ T[%2d] │ %5d │\\n", i+1, *(Tab+i));
}

printf("\\t\\t╰───────────────────┴────────────────────────────╯");
}
/* Menu */

int Menu(void)
{
int choix;

printf("\\t\\t╭───────────────────────────────────────────────────────────────────────────╮\\n");
printf("\\t\\t│ Menu │\\n");
printf("\\t\\t├─────────┬─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ N° │ Choix │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 1 │ Afficher un Tableau │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 2 │ Les chifres qui se termine Par 8 │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 3 │ Calcul des multiples de 3 & les afficher │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 4 │ Afficher tout les nombres formé de 3 chiffres │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 5 │ Chercher un nombre pour vous dans le tableau │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 6 │ Determiner le maximum du tableau │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 7 │ Determiner la derniere position du minimum │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 8 │ Verifier si tout les nombres du tableu sont compris entre X & Y │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 9 │ Inverser le tableau │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 10 │ Decaler le tableau a gauche d'un case │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 11 │ Supprimer tout les nombres pairs │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 12 │ Trier le tableau │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 13 │ Afficher tout les antiers palindrom │\\n");
printf("\\t\\t├─────────┼─────────────────────────────────────────────────────────────────┤\\n");
printf("\\t\\t│ 0 │ ** Qutier le programme ** │\\n");
printf("\\t\\t╰─────────┴─────────────────────────────────────────────────────────────────╯");
printf("\\n\\t\\t\\t\\tTapez votre choix : ");
scanf("%d",&choix);
getchar();

return (choix);

}
/*====================================================================================================*/

/* Fonction principale */

int main(void)
{
int *Tableau, n;
int ch, x, min;

printf("\\t\\t╭───────────────────────────────────────────────────────────────────────────╮\\n");
printf("\\t\\t│ Bienvenu...!! Coubisoft vous presente un programme qui manipule │\\n");
printf("\\t\\t│ Un tableau saisie par l'utilisateur en utilisant │\\n");
printf("\\t\\t│ le fomalisme pointeurt & la manipulation par fonction ... │\\n");
printf("\\t\\t│ │\\n");
printf("\\t\\t│ │\\n");
printf("\\t\\t│ Le programme il est sous licence Copyleft Open source │\\n");
printf("\\t\\t│ Bonne programmation │\\n");
printf("\\t\\t╰───────────────────────────────────────────────────────────────────────────╯");

printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();

/* Saisir le tableau */
system("cls");
printf("\\n\\n\\tCombien de nombre voulez vous saisir dans ce tableau \\? ");
scanf("%d",&n);
Tableau = malloc(sizeof(int)*n);

system("cls");
Saisie(Tableau, &n);

do
{
system("cls");
ch = Menu();

switch (ch)
{

case 1:
{
system("cls");

Affichage(Tableau, &n);
printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();

}break;

case 2:
{
system("cls");

Affich_T8(Tableau, &n);
printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();

}break;

case 3:
{
system("cls");

printf("\\n\\tLes Multiple de 3 sexistant dans le tableau");
Multip_3(Tableau, &n);
printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 4:
{
system("cls");

Nombre_3x(Tableau, &n);
printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 5:
{
system("cls");

x=Chercher(Tableau, &n);
if(x==-1)
printf("Le nombres que vous cherhez n'existe pas dans le tableau :(");
else
printf("Le nobre %d que vous cherchez existe dans le tableau :)\\nIl se trouve dans la case T[%d]", *(Tableau+x), x+1);
getchar();
printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 6:
{
system("cls");

printf("Le maximum est : %d", Max(Tableau, &n));
printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 7:
{
system("cls");
min=P_Min(Tableau, &n);

printf("Le dernier emplacement du minimum est : T[%d] = %d", min+1, *(Tableau+min));

printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 8:
{
system("cls");

Interval(Tableau, &n);
printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 9:
{
system("cls");

Inverse(Tableau, &n);
printf("\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 10:
{
system("cls");

Decal(Tableau, &n, 0);
printf("\\n\\t\\tLe tableau a été decaler d'une case vers la gauche :D");
printf("\\n\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 11:
{
system("cls");

P_Suppr(Tableau, &n);
printf("\\n\\t\\tLe Tableux a été inverser :D");
printf("\\n\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 12:
{
system("cls");

TriShell(Tableau, &n);
printf("Le Tableau a été bien trié :D");
printf("\\n\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 13:
{
system("cls");
Palindrome(Tableau, &n);

printf("\\n\\n\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;

case 0:
exit (0);
break;

default :
{
printf("\\t\\t Choix invalide ... !!");
printf("\\n\\t\\tPress 'Enter' to continue: ... ");
getchar();
}break;
}
}while(ch != 0);

free(Tableau);

return 0;

}

Messages : 21 Points : 5368 Date d'inscription : 23/02/2010

thank you chouaib hhh wa rah souad msikina hta hiya rah tmahnat fih hhh ^^

loool

» Premier pas en Programmation C...
» PROGRAMMATION WEB AVEC PHP