Algorithme pour établir un ordre de passage

Version imprimable

Voir 40 message(s) de cette discussion en une page

06/01/2022, 22h07
maxime_nrgt
Citation:
Envoyé par Mat.M

un simple compteur déclaré en variable global peut suffire

Code:

1 2 3 4 5 6 7 Global Compteur As Integer rem apres dans le code Compteur=Compteur+1 If Compteur >=3 Then FaireQuelqueChose End If

Déclarer une classe globale dans un module de classe et avec une variable de type integer pour mémoriser le type de cheval ou même mieux employer des "string" qui mémorise le nom du cheval

?? Il suffit de faire un tableau de string ou mieux une collection de strings.
Après on peut adresser chaque cellule du feuillet actif et lire la valeur
merci pour votre participation. cependant, le problème a été résolu pus haut avec les 4 tableaux. je dois maintenant transformer cet algorithme sous excel ;)

ATTENTION ! Jeu d’essai incomplet

Citation:

Envoyé par maxime_nrgt

Le problème a été résolu plus haut avec les 4 tableaux.

ATTENTION ! Mon jeu d’essai ne prévoit pas le cas d’un cavalier montant deux ou trois chevaux différents, eux-mêmes montés par un ou deux autres cavaliers. Cela dit, mon algorithme semble fonctionner dans ce contexte. Je sophistique mon jeu d'essai, je teste et je poste le résultat. À bientôt...

Sinon, mon premier tableau est en quelque sorte prédigéré. Il résulte d’un premier tri sur la colonne NOM_CAVALIER pour affecter un N_CAVALIER et un N_ORDRE aux cavaliers montant plusieurs chevaux ; puis d’un second tri sur la colonne NOM_CHEVAL pour affecter un N_CHEVAL et un N_ORDRE aux chevaux montés par plusieurs cavaliers.

PS : J'ai renommé mes colonnes et ajouté une colonne "NOM_CHEVAL", ce que j'aurais dû faire dès le départ ; mes colonnes N_CAVALIER et N_CHEVAL ne sont sans doute pas indispensables.

2ème étape

Avec un SGBD :

Après un tri sur NOM_CAVALIER, NOM_CHEVAL, il est possible d'affecter simultanément un N_CAVALIER et un N_ORDRE croissant pour chaque cavalier montant plusieurs chevaux différents.

Après un tri sur NOM_CHEVAL, NOM_CAVALIER, il est possible d'affecter simultanément un N_CHEVAL et un N_ORDRE croissant pour chaque cheval monté par plusieurs cavaliers différents.

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE

Cavalier_A Cheval_A
1

1

1

Cavalier_A Cheval_B
1

2

2

Cavalier_A Cheval_C
1

3

3

Cavalier_B Cheval_D
2

4

1

Cavalier_C Cheval_D
3

4

2

Cavalier_D Cheval_D
4

4

3

Cavalier_E Cheval_E
5

5

1

Cavalier_E Cheval_F
5

6

2

Cavalier_F Cheval_G
6

7

1

07/01/2022, 16h02
maxime_nrgt

Citation:

Envoyé par APL-AML

ATTENTION ! Mon jeu d’essai ne prévoit pas le cas d’un cavalier montant deux ou trois chevaux différents, eux-mêmes montés par un ou deux autres cavaliers.

Sinon, mon premier tableau est en quelque sorte prédigéré. Il résulte d’un premier tri sur la colonne CAVALIER pour affecter un N° ORDRE aux cavaliers montant plusieurs chevaux ; puis d’un second tri sur la colonne CHEVAL pour affecter un N° ORDRE aux chevaux montés par plusieurs cavaliers.

c'est ce que je viens de me rendre compte en faisant plusieurs essais hélas.
07/01/2022, 16h32
anapurna

salut

pour palier a ce probleme
il te faut une autre colonne définissant la position pour un cavalier

c'est assez simple a mettre en place
si l'Ancient cavaler et le meme que le cavalier precedent alors
sa position = position +1
sinon
Position = 1

ensuite tu tri par position cavalier et tu fait les traitements décrit avant
07/01/2022, 16h46
maxime_nrgt

Citation:

Envoyé par anapurna

salut

pour palier a ce probleme
il te faut une autre colonne définissant la position pour un cavalier

c'est assez simple a mettre en place
si l'Ancient cavaler et le meme que le cavalier precedent alors
sa position = position +1
sinon
Position = 1

ensuite tu tri par position cavalier et tu fait les traitements décrit avant

cela en toute première étape ?

NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE
Cavalier_A	Cheval_A	1	1	1
Cavalier_A	Cheval_B	1	2	2
Cavalier_A	Cheval_C	1	3	3
Cavalier_B	Cheval_D	2	4	1
Cavalier_C	Cheval_D	3	4	2
Cavalier_D	Cheval_D	4	4	3
Cavalier_E	Cheval_E	5	5	1
Cavalier_E	Cheval_F	5	6	2
Cavalier_F	Cheval_G	6	7	1

Version pédagogique avec un jeu d’essai plus complet

Citation:

■ ■ ■ SOMMAIRE ■ ■ ■

1ère étape : Initialiser N_ORDRE (1) à "1"
2ème étape : Renseigner N_ORDRE (2)
3ème étape : Renseigner N_ORDRE (3)
4ème étape : Renseigner N_ORDRE (4)
5ème étape : Numéroter N_PASSAGE
Conclusion

En l’absence de liens hypertexte intra-document, je propose comme palliatif d’utiliser la fonctionnalité de votre navigateur « Rechercher dans la page » : Ctrl/F.

Chaque chapitre correspondant à un item du menu est précédé d’un signet « § ».

Vous saisissez dans la fenêtre de recherche le symbole typographique Paragraphe "§" puis vous naviguez dans le message à l’aide des flèches de direction de la fenêtre ˄ / ˅ ou à l’aide des raccourcis clavier Ctrl+MaJ+G / Ctrl+G.

Affichage du message
Rechercher dans la page : Ctrl/F
Saisie du symbole typographique Paragraphe : "§"
Entrée ou ˄ / ˅ ou Ctrl+MaJ+G / Ctrl+G

Mon jeu d’essai s’est enrichi :

d’un Cavalier_G montant Cheval_A déjà monté par Cavalier_A.
d’un Cavalier_H montant Cheval_C déjà monté par Cavalier_A et montant Cheval_C déjà monté par Cavalier_E.
d’un Cavalier_I montant Cheval_F déjà monté par Cavalier_E

Dans un souci pédagogique, j’ai ajouté une colonne N_ORDRE par étape afin de visualiser l’évolution de N_ORDRE.

La démarche est simple, l’objectif est d’incrémenter N_ORDRE :

pour les cavaliers montant plusieurs chevaux.

puis pour les chevaux montés par plusieurs cavaliers.
L’incrémentation se fait à partir du N_ORDRE du premier des deux ou trois cavaliers montant le même cheval, soit N_ORDRE (1) si N_ORDRE (2) n'est pas renseigné, soit n_ORDRE (2).

Exemple : 3ème étape, les N_ORDRE (3) surlignés.

PS : Excel est plus pratique pour ce genre d’exercice, on peut choisir une couleur pour les cellules des lignes d’un même cheval.

§ 1. 1ère étape

Tri : N_CAVALIER, N_CHEVAL

Initialiser N_ORDRE (1) à "1"

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE (1)

N_ORDRE (2)

N_ORDRE (3)

N_ORDRE (4)

Cavalier_A Cheval_A
1

1

1

Cavalier_A Cheval_B
1

2

1

Cavalier_A Cheval_C
1

3

1

Cavalier_B Cheval_D
2

4

1

Cavalier_C Cheval_D
3

4

1

Cavalier_D Cheval_D
4

4

1

Cavalier_E Cheval_E
5

5

1

Cavalier_E Cheval_F
5

6

1

Cavalier_F Cheval_G
6

7

1

Cavalier_G Cheval_A
7

1

1

Cavalier_HG Cheval_C
8

3

1

Cavalier_H Cheval_E
8

5

1

Cavalier_I Cheval_F
9

6

1

§ 2. 2ème étape

Tri : N_CAVALIER, N_CHEVAL

Affecter un N_ORDRE (2) croissant de 1 à n aux cavaliers montant plusieurs chevaux

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE (1)

N_ORDRE (2)

N_ORDRE (3)

N_ORDRE (4)

Cavalier_A Cheval_A
1

1

1

1

Cavalier_A Cheval_B
1

2

1

2

Cavalier_A Cheval_C
1

3

1

3

Cavalier_B Cheval_D
2

4

1

Cavalier_C Cheval_D
3

4

1

Cavalier_D Cheval_D
4

4

1

Cavalier_E Cheval_E
5

5

1

1

Cavalier_E Cheval_F
5

6

1

2

Cavalier_F Cheval_G
6

7

1

Cavalier_G Cheval_A
7

1

1

Cavalier_H Cheval_C
8

3

1

1

Cavalier_H Cheval_E
8

5

1

1

Cavalier_I Cheval_F
9

6

1

§ 3. 3ème étape

Tri : N_CHEVAL, N_CAVALIER

Affecter un N_ORDRE (3) croissant aux chevaux montés par plusieurs cavaliers

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE (1)

N_ORDRE (2)

N_ORDRE (3)

N_ORDRE (4)

Cavalier_A Cheval_A
1

1

1

1

1

Cavalier_G Cheval_A
7

1

1

2

Cavalier_A Cheval_B
1

2

1

2

Cavalier_A Cheval_C
1

3

1

3

3

Cavalier_H Cheval_C
8

3

1

1

4

Cavalier_B Cheval_D
2

4

1

1

Cavalier_C Cheval_D
3

4

1

2

Cavalier_D Cheval_D
4

4

1

3

Cavalier_E Cheval_E
5

5

1

1

1

Cavalier_H Cheval_E
8

5

1

2

2

Cavalier_E Cheval_F
5

6

1

2

2

Cavalier_I Cheval_F
9

6

1

3

Cavalier_F Cheval_G
6

7

1

§ 4. 4ème étape

Tri : N_CHEVAL, N_CAVALIER

Affecter au N_ORDRE (4) le plus grand des N_ORDRE (2) et N_ORDRE (3)

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE (1)

N_ORDRE (2)

N_ORDRE (3)

N_ORDRE (4)

Cavalier_A Cheval_A
1

1

1

1

1

1

Cavalier_G Cheval_A
7

1

1

2

2

Cavalier_A Cheval_B
1

2

1

2

2

Cavalier_A Cheval_C
1

3

1

3

3

3

Cavalier_H Cheval_C
8

3

1

1

4

4

Cavalier_B Cheval_D
2

4

1

1

1

Cavalier_C Cheval_D
3

4

1

2

2

Cavalier_D Cheval_D
4

4

1

3

3

Cavalier_E Cheval_E
5

5

1

1

1

1

Cavalier_H Cheval_E
8

5

1

2

2

2

Cavalier_E Cheval_F
5

6

1

2

2

2

Cavalier_I Cheval_F
9

6

1

3

3

Cavalier_F Cheval_G
6

7

1

1

§ 5. 5ème étape

Tri : N_ORDRE, N_CAVALIER, N_CHEVAL

Numéroter N_PASSAGE

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE (1)

N_ORDRE (2)

N_ORDRE (3)

N_ORDRE (4)

1
Cavalier_A Cheval_A
1

1

1

1

1

1

2
Cavalier_B Cheval_D
2

4

1

1

1

3
Cavalier_E Cheval_E
5

5

1

1

1

1

4
Cavalier_F Cheval_G
6

7

1

1

5
Cavalier_A Cheval_B
1

2

1

2

2

6
Cavalier_C Cheval_D
3

4

1

2

2

7
Cavalier_E Cheval_F
5

6

1

2

2

8
Cavalier_G Cheval_A
7

1

1

2

2

9
Cavalier_H Cheval_E
8

5

1

2

2

2

10
Cavalier_A Cheval_C
1

3

1

3

3

3

11
Cavalier_D Cheval_D
4

4

1

3

3

12
Cavalier_I Cheval_F
9

6

1

3

13
Cavalier_H Cheval_C
8

3

1

1

4

4

§ 6. Conclusion

Je n’ai aucun argument mathématique, ni aucune explication rationnelle susceptibles de valider mon algorithme. Il ne repose que sur ma réflexion et mon intuition. Cela dit, ça semble bien fonctionner. Il faut tester avec des cas réels.

Ce qu’il me reste à faire :

Remplacer les NOM_CAVALIER et NOM_CHEVAL par de vrais noms pas nécessairement en respectant un ordre alphabétique.
Supprimer les colonnes N_CAVALIER et N_CHEVAL
Ne garder qu’une seule colonne N_ORDRE
Refaire les étapes 1, 2, 3 et 5
Faire l’algorigramme
développer l’algorithme
Créer un billet dans mon blog

08/01/2022, 21h21
maxime_nrgt

1 pièce(s) jointe(s)

Citation:

Envoyé par APL-AML

Mon jeu d’essai s’est enrichi :

Je viens de mettre à éxécution l'algorithme, cependant, je me retrouve avec un même cavalier passant deux fois.
cf pièce jointe
08/01/2022, 21h23
Mat.M

Citation:

Envoyé par maxime_nrgt

cependant, le problème a été résolu pus haut avec les 4 tableaux. je dois maintenant transformer cet algorithme sous excel ;)

mais non le problème n'a pas été résolu vous êtes en train de perdre votre temps à faire des tableaux totalement inutiles "à la main".
Faire du code ça prend autant de temps que faire ce genre de tableau.
Donc ce que je conseille de faire c'est de faire du code, j'en ai fait une ébauche quitte à le rectifier et à l'améliorer pour obtenir les bons résultats.
Ensuite si vous voulez obtenir des tableaux de sortie des traitement de données afin de vérifier l'intégrité de l'ensemble des données c'est précisément l'intérêt de faire du code fonctionnel.

Citation:

Envoyé par maxime_nrgt

Je viens de mettre à exécution l'algorithme, cependant, je me retrouve avec un même cavalier passant deux fois.
cf pièce jointe

sans code ne serait-ce que du pseudo-code ou bien sans organigramme minimum on ne peut pas voir ce qui pose problème.
Faites-nous du code en Javascript ou en Java que tout le monde comprenne sur ce forum et on verra les problèmes de logique
09/01/2022, 18h53
maxime_nrgt

Je viens de mettre tout cet algorithme sous code excel, cependant, des cavaliers apparaissent deux fois d'affilé dans l'ordre final de passage :/

NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE (1)
Cavalier_A	Cheval_A	1	1	1
Cavalier_A	Cheval_B	1	2	1
Cavalier_A	Cheval_C	1	3	1
Cavalier_B	Cheval_D	2	4	1
Cavalier_C	Cheval_D	3	4	1
Cavalier_D	Cheval_D	4	4	1
Cavalier_E	Cheval_E	5	5	1
Cavalier_E	Cheval_F	5	6	1
Cavalier_F	Cheval_G	6	7	1
Cavalier_G	Cheval_A	7	1	1
Cavalier_HG	Cheval_C	8	3	1
Cavalier_H	Cheval_E	8	5	1
Cavalier_I	Cheval_F	9	6	1

NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE (1)	N_ORDRE (2)
Cavalier_A	Cheval_A	1	1	1	1
Cavalier_A	Cheval_B	1	2	1	2
Cavalier_A	Cheval_C	1	3	1	3
Cavalier_B	Cheval_D	2	4	1
Cavalier_C	Cheval_D	3	4	1
Cavalier_D	Cheval_D	4	4	1
Cavalier_E	Cheval_E	5	5	1	1
Cavalier_E	Cheval_F	5	6	1	2
Cavalier_F	Cheval_G	6	7	1
Cavalier_G	Cheval_A	7	1	1
Cavalier_H	Cheval_C	8	3	1	1
Cavalier_H	Cheval_E	8	5	1	1
Cavalier_I	Cheval_F	9	6	1

NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE (1)	N_ORDRE (2)	N_ORDRE (3)
Cavalier_A	Cheval_A	1	1	1	1	1
Cavalier_G	Cheval_A	7	1	1		2
Cavalier_A	Cheval_B	1	2	1	2
Cavalier_A	Cheval_C	1	3	1	3	3
Cavalier_H	Cheval_C	8	3	1	1	4
Cavalier_B	Cheval_D	2	4	1		1
Cavalier_C	Cheval_D	3	4	1		2
Cavalier_D	Cheval_D	4	4	1		3
Cavalier_E	Cheval_E	5	5	1	1	1
Cavalier_H	Cheval_E	8	5	1	2	2
Cavalier_E	Cheval_F	5	6	1	2	2
Cavalier_I	Cheval_F	9	6	1		3
Cavalier_F	Cheval_G	6	7	1

NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE (1)	N_ORDRE (2)	N_ORDRE (3)	N_ORDRE (4)
Cavalier_A	Cheval_A	1	1	1	1	1	1
Cavalier_G	Cheval_A	7	1	1		2	2
Cavalier_A	Cheval_B	1	2	1	2		2
Cavalier_A	Cheval_C	1	3	1	3	3	3
Cavalier_H	Cheval_C	8	3	1	1	4	4
Cavalier_B	Cheval_D	2	4	1		1	1
Cavalier_C	Cheval_D	3	4	1		2	2
Cavalier_D	Cheval_D	4	4	1		3	3
Cavalier_E	Cheval_E	5	5	1	1	1	1
Cavalier_H	Cheval_E	8	5	1	2	2	2
Cavalier_E	Cheval_F	5	6	1	2	2	2
Cavalier_I	Cheval_F	9	6	1		3	3
Cavalier_F	Cheval_G	6	7	1			1

N_PASSAGE	NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE (1)	N_ORDRE (2)	N_ORDRE (3)	N_ORDRE (4)
1	Cavalier_A	Cheval_A	1	1	1	1	1	1
2	Cavalier_B	Cheval_D	2	4	1		1	1
3	Cavalier_E	Cheval_E	5	5	1	1	1	1
4	Cavalier_F	Cheval_G	6	7	1			1
5	Cavalier_A	Cheval_B	1	2	1	2		2
6	Cavalier_C	Cheval_D	3	4	1		2	2
7	Cavalier_E	Cheval_F	5	6	1	2		2
8	Cavalier_G	Cheval_A	7	1	1		2	2
9	Cavalier_H	Cheval_E	8	5	1	2	2	2
10	Cavalier_A	Cheval_C	1	3	1	3	3	3
11	Cavalier_D	Cheval_D	4	4	1		3	3
12	Cavalier_I	Cheval_F	9	6	1			3
13	Cavalier_H	Cheval_C	8	3	1	1	4	4

2 pièce(s) jointe(s)

N_ORDRE = Concaténation de N_CAVALIER et N_CHEVAL

Citation:

Envoyé par Mat.M

Mais non le problème n'a pas été résolu. Vous êtes en train de perdre votre temps à faire des tableaux totalement inutiles "à la main".

Faire du code ça prend autant de temps que faire ce genre de tableau.
Donc ce que je conseille de faire c'est de faire du code, j'en ai fait une ébauche quitte à le rectifier et à l'améliorer pour obtenir les bons résultats.

Ensuite si vous voulez obtenir des tableaux de sortie des traitements de données afin de vérifier l'intégrité de l'ensemble des données c'est précisément l'intérêt de faire du code fonctionnel.

Sans code ne serait-ce que du pseudocode ou bien sans organigramme minimum on ne peut pas voir ce qui pose problème.

Faites-nous du code en JavaScript ou en Java que tout le monde comprenne sur ce forum et on verra les problèmes de logique.

Mes tableaux ne sont pas la solution mais la visualisation d’un algorithme théorique… quitte à le rectifier et à l'améliorer pour obtenir les bons résultats.

Citation:

Envoyé par Mat.M

Sans code ne serait-ce que du pseudocode ou bien sans organigramme minimum on ne peut pas voir ce qui pose problème.

Faites-nous du code en Javascript ou en Java que tout le monde comprenne sur ce forum et on verra les problèmes de logique.

Chacun a sa façon de développer. J’ai besoin de comprendre visuellement les problèmes de logique avant de coder ou de faire un algorigramme.

Par ailleurs, maxime_nrgt cherche à développer sous Excel un algorithme exprimé en "français". Que va-t-il faire d’un code en JavaScript ou en Java.

Citation:

Envoyé par maxime_nrgt

Je viens de mettre à exécution l'algorithme, cependant, je me retrouve avec un même cavalier passant deux fois. cf pièce jointe

Ton jeu d’essai a fait évoluer ma réflexion. Après beaucoup de tâtonnement, je propose un autre algorithme qui semble résoudre le problème. Il faudra voir à l’usage.

Citation:

■ ■ ■ SOMMAIRE ■ ■ ■

Visualisation

1ère étape : Renseigner N_CAVALIER
2ème étape : Renseigner N_CHEVAL
3ème étape : Renseigner N_ORDRE
4ème étape : Renseigner N_PASSAGE
Conclusion

Version N° 1 : N_ORDRE = (N_CAVALIER * 10) + N_CHEVAL
Version N° 2 : N_ORDRE = (N_CHEVAL * 10) + N_ CAVALIER

§ 1. Visualisation

J'ai conservé ma codification pour visualiser ma démarche. J'ai appliqué cette démarche sur le jeu d'essai de maxime_nrgt (voir son jeu d'essai à la fin de ce message).

§ 1.1. 1ère étape : Renseigner N_CAVALIER

Tri : NOM_CAVALIER, NOM_CHEVAL

:arrow: Affecter un N_CAVALIER croissant de 1 à n aux cavaliers montant plusieurs chevaux

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE

Cavalier_A Cheval_A
1

Cavalier_A Cheval_B
2

Cavalier_A Cheval_C
3

Cavalier_B Cheval_D
1

Cavalier_C Cheval_D
1

Cavalier_D Cheval_D
1

Cavalier_E Cheval_E
1

Cavalier_E Cheval_F
2

Cavalier_F Cheval_G
1

Cavalier_G Cheval_A
1

Cavalier_H Cheval_C
1

Cavalier_H Cheval_E
2

Cavalier_I Cheval_F
1

§ 1.2. 2ème étape : Renseigner N_CHEVAL

Tri : NOM_CHEVAL, NOM_CAVALIER

:arrow: Affecter un N_CHEVAL croissant de 1 à n aux cavaliers montant plusieurs chevaux

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE

Cavalier_A Cheval_A
1

1

Cavalier_G Cheval_A
1

2

Cavalier_A Cheval_B
2

1

Cavalier_A Cheval_C
3

1

Cavalier_H Cheval_C
1

2

Cavalier_B Cheval_D
1

1

Cavalier_C Cheval_D
1

2

Cavalier_D Cheval_D
1

3

Cavalier_E Cheval_E
1

1

Cavalier_H Cheval_E
2

2

Cavalier_E Cheval_F
2

1

Cavalier_I Cheval_F
1

2

Cavalier_F Cheval_G
1

1

§ 1.3. 3ème étape : Renseigner N_ORDRE

Tri : NOM_CHEVAL, NOM_CAVALIER

:arrow: N_ORDRE = concaténation N_CAVALIER et N_CHEVAL
:arrow: N_ORDRE = (N_CAVALIER * 10) + N_CHEVAL

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE

Cavalier_A Cheval_A
1

1

11

Cavalier_G Cheval_A
1

2

12

Cavalier_A Cheval_B
2

1

21

Cavalier_A Cheval_C
3

1

31

Cavalier_H Cheval_C
1

2

12

Cavalier_B Cheval_D
1

1

11

Cavalier_C Cheval_D
1

2

12

Cavalier_D Cheval_D
1

3

13

Cavalier_E Cheval_E
1

1

11

Cavalier_H Cheval_E
2

2

22

Cavalier_E Cheval_F
2

1

21

Cavalier_I Cheval_F
1

2

12

Cavalier_F Cheval_G
1

1

11

§ 1.4. 4ème étape : Numéroter N_PASSAGE

Tri : N_ORDRE, NOM_CAVALIER

:arrow: Numéroter N_PASSAGE

N_PASSAGE

NOM_CAVALIER

NOM_CHEVAL

N_CAVALIER

N_CHEVAL

N_ORDRE (1)

1
Cavalier_A Cheval_A
1

1

11

2
Cavalier_B Cheval_D
1

1

11

3
Cavalier_E Cheval_E
1

1

11

4
Cavalier_F Cheval_G
1

1

11

5
Cavalier_C Cheval_D
1

2

12

6
Cavalier_G Cheval_A
1

2

12

7
Cavalier_H Cheval_C
1

2

12

8
Cavalier_I Cheval_F
1

2

12

9
Cavalier_D Cheval_D
1

3

13

10
Cavalier_A Cheval_B
2

1

21

11
Cavalier_E Cheval_F
2

1

21

12
Cavalier_H Cheval_E
2

2

22

13
Cavalier_A Cheval_C
3

1

31

§ 2. Conclusion

“ La théorie, c'est quand on sait tout et que rien ne fonctionne. La pratique, c'est quand tout fonctionne et que personne ne sait pourquoi. ”

Albert Einstein

Citation:

Envoyé par maxime_nrgt

Je viens de mettre tout cet algorithme sous code excel, cependant, des cavaliers apparaissent deux fois d'affilé dans l'ordre final de passage.

Peux-tu vérifier ce nouvel algorithme avec ton jeu d’essai, il semble que cela fonctionne. J’ignore pourquoi l’idée de concaténer N_CAVALIER et N_CHEVAL m’est venue à l’esprit.

J’ai coloré différemment les cavaliers montant plusieurs chevaux et les chevaux montés par plusieurs cavaliers.

§ 2.1. Version N° 1

N_ORDRE = (N_CAVALIER * 10) + N_CHEVAL

Tri : N_ORDRE, NOM_CAVALIER

Pièce jointe 611523

§ 2.2. Version N° 2

N_ORDRE = (N_CHEVAL * 10) + N_ CAVALIER

Tri : N_ORDRE, NOM_CAVALIER

Pièce jointe 611536

10/01/2022, 09h40
anapurna

salut

le principe semble bon il y a juste une chose a faire tout dépend du nombre de cavalier et de cheval max
il faudra multiplier le cavalier par 100, 1 000 ou 10 000 afin de bien différencier les cavaliers des chevaux
10/01/2022, 13h10
maxime_nrgt

1 pièce(s) jointe(s)

Citation:

Envoyé par APL-AML

Pièce jointe 611536

En fait, l'ordre proposé ne me parait pas cohérent avec la réalité sur le terrain, Ex : les tours de maé et maxime sont bien trop rapprochés et engendreront du retard.
La FFE lors des concours "officiels" crée cet ordre.
j'ai donc extrait du site de la ffe des listes de départ afin de les analyser. J'ai trouvé une "symétrie" sur les nombres de tour que font chaques chevaux. Je te la joint ici. (voir feuille 1 et 2).
Mais je ne trouve pas encore leur recette "miracle"
10/01/2022, 16h06
anapurna

Citation:

Envoyé par maxime_nrgt

En fait, l'ordre proposé ne me parait pas cohérent avec la réalité sur le terrain, Ex : les tours de maé et maxime sont bien trop rapprochés et engendreront du retard.
La FFE lors des concours "officiels" crée cet ordre.
j'ai donc extrait du site de la ffe des listes de départ afin de les analyser. J'ai trouvé une "symétrie" sur les nombres de tour que font chaques chevaux. Je te la joint ici. (voir feuille 1 et 2).
Mais je ne trouve pas encore leur recette "miracle"

salut
tu parle dans la deuxième version ou l'on prend le cheval en principal
dans la première version ou le cavalier est maitre maxime et Mae ne sont pas si proche
tu auras toujours un risque de rapprochement pour éviter cela il faut chercher un autre discriminant
par exemple un nombre mini de participant entre deux intervention afin de garantir un temps de repos a minima
10/01/2022, 18h00
APL-AML

Les étapes de ma réflexion

Citation:

Envoyé par anapurna

Le principe semble bon, il y a juste une chose à faire : tout dépend du nombre de cavaliers et de chevaux.

Il faudra multiplier le cavalier par 100, 1 000 ou 10 000 afin de bien différencier les cavaliers des chevaux.

Ta remarque est incompréhensible.

Dans le calcul de N_ORDRE, la multiplication par 10 permet de réaliser la concaténation de N_CAVALIER avec N_CHEVAL si l’on opte pour un tri sur N_ORDRE, NOM_CAVALIER. C’est tout.

Ma démarche :

J’ai repris le jeu d’essai de maxime_nrgt avec Excel et je l’ai torturé dans tous les sens pour trouver une solution, sans parvenir à éviter deux cavaliers ou deux chevaux successifs.

À un moment donné, je me suis dit que je n’y arriverai jamais de cette façon et que je devais être inventif pour trouver une autre façon de procéder. C’est à cet instant que j’ai réalisé que chaque couple NOM_CAVALIER/N_CAVALIER et NOM_CHEVAL/N_CHEVAL était unique. J’ai alors immédiatement pensé à concaténer les deux.

Pourquoi ai-je ensuite trié sur N_ORDRE en majeur et sur NOM_CAVALIER en mineur ? Je n’en sais rien du tout, par instinct, sans doute parce que j’avais concaténé N_CAVALIER devant N_CHEVAL.

Cette nuit, je me suis dit que ça devait également marcher en concaténant N_CHEVAL devant N_CAVALIER puis en triant sur N_ORDRE en majeur et sur NOM_CHEVAL en mineur.

J’ai testé ce matin à l’aube (en fait, il faisait encore nuit… je n’ai pratiquement pas dormi) et j’ai eu la confirmation de ce que je pressentais.

Citation:

Envoyé par maxime_nrgt

En fait, l'ordre proposé ne me parait pas cohérent avec la réalité sur le terrain, Ex. : les tours de maé et maxime sont bien trop rapprochés et engendreront du retard.

J’ai extrait du site de la FFE des listes de départ de concours "officiels", afin de les analyser. J'ai trouvé une "symétrie" sur les nombres de tours que fait chaque cheval. Je te la joins ici. (Voir feuille 1 et 2). Mais je ne trouve pas encore leur recette "miracle"

Le résultat de ma version N° 2 est certes moins satisfaisant que celui de ma version N° 1. L’important était de valider l’algorithme. J’aurais été embêté si ma version N° 2 n’avait pas fonctionné.

Sinon, tu n’es pas obligé de « Répondre avec citation » et de conserver toute la citation. Personnellement, je ne conserve que ce qui motive ma réponse, en synthétisant le texte et en corrigeant toutes les fautes, (grammaire, orthographe et ponctuation).

Ce serait même bien que tu modifies ton message et que tu supprimes toute la citation entre les balises [QUOTE] [/QUOTE], y compris ces balises ou que tu ne conserves à la limite entre ces deux balises, que mes deux images auxquelles tu te réfères dans ta réponse. Le reste de ma citation n’apporte rien et pollue la lecture. On a 72 heures pour modifier son message.

Tu peux aussi cliquer sur le bouton « + Répondre à la discussion » en bas à gauche de la discussion.

Je dis ça, je ne dis rien !

NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER
Cavalier_A	Cheval_A	1
Cavalier_A	Cheval_B	2
Cavalier_A	Cheval_C	3
Cavalier_B	Cheval_D	1
Cavalier_C	Cheval_D	1
Cavalier_D	Cheval_D	1
Cavalier_E	Cheval_E	1
Cavalier_E	Cheval_F	2
Cavalier_F	Cheval_G	1
Cavalier_G	Cheval_A	1
Cavalier_H	Cheval_C	1
Cavalier_H	Cheval_E	2
Cavalier_I	Cheval_F	1

NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL
Cavalier_A	Cheval_A	1	1
Cavalier_G	Cheval_A	1	2
Cavalier_A	Cheval_B	2	1
Cavalier_A	Cheval_C	3	1
Cavalier_H	Cheval_C	1	2
Cavalier_B	Cheval_D	1	1
Cavalier_C	Cheval_D	1	2
Cavalier_D	Cheval_D	1	3
Cavalier_E	Cheval_E	1	1
Cavalier_H	Cheval_E	2	2
Cavalier_E	Cheval_F	2	1
Cavalier_I	Cheval_F	1	2
Cavalier_F	Cheval_G	1	1

NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE
Cavalier_A	Cheval_A	1	1	11
Cavalier_G	Cheval_A	1	2	12
Cavalier_A	Cheval_B	2	1	21
Cavalier_A	Cheval_C	3	1	31
Cavalier_H	Cheval_C	1	2	12
Cavalier_B	Cheval_D	1	1	11
Cavalier_C	Cheval_D	1	2	12
Cavalier_D	Cheval_D	1	3	13
Cavalier_E	Cheval_E	1	1	11
Cavalier_H	Cheval_E	2	2	22
Cavalier_E	Cheval_F	2	1	21
Cavalier_I	Cheval_F	1	2	12
Cavalier_F	Cheval_G	1	1	11

N_PASSAGE	NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE (1)
1	Cavalier_A	Cheval_A	1	1	11
2	Cavalier_B	Cheval_D	1	1	11
3	Cavalier_E	Cheval_E	1	1	11
4	Cavalier_F	Cheval_G	1	1	11
5	Cavalier_C	Cheval_D	1	2	12
6	Cavalier_G	Cheval_A	1	2	12
7	Cavalier_H	Cheval_C	1	2	12
8	Cavalier_I	Cheval_F	1	2	12
9	Cavalier_D	Cheval_D	1	3	13
10	Cavalier_A	Cheval_B	2	1	21
11	Cavalier_E	Cheval_F	2	1	21
12	Cavalier_H	Cheval_E	2	2	22
13	Cavalier_A	Cheval_C	3	1	31

Algorigrammes et Algorithmes

§ 3. Algorigrammes

§ 3.1. Algorigramme N_CAVALIER

► Tri : NOM_CAVALIER, NOM_CHEVAL


                                   ┌─────────────────────────────┐
                            D-PROG │   v_cavalier = ""           │
                                   └──────────────┬──────────────┘
                                                  │◄───────────────────────────────────────────────┐
                                   ┌──────────────┴──────────────┐                                 │
                    D_NOM_CAVALIER │  v_cavalier :: NOM_CAVALIER │                                 │
                      <>           └──────────────┬──────────────┘            =                    │
                    ┌─────────────────────────────●─────────────────────────────┐                  │
     ┌──────────────┴──────────────┐                             ┌──────────────┴──────────────┐   │
     │   N_CAVALIER = 1            │                             │ N_CAVALIER = N_CAVALIER + 1 │   │
     └──────────────┬──────────────┘                             └──────────────┬──────────────┘   │
                    └─────────────────────────────┬─────────────────────────────┘                  │
                                   ┌──────────────┴──────────────┐                                 │
                    F_NOM_CAVALIER │     PRINT N_CAVALIER        │                                 │
                                   │  v_cavalier = NOM_CAVALIER  │                                 │
                                   └──────────────┬──────────────┘                                 │
                                                  ●────────────────────────────────────────────────┘
                                   ┌──────────────┴──────────────┐
                            F-PROG │              ϕ              │
                                   └─────────────────────────────┘

§ 3.2. Algorigramme N_CHEVAL

► Tri : NOM_CHEVAL, NOM_CAVALIER


                                   ┌─────────────────────────────┐
                            D-PROG │     v_cheval = ""           │
                                   └──────────────┬──────────────┘
                                                  │◄───────────────────────────────────────────────┐
                                   ┌──────────────┴──────────────┐                                 │
                      D_NOM_CHEVAL │    v_cheval :: NOM_CHEVAL   │                                 │
                      <>           └──────────────┬──────────────┘            =                    │
                    ┌─────────────────────────────●─────────────────────────────┐                  │
     ┌──────────────┴──────────────┐                             ┌──────────────┴──────────────┐   │
     │     N_CHEVAL = 1            │                             │   N_CHEVAL = N_CHEVAL + 1   │   │
     └──────────────┬──────────────┘                             └──────────────┬──────────────┘   │
                    └─────────────────────────────┬─────────────────────────────┘                  │
                                   ┌──────────────┴──────────────┐                                 │
                      F_NOM_CHEVAL │       PRINT N_CHEVAL        │                                 │
                                   │     v_cheval = NOM_CHEVAL   │                                 │
                                   └──────────────┬──────────────┘                                 │
                                                  ●────────────────────────────────────────────────┘
                                   ┌──────────────┴──────────────┐
                            F-PROG │              ϕ              │
                                   └─────────────────────────────┘

§ 3.3. Algorigramme N_ORDRE = N_CAVALIER * 10) + N_CHEVAL

► Tri : NOM_CHEVAL, NOM_CAVALIER


                                   ┌─────────────────────────────┐
                            D-PROG │              ϕ              │
                                   └──────────────┬──────────────┘
                                                  │◄─────────────────┐
                                   ┌──────────────┴──────────────┐   │
                      T_NOM_CHEVAL │N_ORDRE = (N_CAVALIER*10) + 1│   │
                                   │       PRINT N_ORDRE         │   │
                                   └──────────────┬──────────────┘   │
                                                  ●──────────────────┘
                                   ┌──────────────┴──────────────┐
                            F-PROG │              ϕ              │
                                   └─────────────────────────────┘

§ 3.4. Algorigramme NB_TOURS = N_CAVALIER + N_CHEVAL

► Tri : NOM_CHEVAL, NOM_CAVALIER


                                   ┌─────────────────────────────┐
                            D-PROG │              ϕ              │
                                   └──────────────┬──────────────┘
                                                  │◄─────────────────┐
                                   ┌──────────────┴──────────────┐   │
                      T_NOM_CHEVAL │NB_TOURS=N_CAVALIER+N_CHEVAL │   │
                                   │       PRINT N_ORDRE         │   │
                                   └──────────────┬──────────────┘   │
                                                  ●──────────────────┘
                                   ┌──────────────┴──────────────┐
                            F-PROG │              ϕ              │
                                   └─────────────────────────────┘

§ 4. Algorithmes

Je laisse la programmation des algorithmes aux actifs.

Je ne propose pas d’algorithme JavaScript ou Java pour différentes raisons :

Je cours vers mes 75 ans.
Je ne pratique ni JavaScript, ni Java.
Je ne développe plus depuis près de 15 ans. Pour moi, la messe est dite. J’ai commencé en informatique en 1967 et à développer professionnellement en 1971.
Mon outil de travail est un PC portable de plus de 15 ans avec un clavier fatigué dont la touche Alt/Gr ne fonctionne plus. C’est pratique pour taper les caractères spéciaux !

Je n’interviens sur DVP qu’en sollicitant ma mémoire, mon expérience et ma logique, histoire de retarder mon Alzheimer.

§ 5. Remerciements

Merci à maxime_nrgt de nous avoir proposé ce sujet de réflexion qui mérite d’être promu comme [ACTUALITÉ].

Vous pouvez retrouver ce sujet dans mon blog logique « ALGORITHMIQUE » :

BILLET de BLOG :fleche: Ordre de passage d'une épreuve de concours équestre

Il était du niveau de mon Devoir de vacances :

Discussion :fleche: Sujet d’algorithmie original : imprimer des numéros de table en piles

[ACTUALITÉ] :fleche: Devoir de vacances d'algorithmique : imprimer des numéros de table en piles

BILLET de BLOG :fleche: Imprimer des numéros de table en piles

11/01/2022, 10h25
anapurna

Citation:

Envoyé par APL-AML

Ta remarque est incompréhensible.

Dans le calcul de N_ORDRE, la multiplication par 10 permet de réaliser la concaténation de N_CAVALIER avec N_CHEVAL si l’on opte pour un tri sur N_ORDRE, NOM_CAVALIER. C’est tout.

salut
tout ceci est valable si et seulement si tes cavalier et/ou tes chevaux ne dépasse pas le nombre multiplicateur

c'est bien pour cela que le je dis le principe est bon, il faut juste l'adapter à ses besoin
un exemple simple

Citation:

11 +10*10 = 111
1 +11*10 = 111

comprend tu mieux le problème qu'il peut se produire
je dis cela, je dis rien ...
11/01/2022, 14h30
APL-AML

N_CAVALIER et N_CHEVAL ne sont pas des identifiants
Citation:

Envoyé par anapurna

Tout ceci est valable si et seulement si tes cavaliers et/ou tes chevaux ne dépassent pas le nombre multiplicateur.

Il n’y a pas de nombre multiplicateur.

N_CAVALIER et N_CHEVAL ne sont pas des identifiants et ne peuvent prendre que les valeurs « 1 », « 2 », ou « 3 », selon qu’un cavalier va monter 1 à 3 chevaux ou qu’un cheval sera monté par 1 à 3 cavaliers.

L’objectif est d’avoir tous les couples NOM_CAVALIER/N_CAVALIER et NOM_CHEVAL/N_CHEVAL uniques.

L’algorithme pour définir N_ORDRE consiste à concaténer N_CAVALIER avec N_CHEVAL.

Pour concaténer « 1 » avec « 1 », il suffit de multiplier le premier « 1 » par 10 et d’ajouter le deuxième « 1 ».

Le fait que N_CAVALIER = N_CHEVAL n’a pas d’incidence car la liste est triée en mineur sur NOM_CAVALIER. La version N° 1 du jeu d’essai de maxime_nrgt le montre bien, N_ORDRE vaut 4 fois « 11 », 3 fois « 12 », 3 fois « 21 », 1 fois « 22 » et 2 fois « 31 ».

Les seules combinaisons possibles sont :
- (1 * 10) + 1 = 11
- (1 * 10) + 2 = 12
- (1 * 10) + 3 = 13
- (2 * 10) + 1 = 21
- (2 * 10) + 2 = 22
- (2 * 10) + 3 = 23
- (3 * 10) + 1 = 31
- (3 * 10) + 2 = 32
- (3 * 10) + 3 = 33
Comprends-tu mieux l’algorithme ?

Cela dit, je n’avais aucune idée au départ de cette discussion, de la façon dont j’allais m’y prendre pour trouver cet algorithme. Je l’ai découvert au fur et à mesure et je ne l’explique même pas, du moins à priori, peut-être à postériori… et encore. Si vous voulez en savoir davantage sur ma façon de développer, je vous suggère de lire mon blog, notamment mes billets qui résument certains livres en une dizaine de pages Word chacun (Voir ma bibliographie) ; ils sont faciles à lire. Ça vous changera de vos modèles conceptuels et de vos langages.

Je profite de ce message pour expliquer la différence entre mes versions N° 1 et N° 2 du jeu d’essai de maxime_nrgt par un nombre de cavaliers montant plusieurs chevaux (10) plus important que le nombre de chevaux montés par plusieurs cavaliers (8). Cela suggère qu’il peut être plus intéressant de choisir la version en fonction du nombre de cavaliers montant plusieurs chevaux ou du nombre de chevaux montés par plusieurs cavaliers.

Je remercie au passage maxime_nrgt d’avoir suivi mon conseil tout-à-fait amical concernant ses Réponses avec citation. Cela facilite la lecture pour tout le monde, y compris pour les responsables de ce forum qui peuvent exploiter cette discussion pour en faire une [ACTUALITÉ].
11/01/2022, 16h11
anapurna
Citation:
Envoyé par APL-AML

Il n’y a pas de nombre multiplicateur.

N_CAVALIER et N_CHEVAL ne sont pas des identifiants et ne peuvent prendre que les valeurs « 1 », « 2 », ou « 3 », selon qu’un cavalier va monter 1 à 3 chevaux ou qu’un cheval sera monté par 1 à 3 cavaliers.

L’objectif est d’avoir tous les couples NOM_CAVALIER/N_CAVALIER et NOM_CHEVAL/N_CHEVAL uniques.

L’algorithme pour définir N_ORDRE consiste à concaténer N_CAVALIER avec N_CHEVAL.

Pour concaténer « 1 » avec « 1 », il suffit de multiplier le premier « 1 » par 10 et d’ajouter le deuxième « 1 ».

Le fait que N_CAVALIER = N_CHEVAL n’a pas d’incidence car la liste est triée en mineur sur NOM_CAVALIER. La version N° 1 du jeu d’essai de maxime_nrgt le montre bien, N_ORDRE vaut 4 fois « 11 », 3 fois « 12 », 3 fois « 21 », 1 fois « 22 » et 2 fois « 31 ».

Les seules combinaisons possibles sont :

(1 * 10) + 1 = 11
(1 * 10) + 2 = 12
(1 * 10) + 3 = 13
(2 * 10) + 1 = 21
(2 * 10) + 2 = 22
(2 * 10) + 3 = 23
(3 * 10) + 1 = 31
(3 * 10) + 2 = 32
(3 * 10) + 3 = 33

Comprends-tu mieux l’algorithme ?
l'algorithme je l'avais compris depuis longtemps
j'ai simplement oublié les limite qui son imposé

j'avais en tête ceci :

Citation:

1 cavalier monte 1 a n chevaux (les siens ?)
1 couple cavalier-cheval participe a 1 et 1 seul épreuve
1 épreuve peut être effectué de 1 a n fois par 1 cavalier
1 cheval ne peut participer à 2 épreuves successives sans temps de repos
1 cavalier ne peut participer a 2 épreuves successives sans temps d'échauffement
1 cheval ne peut être monté que 3 fois maximum par concours

et oublié la limite fixe pour les cavaliers

Citation:

1 cavalier ne peut monter que 5 fois par concours

Effectivement, on ne pourra pas, dans cette configuration, dépasser.
la multiplication du second membre par 10 est donc tout à fait recevable autant pour moi
11/01/2022, 17h00
APL-AML

Règles de déroulement d’une épreuve équestre
Extrait du billet que je consacre à ce sujet : mon billet est en cours de rédaction. Synthétiser la discussion va me prendre... un certain temps.

§ 1. La problématique
Citation:
Envoyé par maxime_nrgt

Bonjour,

Je cherche à développer sous Excel un algorithme me permettant d'établir l'ordre de passage d'un concours d'équitation.

Je souhaiterais avoir un algorithme en "français".

J'ai essayé de le créer moi-même mais sans y parvenir. En effet, les conditions pour créer cet ordre de passage sont assez complexes.

Règles de déroulement d’une épreuve équestre

Lors des concours équestres, il y a plusieurs épreuves (telles que des courses, des parcours de saut d'obstacles à différentes hauteurs, etc.).

Les coaches engagent leurs cavaliers dans les différentes épreuves. Ainsi, il peut y avoir 1, 2, 50, 80, 100 inscriptions par épreuves. J'ajoute que je ne recherche pas à faire un ordre sur l'ensemble du concours, mais uniquement sur l’une des épreuves du concours.

Les règles sur l’ensemble du concours et la question de l’heure de passage pour une épreuve ne sont pas concernées ici.

Sur l'ensemble du concours (pour information seulement) :

un cheval ne pourra faire que 3 tours maximum,
et un cavalier ne pourra faire que 5 tours maximum,
on doit savoir si un cheval n'a pas participé à une autre épreuve avant de le faire concourir dans une épreuve « pour qu'il puisse récupérer »,
idem pour un cavalier.

Sur une même épreuve :

un même couple (cheval/cavalier) ne peut participer qu'une seule fois,
Un cavalier ne monte pas forcément 3 chevaux et il peut y avoir autant de chevaux que de cavaliers,
un cavalier peut concourir jusqu’à 3 fois avec des chevaux différents ; il ne peut donc pas passer 3 fois d'affilé (sauf s’il est tout seul...), puisque celui-ci doit s'échauffer avec son cheval avant chaque passage,
Un cheval peut être monté jusqu’à 3 fois par des cavaliers différents mais ne peut pas passer deux fois d'affilé (sauf si c’est le même cheval pour tous les cavaliers...), puisque celui-ci doit également pouvoir récupérer entre deux passages avec des cavaliers différents.

Ces conditions ne peuvent s'appliquer que lorsqu'il y a un nombre de participants et de chevaux par épreuve assez conséquent. D’où mon souhait d’automatiser ce casse-tête que j'ai à faire à chaque concours...

J'espère vous avoir apporté suffisamment de précisions pour m'aider.

Je vous remercie pour votre aide et pour le temps que vous m'accordez !
12/01/2022, 00h00
APL-AML

1 pièce(s) jointe(s)

Comprendre les critères de tri
Citation:

Envoyé par maxime_nrgt

La FFE lors des concours "officiels" crée cet ordre.

J’ai donc extrait du site de la FFE des listes de départ afin de les analyser. J'ai trouvé une "symétrie" sur le nombre de tours que fait chaque cheval. Je te la joins ici. (Voir feuille 1 et 2).

Mais je ne trouve pas encore leur recette "miracle".

Je suis en train de tester la première feuille de 26 passages du fichier Excel de maxime_nrgt et je rencontre un problème avec le cheval CEKORIA DES BERTAINES qui apparait deux fois consécutives. Cela se passe au moment où le N_ORDRE passe de 12 à 13.

Je croyais à tort avoir résolu le problème.

Ceux que le sujet intéresse peuvent faire comme moi, télécharger le fichier Excel test_ffe.xlsx de maxime_nrgt (#32). Comme pour son premier jeu d’essai, j’ai coloré de façon différente les cavaliers montant plusieurs chevaux et les chevaux montés par plusieurs cavaliers.

Je ne remets pas en question la façon de renseigner N_CAVALIER et N_CHEVAL, par contre j’ai changé mes critères de tri pour renseigner N_CHEVAL… pour voir : en majeur sur NOM_CHEVAL et en mineur sur N_CAVALIER (au lieu de NOM_CAVALIER). Cela change les valeurs de N_ORDRE et je n’ai plus ni cavaliers, ni chevaux avec deux passages consécutifs.

Il faut comprendre quels critères de tri permettent de fiabiliser le résultat, et pourquoi.

Dommage que l’on n’ait pas eu ce fichier Excel plus tôt.

Il me reste à tester la deuxième feuille de 33 passages. Cette problématique est de plus en plus captivante.

PS : D’après le fichier Excel de la FFE, l’ordre de passage des deux épreuves ne révèlent aucune recette miracle. La FFE organise tout simplement l’ordre de passage des épreuves à la mimine.

Fichier Excel test_ffe.xlsx de maxime_nrgt ()

Ce fichier n’est pas particulièrement sophistiqué, les colonnes ne sont même pas titrées.

On peut cependant savoir facilement ce qu’elles représentent :
- N°_PASSAGE
- NOM_CAVALIER
- NOM_CHEVAL
- NB_TOURS_CAVALIER
- NB_TOURS_CHEVAL
Je note toutefois une erreur de NB_TOURS_CAVALIER pour CYRIELLE LH (1 au lieu de 2).

En marge de ces colonnes, sont renseignées pour chaque tour (1, 2, 3), le nombre de cavaliers et de chevaux inscrits.

Ainsi :
- 4 cavaliers font 1 tour, 11 cavaliers font 2 tours et aucun cavalier ne fait 3 tours,
- 2 chevaux font 1 tour, aucun cheval ne fait 2 tours et 8 chevaux font 3 tours.
Ce 13/01/2022 Les dernières nouvelles du front !
- Ajout d’une colonne NB_TOURS à trier en majeur du plus grand au plus petit.
  
  L’objectif de cette colonne est double :
  - imposer une priorité de passage aux couples cavalier/cheval selon leur nombre de passages dans l’épreuve,
  - créer un identifiant unique "NB_TOURS - N_ORDRE".
  L’algorithme est simple : NB_TOURS = N_CAVALIER + N_CHEVAL
  
  Ce critère de priorité n’a pas été évoqué par maxime_nrgt dans ses règles de déroulement d’une épreuve mais me parait pertinent dans l’établissement de l’ordre de passage.
  
  Un même "NOM_CAVALIER - N_ORDRE" ne peut appartenir qu'à un seul NB_TOURS.
  
  Le renseignement de cette nouvelle colonne constitue désormais la 4ème étape du processus et l’étape « Numéroter N°_PASSAGE » devient la 5ème étape.
- Le nom de la colonne N_PASSAGE devient N°_PASSAGE.
  
  N = Numéro
  NB = Nombre
  N° = Numéro d’ordre
- La colonne N°_PASSAGE_FFE est conservée (afin de pouvoir être comparée avec la nouvelle colonne N°_PASSAGE après application des trois critères de tri :
  1. N°_PASSAGE (Du plus grand au plus petit)
  2. N_ORDRE (Du plus petit au plus grand)
  3. NOM_CAVALIER (De A à Z)
  Les deux premiers critères de tri suffisent pour garantir l'unicité, l’ajout du troisième critère NOM_CAVALIER ajoute un ordre alphabétique à un ensemble NB_TOURS.
- Les colonnes NB_TOURS_CAVALIER et NB_TOURS_CHEVAL de la FFE ont été transférées à gauche du tableau, à côté de la colonne N°_PASSAGE_FFE.
  
  Ces colonnes ont été conservées au cas où la FFE serait destinataire de mon fichier Excel.
- Les cellules ont été colorisées pour visualiser et vérifier le classement.
- Les deux épreuves de la FFE sur la même feuille de calcul ont été séparées en deux feuilles :
  - 26 inscriptions
  - 33 inscriptions
- Le fait que deux passages d’un cavalier ou d’un cheval puissent être trop rapprochés, dépend du nombre de couples NOM_CAVALIER/NOM_CHEVAL.
  
  Rappel du Règlement : "Ces conditions ne peuvent s'appliquer que lorsqu'il y a un nombre de participants et de chevaux par épreuve assez conséquent."
Ci-joint le fichier Excel issu du fichier original "test_ffe.xlsx" : Pièce jointe 611819

Voir 40 message(s) de cette discussion en une page