Una distribuzione migliore

Con quel codice che ho fatto ultimamente, però, l'ultimo turno viene sempre ridistribuito a quello che ha espresso la più alta preferenza che si trova per ultimo.
Se ad esprimere la preferenza più alta sono più di uno, il progressivo restringersi dell'array dal basso elimina persone che hanno la stessa preferenza dell'ultimo.

Luigi 50 33
Giuseppe 50 33
Mario 50 33
resto 1
-----
Luigi 50 33
Giuseppe 50 33
Mario 50 33
resto 1
-----
Luigi 50 33
Giuseppe 50 33
Mario 50 34
resto 0
-----

Questo non va bene.

Dovrei assicurare la casualità, e quindi trovare un altro algoritmo...

Si potrebbe procedere in modo da:

• Isolare quelli che esprimono il grado più alto di preferenza
• Porli in un altro array
• Rimescolarli in modo casuale
• Procedere con l'attribuzione per riduzione progressiva dell'array come fatto prima.

---

Intanto, verifichiamo se le operazioni svolte su un altro array si ripercuotono sugli oggetti elencati nel primo array. Sono convinto che debba essere necessariamente così...
Però verifichiamo.
Dispongo gli oggetti su un array:

        mario.nome = "Mario"
        giuseppe.nome = "Giuseppe"
        luigi.nome = "Luigi"
        mario.preferenza = 50
        giuseppe.preferenza = 50
        luigi.preferenza = 50

        matrice = New ArrayList
        matrice.Add(mario)
        matrice.Add(giuseppe)
        matrice.Add(luigi)

Ora preparo un altro ArrayList e vi trasferisco alcuni elementi. Verifico prima il valore sulla finestra immediata.

        Debug.Print(matrice(0).preferenza)
        Dim matrice2 As New ArrayList
        matrice2.Add(matrice(0))

Ora modifico un valore dell'elemento e verifico se anche l'elemento del primo ArrayList si è modificato.

        matrice2(0).preferenza = 1234

        Debug.Print(matrice(0).preferenza)

50
1234

Ecco, come volevasi dimostrare. Era ovvio, del resto!

---

---

E dunque, determiniamo il massimo valore presente in matrice.

        mario.preferenza = 50
        giuseppe.preferenza = 50
        luigi.preferenza = 50

.......

        Dim base As Integer = 0
        For Each elemento In matrice
            If elemento.preferenza > base Then base = elemento.preferenza
        Next

        Debug.Print(base)

50

Vario un po' i valori...

        mario.preferenza = 20
        giuseppe.preferenza = 80
        luigi.preferenza = 50

........

        Dim base As Integer = 0
        For Each elemento In matrice
            If elemento.preferenza > base Then base = elemento.preferenza
        Next

80

Sì, sì, funziona...

Avevo già elaborato una funzioncina che svolgeva questo compitino, l'ho messa in un modulo:

Module funzioni
    Public Function Max(ByVal m As ArrayList) As Integer
        Dim base As Integer = 0
        For Each elemento In m
            If elemento > base Then base = elemento
        Next
        Return base
    End Function
End Module

Vediamo se funziona in questo contesto...

        mario.preferenza = 20
        giuseppe.preferenza = 80
        luigi.preferenza = 50

        matrice = New ArrayList
        matrice.Add(mario)
        matrice.Add(giuseppe)
        matrice.Add(luigi)

        Debug.Print(Max(matrice))

Eccezione first-chance di tipo 'System.InvalidCastException' in Microsoft.VisualBasic.dll

AHIAHIAHI!!! Invalid cast!!! Certo! Elemento è l'oggetto, non la proprietà che mi interessa!!!

Vediamo...

Module funzioni
    Public Function Max(ByVal m As ArrayList) As Integer
        Dim base As Integer = 0
        For Each elemento In m
            If elemento.preferenza > base Then base = elemento.preferenza
        Next
        Return base
    End Function

End Module

Non è il massimo, ma funziona...

80

Bene.
Ora devo isolare in un altro array gli elementi che portano questo valore massimo.

        matrice2 = New ArrayList
        For Each elemento In matrice
            If elemento.preferenza = Max(matrice) Then matrice2.Add(elemento)
        Next

        For Each elemento In matrice2
            Debug.Print(elemento.nome & " " & elemento.preferenza)
        Next

...con verifica, ovviamente. Ho impostato così i valori di preferenza delle persone:

        mario.preferenza = 120
        giuseppe.preferenza = 80
        luigi.preferenza = 120

Vediamo...

Mario 120
Luigi 120

Perfetto!

Cambiamo i valori e vediamo ancora...

        mario.preferenza = 80
        giuseppe.preferenza = 80
        luigi.preferenza = 20

Mario 80
Giuseppe 80

Benissimo!

Ho ottenuto di isolare in un altro ArrayList solo quelli che hanno una preferenza maggiore, onde attribuire i turni che avanzano come resto nella prima distribuzione.
Mi sembra giusto, infatti, attribuire più turni a chi preferisce farne di più. Ma in modo casuale qualora questa distribuzione debba essere necessariamente disuguale.