Partage
  • Partager sur Facebook
  • Partager sur Twitter

Tableau, élément le plus fréquent

Pouet_forever
  • Langage C
    25 décembre 2009 à 23:10:13

    Si on se soucie pas trop de la mémoire utilisée on peut imaginer ça :

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

#define N 10

int main(void) {
	int tab[N] = { 6, 2, 3, 6, 5, 4, 2, 6, 8, 9 };
	int *nb_occur = NULL;
	int i;
	int max = 0, vmax = 0;
	
	/* Recherche de la valeur max du tableau */
	for (i = 0; i < N; i++)
		if (tab[i] > max)
			max = tab[i];
	
	/* Allocation de n+1 cases */
	if ((nb_occur = calloc(max + 1, sizeof *nb_occur)) == NULL)
		return EXIT_FAILURE;
	
	/* Parcours du tableau */
	for (i = 0; i < N; i++) {
		/* On incrémente le nombre de fois qu'on trouve ce nombre */
		nb_occur[tab[i]]++;
		/* Si le nombre est plus grand on sauvegarde les valeurs */
		if (nb_occur[tab[i]] > vmax) {
			max = tab[i];
			vmax = nb_occur[tab[i]];
		}
	}
	
	free(nb_occur);
	printf("%d: %d fois", max, vmax);
	return EXIT_SUCCESS;
}

    Je pense que l'idée est bonne mais on peut sûrement l'améliorer pour gaspiller moins de mémoire ^^
    Dites moi ce que vous en pensez :)

    Edit : Aller juste pour délirer :lol:
    Avec ce code je ne parcoures qu'une seule fois le tableau ! (mais faut voir tout ce qu'il y a à côté xD )
    J'en profite pour demander un conseil : Comment je peux faire pour libérer intelligemment tout mon arbre ? mdr

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

#define N 10

struct arbre {
	struct arbre *zero;
	struct arbre *un;
	struct arbre *deux;
	struct arbre *trois;
	struct arbre *quatre;
	struct arbre *cinq;
	struct arbre *six;
	struct arbre *sept;
	struct arbre *huit;
	struct arbre *neuf;
	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 racine) {
	
}

int main(void) {
	unsigned int tab[N] = { 457, 2, 365, 6, 457, 4, 2, 6, 457, 555 };
	int i, prof, n;
	int max = 0, vmax = 0;
	struct arbre racine = { NULL };
	struct arbre *tmp = NULL;
	
	for (i = 0; i < N; i++) {
		prof = log10(tab[i]);
		tmp = &racine;
		n = tab[i];
		while (n != 0) {
			switch (lrint(n / pow(10, prof))) {
				case 0:
					if (tmp->zero == NULL)
						ajouterBranche(&tmp->zero);
					tmp = tmp->zero;
					break;
				case 1:
					if (tmp->un == NULL)
						ajouterBranche(&tmp->un);
					tmp = tmp->un;
					break;
				case 2:
					if (tmp->deux == NULL)
						ajouterBranche(&tmp->deux);
					tmp = tmp->deux;
					break;
				case 3:
					if (tmp->trois == NULL)
						ajouterBranche(&tmp->trois);
					tmp = tmp->trois;
					break;
				case 4:
					if (tmp->quatre == NULL)
						ajouterBranche(&tmp->quatre);
					tmp = tmp->quatre;
					break;
				case 5:
					if (tmp->cinq == NULL)
						ajouterBranche(&tmp->cinq);
					tmp = tmp->cinq;
					break;
				case 6:
					if (tmp->six == NULL)
						ajouterBranche(&tmp->six);
					tmp = tmp->six;
					break;
				case 7:
					if (tmp->sept == NULL)
						ajouterBranche(&tmp->sept);
					tmp = tmp->sept;
					break;
				case 8:
					if (tmp->huit == NULL)
						ajouterBranche(&tmp->huit);
					tmp = tmp->huit;
					break;
				case 9:
					if (tmp->neuf == NULL)
						ajouterBranche(&tmp->neuf);
					tmp = tmp->neuf;
					break;
				default:
					break;
			}
			n /= 10;
			prof--;
		}
		tmp->cpt++;
		if (tmp->cpt > max) {
			max = tmp->cpt;
			vmax = tab[i];
		}
	}
	libererTout(racine);
	printf("%d: %d fois", vmax, max);
	return EXIT_SUCCESS;
}


    Edit2 : Voilà avec la fonction de libération :D

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

#define N 10

struct arbre {
	struct arbre *zero;
	struct arbre *un;
	struct arbre *deux;
	struct arbre *trois;
	struct arbre *quatre;
	struct arbre *cinq;
	struct arbre *six;
	struct arbre *sept;
	struct arbre *huit;
	struct arbre *neuf;
	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) {
	if (tmp == NULL)
		return;
	
	if (tmp->zero != NULL)
		libererTout(tmp->zero);
	
	if (tmp->un != NULL)
		libererTout(tmp->un);
	
	if (tmp->deux != NULL)
		libererTout(tmp->deux);
	
	if (tmp->trois != NULL)
		libererTout(tmp->trois);
		
	if (tmp->quatre != NULL)
		libererTout(tmp->quatre);
	
	if (tmp->cinq != NULL)
		libererTout(tmp->cinq);
	
	if (tmp->six != NULL)
		libererTout(tmp->six);
	
	if (tmp->sept != NULL)
		libererTout(tmp->sept);
	
	if (tmp->huit != NULL)
		libererTout(tmp->huit);
	
	if (tmp->neuf != NULL)
		libererTout(tmp->neuf);
	
	free(tmp);
}

int main(void) {
	unsigned int tab[N] = { 457, 2, 365, 6, 457, 4, 2, 6, 457, 555 };
	int i, prof, n;
	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++) {
		prof = log10(tab[i]);
		tmp = racine;
		n = tab[i];
		while (n != 0) {
			switch (lrint(n / pow(10, prof))) {
				case 0:
					if (tmp->zero == NULL)
						ajouterBranche(&tmp->zero);
					tmp = tmp->zero;
					break;
				case 1:
					if (tmp->un == NULL)
						ajouterBranche(&tmp->un);
					tmp = tmp->un;
					break;
				case 2:
					if (tmp->deux == NULL)
						ajouterBranche(&tmp->deux);
					tmp = tmp->deux;
					break;
				case 3:
					if (tmp->trois == NULL)
						ajouterBranche(&tmp->trois);
					tmp = tmp->trois;
					break;
				case 4:
					if (tmp->quatre == NULL)
						ajouterBranche(&tmp->quatre);
					tmp = tmp->quatre;
					break;
				case 5:
					if (tmp->cinq == NULL)
						ajouterBranche(&tmp->cinq);
					tmp = tmp->cinq;
					break;
				case 6:
					if (tmp->six == NULL)
						ajouterBranche(&tmp->six);
					tmp = tmp->six;
					break;
				case 7:
					if (tmp->sept == NULL)
						ajouterBranche(&tmp->sept);
					tmp = tmp->sept;
					break;
				case 8:
					if (tmp->huit == NULL)
						ajouterBranche(&tmp->huit);
					tmp = tmp->huit;
					break;
				case 9:
					if (tmp->neuf == NULL)
						ajouterBranche(&tmp->neuf);
					tmp = tmp->neuf;
					break;
				default:
					break;
			}
			n /= 10;
			prof--;
		}
		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;
}

    Edit3 : En fait ya un problème ^^
    Je prend pas en compte le dernier chiffre :-°
    On verra ça un autre jour ^^
    Bonne nuit
    • Partager sur Facebook
    • Partager sur Twitter
    GurneyH
    • Langage C
      26 décembre 2009 à 6:20:11

      Il est fou! :p
      Le code avec l'arbre est faux... Pour 457, par exemple, tu remplis ton arbre avec 444.
      VC studio n'apprécie pas les double, dans le switch.

      J'ai essayé de corriger les erreurs. ;)
      #include <stdio.h>
#include <stdlib.h>
#include <math.h>

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

void ajouterBranche(struct arbre **branche, int digit)
{
    if ((*branche)->fils[digit] == NULL)
    {
        struct arbre *new = calloc(1, sizeof *new);
        if (new == NULL)
            exit(EXIT_FAILURE);
        (*branche)->fils[digit] = new;
    }
}


void libererArbre(struct arbre **this)
{
    if (*this == NULL)
        return;
    else
    {
        size_t i;
        for (i = 0; i < 10; ++i)
            libererArbre(&((*this)->fils[i]));
        free(*this), *this = NULL;
    }
}



int main(void)
{
    unsigned int tab[] = {457, 2, 365, 6, 457, 4, 2, 6, 457, 555};
    size_t N = sizeof tab / sizeof *tab;
    int i, n;
    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];
        while (n != 0)
        {
            int d = floor(n % 10);
            ajouterBranche(&tmp, d);
            tmp = tmp->fils[d];
            n /= 10;
        }
        tmp->cpt++;
        if (tmp->cpt > max)
        {
            max = tmp->cpt;
            vmax = tab[i];
        }
    }

    libererArbre(&racine);
    printf("%d: %d fois\n", vmax, max);

    return EXIT_SUCCESS;
}

      Reste à faire des tests...

      Pour ton premier code, l'occupation mémoire est problématique avec, ce tableau par exemple
      int tab[N] = { 6, 2, 3, 6, 5, 4, 2, 6, 8, INT_MAX - 1};

      edit: remplacé le couple (malloc, memset) par calloc, mise en forme du code...
      • Partager sur Facebook
      • Partager sur Twitter
      Zeste de Savoir, le site qui en a dans le citron !
      Arthurus
        26 décembre 2009 à 6:31:48

        Citation : GurneyH

        Il est fou! :p



        Oui :lol::lol:
        • Partager sur Facebook
        • Partager sur Twitter
        Alienore
          26 décembre 2009 à 10:51:28

          On utilise un tableau auxiliaire. On parcourt d'abord une fois la liste pour connaitre le min et le max puis on crée un tableau de max - min + 1 cases en initialisant toutes les cases à 0. On parcourt une seconde fois le tableau. Pour chaque nombre, on incrémente la valeur dans tab_aux[tab[i] - min].
          On va voir le tableau auxiliaire en voyant quel est le nombre le plus élevé pour renvoyer ind_max + min.

          2 parcours du tableau initial. 2 parcours du tableau auxiliaire (un pour l'initialisation et 1 pour la recherche du max). En temps, on aura donc quelque chose en O(n + m) (n étant la taille du tableau et m l'intervalle des valeurs).
          En place, on a utilisé un tableau de m cases.

          On a donc quelque chose de linéaire en temps et en espace.

          Edit : oups, désolée, je n'avais pas lu la seconde page :-°

          L'idée de l'arbre est pas mal sinon. Personnellement, pour libérer intelligemment un arbre, je fais simple : J'appelle la fonction pour libérer un arbre pour chacun des fils et je libère ensuite la racine. Par contre si la racine est le noeud VIDE, je ne fais rien.
          • Partager sur Facebook
          • Partager sur Twitter
          Pouet_forever
          • Langage C
            26 décembre 2009 à 12:47:17

            Citation : GurneyH

            Il est fou! :p


            Complètement mais je savais pas quoi faire :lol:
            Et puis ça me fait pratiquer un peu la notion d'arbre :)

            En fait j'ai pas fait un tableau de 10 cases et tu vas voir pourquoi dès que je posterai le prochain code :p
            Sinon pour le fait que ça ne fonctionne pas j'avais fait la remarque déjà ^^ je vais corriger ça aujourd'hui :D

            Sinon pour le switch je n'ai pas de double :euh: j'ai un long ! (la fonction lrint renvoie un long)

            Edit : Ptite question sur ton code, pourquoi tu fais ça : int d = floor(n % 10);
            Là tu ajoutes les nombres "de poids faible" mais il faut ajouter les nombres "de poids fort". Je me trompe ?
            • Partager sur Facebook
            • Partager sur Twitter
            Floooder
              26 décembre 2009 à 13:12:52

              Bah tu peux soit avoir les bits de poids fort le plus proche de la racine, ou alors les bits de poids faible le plus proche de la racine.

              L'important c'est de tous les faire dans le même sens :p

              Par contre tu peux aussi utiliser un arbre binaire pour le faire avec des données de n'importe quel type (en enregistrant la valeur binaire)
              • Partager sur Facebook
              • Partager sur Twitter
              GurneyH
              • Langage C
                26 décembre 2009 à 13:20:34

                Citation : Flooder


                L'important c'est de tous les faire dans le même sens :p



                Effectivement, l'ordre dans lequel on stocke les chiffres à peu d'importance(il faut savoir ce qu'on fait.)

                Pour la fonction lrint, c'est du C99... Avec mes réglages, GCC n'en veux pas, et avec visual c'est mort...

                Citation : Pouet


                En fait j'ai pas fait un tableau de 10 cases et tu vas voir pourquoi dès que je posterai le prochain code :p


                J'ai hâte. :p
                • Partager sur Facebook
                • Partager sur Twitter
                Zeste de Savoir, le site qui en a dans le citron !
                Pouet_forever
                • Langage C
                  26 décembre 2009 à 13:22:10

                  Ah ^^
                  Je vais noter ça sur papier parce que ça me parle pas là ^^

                  Voilà la dernière version (fonctionnelle normalement :D )
                  Si vous comprenez rien demandez xD

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

#define N 10

#define DECLAR_STRUCT(type, var, num, rien)	\
	type var;

#define SUPP_ARBRE(type, var, num, tmp)	\
	if (tmp->var != NULL)				\
		libererTout(tmp->var);

#define CASE_SWITCH(type, var, num, tmp)	\
	case num:								\
		if (tmp->var == NULL)				\
			ajouterBranche(&tmp->var);		\
		tmp = tmp->var;						\
		break;

#define YAHOO(_, ...)	\
	_(struct arbre *, zero, 0, __VA_ARGS__)		\
	_(struct arbre *, un, 1, __VA_ARGS__)		\
	_(struct arbre *, deux, 2, __VA_ARGS__)		\
	_(struct arbre *, trois, 3, __VA_ARGS__)	\
	_(struct arbre *, quatre, 4, __VA_ARGS__)	\
	_(struct arbre *, cinq, 5, __VA_ARGS__)		\
	_(struct arbre *, six, 6, __VA_ARGS__)		\
	_(struct arbre *, sept, 7, __VA_ARGS__)		\
	_(struct arbre *, huit, 8, __VA_ARGS__)		\
	_(struct arbre *, neuf, 9, __VA_ARGS__)

struct arbre {
	YAHOO(DECLAR_STRUCT )
	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) {
	if (tmp == NULL)
		return;
	YAHOO(SUPP_ARBRE, tmp)
	free(tmp);
}

int main(void) {
	unsigned int tab[N] = { 125, 2, 3, 4, 5, 125, 7, 8, 9, 1 };
	int i, prof, n;
	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++) {
		prof = log10(tab[i]);
		tmp = racine;
		n = tab[i];
		do {
			switch (lrint(n / pow(10, prof)) % 10) {
				YAHOO(CASE_SWITCH, tmp)
				default:
					break;
			}
			prof--;
		} while (prof >= 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;
}

                  Citation : GurneyH

                  Pour la fonction lrint, c'est du C99... Avec mes réglages, GCC n'en veux pas, et avec visual c'est mort...


                  Ah ... désolé ^^
                  Un petit cast et c'est bon ^^
                  • Partager sur Facebook
                  • Partager sur Twitter
                  GurneyH
                  • Langage C
                    26 décembre 2009 à 13:24:02

                    Citation : Pouet


                    Je vais noter ça sur papier parce que ça me parle pas là ^^


                    Qu'est ce qui ne te parle pas?
                    • Partager sur Facebook
                    • Partager sur Twitter
                    Zeste de Savoir, le site qui en a dans le citron !
                    Pouet_forever
                    • Langage C
                      26 décembre 2009 à 13:26:11

                      Le fait de stocker tes valeurs par les valeurs "de poids faible" plutôt que par le "poids fort" ^^
                      Ca doit être tout bête mais j'aime bien comprendre ce que je fais :)

                      Et puis je modifierai mon code en conséquence parce que c'est très lourd :D (enfin c'était le but au départ xD )

                      Edit : Ouais en fait c'est mieux et beaucoup plus simple :-°
                      Voilà le code :

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

#define N 10

#define DECLAR_STRUCT(type, var, num, rien)	\
	type var;

#define SUPP_ARBRE(type, var, num, tmp)	\
	if (tmp->var != NULL)				\
		libererTout(tmp->var);

#define CASE_SWITCH(type, var, num, tmp)	\
	case num:								\
		if (tmp->var == NULL)				\
			ajouterBranche(&tmp->var);		\
		tmp = tmp->var;						\
		break;

#define YAHOO(_, ...)	\
	_(struct arbre *, zero, 0, __VA_ARGS__)		\
	_(struct arbre *, un, 1, __VA_ARGS__)		\
	_(struct arbre *, deux, 2, __VA_ARGS__)		\
	_(struct arbre *, trois, 3, __VA_ARGS__)	\
	_(struct arbre *, quatre, 4, __VA_ARGS__)	\
	_(struct arbre *, cinq, 5, __VA_ARGS__)		\
	_(struct arbre *, six, 6, __VA_ARGS__)		\
	_(struct arbre *, sept, 7, __VA_ARGS__)		\
	_(struct arbre *, huit, 8, __VA_ARGS__)		\
	_(struct arbre *, neuf, 9, __VA_ARGS__)

struct arbre {
	YAHOO(DECLAR_STRUCT)
	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) {
	if (tmp == NULL)
		return;
	YAHOO(SUPP_ARBRE, tmp)
	free(tmp);
}

int main(void) {
	unsigned int tab[N] = { 125, 2, 3, 4, 5, 125, 7, 8, 9, 1 };
	int i, prof, n;
	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 {
			switch (n % 10) {
				YAHOO(CASE_SWITCH, tmp)
				default:
					break;
			}
			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;
}
                      • Partager sur Facebook
                      • Partager sur Twitter
                      rocklee.gt
                        26 décembre 2009 à 13:37:00

                        J'aurais jamais imaginer que trouver le nombre le plus fréquent d'un tableau soit si dur :p
                        • Partager sur Facebook
                        • Partager sur Twitter
                        Pouet_forever
                        • Langage C
                          26 décembre 2009 à 13:40:45

                          C'est pas dur :D
                          C'est moi qui complique tout juste pour ne parcourir ton tableau qu'une seule fois :D
                          Mais bon au final ça ne sert à rien parce que je parcoures mon arbre des centaines de fois :lol:
                          C'était juste pour le délire ^^
                          • Partager sur Facebook
                          • Partager sur Twitter
                          GurneyH
                          • Langage C
                            26 décembre 2009 à 13:44:22

                            :waw:
                            Il est fou. :p

                            Là, tu vas être obligé d'expliquer ce que tu fait...

                            Et pourquoi fflush ? '\n', n'est pas suffisant ?
                            • Partager sur Facebook
                            • Partager sur Twitter
                            Zeste de Savoir, le site qui en a dans le citron !
                            rocklee.gt
                              26 décembre 2009 à 13:55:13

                              Il ne faut pas oublier qu'à la base, on programme pour être plus fainéant et faire le moins de choses possibles. Tu vas à l'encontre de ce principe :D

                              fflush vide la sortie standard. C'est peut-être juste pour être sûr de ne rien laisser avant de quitter le programme.
                              • Partager sur Facebook
                              • Partager sur Twitter
                              Pouet_forever
                              • Langage C
                                26 décembre 2009 à 15:22:21

                                Citation : GurneyH

                                Et pourquoi fflush ? '\n', n'est pas suffisant ?


                                Parce que j'utilise jamais cette fonction, je me suis dit que pour une fois je pourrais l'utiliser :D

                                @rocklee.gt : Le '\n' fait que printf appelle automatiquement fflush ^^

                                Pour le fonctionnement vous verrez tout ça dans le tuto que je suis en train de faire je vais essayer d'expliquer ^^

                                Dans un premier temps on déclare une macro qui prends comme premier argument le nom d'une macro et comme deuxième argument des paramètres facultatifs.
                                Donc en fait cette macro ne sert que d'intermédiaire pour appeler d'autres macros :)

                                #define YAHOO(_, ...)	\
	_(struct arbre *, zero, 0, __VA_ARGS__)		\
	_(struct arbre *, un, 1, __VA_ARGS__)		\
	_(struct arbre *, deux, 2, __VA_ARGS__)		\
	_(struct arbre *, trois, 3, __VA_ARGS__)	\
	_(struct arbre *, quatre, 4, __VA_ARGS__)	\
	_(struct arbre *, cinq, 5, __VA_ARGS__)		\
	_(struct arbre *, six, 6, __VA_ARGS__)		\
	_(struct arbre *, sept, 7, __VA_ARGS__)		\
	_(struct arbre *, huit, 8, __VA_ARGS__)		\
	_(struct arbre *, neuf, 9, __VA_ARGS__)

                                Donc si j'appelle ma macro comme ça :

                                struct arbre {
	YAHOO(DECLAR_STRUCT)
	int cpt;
};

                                Ca revient à écrire :

                                struct arbre {
	DECLAR_STRUCT(struct arbre *, zero, 0, NULL)
	DECLAR_STRUCT(struct arbre *, un, 1, NULL)	
	DECLAR_STRUCT(struct arbre *, deux, 2, NULL)
	DECLAR_STRUCT(struct arbre *, trois, 3, NULL)
	DECLAR_STRUCT(struct arbre *, quatre, 4, NULL)
	DECLAR_STRUCT(struct arbre *, cinq, 5, NULL)
	DECLAR_STRUCT(struct arbre *, six, 6, NULL)
	DECLAR_STRUCT(struct arbre *, sept, 7, NULL)
	DECLAR_STRUCT(struct arbre *, huit, 8, NULL)
	DECLAR_STRUCT(struct arbre *, neuf, 9, NULL)
	int cpt;
};

                                Et donc au final comme ma macro est définie comme ça :

                                #define DECLAR_STRUCT(type, var, num, rien)	\
	type var;

                                type sera remplacé par 'struct arbre *'
                                var sera remplacé par 'zero', 'un', 'deux', ..., 'neuf'

                                Ca me donne :

                                struct arbre {
	struct arbre *zero;
	struct arbre *un;
	struct arbre *deux;
	struct arbre *trois;
	struct arbre *quatre;
	struct arbre *cinq;
	struct arbre *six;
	struct arbre *sept;
	struct arbre *huit;
	struct arbre *neuf;
	int cpt;
};


                                Après ça marche pareil pour toutes les autres ^^

                                YAHOO(SUPP_ARBRE, tmp)

                                Donne :

                                SUPP_ARBRE(struct arbre *, zero, 0, tmp)
SUPP_ARBRE(struct arbre *, un, 1, tmp)	
SUPP_ARBRE(struct arbre *, deux, 2, tmp)
SUPP_ARBRE(struct arbre *, trois, 3, tmp)
SUPP_ARBRE(struct arbre *, quatre, 4, tmp)
SUPP_ARBRE(struct arbre *, cinq, 5, tmp)
SUPP_ARBRE(struct arbre *, six, 6, tmp)
SUPP_ARBRE(struct arbre *, sept, 7, tmp)
SUPP_ARBRE(struct arbre *, huit, 8, tmp)
SUPP_ARBRE(struct arbre *, neuf, 9, tmp)

                                Au final on a :

                                if (tmp->zero != NULL)
	libererTout(tmp->zero);
if (tmp->un != NULL)
	libererTout(tmp->un);
if (tmp->deux != NULL)
	libererTout(tmp->deux);
if (tmp->trois != NULL)
	libererTout(tmp->trois);
if (tmp->quatre != NULL)
	libererTout(tmp->quatre);
if (tmp->cinq != NULL)
	libererTout(tmp->cinq);
if (tmp->six != NULL)
	libererTout(tmp->six);
if (tmp->sept != NULL)
	libererTout(tmp->sept);
if (tmp->huit != NULL)
	libererTout(tmp->huit);
if (tmp->neuf != NULL)
	libererTout(tmp->neuf);


                                Pareil pour le CASE_SWITCH :)
                                Bon c'est un peu tiré par les cheveux je l'admet :D
                                Pour l'algorithme je pense que ya pas besoin d'explications :)
                                • Partager sur Facebook
                                • Partager sur Twitter
                                Anonyme
                                  26 décembre 2009 à 15:29:44

                                  CokieForever > Pourquoi pas un tableau au lieu de toutes ces conditions rebondantes ?
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  rocklee.gt
                                    26 décembre 2009 à 15:33:19

                                    Citation : Pouet_forever

                                    Le '\n' fait que printf appelle automatiquement fflush ^^



                                    Eh bien, on en apprend tout les jours. :)

                                    Par contre, ça m'intéresserait d'avoir la documentation permettant d'en déduire cette propriété.
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    Anonyme
                                      26 décembre 2009 à 15:38:34

                                      Citation : rocklee.gt

                                      Par contre, ça m'intéresserait d'avoir la documentation permettant d'en déduire cette propriété.


                                      Pareil. Est-ce pareil que le std::endl du C++ ?

                                      EDIT :

                                      Citation : Norme C99 - 5.2.2

                                      \n (newline) Moves the active position to the initial position of the next line.


                                      Rien concernant l'appel de fflush()
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                      GurneyH
                                      • Langage C
                                        26 décembre 2009 à 15:54:25

                                        pour fflush()
                                        Ce n'est pas une doc, mais bon...
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        Zeste de Savoir, le site qui en a dans le citron !
                                        Pouet_forever
                                        • Langage C
                                          26 décembre 2009 à 16:01:06

                                          Ah merci GurneyH j'arrivais pas à remettre la main dessus :lol:
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                          rocklee.gt
                                            26 décembre 2009 à 16:10:00

                                            Merci pour le lien. Cela signifie que fflush est intéressant seulement dans le cas d'une redirection vers un fichier. Ca réponds à une de mes questions que je me posait depuis un moment déjà. ;)
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                            Anonyme
                                              26 décembre 2009 à 16:22:18

                                              En effet, merci GurneyH ;)
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                              CokieForever
                                                26 décembre 2009 à 18:56:36

                                                Citation : Monsieur_JaKy

                                                CokieForever > Pourquoi pas un tableau au lieu de toutes ces conditions rebondantes ?


                                                Euh de quel code tu parles ? Le mien situé (beaucoup) plus haut ? Je comprends pas la question :p
                                                Enfin, peu importe, le PO n'est plus là, mais c'est marrant, ça continue :lol:
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                http://ikturm.wordpress.com/ ; http://www.arb-assoc.fr
                                                Anonyme
                                                  26 décembre 2009 à 23:59:43

                                                  Et bien dans ton arbre, pourquoi ne pas utiliser un tableau de 9 pointeurs sur la structure arbre au lieu de 9 variables ?
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                  rocklee.gt
                                                    27 décembre 2009 à 0:31:18

                                                    @Monsieur_JaKy: Je crois que tu confonds Pouet_forever et CokieForever :p
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    Pouet_forever
                                                    • Langage C
                                                      27 décembre 2009 à 0:42:30

                                                      Si il parle de moi je comprend pas trop parce que j'ai bien 10 pointeurs (pas 9 ;) ) et une variable pour le comptage :)
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                      rocklee.gt
                                                        27 décembre 2009 à 0:55:40

                                                        Oui mais justement, il demande pourquoi ne pas avoir rassemblé tes 10 pointeurs dans un tableau à 10 cases. Au lieu d'avoir tmp->zero, tu aurais tmp->tab[0]. Enfin, c'est ce que j'ai cru comprendre. :-°
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        Pouet_forever
                                                        • Langage C
                                                          27 décembre 2009 à 0:58:53

                                                          Ah !
                                                          Oui effectivement, mais comme je l'ai fait remarqué à GurneyH c'était justement pour m'amuser avec les macros :lol:
                                                          Sinon c'est clair qu'un tableau de 10 cases aurait été bien plus simple ;)
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                          Anonyme
                                                            27 décembre 2009 à 11:28:08

                                                            Lol, désolé de vous avoir confondu (le forever m'avait induit en erreur ;) )
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter

                                                            Tableau, élément le plus fréquent

                                                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                            • Editeur ●
                                                            • Markdown