Discussion :

[gregcat]

j'ai développé cette procédure qui permet de trouver une valeur majoritairement présente dans une liste.
Mais je voudrais savoir si il a des amélioration ou corrections possible !

merci de votre aide

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
{
 valeurMajoritaireDansListe                                           GC : 21/8/2007
 
 Procédure permettant de trouver une valeur majoritairement présente au sein d'une liste
 -----------------------------------------------------------------------------------------
 elle renvoie l'index de la valeur majoritaire en question et le
 nombre de répétition de cette même valeur
 
 
 indice retourne -1 si 0 élément dans la liste
 
 indice retourne -2 si la liste contient des séries dont le nombre de valeurs est identique
           meme si existe des nombre de répétition de valeurs différentes mais inférieures
 
 indice retourne 0 ou supérieur pour spécifier l'index de l'élément Majoritaire
 
 nbrepet retourne le nombre de répétition de valeurs de l'élément quand il est majoritaire
           et même quand le nombre de répétition de valeurs est identique
           et meme si existe des nombre de répétition de valeurs différentes mais inférieures
 
 
}
procedure TForm6.valeurMajoritaireDansListe(var Liste:Tstringlist;var nbr_repetition:integer;var indice:integer);
var
    i               : integer; // indice de la boucle de parcours de la liste de valeurs
    Nbr_repet       : integer; // nombre répétition de même valeurs dans la liste
    valeur_prec     : string;  // sauvegarde de Nbr_repet pour comparaison avec la valeur courante
 
    max_repet       : integer; // contient le nombre le plus élevé de répétition de valeurs
    Nbr_repet_prec  : integer; // sauvegarde de Nbr_repet_prec pour comparaison avec la valeur courante
    variation_repet : boolean; // indique si il y a eu des séries avec difference dans leur nombres de valeurs
    finserie        : boolean; // Indique si on est en fin de série de même valeurs meme pour une série de 1 seule valeur
    nb_serie        : integer; // Indique nombre de série de mêmes valeurs trouvées dans la liste générale
begin
  // si 0 élément indice=-1;
  indice:=-1;
  Nbr_repet:=1;
 
  valeur_prec:='';
  max_repet:=0;
  // on trie automatiquement la liste
  Liste.Sorted:=true;
  liste.Sort;
 
  // Si plus d'1 élément dans la liste
  if liste.Count>1 then
  begin
 
    Nbr_repet_prec:=0;
 
    // par défaut on considère que les séries
    // n'auront pas le même nombre de valeurs
    variation_repet:=false;
 
    nb_serie:=0;
 
    for i := 0 to liste.count - 1 do
    begin
      // comparaison de l'ancienne valeur enregistré avec la valeur courante lue
      if valeur_prec=Liste[i] then
        inc(Nbr_repet)
      else
        // si il y a différence avec l'ancienne valeur alors on est le le 1er
        // élément d'une nouvelle série de valeur(s)
        Nbr_repet:=1;
 
      // test si on est pas sur la derniere valeur d'une série de valeur(s)
      finserie:=false;
 
      // test si la valeur suivante est différente de la valeur courante
      // si c'est le cas on est donc sur le dernier élément d'une série de valeur(s)
      if i<liste.count-1 then
        if (liste[i]<>liste[i+1]) then
           finserie:=true;
 
       // on est sur la fin de la liste donc aussi en fin de série
      if i=liste.count-1 then
        finserie:=true;
 
      // est on en fin de série
      if finserie then
      begin
        // si on a trouvé une valeur de répétition plus élevée que la précedente
        // on garde toujours dans "max_repet" la valeur la plus élevée
        // est on indique l'index de la valeur correspondante
        if nbr_repet>max_repet then
        begin
          max_repet:=Nbr_repet;
          indice:=i;
        end;
 
        // si on a déjà traité une série
        // y a t'il une variation de nombre de valeur par série?
        if (nb_serie>0) and (nbr_repet<>nbr_repet_prec) then
           variation_repet:=true;
 
        // on sauvegarde le nombre de répétition pour comparaison de changement en début de boucle
        Nbr_repet_prec:=nbr_repet;
        inc(nb_serie);
 
      end;
        // on sauvegarde la valeur courante pour comparaison de changement en début de boucle
      valeur_prec:=liste[i];
    end;
  end;
  // Cas d'un seul élément
  if liste.Count=1 then
  begin
    indice:=0; // on pointe sur le seul élément
    max_repet:=1; // est la répétition est donc de 1
  end;
  // en cas de nombres de séries identiques
  if not variation_repet then
    indice:=-2;
  // on affecte au parametre nbr_repetition le nombre calculé de répétition
  nbr_repetition:=max_repet;
 
end;
procedure TForm6.Button2Click(Sender: TObject);
var
  liste:tstringlist;
  indice,nbrepet:integer;
begin
  liste:=tstringlist.Create;
 
  liste.Add('1');
  liste.Add('1');
  liste.Add('3');
 
  memo_info_analyse.Lines:=liste;
 
  valeurMajoritaireDansListe(liste,nbrepet,indice);
 
  if indice=-2 then
    memo_info_analyse.Lines.add('nombres de repetitions identiques pour toute les séries  : '+inttostr(nbrepet)+' répétitions');
 
 
 
  if indice>-1 then
    memo_info_analyse.Lines.add('repetition la plus elevée : '+inttostr(nbrepet)+
                              ' dont la valeur est :"'+liste[indice]+'"' );
 
  liste.free;
 
end;

[Qwazerty]

SAlut
Si j'etais toi je trierai mes chiffre par ordre croissant ou decroissant peu importe. Ca prend paut etre un peu de temps pour le faire mais ca t'evite d'en perdre ennormement avec cette ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
      if i<liste.count-1 then
        if (liste[i]<>liste[i+1]) then
           finserie:=true;

Par ce que la tu perd bcp de temps a regarder a chaque fois si un autre nombre se balade dans le reste de ta liste et ce pour chaque nombre de ta liste, tu devrais deja gagner pas mal de temps comme ca

A++
Qwaz