Newsgroup: it.comp.lang.visual-basic
Titolo: dictionary o array

Sto leggendo un file di testo con il semplice
 
open1...#1
while not  eof
wend
ecccc...
 
nel file di testo:
1234
3456
3456
3456
1234
9999
9999
9999
ecc...
 
dovei caricare o un dctionary con chiavi uniche e sommare quante
occorrenze si verificano durante la lettura del file...
quindi assgnare a 1234 >2 perchè si presenta 2 volte, a 3456>3 perche
si presenta 3 volte... e così via
 
alla fine fare ul loop di tutti gli elementi con un for nxt, udond,
for each o altro.
spero di essere stato chiaro
 
note:
i vari valori si strovano sempre in mid(stringatesto, 56,4)
 
 
 


Se programmare non fa per te, adotta un programmatore.
 
         Dim dict As New Dictionary(Of String, Integer)
         Dim key As Dictionary(Of String, Integer).KeyCollection = dict.Keys
         Dim f As New StreamReader("elenco.txt")
         Dim s As String
 
         Do While f.Peek() >= 0
             s = f.ReadLine().Substring(56, 4)
             Try
                 dict(s) += 1
             Catch
                 dict.Add(s, 1)
             End Try
         Loop
 
         For Each i As String In key
             ListBox1.Items.Add(i & " " & dict(i))
         Next
 

 Sto leggendo un file di testo con il semplice
....leggere più sotto ti fa proprio schifo eh!
"LINQ lista univoca da lista generale"....ho avuto ieri il tuo stesso 
problema....la soluzione che ti hanno dato è brute force e 
probabilmente corretta! E fino a quando non esisteva LINQ probabilmente 
l'unica possibile
ADESSO
        Dim lista = From tag In s.Split(","c) Select tag
                    Group By tag Into gruppo = Group, occorrenza = 
Count()
 
 
        Dim tt As Dictionary(Of String, Integer)
        tt = lista.ToDictionary(Function(p) p.tag, Function(c) 
c.occorrenza)
 
VOILA'!
l'unica cosa da chiarire....qui io avevo da parserizzare (Trattare) una 
stringa CSV (dati separati da virgole)...è probabile che se tratti un 
file avrai la stessa situazione al limite dovrai cambiare solo il 
carattere da riconoscere come separatore. Insomma leggi il file come 
vuoi mettilo in qualcosa che produca un oggetto 
IEnumerable(praticamente ogni lista nel framework)...e dallo in pasto a 
linq!
 
-- 
----- Italliaaaaa 3227! -----
Sa cosa mi disse a Roma il cardinale Poletti? "Lei fa del bene, perchè 
con il suo personaggio la gente si rilassa e sorride, riconciliandosi 
un poco con la vita." ...Fra poco mi venderanno in farmacia.
(Lino Banfi)
 
 


forse ho dimenticato che sto lavorando con vb 6.0 classico
grazie comunque dell'aiuto

 - Mostra testo citato -



brute a chi? ;-)
in realtà ho seguito pedestremente l'analisi (se così la vuoi chiamare), 
ormai qualità rara tra i programmatori che, tra l'altro si stanno, piano 
piano, perdendo perché ormai sono ridotti a chiamare oggetti che fanno 
il mestiere al posto loro e non conoscono più algoritmi. Prova togliere 
il cellofan ad un programmatore nuovo di pacca e chiedigli di 
implementarti un bubble-sort... :-(
 
Un saluto.

 .....leggere più sotto ti fa proprio schifo eh!
 
Anche te però :P leggere meglio cosa ha scritto... quello non è .Net :)
 

"sal21"  ha scritto nel messaggio 
news:9e825ea6-6aec-4dd5...@k10g2000yqn.googlegroups.com...

****************************
 
Capito pochissimo(scusa).
 
Usando una Collection puoi fare qualcosa tipo
questo qui sotto. Io sto utilizzando Excel e la colonna A1
del Foglio1 perchè non ho vb installato su questa macchina,
ma il succo è quello.
 
Creo una semplice classe(Class1) con questo codice:
 
Private lQuantità As Long
Private sIndice As String
 
Public Property Get Quantità() As Long
    Quantità = lQuantità
End Property
 
Public Sub mQuantità()
    lQuantità = lQuantità + 1
End Sub
 
Public Property Get Indice() As String
    Indice = sIndice
End Property
 
Public Property Let Indice(ByVal s As String)
    sIndice = s
End Property
 
 
Questa la routine che legge la colonna A
e mi riporta i valori trovati per ciascun Item della Collection:
 
Public Sub m()
 
    Dim sh As Worksheet
    Dim rng As Range
    Dim c As Range
    Dim col As Collection
    Dim cls As Classe1
 
 
    Set sh = ThisWorkbook.Worksheets("Foglio1")
    Set col = New Collection
 
    With sh
        Set rng = .Range("A1").CurrentRegion
        For Each c In rng
            On Error Resume Next
            Set cls = New Classe1
            cls.Indice = CStr(c.Value)
            cls.mQuantità
            col.Add cls, CStr(c.Value)
            If Err.Number <> 0 Then
                col.Item(c.Value).mQuantità
            End If
            On Error GoTo 0
        Next
    End With
 
    For Each cls In col
        MsgBox cls.Indice & " Quantità: " & cls.Quantità
    Next
 
    Set col = Nothing
    Set c = Nothing
    Set rng = Nothing
    Set sh = Nothing
 
End Sub
 
--
---------------------------
Mauro Gamberini
Microsoft MVP - Excel
http://www.riolab.org/
 
http://www.maurogsc.eu/
 
 


wrote:

vediamo se ho capito
file di input
1234
3456
3456
3456
1234
9999
9999
9999
programma
'dentro un command_click o dove ti pare
 Dim col As New Collection
    Dim riga As String
 
 
    Open "c:\dup.txt" For Input As #1
 
    Do While Not EOF(1)
       Line Input #1, riga
       mUpdPlus col, riga
    Loop
    Close #1
 
    Dim i As Integer
    For i = 1 To col.Count
        debug.print col(i)
    Next
'fuori dal command
 
Function mUpdPlus(c As Collection, s As String)
    Dim i As Integer
    Dim p As String
    Dim ar() As String
    Dim Found As Boolean
    Found = False
    For i = 1 To c.Count
        p = c.item(i)
        ar = Split(p, "#")
        If ar(0) = s Then
            c.Remove (i)
            c.Add ar(0) & "#" & CStr(CInt(ar(1)) + 1)
            Found = True
            Exit For
        End If
    Next
    If Found = False Then
        c.Add s & "#" & CStr(1)
    End If
 
End Function
 
 
result
3456#3
1234#2
9999#3
 

 - Mostra testo citato -
 
SammyJR . grazie! proprio quello che mi serviva!!!!!!!!!!!!!!

 "sal21"  ha scritto nel messaggionews:9e825ea6-6aec-4dd5...@k10g2000yqn.googlegroups.com...

Mauro, il codice è perfetto devo solo adattarlo al txt, spero che
funzini, altrimenti ti riscrivo, che ne pensi?:-):-):-)

 brute a chi? ;-)
zac
Brute a te....! Perchè l'analisi è importantissima ma in un mondo ad 
oggetti anche l'implementazione!
TRY
CATCH
costringe il framework a trappare una eccezione ...a scrivere codice 
"pesante".
Non lo dico io....lo dicono vari guru (e mi han anche ripreso più volte 
quando scrivevo codice pieno di try catch)...meno eccezioni sollevi 
meglio "fila veloce" la tua applicazione!
C'è Linq...apposta per trattare liste di oggetti...usiamolo!
Ovviamente fino ad un mese fa anche io sto coso strano chiamato linq lo 
guardavo con scetticismo!
 
Ciao! ;o)
 
-- 
----- Italliaaaaa 3227! -----
Pasquà...Pasquale Zagaria...u'fighh'Riccard
[Vieni avanti cretino (1982)
c'ho pure il video! 
http://www.martek.it/public/dblog/banfi1.swf
 ]
 
 

Ha detto: Loganino
Il giorno: giovedì, 17/11/2011

Beh non me ne sono accorto...
..ho visto la soluzione proposta
...ho visto StreamReader
....ho fatto 1+1
.....so na sega che è uguale a -1 !!!
 
-- 
----- Italliaaaaa 3227! -----
Il coraggio ce l'ho. E' la paura che mi frega.
(Totò)
 
 

         Next
ho provato il tuo codice
funziona
ma nella console mi da questo warning
Eccezione first-chance di tipo
'System.Collections.Generic.KeyNotFoundException' in mscorlib.dll
 
che mi sembra di aver capito succeda nell'istruzione   dict(s) += 1
 
 
ti risulta?

 wrote:
SCUSATE EH!....è pacifico che usate adesso 
vb.net
 
mi spiegate perchè questo non vi garba????
FILE DI TESTO
dati.txt
Contenuto
ProdottoNr1234pippo
ProdottoNr1034pluto
ProdottoNr1134paperino
ProdottoNr1212paperone
ProdottoNr1083zuma
ProdottoNr0085sila
ProdottoNr0001mina
ProdottoNr0001tina
ProdottoNr1234pollo
ProdottoNr1034mollo
ProdottoNr2152giallo
ProdottoNr2152gallo
 
prendi una windows form metteteci una textbox una listbox ed un button
incollate
Imports System.IO
Imports System.Linq
Public Class Form1
    Private Sub Button1_Click(sender As System.Object, e As 
System.EventArgs) Handles Button1.Click
        Dim fileContents As String
        Dim tt As Dictionary(Of String, Integer)
        fileContents = 
My.Computer.FileSystem.ReadAllText(Path.Combine(Application.StartupPath, 
"dati.txt"))
        Dim Lista = From tagCompleto In fileContents.Replace(vbCrLf, 
vbLf).Split(vbLf)
                    Select dato = tagCompleto.Substring(10, 4)
                    Group By dato Into gruppo = Group, occorrenza = 
Count()
        tt = Lista.ToDictionary(Function(p) p.dato, Function(c) 
c.occorrenza)
        With ListBox1
            .Items.Clear()
            .DataSource = New BindingSource(tt, Nothing)
            'nel nostro caso viceversa...abbiamo i tag come chiavi e 
nel valore le occorrenze
            'quindi NON...
            '.ValueMember = "Value"
            '.SelectedValue = "Key"
            'MA ....
            .ValueMember = "value"
            .DisplayMember = "key"
            .SelectedValue = "value"
        End With
    End Sub
    Private Sub ListBox1_Click(sender As Object, e As System.EventArgs) 
Handles ListBox1.Click
        Me.TextBox1.Text = ListBox1.Text + " (" + 
ListBox1.SelectedValue.ToString + ")"
    End Sub
End Class
 
FATTO!
28 righe di codice compresi interfaccia, commenti e spiegazioni varie!
e perchè non ho accorpato le prime righe per chiarezza didattica!
 
....insomma sto linq lo comincio davvero ad apprezzare!!!
 
-- 
----- Italliaaaaa 3227! -----
Ho visto cose che voi umani non potreste immaginare... navi da 
combattimento in fiamme al largo dei bastioni di Orione. E ho visto i 
raggi B balenare nel buio vicino alle porte di Tannhauser. E tutti quei 
momenti andranno perduti nel tempo come lacrime nella pioggia. È tempo 
di morire...
 
Unità NEXUS6 Roy Batty N6MAA10816 Ment.LEV A
 
 

 ti risulta?
 
Ciao,
si, mi risulta ed è il motivo per cui funziona. Faccio una premessa: ho 
risposto all'op proporzionalmente al suo post che, con errori di 
digitazione, assenza di tentativi di approccio e manifesta scarsa 
volontà di fare qualche ricerca in rete, mi ha fatto optare per una 
soluzione (come dice Wodka40°) "brute". In sostanza funziona così:
 
              s = f.ReadLine().Substring(56, 4)
              Try
                  dict(s) += 1
              Catch
                  dict.Add(s, 1)
              End Try
 
parto dal presupposto che la chiave esista e provo ad incrementarne il 
contatore di occorrenze; se viene sollevata l'eccezione vuol dire che la 
chiave non esiste e quindi la aggiungo inizializzando il contatore di 
occorrenze ad 1. In realtà sarebbe meglio evitare che venga sollevata 
eccezione scrivendo il codice in questo modo:
 
             s = f.ReadLine().Substring(56, 4)
             If dict.ContainsKey(s) Then
                 dict(s) += 1
             Else
                 dict.Add(s, 1)
             End If
 
Come mi hanno raccontato, alcuni guru, affermano che la versione con la 
gestione delle eccezioni potrebbe essere più lenta ma al posto loro, ci 
andrei cauto nel darlo per assunto: non mi sono preso la briga di 
verificarlo ma su un buon numero di esempi ho avuto occasione di notare 
che Microsoft predilige proporre soluzioni con la gestione delle 
eccezioni ed un motivo ci sarà. Una buona soluzione è anche quella 
proposta da Wodka40° ma personalmente, usare linkq per una tal 
sciocchezza, mi sembra sia un po' come assoldare una ditta di trasporti 
per fare il giro dell'isolato con la bici invece di inforcarla e 
pedalare; insomma, mi sembra eccessivo scomodare sql per 'sto mestiere.
 
Un saluto a tutti.

 per 'sto mestiere.
ZAC
Scusami ma io sono un tipo cocciuto...ma allo stesso tempo 
aperto...sembrerà strano ma son così: son convinto delle mie idee ma se 
mi dimostri che son sbagliate ti do assolutamente ragione!
Io LINQ non l'ho mai usato finoa  poco tempo fa...venendo dal vb6 avevo 
la mia buona dose di "invcancrenimento" da presunzione: sapevo fare 
quelle 2 3 4 5 6 ...n cose in vb6 e non accetavo cambiamenti!
Devo dare atto a MAuro di questo ng di avermi costretto a pensare che 
"c'era un altro mondo" la fuori!
 
ED ADESSO vediamo se convinco anche te
ho preso un 
vb.net
 
ed ho fatto 2 routine
 
UNA DEL METODO "DMAXIME"
 
Public Function Dmaxime(nomefile As String) As Long
        Dim misura As New Stopwatch
        misura.Start()
 
        Dim dict As New Dictionary(Of String, Integer)
        Dim key As Dictionary(Of String, Integer).KeyCollection = 
dict.Keys
        Dim f As New StreamReader(nomefile)
        Dim s As String
 
        Do While f.Peek() >= 0
            s = f.ReadLine().Substring(10, 4)
            Try
                dict(s) += 1
            Catch
                dict.Add(s, 1)
            End Try
        Loop
        f.Close()
 
        misura.Stop()
        Debug.Print("Check dmaxime riempimento dictionary: " + 
dict.Count.ToString)
        Return misura.ElapsedTicks
    End Function
 
ED UNA DEL METODO "WODKA40°"
    Public Function Wodka(nomeFile As String) As Long
        Dim misura As New Stopwatch
        misura.Start()
        Dim fileContents As String
        Dim tt As Dictionary(Of String, Integer)
        fileContents = My.Computer.FileSystem.ReadAllText(nomeFile)
        Dim Lista = From tagCompleto In fileContents.Replace(vbCrLf, 
vbLf).Split(vbLf)
                 Select dato = tagCompleto.Substring(10, 4)
                 Group By dato Into gruppo = Group, occorrenza = 
Count()
 
        tt = Lista.ToDictionary(Function(p) p.dato, Function(c) 
c.occorrenza)
        misura.Stop()
 
        Debug.Print("Check wodka riempimento dictionary: " + 
tt.Count.ToString)
        tt = Nothing
        Return misura.ElapsedTicks
    End Function
 
AVVERTENZE:
 
A) Il debug alla fine non rileva ai fini della velocità (è fermato 
prima il cronometro) ma ti rivelerebbe tante cose se lo osservi...te 
l'ho lasciato...
B) Ho agganciato la sola parte di riempimento dictionary perchè poi 
l'interfaccia con il listbox si può fare in tanti modi (anche wpf 
volendo). Ad esempio quello che avevo proposto io perdeva tempo 
attraverso un oggetto BindingSource per risolvere elegantemente il 
problema "Mostro il testo ma al click voglio il valore"...
 
Una winform un bottone ed un listbox(io ho riciclato una vecchia form)
dentro il bottone
 
    Private Sub Button2_Click(sender As System.Object, e As 
System.EventArgs) Handles Button2.Click
        Dim n As Integer
        Dim miofile As String = Path.Combine(Application.StartupPath, 
"dati.txt")
        For n = 1 To 10
            ListBox1.Items.Add("Dmaxime: " + 
(Dmaxime(miofile).ToString))
            ListBox1.Items.Add("Wodka40: " + (Wodka(miofile).ToString))
        Next
 
    End Sub
 
dico solo...lancialo...e guarda QUANTO pesano le eccezioni....forse ce 
la faccio a convincerti!
 
CHIARIAMO SUBITO A SCANSO DI EQUIVOCI
1)
non voglio ne umiliarti ne sentirmi dire bravo....in spirito di 
community come a me hanno aperto gli occhi e segnalato un miglioramento 
che era possibile fare se soltanto avessi avuto voglia di studiare una 
cosa per me nuova ed inutile...così mi sento in dovere di contribuire 
con i miei poveri 2cents alla evoluzione generale dei programmatori 
italiani (in 
vb.net
 ovvio) che frequentano questa community.
2)
Vorrei anche sottolineare che LINQ con SQL non ci incastra nulla...LINQ 
in parole povere,improprie e terra terra è un modo di trattare LISTE di 
oggetti ENUMERABILI: che siano un record, o un array...o i caratteri di 
un file...per lui è lo stesso! Quindi...perfetto per queste cose!
NON ti far fuorviare dal fatto che abbia SELECT WHERE GROUPBY ed 
altro...con l'interrogazione dei database non c'entra nulla!
Puoi declinarlo per usare record. di sqlserver..LINQ to SQL...o entità 
LINQ to Entity...ma lo puoi usare anche per mischiare due array....o 
riempire un dictionary da un file!
 
Saluti!
 
-- 
----- Italliaaaaa 3227! -----
Anche sul trono più alto del mondo, si sta seduti sul proprio culo.
( Michel de Montaigne )
 
 

Nel suo scritto precedente, Wodka40° ha sostenuto :
ovviamente ho usato il solito
FILE DI TESTO
dati.txt
Contenuto
ProdottoNr1234pippo
ProdottoNr1034pluto
ProdottoNr1134paperino
ProdottoNr1212paperone
ProdottoNr1083zuma
ProdottoNr0085sila
ProdottoNr0001mina
ProdottoNr0001tina
ProdottoNr1234pollo
ProdottoNr1034mollo
ProdottoNr2152giallo
ProdottoNr2152gallo
 
-- 
----- Italliaaaaa 3227! -----
Please, visits website, but please visit Italy. We’re t’best country in 
the world in terms of: Culture, Landscapes, Arts, History, Cities, 
Villages, Beautiful countryside, seaside, mountains. That is Italy. You 
know, perhaps, you dreaming about. But please, visit or country. We 
will welcome you warmly and with a better organization.
(Francesco Rutelli Video a: 
http://www.martek.it/dblog/mostraVideo.asp?p=/public/dblog/Rutelli1.wmv
 
)
 
 

 dmaxime ha detto questo lunedì :
....a chi interessa in dettaglio....
DMAXIME
legge il file
RIGA PER RIGA
AD OGNI riga controlla se c'è una eccezione
SE C'E' la gestisce per contare i gruppi di occorrenze
esegue tutto questo sopra FINO alla fine del file
 
WODKA
LEGGE tutto il file e lo mette in memoria
tratta la fine del record che è un vbcrlf per poter SPLITTARE il file 
in memoria in un array di record...il risultato è sempre in memoria
USA LINQ per scorrere la lista ottenuta e raggruppare i dati per 
nome...e poi conta gli elementi di questi gruppi(fa tutto linq)
a questo punto LINQ  spara fuori ...sempre in memoria...una lista di 
risultati.
Usa il metodo toDictionary per trasformare la lista in un Dictionary 
scegliendo i dati che fanno da chiave e quelli da valore
 
DMAXIME usa parecchio il disco fisso e le eccezioni per raggruppare
WODKA40 usa una volta il disco e parecchio la memoria RAM...e nessuna 
eccezione per raggruppare



wrote:

grazie per la risposta
 


Lo sapevo che avresti risposto così... sei come i tuoi amici guru... :-) 
ogni tanto, provate ad uscire dal vostro mondo gestionale:
 
1) sql ci incastra eccome! la grammatica è simile = conoscere sql aiuta 
e se ne sei digiuno in primis la tua soluzione non salta agli occhi ed 
in ogni caso ti devi spulciare pagine e pagine per realizzare un 
accrocchio di query funzionante; la "group by" poi... se non sai che 
esiste...
 
2) immaginala in un contesto (ce ne sono a decine nell'ambito 
automazione) dove le chiavi sono 2 o 3 e le occorrenze, invece, migliaia 
di migliaia per ciascuna chiave: la soluzione con try...catch deve solo 
trovare ed incrementare... quando la lanci e ti sposta anche il pc!
 
3) accesso al disco? anche StreamReader è bufferizzata e fa un solo accesso.
 
Probabilmente nel vostro ambito avreste ragione però nella 
programmazione è sempre l'environment che che decide l'approccio.
 
PS:
Non ho ancora fatto la prova ma appena troverò il tempo farò un po' di 
statistica e ti farò sapere. Grazie, intanto.
 
Ciao.

> dmaxime ha detto questo lunedì :
sigh!evabbe....posso dire, senza che ti offenda, che non hai capito una 
beneamata di quanto ho scritto?
le risposte ai tuoi punti
1)
...esistono le guide...i tutorial e la prova pratica...costo da 100 
euro a zero...esempio di "zero" 
http://totemslair.org/index2.php#
 
 
2)
Proprio in casi con centinaia di occorrenze...è drammatico 
...DRAMMATICO(più grosso non c'è verso scriverlo su un NG)..l'impatto 
del raggruppamento e conteggio con try catch
3)
...può essere...ma in casi di grandi file...l'accesso viene 
segmentato...e comunque...lancia il codice e rimani basito!
 
NON VUOI LANCIARE IL CODICE? te lo faccio IO!
*********TEST SU 10 PROVE ALternate: Dmaxime vs. Wodka40 ***********
.......START 24/11/2011 18:41:27 ......
Dmaxime: 1029215
Wodka40: 33711
Dmaxime: 1155333
Wodka40: 1598
Dmaxime: 1001900
Wodka40: 1704
Dmaxime: 582483
Wodka40: 1324
Dmaxime: 558761
Wodka40: 1546
Dmaxime: 599732
Wodka40: 1419
Dmaxime: 896833
Wodka40: 1648
Dmaxime: 608397
Wodka40: 6648
Dmaxime: 602720
Wodka40: 1382
Dmaxime: 495984
Wodka40: 1517
.......END 24/11/2011 18:41:30 ......
 
Ma potresti obiettare che son file piccoli!
Ho preso pinocchio dal "progetto Gutemberg" ...in inglese...
http://www.gutenberg.org/files/500/500.txt
 
salvato in un file pinocchio.txt
Vuoi le occorrenze delle parole? ancora più semplice!
    Public Function Wodka2(nomeFile As String) As Long
        Dim misura As New Stopwatch
        misura.Start()
        Dim fileContents As String
        Dim tt As Dictionary(Of String, Integer)
        fileContents = My.Computer.FileSystem.ReadAllText(nomeFile)
        Dim Lista = From parola In fileContents.Replace(vbCrLf, " 
").Split(" ")
                    Group By parola Into gruppo = Group, occorrenza = 
Count()
 
        tt = Lista.ToDictionary(Function(p) p.parola, Function(c) 
c.occorrenza)
        misura.Stop()
        pp = tt
        tt = Nothing
        Return misura.ElapsedTicks
    End Function
pp=tt è uno stupido accrocchio per esportare il dictionary e popolare 
un listbox!
 
    Private Sub Button2_Click(sender As System.Object, e As 
System.EventArgs) Handles Button2.Click
        Dim n As Integer
        Dim miofile As String = Path.Combine(Application.StartupPath, 
"pinocchio.txt")
        Console.WriteLine("*********TEST SU 10 PROVE : Wodka40 
***********")
        Console.WriteLine(".......START " + Date.Now.ToString + " 
......")
 
        For n = 1 To 10
  Console.WriteLine("Wodka40: " + (Wodka2(miofile).ToString))
        Next
 Console.WriteLine(".......END " + Date.Now.ToString + " ......")
        Console.WriteLine()
        With ListBox1
            .Items.Clear()
            .DataSource = New BindingSource(pp, Nothing)
            .ValueMember = "value"
            .DisplayMember = "key"
            .SelectedValue = "value"
        End With
 End Sub
ed infine
    Private Sub ListBox1_Click(sender As Object, e As System.EventArgs) 
Handles ListBox1.Click
        Me.TextBox1.Text = ListBox1.Text + " (" + 
ListBox1.SelectedValue.ToString + ")"
    End Sub
 
Lancio....ci pensa poco...mi popola il list box...clicco su una parola 
mi appare nella textbox le occorrenze
MA IL BELLO.......
 
*********TEST SU 10 PROVE : Wodka40 ***********
.......START 24/11/2011 19:47:31 ......
Wodka40: 236324
Wodka40: 199910
Wodka40: 200651
Wodka40: 180162
Wodka40: 222623
Wodka40: 202268
Wodka40: 260225
Wodka40: 218134
Wodka40: 207761
Wodka40: 263813
.......END 24/11/2011 19:47:31 ......
 
ORA ...non so che algoritmo userai....ma con un "conta occorrenze" a 
base di try catch (ossia di forza bruta ma parecchio bruta...BARBARICA 
oserei dire!) difficilmente farai di meglio!
 
...dopo se vuoi mi tiro giù i "Promessi sposi" e provo con quello!
 
-- 
----- Italliaaaaa 3227! -----
Mi disturba la morte, è vero. Credo che sia un errore del padreterno. 
Non mi ritengo per niente indispensabile,
ma immaginare il mondo senza di me: che farete da soli?
(Vittorio Alfieri)
 
 

Su una cosa hai ragione: mi sembra incredibile. Mi hai convinto a 
provare. L'avrai provato senza debugger, immagino.


 
Si, dai, tiralo giù che ci facciamo due risate.
 
Io non denigro il tuo approccio, dico solo che avrebbe più senso 
utilizzarlo in contesti più complessi, come in questo ad esempio, dove 
non par vero di avere a disposizione strumenti così potenti:
 
http://blogs.ugidotnet.org/PietroLibroBlog/archive/2008/05/09/92586.aspx
 
 
altrimenti:
[tratto da "Re: dictionary o array" del 21/11 8:56]
 
mi sembra sia un po' come assoldare una ditta di trasporti per fare il 
giro dell'isolato con la bici invece di inforcarla e pedalare
 
Dopodiché io mi studierò un po' di sql/linkq e tu, se ne avrai voglia, 
un po' di algoritmi. Da parte mia, su questo discorso, non ci spenderò 
nemmeno più un bit.
 
Stammi bene.

 Stammi bene.
Anche tu!
 
Per chi interessa la questione invece...
 
...usiamo la versione ottimizzata
il test COMPILATO COME RELEASE è fatto su 10 prove
   Private Sub Button2_Click(sender As System.Object, e As 
System.EventArgs) Handles Button2.Click
        Dim n As Integer
        Dim miofile As String = Path.Combine(Application.StartupPath, 
"dati.txt")
        Dim t As New Logging.Log("test")
        MsgBox(t.DefaultFileLogWriter.FullLogFileName)
        t.WriteEntry("*********TEST SU 10 PROVE : Wodka40 vs Dmaxime 
***********")
        t.WriteEntry(".......START " + Date.Now.ToString + " ......")
        For n = 1 To 10
            t.WriteEntry("Dmaxime: " + (Dmaxime2(miofile).ToString))
            t.WriteEntry("Wodka40: " + (Wodka(miofile).ToString))
        Next
        t.WriteEntry(".......END " + Date.Now.ToString + " ......")
        MsgBox("end")
    End Sub
 
usato un log per registrare i dati
la mia routine
   Public Function Wodka(nomeFile As String) As Long
        Dim misura As New Stopwatch
        misura.Start()
        Dim fileContents As String
        Dim tt As Dictionary(Of String, Integer)
        fileContents = My.Computer.FileSystem.ReadAllText(nomeFile)
        Dim Lista = From tagCompleto In fileContents.Replace(vbCrLf, 
vbLf).Split(vbLf)
                 Select dato = tagCompleto.Substring(10, 4)
                 Group By dato Into gruppo = Group, occorrenza = 
Count()
 
        tt = Lista.ToDictionary(Function(p) p.dato, Function(c) 
c.occorrenza)
        misura.Stop()
 
        tt = Nothing
        Return misura.ElapsedTicks
    End Function
 
 
 
confrontata con  LA VERSIONE SENZA l'ottimizzazione  di  dmaxime
ossia quella
            Try
                dict(s) += 1
            Catch
                dict.Add(s, 1)
            End Try
mi dichiara
 
test	Information	0	*********TEST SU 10 PROVE : Wodka40 vs Dmaxime 
***********
test	Information	0	.......START 25/11/2011 13:07:42 ......
test	Information	0	Dmaxime: 4626
test	Information	0	Wodka40: 26633
test	Information	0	Dmaxime: 3635
test	Information	0	Wodka40: 934
test	Information	0	Dmaxime: 3368
test	Information	0	Wodka40: 912
test	Information	0	Dmaxime: 13791
test	Information	0	Wodka40: 1287
test	Information	0	Dmaxime: 4002
test	Information	0	Wodka40: 1100
test	Information	0	Dmaxime: 3938
test	Information	0	Wodka40: 1092
test	Information	0	Dmaxime: 3515
test	Information	0	Wodka40: 949
test	Information	0	Dmaxime: 78523
test	Information	0	Wodka40: 1043
test	Information	0	Dmaxime: 3894
test	Information	0	Wodka40: 994
test	Information	0	Dmaxime: 3626
test	Information	0	Wodka40: 872
test	Information	0	.......END 25/11/2011 13:07:42 ......
test	Information	0	*********TEST SU 10 PROVE : Wodka40 vs Dmaxime 
***********
test	Information	0	.......START 25/11/2011 13:07:46 ......
 
MENTRE ...HA RAGIONE DMAXIME.... la versione
            If dict.ContainsKey(s) Then
                dict(s) += 1
            Else
                dict.Add(s, 1)
            End If
eseguendo un solo confronto contro una creazione di liste
spunta un
test	Information	0	.......START 25/11/2011 13:31:20 ......
test	Information	0	Dmaxime: 898
test	Information	0	Wodka40: 981
test	Information	0	Dmaxime: 771
test	Information	0	Wodka40: 712
test	Information	0	Dmaxime: 519
test	Information	0	Wodka40: 631
test	Information	0	Dmaxime: 516
test	Information	0	Wodka40: 621
test	Information	0	Dmaxime: 515
test	Information	0	Wodka40: 630
test	Information	0	Dmaxime: 559
test	Information	0	Wodka40: 623
test	Information	0	Dmaxime: 513
test	Information	0	Wodka40: 633
test	Information	0	Dmaxime: 515
test	Information	0	Wodka40: 647
test	Information	0	Dmaxime: 529
test	Information	0	Wodka40: 619
test	Information	0	Dmaxime: 527
test	Information	0	Wodka40: 905
test	Information	0	.......END 25/11/2011 13:31:20 ......
 
Quindi concludendo....
le eccezioni servono!... parecchio!...ma sono ONEROSE in termini di 
tempo macchina...il perchè lo lascio ai guru(se funziona come in C 
penso perchè quando trova una eccezione da gestire deve saltare ad un 
punto del codice e nel farlo memorizzare una copia di tutti i registri 
della CPU...eseguire la routine dell'eccezione ...riprstinare i 
registri e saltare all'indietro dove era rimasto nel flusso del 
codice).
Quindi le eccezioni sono da usare CON PRUDENZA E MISURA !...SE 
POSSIBILE...usate algoritmi che le evitano!
Per intendersi pensate alla strada
            Try
                dict(s) += 1
            Catch
                dict.Add(s, 1)
            End Try
come una lenta scorciatoia da cavernicoli tutto muscoli e niente 
cervello!
...oppure ad una scorciatoia per costruire alla svelta una demo che non 
si pianta per acquisire il cliente!...poi però programmate il prodotto 
come si deve!
 
Saluti!
 
p.s.
Ovviamente non c'è nulla contro Dmaxime...anche se non ci crede....è 
stata l'occasione da parte mia per vedere se i miei guru mi avevano 
detto la verità!
 
p.p.s.
       If dict.ContainsKey(s) Then
                dict(s) += 1
            Else
                dict.Add(s, 1)
            End If
è vero...non l'avevo vista! Ero concentrato a dimostrare che a colpi di 
try catch "son buoni tutti" ma poi se si incazzano perchè dotnet è 
lento... non è tutta colpa di dotnet!
 
...e con questo credo si possa chiudere la discussione! Terra qui Base 
luna...passo e chiudo!
 
-- 
----- Italliaaaaa 3227! -----
Il grande maestro di pittura meta-gastro-fisica Luciano Lupoletti in:
David Arlequin
http://www.lupoletti.com/public/lupoletti/09-10-24-12-05-21@David%20Arlequin%20-%20Olio%20su%20tela.jpg
 
 
(ROTFL: oddio mi ribalto)