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.