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 |
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
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
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
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 !
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 » :
Il était du niveau de mon Devoir de vacances :
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É].
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 !
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 !
Ci-joint le fichier Excel issu du fichier original "test_ffe.xlsx" : Pièce jointe 611819