Partage
  • Partager sur Facebook
  • Partager sur Twitter

Exercices pour débutants en C

Au menu : zSommeChiffres (nombres, algo)

31 janvier 2010 à 14:50:39

En fait pour l'exercice 6 je l'avais déjà fait sur un autre topic :p

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 10

struct arbre {
	struct arbre * tab[10];
	int cpt;
};

void ajouterBranche(struct arbre * (*branche)) {
	struct arbre * new = malloc(sizeof *new);
	if (new == NULL)
		exit(EXIT_FAILURE);
	memset(new, 0, sizeof *new);
	*branche = new;
}

void libererTout(struct arbre *tmp) {
	int i;
	if (tmp == NULL)
		return;
	for (i = 0; i < 10; i++) {
		if (tmp->tab[i] != NULL)
			libererTout(tmp->tab[i]);
	}
	free(tmp);
}

int main(void) {
	unsigned int tab[N] = { 125, 2, 3, 4, 5, 125, 7, 8, 9, 1 };
	int i, prof, n, mod;
	int max = 0, vmax = 0;
	struct arbre *racine = calloc(1, sizeof *racine);
	struct arbre *tmp = NULL;
	
	if (racine == NULL)
		return EXIT_FAILURE;
	
	for (i = 0; i < N; i++) {
		tmp = racine;
		n = tab[i];
		do {
			mod = n % 10;
			if (tmp->tab[mod] == NULL)
				ajouterBranche(&tmp->tab[mod]);
			tmp = tmp->tab[mod];
			
			prof--;
			n /= 10;
		} while (n > 0);
		tmp->cpt++;
		if (tmp->cpt > max) {
			max = tmp->cpt;
			vmax = tab[i];
		}
	}
	
	printf("%d: %d fois", vmax, max);
	fflush(stdout);
	libererTout(racine);
	return EXIT_SUCCESS;
}

Je l'ai amélioré (j'ai viré toutes les X-macros :-° )
Faut que je teste pour voir si en pratique c'est rapide (ça m'étonnerais :lol: )

Edit : J'ai fait un test avec un tableau de la taille maximum d'un signed int 2147483646 (-1), ça me donne :

real        1m47.564s
user        0m27.738s
sys        0m6.493s

Finalement c'est pas si mal que ça :D
Seul gros bémol : Je monte à près de 10 Go de mémoire utilisée :-° (vive la mémoire virtuelle :lol: )
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 15:20:30

ah bon ?!
Tu veux dire avec une autre méthode ou celle-ci ?
Parce que là, j'aimerais déclarer un tableau avec pour taille une variable.. en C89 on peut pas le faire comme ca non ? (désolé d'être si naïf, mais je suis très débutant en C, on va pas se mentir ;) )
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 15:30:10

T'as pas fait une erreur sur le deuxième exemple de l'exo 2?? 11 n'est pas affiché.. ou alors j'ai pas compris l'exo :p
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 15:31:59

@ TerresMinees : Dans tes fonctions indexMin/Max on te demande trouver l'index, pas de trouver la valeur qui se trouve à l'index :)

Dans l'exo 2 ton code ne compile pas :D
Le but est tout simple en fait. Fait comme si tu le faisais sur papier !
Tu as une liste d'éléments et une autre. Tu prends le premier élément de ta première liste et tu le compare à tous les éléments de ta deuxième liste. Tu prends le deuxième élément de ta première liste et tu le compare à tous les éléments de ta deuxième liste, etc. :)
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 15:33:46

Donc j'ai bien compris, dans ce cas il y a un souci avec l'exemple de gurney, il manque 11
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 15:36:18

Oui effectivement il manque un 11 dans l'exemple de GurneyH ;)

Edit: Voilà ma fonction avec seulement 2 boucles :)

void triangle_de_pascal(int nb_lignes) {
	int tab[100] = { 1 };
	int i, j;
	int indice = 0;
	
	for (i = 0; i < nb_lignes; i++) {
		indice++;
		tab[indice] = 1;
		for (j = indice-1; j >= 1; j--) {
			printf("%d ", tab[j]);
			tab[j] += tab[j-1];
		}
		printf("%d", tab[j]);
		puts("");
	}
}
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 17:12:07

Bonjour,
dans le tuto de mateo21 sur le language C ,j'ai eu un problème dans un exercice sur les tableau:
j'ai posé ma question à cet endroit :http://www.siteduzero.com/tutoriel-50-14015-p13-les-tableaux.html#r48300

vue que ce post est fort regardé je me suis permis de mettre le lien ici... si quelqu'un pouvais y jeter un oeil, je ne comprend vraiment pas mon erreur :'(.
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 17:19:01

Pour le 11, effectivement c'est une erreur. j'ai corrigé.

@Pouet: Super ta solution pour le triangle de Pascal. :)

J'ai testé ta solution pour l'exercice 6. avec N = 10^8(10^9, j'étais un peu gourmand. :-° ), et des entiers dans la plage[0, UINT_MAX].
Sur mon ordinateur de course, j'ai
11078: 3300 fois

Process returned 0 (0x0)   execution time : 61.578 s
Press any key to continue.



Pour ta fonction index, tu passe le signe comme un char.
Je ne connais pas de fonctions de la lib standard qui prenne un char en paramètre ou qui retourne un char, c'est toujours un int(ton char sera converti en int, de toutes façons.)
int index(int * tab, int sz, int compar)


Sinon, tout est vraiment très propre, et un débutant qui regarde tes tris, (là manière dont tu t'es organisé, etc...), peut apprendre beaucoup en regardant tes codes(même si les pointeurs de fonctions, seront peut-être un peu durs à digérer).
  • Partager sur Facebook
  • Partager sur Twitter
Zeste de Savoir, le site qui en a dans le citron !
31 janvier 2010 à 18:10:06

@Gurney: je veux pas t'embêter mais peux-tu me répondre s'il te plaît ?
#r4614253
(je veux faire ca pour pouvoir changer la taille du tableau par la suite sans avoir de problème, mais sinon j'ai qu'à mettre la taille du tableau directement, au lieu de passer par une variable, mais c'est moins flexible.)

(le message s'adressait à toi, mais merci quand même à pouet pour avoir répondu :) )
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 18:25:32

Citation : TerresMinees

@Gurney: je veux pas t'embêter mais peux-tu me répondre s'il te plaît ?
#r4614253
(je veux faire ca pour pouvoir changer la taille du tableau par la suite sans avoir de problème, mais sinon j'ai qu'à mettre la taille du tableau directement, au lieu de passer par une variable, mais c'est moins flexible.)

(le message s'adressait à toi, mais merci quand même à pouet pour avoir répondu :) )


Pouet t'a expliqué comment faire. Tu n'as pas d'allocation à faire, puisque tu peux afficher le résultat au fur et à mesure.
  • Partager sur Facebook
  • Partager sur Twitter
Zeste de Savoir, le site qui en a dans le citron !
31 janvier 2010 à 18:47:56

Voilà ma contribution pour les cinq premiers exercices :
#include <stdio.h>
#include <stdlib.h>

void aff(int *, size_t);
/* Exo 1 -- Prototypes */
size_t indexMin (int *, size_t );
size_t indexMax (int *, size_t );
/* Exo 2 -- Prototypes */
int cmpCroissant (const void *, const void *);
int cmpDecoissant (const void *, const void *);
void afficherEltCommuns (int *, size_t, int *, size_t );
/* Exo 3 -- Prototypes */
void triCroissant(int *, size_t);
void triDecroissant(int *, size_t);
/* Exo 4 -- Prototype */
void zeroADroite(int *, size_t);
/* Exo 5 -- Prototype */
void trianglePascal(int);

void
aff(int * tab, size_t size) {
    size_t i;
    for (i = 0 ; i < size; ++i)
        printf("%s%d", (0 == i)?"[":" ", tab[i]);
    printf("]\n");
}

/* Exo 1 -- Implementation */
size_t
indexMin (int * tab, size_t size) {
    size_t min;
    size_t i;

    min = 0;
    for (i = 0 ; i < size ; ++i) {
        min = (tab[min] > tab[i])? i : min;
    }
    return min;
}

size_t
indexMax (int * tab, size_t size) {
    size_t max;
    size_t i;

    max = 0;
    for (i = 0 ; i < size ; ++i) {
        max = (tab[max] < tab[i])? i : max;
    }
    return max;
}

/* Exo 2 -- Implementation */
int
cmpCroissant (const void * elem1, const void * elem2) {
    int const *p_elem1 = elem1;
    int const *p_elem2 = elem2;

    return *p_elem1 - *p_elem2;
}

int
cmpDecroissant (const void * elem1, const void * elem2) {
    int const *p_elem1 = elem1;
    int const *p_elem2 = elem2;

    return *p_elem2 - *p_elem1;
}

void
afficherEltCommuns (int * tab1, size_t size1, int * tab2, size_t size2) {
    int * inter = NULL;
    size_t i, j, k;
    /* Pas plus d'elemments communs que la taille du plus petit tableau  */
    size_t sizeInter = (size1 > size2)? size2 : size1;
    inter = malloc(sizeInter * sizeof(int));
    if (NULL == inter) {
        return;
    }

    /* On trie les tableaux  */
    qsort(tab1, size1, sizeof *tab1, cmpCroissant);
    qsort(tab2, size2, sizeof *tab2, cmpCroissant);

    i = j = k = 0;
    while (i < size1 && j < size2) {
        if (tab1[i] == tab2[j]) {
            inter[k] = tab1[i];
            ++k, ++i, ++j;
        } else if (tab1[i] > tab2[j]) {
            ++j;
        } else {
            ++i;
        }
    }

    for (i = 0 ; i < k ; ++i) {
        printf("%s%d", (0 == i)?"[":" ", inter[i]);
    }
    printf("]\n");
    free(inter);
}

/* exo 3 -- Implementation */
void
triCroissant(int *v, size_t size) {
    qsort(v, size, sizeof *v, cmpCroissant);
}

void
triDecroissant(int *v, size_t size) {
    qsort(v, size, sizeof *v, cmpDecroissant);
}

/*Exo 4 -- Implementation*/
void
zeroADroite(int * tab, size_t size) {
    int last = size-1;
    size_t i;

    for (i = 0 ; i < size ; ++i) {
        if (0 == tab[i]) {
            tab[i] = tab[i]+tab[last];
            tab[last] = tab[i]-tab[last];
            tab[i] = tab[i]-tab[last];
            --last, --size;
        }
    }
}

/* Exo 5 -- Implementation*/
void
trianglePascal(int nbLignes) {
    int triangle[100] = {1};
    size_t i, j;
    int ligne = 1;

    for (i = 0; i < nbLignes; ++i, ++ligne) {
        triangle[ligne] = 1;
        for (j = ligne-1; j >= 1; --j) {
            printf("%d ", triangle[j]);
            triangle[j] += triangle[j-1];
        }
        printf("%d\n", triangle[j]);
    }
}

int
main (void) {
    int tab1[] = {0, 0, 0, 1, 11, 2, 3, 4, 5, 256, 254, 268, 4, 3, 8, 10};
    int tab2[] = {3, 4, 5, 6,  0, 7, 0, 256, 268, 1, 3, 8, 10, 11};
    size_t size1 = sizeof tab1 / sizeof *tab1;
    size_t size2 = sizeof tab2 / sizeof *tab2;

    printf("tab1 = ");
    aff(tab1, size1);
    printf("tab2 = ");
    aff(tab2, size2);
    
    printf("\nIndice maximal de tab1 : %3lu.\n", (unsigned long int)indexMax(tab1, size1));
    printf("Indice minimal de tab1 : %3lu.\n", (unsigned long int)indexMin(tab1, size1));

    printf("\nIndice maximal de tab2 : %3lu.\n", (unsigned long int)indexMax(tab2, size2));
    printf("Indice minimal de tab2 : %3lu.\n", (unsigned long int)indexMin(tab2, size2));
    
    printf("Intersection de tab1 et tab2 :\n");
    afficherEltCommuns(tab1, size1, tab2, size2);

    printf("\nZero a droite :\n");
    zeroADroite(tab1, size1);
    zeroADroite(tab2, size2);
    printf("tab1 = ");
    aff(tab1, size1);
    printf("tab2 = ");
    aff(tab2, size2);

    printf("\nTri Croissant :\n");
    triCroissant(tab1, size1);
    triCroissant(tab2, size2);
    printf("tab1 = ");
    aff(tab1, size1);
    printf("tab2 = ");
    aff(tab2, size2);

    printf("\nTri Deroissant :\n");
    triDecroissant(tab1, size1);
    triDecroissant(tab2, size2);
    printf("tab1 = ");
    aff(tab1, size1);
    printf("tab2 = ");
    aff(tab2, size2);

    printf("\nTriangle de Pascal (17 premieres lignes) :\n");
    trianglePascal(17);

    return 0;
}


Je ferais les 2 derniers dés que j'aurais le temps car le 6 me semble assez long alors que le 7 est (à mon avis) vraiment simple.
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 19:01:29

Citation : GurneyH

@Pouet: Super ta solution pour le triangle de Pascal. :)


Merci ^^

Citation : GurneyH

J'ai testé ta solution pour l'exercice 6. avec N = 10^8(10^9, j'étais un peu gourmand. :-° ), et des entiers dans la plage[0, UINT_MAX].
Sur mon ordinateur de course, j'ai

11078: 3300 fois

Process returned 0 (0x0)   execution time : 61.578 s
Press any key to continue.

Le seul gros bémol de cette technique c'est le malloc à gogo, et donc la mémoire utilisée ^^
Tu as regardé combien ça prenait de mémoire ? :D

Citation : GurneyH

Pour ta fonction index, tu passe le signe comme un char.
Je ne connais pas de fonctions de la lib standard qui prenne un char en paramètre ou qui retourne un char, c'est toujours un int(ton char sera converti en int, de toutes façons.)

int index(int * tab, int sz, int compar)

Ouais un caractère est convertit en int de toutes façons ^^ (sizeof('c') == sizeof(int))

Citation : GurneyH

Sinon, tout est vraiment très propre, et un débutant qui regarde tes tris, (là manière dont tu t'es organisé, etc...), peut apprendre beaucoup en regardant tes codes(même si les pointeurs de fonctions, seront peut-être un peu durs à digérer).


Merci :)
Pour les pointeurs de fonction c'était peut-être un peu trop c'est sûr :-° mais j'avais pas envie de faire du copier/coller :D

@Lithrein: Dommage t'as loupé les balises de code :-°
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 19:04:46

@Lithrein :

Tu as un problème de balise. ;)

ET, heu, le but n'est pas d'utiliser qsort, pour l'exercice 3. :'(

L'exercice 6 et 7 sont faciles, d'ailleurs j'ai mis pour avancés, mais tout le monde peut les faire. Disons, que pour les plus avancés, le but est d'avoir un truc efficace. ;)

  • Partager sur Facebook
  • Partager sur Twitter
Zeste de Savoir, le site qui en a dans le citron !
31 janvier 2010 à 19:12:48

Question pour le dernier :

On peut tout simplement trier le tableau avec qsort ? :-°
Ou il faut aussi implémenter la fonction de tri, ou encore trouver autre chose :D
Avec qsort on à une fonction en O(n log(n)) ^^
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 19:12:51

Citation : GurneyH


ET, heu, le but n'est pas d'utiliser qsort, pour l'exercice 3. :'(



Je m'en doute bien mais j'avais un peu la flemme de recoder qsort encore une fois. :p mais je peux l'implémenter si tu veux. :)
Edit : Oups, j'avais sauter l'indication qui précisait qu'il fallait utiliser les fonctions de l'exercice 1.

Citation : Pouet_forever

Question pour le dernier :

On peut tout simplement trier le tableau avec qsort ? :-°
Ou il faut aussi implémenter la fonction de tri, ou encore trouver autre chose :D
Avec qsort on à une fonction en O(n log(n)) ^^

Je penser traiter le problème de cette façon, c'est pour ça que je trouvais l'exercice vraiment très simple.

Ps : Pour le problème de balises c'est réglé.
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 19:15:00

Pour le 3 c'est pas le tri rapide qu'il faut utiliser, mais le tri par sélection :p

main.c: In function 'main':
main.c:160: warning: format '%3d' expects type 'int', but argument 2 has type 'size_t'
main.c:161: warning: format '%3d' expects type 'int', but argument 2 has type 'size_t'
main.c:163: warning: format '%3d' expects type 'int', but argument 2 has type 'size_t'
main.c:164: warning: format '%3d' expects type 'int', but argument 2 has type 'size_t'

Le formateur pour size_t c'est %zd ;)

Je trouve ta fonction afficherEltCommuns inutilement compliquée :euh:
Appel à malloc, tri des 2 tableaux, tu es sûr d'avoir besoin de tout ça ? :p
D'ailleurs tu as une fonction pour afficher ton tableau, pourquoi ne pas l'utiliser ? ^^

Ta fonction zeroADroite est incorrecte :p
Tu inverses tes éléments depuis la fin, mais si tu as des 0 à la fin ton tableau se retrouvera avec des 0 au début ;)
Il faudrait que tu tries ton tableau pour que ce soit correct :)

  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 19:26:30

@Pouet : l'indicateur de format %zd c'est du C99 donc ça passe pas au compilateur.
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 19:50:16

En fait pour l'exo 6, si on se soucie pas de la mémoire on peut tout simplement faire ça :

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int mode(int * tab, int sz) {
	int i, max = 0;
	int * oper = malloc(sizeof(int) * INT_MAX);
	
	if (oper == NULL)
		return 0;
	
	for (i = 0; i < sz; i++) {
		oper[tab[i]]++;
		if (oper[tab[i]] > max)
			max = tab[i];
	}
	
	free(oper);
	return max;
}

#define NB 2147483646

void fill_tab(int * tab) {
	int i;
	
	for (i = 0; i < NB; i++) {
		tab[i] = rand();
	}
}

int main(void) {
	int * tab = NULL;
	
	tab = malloc(NB * sizeof(int));
	if (tab == NULL)
		return EXIT_FAILURE;
	
	fill_tab(tab);
	printf("On commence ...\n");
	printf("%d", mode(tab, NB));
	return EXIT_SUCCESS;
}
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 19:52:36

Voilà la mienne pour les premiers aussi, je ferai les derniers plus tard, mardi ou mercredi

#include <stdio.h>

int       indexMin(int *, int);
int       indexMax(int *, int);
void      afficherEltCommuns(int *, int *, int, int);
void      xchang(int *, int, int);
void      triCroissant(int *, int);
void      triDecroissant(int *, int);
int       indexNul(int *, int);
void      zeroADroite(int *, int);

typedef unsigned int u_int;

int     indexMin(int *grid, int SizeGrid)
{
 int     iter;
 int     posit;

 iter = -1;
 posit = 0;
 while ( ++iter < SizeGrid )
	if ( *(grid + iter) < *(grid + posit) )
		posit = iter;
 return (posit);
}

int indexMax(int *grid, int SizeGrid)
{
 int     iter;
 int     posit;

 iter = -1;
 posit = 0;
 while ( ++iter < SizeGrid )
 	{
		if ( *(grid + iter) >= *(grid + posit) )
			posit = iter;
	}
 return (posit);
}

void    afficherEltCommuns(int *grid1, int *grid2, int Sz1, int Sz2)
{
 int     i;
 int     j;

 i = -1;
 while ( ++i < Sz1 )
	{
		j = 0;
		while ( (j < Sz2) && ((*(grid1 + i)) != (*(grid2 + j))) )
			j++;
		if ( (*(grid1 + i)) == (*(grid2 + j)) && (j != Sz2 ))
			printf("%d\n", *(grid1 + i));
	}
}

void      xchang(int *Grid, int pos1, int pos2)
{
 int     temp;

 temp = *(Grid + pos1);
 *(Grid + pos1) = *(Grid + pos2);
 *(Grid + pos2) = temp;
}

void      triCroissant(int *Grid, int SzGrid)
{
 int     min;
 int     iter;

 iter = -1;
 while ( ++iter < SzGrid )
	{
		min = indexMin(Grid + iter, SzGrid - iter);
		xchang(Grid + iter, min, 0);
	}
}

void     triDecroissant(int *Grid, int SzGrid)
{
 int     min;
 int     iter;

 iter = -1;
 while ( ++iter < SzGrid )
	{
		min = indexMax(Grid + iter, SzGrid - iter);
		xchang(Grid + iter, min, 0);
	}
}

int       indexNul(int *Grid, int SzGrid)
{
 int     iter;

 iter = -1;
 while ( ++iter < SzGrid )
	{
		if ( Grid[iter] == 0 )
			return (iter);
	}
 return (-1);
}

void      zeroADroite(int *Grid, int SzGrid)
{
 int     index;

 while ( SzGrid >= 0 )
	{
		index = indexNul(Grid, SzGrid);
		if ( index != -1 )
			{
				while ( index < SzGrid - 1 )
					{
						xchang(Grid, index, index + 1);
						index++;
					}
			}
		SzGrid--;
	}
}


Critiquez, critiquez j'attends avidement vos avis
  • Partager sur Facebook
  • Partager sur Twitter
31 janvier 2010 à 22:39:45

Citation : Pouet


Le formateur pour size_t c'est %zd ;)


C'est du C99; comme déjà dit...

Je propose un truc...
On laisse les vrais débutants faire les exercices qui leurs sont destinés...
On aide, on conseille...
Mais en 2ème semaine, on se laisse de la place, pour se mettre des coups! :)

But du jeu? Poster du code!
Après, vraiment, on s'éclate sur les derniers exercices! Pour le moment c'est HS!...
  • Partager sur Facebook
  • Partager sur Twitter
Zeste de Savoir, le site qui en a dans le citron !
1 février 2010 à 1:03:42

Bon , je tente les 4 premiers (soyez pas trop méchants s'il vous plait :euh: ) :




Exercice 1 :



int indexMin(int tableau[], int tailleTableau)
{
  int min = tableau[0] ,Imin = 0, i;     
    
  for(i = 0 ;i < tailleTableau ;i ++) 
  {
        if(tableau[i]<min)
        {min = tableau[i] , Imin = i;}
  }  
  
return Imin ;    
}


int indexMax(int tableau[], int tailleTableau)
{
  int max = tableau[0] ,Imax = 0, i;     
    
  for(i = 0 ;i < tailleTableau ;i ++) 
  {
        if(tableau[i]>=max)
        {max = tableau[i] , Imax = i;}
  }  
  
return Imax ;    
}


Le 2 :



void afficherEltCommuns(int tableau1[], int tableau2[], int tailleTableau1, int tailleTableau2)
{
     int i , j ;
     
     printf("elements en commun : [");
     
     for(i = 0 ; i < tailleTableau1 ; i++)
     {
           for(j = 0 ; j < tailleTableau2 ; j++)
           {
                 if(tableau1[i] == tableau2[j])
                 {printf(" %d",tableau1[i]);j = tailleTableau2;} 
           
           }
     }  
     
     printf(" ]\n");    
}


Le 3 :



void triCroissant(int tableau[], int tailleTableau)
{
     int i , buff;
     
     for(i = 0 ; i < tailleTableau ; i++)
     {
           buff = tableau[indexMax(tableau,tailleTableau-i)]; 
           tableau[indexMax(tableau,tailleTableau-i)] = tableau[tailleTableau-1-i];
           tableau[tailleTableau-1-i] = buff ; 
     }
}

void triDecroissant(int tableau[], int tailleTableau)
{
     int i , buff;
     
     for(i = 0 ; i < tailleTableau ; i++)
     {
           buff = *(tableau+indexMax(tableau+i,tailleTableau-i)+i); 
           *(tableau+indexMax(tableau+i,tailleTableau-i)+i) = tableau[i];
           tableau[i] = buff ; 
     }              
}


Et le 4 :




void zeroADroite(int tableau[], int tailleTableau)
{
     int i , j;
     
     for(i = tailleTableau - 1; i > -1 ; i --)
     {
           if(tableau[i] == 0)
           {
               for(j = i; i < tailleTableau - 1 && tableau[i+1] != 0; i++) 
               {tableau[j] = tableau[j+1];}
               tableau[j+1] = 0;
           }
     }
}




Toutes critiques constructives sont les bienvenues (surtout pour le 3 ... :honte: , je sais pas trop si j'ai le droit de faire ça ).Je verrai plus tard pour la suite.


Merci .
  • Partager sur Facebook
  • Partager sur Twitter
1 février 2010 à 4:13:09

Voila pour la mienne, flemme de coder l'autre partie, il est 4h du matin. ;)


void    count(char *str, int *c)
{
 int i;

 i = 0;
 while (str[i] != '\0')
  {
    c[0] = (str[i] - '0') + c[0];
    i++;
  }
}

int    main(int ac, char **av)
{
 int i;

 i = 0;
 count(av[1], &i);
 printf("%i\n", i);
 return (0);
}


  • Partager sur Facebook
  • Partager sur Twitter
1 février 2010 à 7:57:17

moustick1991: Ton code me paraît correct.
Dans ton code pour l'exercice 3, dans tes deux fonctions tricroissant et tridecroissant tu calcules l'index du max deux fois. Sur de gros tableaux ça peut avoir un impact sur les performances de ton code. Utilises une variable.

Conseil de style : Les instructions condensées sur une ligne entre accolades sont franchement pas très lisibles, à éviter donc.
  • Partager sur Facebook
  • Partager sur Twitter
1 février 2010 à 11:18:04

Un sujet est ouvert ici pour poster les réponses.
  • Partager sur Facebook
  • Partager sur Twitter
Zeste de Savoir, le site qui en a dans le citron !
1 février 2010 à 17:35:25

Citation : GurneyH

C'est du C99; comme déjà dit...


Désolé ^^
Chez moi size_t c'est un long et pas un int c'est pour ça :-° j'ai toujours des warning ^^

Pour le reste ok :)
Et désolé si j'ai posté un peu trop de code par ci par là :(
  • Partager sur Facebook
  • Partager sur Twitter
1 février 2010 à 17:46:10

Citation : Pouet-forever

Et désolé si j'ai posté un peu trop de code par ci par là :(



Tu n'as pas à être désolé... :)
  • Partager sur Facebook
  • Partager sur Twitter
Zeste de Savoir, le site qui en a dans le citron !
1 février 2010 à 23:19:58

Bonjour, je met mon code pour l'exo du moi de janvier si quelqu'un peut me dire s'il y a des erreurs, des incohérences,ou des optimisations je suis preneur!

ps : je n'ai pas encore fais la dernière partie.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>



int zSommeChiffres(int n)
{
    int somme=0;

    while((n%10)!=0)
    {
        somme += n%10;
        n /= 10;
    };

    return somme;
}

int zSommeChiffresChar(char *src)
{
    int somme = 0 , i = 0;
    int taille=strlen(src);
    for(i=0;i<taille;i++)
    {
        somme+=((src[i])-48);
    }

    return somme;
}


int main(void)
{
    int n1 = 92538;
    char *n2="1459784612340012340123478942651012315647894561230123456789";
    printf("%d -> %d\n", n1 , zSommeChiffres(n1));
    printf("%s -> %d\n", n2, zSommeChiffresChar(n2));


    return 0;
}


  • Partager sur Facebook
  • Partager sur Twitter
2 février 2010 à 3:52:53

Avec
int n1 = 925380;

Ta fonction int zSommeChiffres(int n) retourne 0. ;)

Regarde bien cette ligne
while((n%10)!=0)
le problème est là.

Dans l'autre fonction, tu as
somme+=((src[i])-48);
Déjà, ça fait beaucoup de parenthèses...

En ascii '0' = 48.
donc ta ligne devient
somme += src[i] - '0';

En plus d'être plus lisible, ce sera portable sur la majorité des charset.
  • Partager sur Facebook
  • Partager sur Twitter
Zeste de Savoir, le site qui en a dans le citron !
2 février 2010 à 8:42:36

Citation

Ta fonction int zSommeChiffres(int n) retourne 0



oh oui le reste est null :-° quel c** ;););)
je cherche une solution.

ok pour les parenthése.
merci
  • Partager sur Facebook
  • Partager sur Twitter
2 février 2010 à 10:40:39

bonjour,
j'ai fait les premiers exos du mois de fevrier avec une solution versus "tableaux" parce que je suis plus à l'aise que les pointeurs. :p
je m'engage, à fournir un peu plus tard la version pointeurs :D
Néanmoins je suis pas satisfait de deux exos :
-celui qui concerne de trouver deux elements identiques dans deux tableaux, j'ai une solution partielle!
et j'ai pas trouve comment faire differemment
- celui qui concerne le zero a droite, je pense avoir trouve une solution mais elle me parait......
enfin je vous laisse juger ici :
#include <stdio.h>
#include <stdlib.h>

int indexMin(int tableau[], int tailleTableau);
int indexMax(int tableau[], int tailleTableau);
void afficherEltCommuns(int t1[], int t2[],int tailleTableau1,int tailleTableau2);
void affiche(int tableau[], int tailleTableau);
void triCroissant(int tableau[], int tailleTableau);
void triDecroissant(int tableau[], int tailleTableau);
void zeroADroite(int tableau[], int tailleTableau);





int main(void)
{
    int tableau[] = {1, 0, 4, 0, 0, -7};
    int tableau1[] = {0, 1, -1, 3, 8};
    int tableau2[] = {10, 1, 11, 7, 98, 8, 7, 8};
    // taille du tableau / taille d'un element = nombre d elements
    int tailleTableau = sizeof (tableau) / sizeof (int);
    int tailleTableau1 = sizeof (tableau1) / sizeof (int);
    int tailleTableau2 = sizeof (tableau2) / sizeof (int);

    printf("n de l'index du chiffre le plus petit : %d\n",indexMin(tableau,tailleTableau));//exo1
    printf("n de l'index du chiffre le plus grand : %d\n",indexMax(tableau,tailleTableau));//exo2
    afficherEltCommuns(tableau1, tableau2,tailleTableau1,tailleTableau2);//exo3

    printf("\ntableau a trier :");//exo 4
    affiche (tableau1,tailleTableau1);
    triCroissant(tableau1,tailleTableau1);
    printf("\ndans l'ordre croissant :");
    affiche (tableau1,tailleTableau1);
    triDecroissant(tableau1,tailleTableau1);
    printf("\ndans l'ordre decroissant :");
    affiche (tableau1,tailleTableau1);

    printf("\n\n exo ZERO a droite :");
    affiche (tableau,tailleTableau);
    zeroADroite(tableau,tailleTableau);
    affiche (tableau,tailleTableau);


    return 0;
}

int indexMin(int tableau[], int tailleTableau)
{
    int resultat=0;
    int i,j;
    j= tableau[0];
    for (i=1;i<tailleTableau;i++)
    {
        if (j>tableau[i])
        {
            resultat = i ;
            j=tableau[i];
        }
    }
    return resultat;
}

int indexMax(int tableau[], int tailleTableau)
{
    int resultat=0;
    int i,j;
    j= tableau[0];
    for (i=1;i<tailleTableau;i++)
    {
        if (j<tableau[i])
        {
            resultat = i;
            j=tableau[i];
        }
    }
    return resultat;
}

void afficherEltCommuns(int t1[], int t2[],int tailleTableau1,int tailleTableau2)
// a ameliorer resultat pas conforme a ce qui est demande
{
    int i, j;
    printf("les elements identiques des deux tableaux sont : ");
    for (i=0;i<tailleTableau1;i++)
    {
        for (j=0;j<tailleTableau2;j++)
        {
            if (t1[i] == t2[j])
            {
                printf(" %d ",t1[i]);
            }
        }
    }
    printf("\n");
}

void affiche(int tableau[], int tailleTableau)
{
    int i;
    printf("\n");
    for (i=0;i<tailleTableau;i++)
    {
        printf (" %d ",tableau[i]);
    }
}
void triCroissant(int tableau[], int tailleTableau)
{
    /*
        1.On recherche l'index de la valeur maxi
        2.On insère l'élément max à la bonne position dans le tableau
        3.On répète les 2 premières opérations sur le reste du tableau tant que le tableau n'est pas entièrement trié
    */
    int index,echange,i;
    for (i=0;i<tailleTableau;i++)
    {
        index =indexMax(tableau, tailleTableau-i);
        echange = tableau[index];
        tableau[index]=tableau[tailleTableau -i-1];
        tableau[tailleTableau - i-1] = echange;
    }
}

void triDecroissant(int tableau[], int tailleTableau)
{
    /*
        1.On recherche l'index de la valeur mini
        2.On insère l'élément max à la bonne position dans le tableau
        3.On répète les 2 premières opérations sur le reste du tableau tant que le tableau n'est pas entièrement trié
    */
    int index,echange,i;
    for (i=0;i<tailleTableau;i++)
    {
        index =indexMin(tableau, tailleTableau-i);
        echange = tableau[index];
        tableau[index]=tableau[tailleTableau -i-1];
        tableau[tailleTableau - i-1] = echange;
    }
}

void zeroADroite(int tableau[], int tailleTableau)
{
    int i,j,k;
    i=0;
    k=0;//compteur de boucle secondaire
    while ((i<tailleTableau)&&(k<tailleTableau))//pas trouve autre chose pour eviter une boucle infinie i+k tour maximum
    {
        if (tableau[i]==0)
        {
            //alors on decale vers la droite
            for (j=i;j<(tailleTableau-1);j++)
            {
                tableau[j]=tableau[j+1];
            }
            k++;
            tableau[tailleTableau-1]=0;
        }
        else
        {
            i++;
        }
    }
}
j'ai regarde les solutions des autres mais j'ai rien compris
  • Partager sur Facebook
  • Partager sur Twitter