Le premier l emporte

Dans ce système chaque personne a un vote. Le candidat avec le plus grand nombre de votes est déclaré vainqueur.

compteVotes l =
    let 
        compte x l3 = List.length(List.filter (\y -> y == x) l3) 
        trouveCandidats l2 =
            case l2 of 
                x::xs ->  x:: (List.filter(\y -> y/= x) (trouveCandidats xs))
                []    -> []
    in List.map ((\elt -> (compte elt l, elt))) ( trouveCandidats l )

Alternative

Dans ce système chaque personne peut voter pour 1 ou plusieurs candidats en les listant sur le bulletin de vote dans un ordre de préférence (1er choix,2nd choix,...,dernier choix).
Pour décider du vainqueur chaque bulletin de vote vide est retiré(1) , ensuite chaque candidat minoritaire est retiré de tous les bulletins de vote(2). Ce processus est répété jusqu'à ce qu'il ne reste plus qu'un candidat, lequel est déclaré vainqueur(3).

(1)

enleveSiVide ll =  List.filter(\l -> List.length l /= 0) ll

(2)

elim x ll = List.map(\l ->  (List.filter (\elt -> x/= elt)l) )ll

(3)

trouveTete : List(List a ) -> List a 
trouveTete ll = 
    let 
        r = List.concat (List.map (\l -> (List.take 1 l)) ll)
        cv = compteVotes r -- On utilise le premier algorithme 
    in List.map (\elt -> (Tuple.second elt)) (tri cv)

gagnant g = 
    case (trouveTete (enleveSiVide g)) of 
        [elt] -> elt
        x::s -> gagnant (elim x g)
        [] -> ""

Déroulement

[[R,G],[B],[G,R,B],[B,G,R],[G]]

Etape 1
R -> 1
B -> 2
G -> 2

On retire R de chaque bulletins :
[[G],[B],[G,B],[B,G],[G]]
G -> 3
B -> 2

Donc G gagne.

Attention

Cet algorithme me traite pas le cas d égalité.

Cela peut s observer avec cet exemple :

Cas 1
Premier Votant : [R,G]
Second Votant : [G,R]

Cas2
Premier Votant : [G,R]
Second Votant : [R,G]

Ces deux cas ne renvoient pas le même résultat.

Pourquoi ?
Parce que dans le premier cas :
L' étape 1 élimine R, il reste [[G],[G]]
Donc il reste G.

et dans le second cas :
L'étape 1 élimine G, il reste [[R],[R]]
Donc il reste R.

Liens

Code complet