Discussion :

[Oberown]

J'ai une course de voiture, où je dois rentrer les résultats des positions des 4 premiers arrivés.

Par exemple:
voiture C 1er
voiture D 2eme
voiture E 3eme
voiture G 4eme

Il est possible qu'il y ai un ou plusieurs exaquo, et dans ce genre de cas je saute les numéros
A 1er
D 1er
G 3eme
E 4eme

ou

H 1er
I 1er
A 1er
R 4eme

ou

J 1er
A 2e
G 2e
C 4e

Je voudrais lors de la saisie des résultas être capable de voir si je ne n'ai pas fait une erreur.
Par exemple ce résultat est faux (B et D doivent avoir une place de plus)
J 1er
A 1er
B 2eme
D 3eme

Avez-vous des idées de pistes ?

[Graffito]

A partir des données triées par rang d'arrivée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
ResultOk=true ;
ClassementCourant=1 ;
for (int i=0;i<Classement.Count && ResultOk;i++) 
  if (Classement[i]!=ClassementCourant)
  {
     ClassementCourant=i+1 ; // En principe, classement[0]=1
     ResultOk=Classement[i]==i+1 ;
  }

[Zavonen]

Après tout il n'y a que 8 cas possibles.
Si l'arrivée est une liste de 4 couples du type (V,r) où V est une voiture et r son rang.
Il suffit d'extraire les rangs, de les trier et de comparer avec un des 8 résultats possibles.
Exemple de code en python

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#liste des 8 cas possibles pour les arrivées
Possibles=[[1,1,1,1],[1,1,1,4],[1,1,3,3],[1,1,3,4],[1,2,2,2],[1,2,2,4],[1,2,3,3],[1,2,3,4]]
 
def Isok(arrivee):
    """Fonction de test"""
    voitures=[x[0] for x in arrivee]#isoler les voitures
    ranks=[x[1] for x in arrivee]#isoler les rangs
    ranks.sort() #les trier
    #vérifier qu'il n'y a pas de doublons dans les voitures
    comptes=[voitures.count(x) for x in voitures] #nombres d'occurence des 4 voitures dans l'arrivée
    if any([c>1 for c in comptes]):#si une répétition
        return False #alors erreur
    else:#sinon
        return ranks in Possibles #tester si vraisemblable
 
 
if __name__ == "__main__":
    print Isok([('A',1),('C',2),('G',4),('E',3)]);
    print Isok([('A',1),('C',2),('G',2),('E',3)]);
    print Isok([('A',1),('A',2),('G',4),('E',3)]);
 
"""Résultat:
True
False
False
"""

[Graffito]

#vérifier qu'il n'y a pas de doublons dans les voitures

Je n'ai pas traité cette contraine dans mon Algo !

[Oberown]

Il y a une erreur Savoven dans ton algo

Il est possible qu'on est 5 voitures ou plus qui soit arrivés 1er ou 3 voitures 1er et 5 voitures 4eme etc...

Voici ce que j'ai fait en VB .net (la liste est déjà trié)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 Dim resHaut As Integer = 1
            Dim resActuelle As Integer = 1
Dim resultat As Boolean = true
 
            For Each r As Integer In lstRes
                If r <> resHaut AndAlso r <> resActuelle Then
                    resultat = False
                End If
                resHaut = resHaut + 1
                resActuelle = r
            Next

La position du véhicule doit soit avoir la même position que celui d'avant ou avoir le numéro de la position relative.

[Zavonen]

Il y a une erreur Savoven dans ton algo

Oui, pas le temps de regarder aujourd'hui, je verrai demain.

[Zavonen]

Voici un code corrigé

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
voitures=['A','B','C','D','E','F','G']
 
def Isok(arrivee):
    """Fonction de test"""
    arrivees=[x[0] for x in arrivee]#isoler les voitures
    ranks=[x[1] for x in arrivee]#isoler les rangs
    #Compter les premiers
    rank1=ranks.count(1)
    #compter les seconds
    rank2=ranks.count(2)
    #compter les troisièmes
    rank3=ranks.count(3)
    #compter les quatrièmes
    rank4=ranks.count(4)
    #vérifier que toutes les voitures déclarées à l'arrivée font partie de la course
    if any(x not in voitures for x in arrivees):
        return False
    #vérifier qu'il n'y a pas de doublons dans les voitures arrivées
    comptes=[arrivees.count(x) for x in arrivees] #nombres d'occurence des 4 voitures dans l'arrivée
    if any([c>1 for c in comptes]):#si une répétition
        return False #alors erreur
    else:#sinon vérifier la cohérence du classement
        if rank1==0: #il y a forcément au moins un premier
            return False
        if rank2>0 and rank1>=2: # si il y a deux premiers ou plus il ne peut y avoir de second
            return False
        if rank1==1 and rank2<=0: #s'il n'y a qu'un premier il faut au moins un second
            return False
        if rank3>0 and rank1+rank2>=3:# s'il le nombre des seconds et premiers excède 3 pas de troisième
            return False
        if rank1+rank2 <=2 and rank3<=0:#si le nombre des premiers ets econd n'excède pas 3 il faut au moins un troisième
            return False
        if rank4>0 and rank1+rank2+rank3>=4: #etc #etc
            return False
        if rank1+rank2+rank3<=3 and rank4<=0:#idem
            return False
        return True
 
 
if __name__ == "__main__":
    print Isok([('A',1),('C',1),('B',1),('G',4),('E',4)]);
    print Isok([('A',1),('A',1),('G',3),('E',4)]);
    print Isok([('H',1),('C',1),('G',3),('E',4)]);
 
 
"""Résultat:
True
False
False
"""

[Oberown]

Zavonen, ton code est juste mais pas assez modulaire.
Si par exemple on a besoin de classer les 6 premiers ou d'aller jusqu'au 10eme.
Il faudrait remodifier toutes tes conditions.

[Zavonen]

Il faudrait remodifier toutes tes conditions.

Je rentre de voyage dès que j'ai une minute je vais regarder ça.

[Zavonen]

Version 'modularisée'...de la précédente
A vérifier (fait rapidement)

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
voitures=['A','B','C','D','E','F','G']
 
def Isok(arrivee,n):
    """Fonction de test"""
    arrivees=[x[0] for x in arrivee]#isoler les voitures
    ranks=[x[1] for x in arrivee]#isoler les rangs
    #Compter les premiers, les seconds, etc...jusqu'au n-ièmes
    rank=[0]*(n+1)
    for i in range(1,n+1):
        rank[i]=ranks.count(i)
    #faire les cumuls
    cumuls=[0]*(n+1)
    for i in range(1,n+1):
        cumuls[i]=reduce (lambda x,y:x+y,rank[0:i+1])
    #vérifier que toutes les voitures déclarées à l'arrivée font partie de la course
    if any(x not in voitures for x in arrivees):
        return False
    #vérifier qu'il n'y a pas de doublons dans les voitures arrivées
    comptes=[arrivees.count(x) for x in arrivees] #nombres d'occurence des n voitures dans l'arrivée
    if any([c>1 for c in comptes]):#si une répétition
        return False #alors erreur
    else:#sinon vérifier la cohérence du classement
        for i in xrange(1,i+1):
            if rank[i]>0 and cumuls[i-1]>=i:
                return False
            if rank[i]<=0 and cumuls[i-1]<i:
                return False
        return True
 
 
if __name__ == "__main__":
    print Isok([('A',1),('C',1),('B',1),('G',4),('E',4)],4);
    print Isok([('A',1),('A',1),('G',3),('E',4)],4);
    print Isok([('H',1),('C',1),('G',3),('E',4)],4);

[Zavonen]

Et, après tout, pourquoi ne pas calculer, sans risque d'erreur, tout le classement à partir des résultats (temps)?

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import random
 
Voitures=[x for x in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ']#26 voitures au départ
def RandomResult():
    """Un résultat aléatoire pour les arrivées"""
    return [(v,random.randint(10,20)) for v in Voitures]
 
def rangs(L):
    """Calcule les rangs à partir du classement """
    R=[]
    n=1
    while L!=[]:
        X=L[0]
        k=len(X)
        R+=[(v,n) for v in X]
        n+=k
        L=L[1:]
    return R
 
if __name__ == "__main__":
    Resultats=RandomResult() # résultats sous forme de couples (V,t) voiture, temps
    Temps=[x[1] for x in Resultats]#récupérer les temps
    Temps=list(set(Temps))#éliminer les doublons et classer
    Classement=[[c for c in Voitures if (c,t) in Resultats] for t in Temps]#classer les voitures par ordre d'arrivée
    print Resultats;
    print Temps
    print Classement
    print rangs(Classement)