Partage
  • Partager sur Facebook
  • Partager sur Twitter

Nombre de chaines identiques

Sujet résolu
    27 décembre 2007 à 13:04:33

    Bonjour,
    Voila je vous explique mon probleme. J'ai un fichier et dans ce fichire
    a chaque ligne j'ai un nom. Des fois j'ai le meme nom a d'autres lignes.
    En fait ce que je voudrais faire c'est pouvoir compter le nombre de fois que ce nom apparait.
    Exemple :

    albert
    roger
    david
    albert
    tat
    toto
    titi
    david
    frank
    toto

    Je veux compter combien de fois apparait chaque nom.
    J'ai chercher, mais je vois pas comment faire

    Merci d'avance
    • Partager sur Facebook
    • Partager sur Twitter
      27 décembre 2007 à 13:10:00

      Citation : GomuSan


      Je veux compter combien de fois apparait chaque nom.
      J'ai chercher, mais je vois pas comment faire


      Algorithme classique de recherche de doublons...

      Tu fais un tableau de chaines dans lequel tu places les noms.
      pour chaque nom, tu cherches si le même existe ailleurs. Si tu le trouves, tu incrémente un compteur.

      Il faut 2 indices, 2 boucles, strcmp()...

      Autre méthode, trier, puis parcourir en comptant les mots identiques... Bref, il faut un peu réfléchir. L'informatique, c'est ça. Le codage, c'est rien...

      • Partager sur Facebook
      • Partager sur Twitter
      Music only !
        27 décembre 2007 à 13:10:22

        Mmh ça sent les tableaux + malloc.

        Comme ça je te dirais de faire ainsi: un tableau parcourant chaque ligne:: si on trouve un nouveau nom on l'inscrit dans un tableau de chaine où l'on modifierai sa taille à chaque nouveau nom.

        Il doit avoir une meilleure solution mais je vois que ça moi ôÔ

        Au pire des cas si tu veux pas te fatiguer à faire à chaque fois un malloc -> tu parcoures tout ton fichier -> tu comptes les sauts de lignes -> Malloc de ce nombre sur le tableau et tu es tranquilles.


        Citation : Pas de titre

        Tu fais un tableau de chaines dans lequel tu places les noms.


        Et Malloc ? On fait comment pour définir la taille d'un tableau 2D?
        • Partager sur Facebook
        • Partager sur Twitter
          27 décembre 2007 à 13:13:08

          Il faut que tu crées un tableau de nom pour avoir chacun d'eux.

          Exemple : tu as albert, tu regardes dans le tableau (celui contenant les noms des fichiers) tu vois qu'il n'y est pas donc tu l'ajoutes. Par contre, si tu le trouves alors tu incrémentes la variable en conséquence.

          Pour parcourir le fichier je pense qu'une structure du type :
          1. typedef struct
          2. {
          3.     char nom[20];
          4.     int nb;
          5. }Pers;


          conviendrait pour répondre à la question.
          • Partager sur Facebook
          • Partager sur Twitter
            27 décembre 2007 à 13:14:43

            Citation : Gambit2099


            Citation : Pas de titre

            Tu fais un tableau de chaines dans lequel tu places les noms.


            Et Malloc ? On fait comment pour définir la taille d'un tableau 2D?


            http://mapage.noos.fr/emdel/notes.htm#tabdyn_2d
            Mais qui a parlé d'un tableau 2D ?

            Un simple tableau 1D de char* auquel on accroche une copie de chaque chaine (strdup()) est suffisant.
            • Partager sur Facebook
            • Partager sur Twitter
            Music only !
              27 décembre 2007 à 13:17:30

              Citation : -ed-

              Citation : Gambit2099


              Citation : Pas de titre

              Tu fais un tableau de chaines dans lequel tu places les noms.


              Et Malloc ? On fait comment pour définir la taille d'un tableau 2D?


              http://mapage.noos.fr/emdel/notes.htm#tabdyn_2d
              Mais qui a parlé d'un tableau 2D ?

              Un simple tableau 1D de char* auquel on accroche une copie de chaque chaine (strdup()) est suffisant.



              En fait j'aurais du dire:
              Et comment il faut pour définir la taille de son tableau 2D? (c'est ça que je pensais que tu avais oublié dans ton post: parler de malloc).
              • Partager sur Facebook
              • Partager sur Twitter
                27 décembre 2007 à 13:20:11

                Citation : -ed-


                Tu fais un tableau de chaines dans lequel tu places les noms.
                pour chaque nom, tu cherches si le même existe ailleurs. Si tu le trouves, tu incrémente un compteur.

                Il faut 2 indices, 2 boucles, strcmp()...



                J'y avais pensé sur papier. Mais je voulais juste avoir vos avis, pour ne pas partir dans une mauvaise direction ;)

                En fait mon idée c'est d'avoir un tableau a 2 dimensions, ou je rentre tout les noms, et un tableau d'entier. A chaque fois que je trouve un nom je le rentre dans le tableau et je verifie avant s'il n'existe pas, s'il existe deja j'incremente mon tableau d'entiers au meme indice du nom.

                Mais le probleme, c'est que je saurais pas a quel case du tableau correspond chaque nom :S

                Par contre ed, je vois pas comment faire sa avec un tableau a 1 une dimension.
                • Partager sur Facebook
                • Partager sur Twitter
                  27 décembre 2007 à 13:28:08

                  Citation : GomuSan


                  Par contre ed, je vois pas comment faire sa avec un tableau a 1 une dimension.


                  Si tu ne réfléchis jamais au moyen de trouver les solutions, tu ne vas pas avancer...
                  1. calculer le nombre de mots (N)
                  2. allouer un tableau de N char *
                  3. lire le fichier ligne à ligne (fgets())
                  4. à chaque ligne, 
                  5. - nettoyer (fclean(), faire une recherche sur le forum)
                  6. - dans chaque pointeur du tableau, stocker l'adresse d'une 
                  7. copie dynamique du nom 
                  8. (strdup() peut aider. C'est POSIX.1, donc très portable. 
                  9. De plus, facile à reproduire si nécessaire).
                  10. etc.

                  Pour ta question précédente, si tu affiches l'information au fur et à mesure, tu n'as besoin que d'un seul compteur.
                  • Partager sur Facebook
                  • Partager sur Twitter
                  Music only !
                    27 décembre 2007 à 13:31:58

                    Desolé, mais je comprends toujours pas et dire que je ne reflechis pas, c'est nimporte quoi parce que je reflechi depuis 11h du matin. Desolé mais on a pas tous ton niveau.

                    Bref, je veux pas m'embrouillé, donc pour te dire, qu'on doit pas utilisé des trucs qu'on a pas vu, donc strdup et fclean, sont a bannir. Et ton histoire de pointeur du tableau, je capte pas.
                    • Partager sur Facebook
                    • Partager sur Twitter
                      27 décembre 2007 à 13:37:42

                      Alors, si tu veux que l'on t'aide dit nous ce que tu as vu histoire de pas partir n'importe où.

                      Pour fclean, c'est une fonction qui vide le buffer d'entrée pour enlever les reste des saisies précédentes. strdup permet de faire une copie dynamique de la chaîne mais je peux pas en dire plus.
                      • Partager sur Facebook
                      • Partager sur Twitter
                        27 décembre 2007 à 13:42:09

                        J'ai tout vu, sauf les tableaux a 2 dimensions et strdup et fclean
                        J'ai vu strcmp, strcat, strcpy
                        • Partager sur Facebook
                        • Partager sur Twitter
                          27 décembre 2007 à 13:45:19

                          Tu n'as pas plus précis, car si tu as tout vu sauf ce que tu cites alors tu ne devrais pas avoir de problème avec les pointeurs, l'allocation dynamique ... donc tout ce qu'a mis -ed- devrait être clair comme de l'eau de roche. (enfin presque car faut un peu y réfléchir)
                          • Partager sur Facebook
                          • Partager sur Twitter
                            27 décembre 2007 à 13:47:04

                            Ouais j'ai vu tout sa, mais il me parle de strdup. Nan mais j'ai compris qu'il fallait les utiliser mais je vois pas comment.

                            Et j'ai pas compris ton struct, comment parcourir avec, faut faire un tableau de struct?
                            • Partager sur Facebook
                            • Partager sur Twitter
                              27 décembre 2007 à 13:51:09

                              La solution de l'arbre avec une branche par lettre et une valeur est la plus efficace.
                              Par exemple :

                              1. Liste :
                              2.         julien
                              3.         jean
                              4.         jean
                              5.         julien
                              6.         julie
                              7.         julien
                              8. Arbre :
                              9.                 J
                              10.               / 0 \
                              11.              E     U
                              12.            / 0     0 \
                              13.           A           L
                              14.         / 0           0 \
                              15.        N                I
                              16.        2                0 \
                              17.                           E
                              18.                           1 \
                              19.                             N
                              20.                             3
                              • Partager sur Facebook
                              • Partager sur Twitter
                                27 décembre 2007 à 14:01:28

                                Citation : Frava

                                La solution de l'arbre avec une branche par lettre et une valeur est la plus efficace.
                                Par exemple :

                                1. Liste :
                                2.         julien
                                3.         jean
                                4.         jean
                                5.         julien
                                6.         julie
                                7.         julien
                                8. Arbre :
                                9.                 J
                                10.               / 0 \
                                11.              E     U
                                12.            / 0     0 \
                                13.           A           L
                                14.         / 0           0 \
                                15.        N                I
                                16.        2                0 \
                                17.                           E
                                18.                           1 \
                                19.                             N
                                20.                             3


                                Oula, plus vous me repondrez et moins je comprends... C'est quoi cet arbre ?

                                Sinon, j'ai encore reflechi et je pense que la reponse d'aurek est pas mal, avec le struct. J'ai pensé a faire un tableau de struct.
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  27 décembre 2007 à 14:11:39

                                  Citation : GomuSan

                                  Oula, plus vous me repondrez et moins je comprends... C'est quoi cet arbre ?


                                  C'est une representation graphique de l'arbre que tu obtiendrais apres avoir parcouru une (et une seule) fois la liste de noms. Il y a tout : les noms ainsi que le nombre de fois qu'ils sont apparus.
                                  Mais bon, si le concept que je t'ai donne te depasse je ne peux pas t'aider car l'implementation ne serait pas a ta portee ... Sache juste que c'est l'algorithme de meilleure complexité pour ton cas.
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    27 décembre 2007 à 14:15:57

                                    Bon c'est pas la peine, je vais chercher tout seul, sa me fera du bien et au moins j'aurais le merite d'avoir trouvé.

                                    Merci quand meme, et desolé ceux que j'ai un peu embrouillé
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      27 décembre 2007 à 14:26:18

                                      Citation : GomuSan

                                      Bon c'est pas la peine, je vais chercher tout seul, sa me fera du bien et au moins j'aurais le merite d'avoir trouvé.


                                      Oups ^^

                                      Bonne chance :D
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        27 décembre 2007 à 14:27:13

                                        Merci, je vous tiens au courant de ma solution :p
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          27 décembre 2007 à 19:23:45

                                          L'algo de l'arbre devrait etre quelque chose du genre :

                                          1. typedef struct noeud
                                          2. {
                                          3.   int n; /* nombre de fois que ce noeud a terminé un nom */
                                          4.   struct noeud* t[26]; /* un noeud fils par lettre de l'alphabet */
                                          5. } noeud;
                                          6. noeud* nouveau_noeud ()
                                          7. {
                                          8.   int i;
                                          9.   noeud *p = (noeud*) malloc (sizeof (noeud));
                                          10.   p->n = 0;
                                          11.   for (i=0; i<26; i++) p->t[i] = NULL;
                                          12.   return p;
                                          13. }
                                          14. void ajoute_nom (noeud *n, char *s )
                                          15. {
                                          16.   if (s == NULL || n == NULL)
                                          17.   {
                                          18.         return;
                                          19.   }
                                          20.   if (s[0] == '\0')
                                          21.   {
                                          22.         n->n++ ;
                                          23.         return; /* On est arrivés au bout du nom */
                                          24.   }
                                          25.   if ( n->t[s[0] - 'a'] == NULL )
                                          26.   {
                                          27.         n->t[ s[0] - 'a' ] = nouveau_noeud();
                                          28.   }
                                          29.   ajoute_nom (n->t[ s[0] - 'a' ] ,&(s[1]));
                                          30. }
                                          31. }


                                          Si on veut pouvoir lire un dictionnaire ou des noms avec accent ou majuscules il faudrait utiliser une liste chainee triee a la place du tableau de 26 cases :p
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            28 décembre 2007 à 20:00:53

                                            Je me demandais si tu avais reussit a trouver GomuSan. Si ce n'est pas le cas, essaie ca :

                                            1. #include <stdlib.h>
                                            2. #include <stdio.h>
                                            3. typedef struct noeud
                                            4. {
                                            5.   int n; /* nombre de fois que ce noeud a terminé un nom */
                                            6.   struct noeud* t[26]; /* un noeud fils par lettre de l'alphabet */
                                            7. } noeud;
                                            8. noeud* nouveau_noeud ()
                                            9. {
                                            10.   int i;
                                            11.   noeud *p = (noeud*) malloc (sizeof (noeud));
                                            12.   p->n = 0;
                                            13.   for (i=0; i<26; i++) p->t[i] = NULL;
                                            14.   return p;
                                            15. }
                                            16. void ajouter_nom (noeud *n, char *s )
                                            17. {
                                            18.   if (s == NULL || n == NULL)
                                            19.   {
                                            20.         return;
                                            21.   }
                                            22.   if (s[0] == '\0')
                                            23.   {
                                            24.         n->n++ ;
                                            25.         return; /* On est arrivés au bout du nom */
                                            26.   }
                                            27.   if ( n->t[s[0] - 'a'] == NULL )
                                            28.   {
                                            29.         n->t[ s[0] - 'a' ] = nouveau_noeud();
                                            30.   }
                                            31.   ajouter_nom (n->t[ s[0] - 'a' ] ,&(s[1]));
                                            32. }
                                            33. int nombre_d_occurrences (noeud *n, char *s)
                                            34. {
                                            35.   int r;
                                            36.   if (n == NULL || s == NULL)
                                            37.     r = 0 ;
                                            38.   else if (s[0] == '\0')
                                            39.     r = n->n;
                                            40.   else if (n->t[s[0] - 'a'] == NULL)
                                            41.     r = 0;
                                            42.   else
                                            43.     r = nombre_d_occurrences(n->t[s[0] - 'a'], &s[1]);
                                            44.   return r;
                                            45. }
                                            46. void afficher_arbre (noeud *n)
                                            47. {  
                                            48.   int i;
                                            49.   int vide = 1;
                                            50.   if (n == NULL) return;
                                            51.   printf ("(%d", n->n);
                                            52.   for (i = 0; i < 26; i++)
                                            53.   {
                                            54.     if (n->t[i] == NULL) continue;
                                            55.     if (vide) printf (",");
                                            56.     vide = 0;
                                            57.     printf ("%c", 'a' + i);
                                            58.     afficher_arbre( n->t[i] );
                                            59.   }
                                            60.   printf (")");
                                            61. }
                                            62. int main ()
                                            63. {
                                            64.   const int N = 7;
                                            65.   char *liste [] = {"julien", "jean", "jean", "julien", "julie", "julien", "juliette"};
                                            66.   noeud *racine = nouveau_noeud();
                                            67.   int i = 0;
                                            68.   for (i = 0; i < N; i++)
                                            69.   {
                                            70.     ajouter_nom (racine, liste[i]);
                                            71.   }
                                            72.   /* On affiche la liste de noms */
                                            73.   printf ("Liste =");
                                            74.   for (i = 0; i < N; i++) printf (" %s",liste[i]);
                                            75.   printf ("\n\n");
                                            76.   /* On affiche l'arbre resultant */
                                            77.   printf ("Arbre resultant = ");
                                            78.   afficher_arbre(racine);
                                            79.   printf ("\n\n");
                                            80.   /* On affiche quelques recherches de noms */
                                            81.   printf ("Quelques recherches sur les noms :\n");
                                            82.   printf ("juliette = %d\n", nombre_d_occurrences(racine,"juliette"));
                                            83.   printf ("julien   = %d\n", nombre_d_occurrences(racine,"julien"));
                                            84.   printf ("julie    = %d\n", nombre_d_occurrences(racine,"julie"));
                                            85.   printf ("toto     = %d\n", nombre_d_occurrences(racine,"toto"));
                                            86.   printf ("jean     = %d\n", nombre_d_occurrences(racine,"jean"));
                                            87. }

                                            Comme je l'ai dis precedemment, il faut absolument gerer des listes triees a la place du tableau pour les fils si l'on veut faire quelque chose de plus general, mais bon, l'avantage du tableau c'est que ca m'a prit une petite demi-heure a coder :p
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              30 décembre 2007 à 18:22:20

                                              En fait, ma solution marchait pas :S
                                              Mais j'ai toujours pas compris comment fonctionner ton tableau ?
                                              Moi sa serait pour un tableau a 10 000 lignes
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                30 décembre 2007 à 18:46:46

                                                Citation : GomuSan

                                                Mais j'ai toujours pas compris comment fonctionner ton tableau ?


                                                Hum, la structure de cette base de donnees de mots n'est pas un tableau mais un arbre. Et comment l'expliquer !!? Ce serait comme si tu avais un tableau avec une case pour chaque lettre de l'alphabet. Quand tu veux ajouter un mot dans la base de donnees, tu regardes sa premiere lettre, tu selectionnes la case correspondant a cette lettre et tu mets le reste du mot (c'est a dire le mot sans sa premiere lettre) dans cette case, sauf que chaque case fonctionne de la meme manniere (et possede donc aussi un tableau avec une case par lettre de l'alphabet), Et le tour est joué :p

                                                Est-ce assez clair comme explication ?

                                                Citation : GomuSan

                                                Moi sa serait pour un tableau a 10 000 lignes


                                                Tu veux dire une liste de 10000 mots dans un fichier ?
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  30 décembre 2007 à 20:47:56

                                                  Exact une liste de 10000 mots que je stocke dans un tableau de structure.

                                                  Ok j'ai capté ton arbre mais bon j'aime pas trop cette solution. Doit y avoir un autre moyen plus ordinaire
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    30 décembre 2007 à 21:25:37

                                                    Salut !

                                                    Je sais pas si ma solution va te convenir, mais je la mets quand même.

                                                    Comme je l'ai dit dans mes précédents post, je pensais faire une structure avec nom et le compteur associé à ce nom. Alors voilà le code que j'ai fait pour mettre en place cette idée :

                                                    1. #include <stdio.h>
                                                    2. #include <string.h>
                                                    3. #define NBELE 10
                                                    4. typedef struct
                                                    5. {
                                                    6.     char nom[20];
                                                    7.     int nb;
                                                    8. }
                                                    9. Pers;
                                                    10. int recherche(Pers *pers, char *nom, int nb);
                                                    11. int chargeTab(Pers *pers, char *nomFichier);
                                                    12. void test(void);
                                                    13. int recherche(Pers *pers, char *nom, int nb)
                                                    14. {
                                                    15.     int i;
                                                    16.     for(i = 0; i < nb; i++)
                                                    17.         if(strcmp(nom, pers[i].nom) == 0)
                                                    18.             return i;
                                                    19.     return -1;
                                                    20. }
                                                    21. int chargeTab(Pers *pers, char *nomFichier)
                                                    22. {
                                                    23.     char nom[20] = "";
                                                    24.     int i = 0, ret;
                                                    25.     FILE *fichier = fopen(nomFichier, "r");
                                                    26.     if(fichier == NULL)
                                                    27.         return -1;
                                                    28.     fscanf(fichier, "%s%*c", nom);
                                                    29.     while(feof(fichier) == 0)
                                                    30.     {
                                                    31.         /* On cherche si le prenom est deja dans le tableau */
                                                    32.         ret = recherche(pers, nom, i);
                                                    33.         /* Si prenom pas deja present, on le rajoute */
                                                    34.         if(ret == -1)
                                                    35.         {
                                                    36.             strcpy(pers[i].nom, nom);
                                                    37.             pers[i].nb = 1;/* On fixe le compteur a 1 */
                                                    38.             i++;/* On ajoute une case utilisée à notre tableau */
                                                    39.         }
                                                    40.         /* Sinon on ajoute un à son compteur */
                                                    41.         else
                                                    42.             pers[ret].nb++;
                                                    43.         fscanf(fichier, "%s%*c", nom);
                                                    44.     }
                                                    45.     fclose(fichier);
                                                    46.     return i;/* On retourne le nombre de case du tableau */
                                                    47. }
                                                    48. void test(void)
                                                    49. {
                                                    50.     Pers pers[NBELE];
                                                    51.     int i, ret;
                                                    52.     ret = chargeTab(pers, "liste.txt");
                                                    53.     if(ret != -1)
                                                    54.         for(i = 0; i < ret; i++)
                                                    55.             printf("%s %d\n", pers[i].nom, pers[i].nb);
                                                    56.     else
                                                    57.         printf("erreur à l'ouverture du fichier\n");
                                                    58. }


                                                    Fichier texte associé

                                                    1. albert
                                                    2. jean
                                                    3. toto
                                                    4. albert
                                                    5. arnaud
                                                    6. jean
                                                    7. etienne


                                                    Resultat :

                                                    albert 2
                                                    jean 2
                                                    toto 1
                                                    arnaud 1
                                                    etienne 1
                                                    Press ENTER to continue.


                                                    Si tu n'as pas compris poses des questions.
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      30 décembre 2007 à 21:43:26

                                                      Citation : GomuSan

                                                      Ok j'ai capté ton arbre mais bon j'aime pas trop cette solution.


                                                      Libre a toi de choisir l'algo que tu vas implementer. Excuse moi de preferer l'efficacité :p




                                                      Edit: Oh!!! aurek aussi a craqué et a implementé sa solution ^^
                                                      Je vais donc lui poser la question. Trouves-tu la solution de l'arbre si etrange que ca ?
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        31 décembre 2007 à 12:14:00

                                                        Salut, merci
                                                        Mais perso, j'aurais jamais trouvé un truc aussi poussé.

                                                        Y a un truc que je comprends pas c'est ça

                                                        1. fscanf(fichier, "%s%*c", nom);


                                                        Sa veut dire quoi %s%*c et pourquoi return -1 ?
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          31 décembre 2007 à 13:55:48

                                                          Citation : GomuSan

                                                          Sa veut dire quoi %s%*c et pourquoi return -1 ?


                                                          "%s%*c" : en lisant un peu la doc de fscanf tu devrais pouvoir comprendre ^^
                                                          "return -1" : Un nombre de cases negatif ca veut dire quoi d'apres toi ?
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            31 décembre 2007 à 13:56:35

                                                            Pourquoi -1 ? en fait, dans ma fonction de recherche, je retourne soit la position dans le tableau si le nom existe déjà pour pouvoir par la suite ajouter 1 dans son compteur sinon, je retourne -1 comme ça, je sais qu'il faut que je le rajoute dans le tableau.

                                                            %s%*c permet de supprimer le '\n' final qui se trouve dans la chaîne une fois que je l'ai lu dans le fichier.


                                                            @Frava: je regarde ta solution pour essayer de la comprendre. Les arbres sont un mystère pour moi. Pour son étrangeté, ben au début je vais dire que j'ai eu du mal à comprendre le schéma que tu avais fait. Mais après, c'est une solution comme une autre. Même si c'est la solution la plus performante.
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              31 décembre 2007 à 14:05:26

                                                              Citation : aurek

                                                              %s%*c permet de supprimer le '\n' final qui se trouve dans la chaîne une fois que je l'ai lu dans le fichier.

                                                              Et si il n'y a pas de '\n' (ça peut arriver avec la dernière ligne) ? Il se passe quoi ? Simple question, je ne connais pas fscanf(), et je ne tiens pas à le connaitre...
                                                              • Partager sur Facebook
                                                              • Partager sur Twitter
                                                              Music only !

                                                              Nombre de chaines identiques

                                                              × 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