Newsgroup: it.comp.lang.delphi
Titolo: Conta occorrenze TEdit

Ho in un TEdit una stringa del tipo sigle nazioni
 
ita,ger,ger,fra,ita,ita,fra,ger,ita
 
vorrei calcolare il numero massimo delle volte in cui la stringa pi� 
frequente appare
 
nel caso di cui sopra 4 volte (ita)
 
altra stringa
 
ger,ger,ita,ita
 
in questo caso 2 (ger,ita)
 
altra stringa
 
ger,ita,fra,ita,fra,fra
 
in questo caso 3 (fra)
 
altra stringa
 
ita,fra
 
in questo caso 1 (ita,fra)
 
altra stringa
 
fra,ita,fra
 
in questo caso 2 (fra)
 
Ho trovato una funzione sulla rete,ma mi calcola solo il numero delle parole 
della stringa.
 
Grazie per un eventuale aiuto.
 
 

 Ho trovato una funzione sulla rete,ma mi calcola solo il numero delle parole 
 
 
... quindi, l'unico modo di lavorare è cercare codice nel web?
 
 
A.

Ok ok ti aiuto ma solamente un pochino.....
 
 
Fatta in 5 minuti usando una form con un TEdit, un TMemo per vedere i 
risultati ed un bottone:
 
procedure TForm1.Button1Click(Sender: TObject);
Type
   // --------------------------------------------
   // Record di memorizzazione
   // --------------------------------------------
   TRecSearch = Record
                  Nome      : String;
                  Contatore : Integer;
                End;
Var
   NNazioni : Integer;              // Contatore
   Nazioni  : Array Of TRecSearch;  // Vettore dinamico
 
   (* 
*********************************************************************** *)
   (* 
*********************************************************************** *)
 
      Procedure Aggiunge(Nome : String);
      Var
        I  : Integer;
        Ok : Boolean;
        S  : String;
      Begin
        // --------------------------------------------
        // Prelevamento nome
        // --------------------------------------------
        S := Nome;
 
        // --------------------------------------------
        // Eliminazione spazi iniziali e finali
        // --------------------------------------------
        While Copy(S, 1, 1) = ' ' Do Delete(S, 1, 1);
        While Copy(S, Length(S), 1) = ' ' Do Delete(S, Length(S), 1);
 
        // --------------------------------------------
        // Conversione in minuscolo
        // --------------------------------------------
        S := LowerCase(S);
 
        // --------------------------------------------
        // Controllo per stringa non vuota
        // --------------------------------------------
        If (S <> '') Then
           Begin
             // --------------------------------------------
             // Ciclo di ricerca
             // --------------------------------------------
             Ok := False;
             I  := 1;
             While (I <= NNazioni) And (Not Ok) Do
                   Begin
                     If (S = Nazioni[I-1].Nome) Then
                        Begin
                          Inc(Nazioni[I-1].Contatore);
                          Ok := True;
                        End;
 
                     Inc(I);
                   End;
 
             // --------------------------------------------
             // Nome non trovato -> Aggiunge
             // --------------------------------------------
             If Not Ok Then
                Begin
                  Inc(NNazioni);
                  SetLength(Nazioni, NNazioni);
                  Nazioni[NNazioni-1].Nome      := S;
                  Nazioni[NNazioni-1].Contatore := 1;
                End;
           End;
      End;
   (* 
*********************************************************************** *)
   (* 
*********************************************************************** *)
 
Var
   S, S1 : String;
   Punta : Integer;
   I     : Integer;
   Appo  : TRecSearch;
   Ok    : Boolean;
begin
   // --------------------------------------------
   // Inizializzazione contatore
   // --------------------------------------------
   NNazioni := 0;
 
   // --------------------------------------------
   // Prelevamento stringa
   // --------------------------------------------
   S := Edit1.Text;
 
   // --------------------------------------------
   // Ciclo di ricerca e memorizzazione
   // --------------------------------------------
   While (S <> '') Do
         Begin
           Punta := Pos(',', S);
 
           If Punta > 0 Then
              Begin
                S1 := Copy(S, 1, Punta-1);
                Delete(S, 1, Punta);
              End
                Else
              Begin
                S1 := S;
                S  := '';
              End;
 
           Aggiunge(S1);
         End;
 
   // --------------------------------------------
   // Ordinamento vettore decrescente
   // - è un bubble sort idiota -
   // --------------------------------------------
   Repeat
      Ok := True;
 
      For I := 1 To NNazioni-1 Do
          If (Nazioni[I-1].Contatore < Nazioni[I].Contatore) Then
             Begin
               Appo         := Nazioni[I-1];
               Nazioni[I-1] := Nazioni[I];
               Nazioni[I]   := Appo;
 
               Ok           := False;
             End;
   Until Ok;
 
   // --------------------------------------------
   // Visualizzazione risultato
   // --------------------------------------------
   Memo1.Lines.Clear;
   For I := 1 To NNazioni Do
       Begin
         Memo1.Lines.Add(Nazioni[I-1].Nome+' : 
'+IntToStr(Nazioni[I-1].Contatore));
       End;
 
   // --------------------------------------------
   // Finalizzazione vettore dinamico
   // --------------------------------------------
   If NNazioni > 0 Then Finalize(Nazioni);
end;
 
 
ovviamente per prelevare la stringa più frequente basta prendere il 
valore puntato da Nazioni[0]
 
bye
 
 

Ti ringrazio molto per il tuo codice,funziona perfettamente e sono riuscito 
ad adattarlo allo interno di un ciclo in una
stringrid,per un programma di scacchi che sto realizzando.
Da solo non ci sarei riuscito,grazie di nuovo.
LuigiPaolo