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 excelEnvoyé par Mat.M
Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter
Discussion :
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
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.
Cavalier_A Cheval_A Cavalier_A Cheval_B Cavalier_A Cheval_C Cavalier_B Cheval_D Cavalier_C Cheval_D Cavalier_D Cheval_D Cavalier_E Cheval_E Cavalier_E Cheval_F Cavalier_F Cheval_G
c'est ce que je viens de me rendre compte en faisant plusieurs essais hélas.
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 ?
Version pédagogique avec un jeu d’essai plus complet
■ ■ ■ 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"
Cavalier_A Cheval_A Cavalier_A Cheval_B Cavalier_A Cheval_C Cavalier_B Cheval_D Cavalier_C Cheval_D Cavalier_D Cheval_D Cavalier_E Cheval_E Cavalier_E Cheval_F Cavalier_F Cheval_G Cavalier_G Cheval_A Cavalier_HG Cheval_C Cavalier_H Cheval_E Cavalier_I Cheval_F
§ 2. 2ème étape
Tri : N_CAVALIER, N_CHEVAL
- Affecter un N_ORDRE (2) croissant de 1 à n aux cavaliers montant plusieurs chevaux
Cavalier_A Cheval_A Cavalier_A Cheval_B Cavalier_A Cheval_C Cavalier_B Cheval_D Cavalier_C Cheval_D Cavalier_D Cheval_D Cavalier_E Cheval_E Cavalier_E Cheval_F Cavalier_F Cheval_G Cavalier_G Cheval_A Cavalier_H Cheval_C Cavalier_H Cheval_E Cavalier_I Cheval_F
§ 3. 3ème étape
Tri : N_CHEVAL, N_CAVALIER
- Affecter un N_ORDRE (3) croissant aux chevaux montés par plusieurs cavaliers
Cavalier_A Cheval_A Cavalier_G Cheval_A Cavalier_A Cheval_B Cavalier_A Cheval_C Cavalier_H Cheval_C Cavalier_B Cheval_D Cavalier_C Cheval_D Cavalier_D Cheval_D Cavalier_E Cheval_E Cavalier_H Cheval_E Cavalier_E Cheval_F Cavalier_I Cheval_F Cavalier_F Cheval_G
§ 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)
Cavalier_A Cheval_A Cavalier_G Cheval_A Cavalier_A Cheval_B Cavalier_A Cheval_C Cavalier_H Cheval_C Cavalier_B Cheval_D Cavalier_C Cheval_D Cavalier_D Cheval_D Cavalier_E Cheval_E Cavalier_H Cheval_E Cavalier_E Cheval_F Cavalier_I Cheval_F Cavalier_F Cheval_G
§ 5. 5ème étape
Tri : N_ORDRE, N_CAVALIER, N_CHEVAL
- Numéroter N_PASSAGE
Cavalier_A Cheval_A Cavalier_B Cheval_D Cavalier_E Cheval_E Cavalier_F Cheval_G Cavalier_A Cheval_B Cavalier_C Cheval_D Cavalier_E Cheval_F Cavalier_G Cheval_A Cavalier_H Cheval_E Cavalier_A Cheval_C Cavalier_D Cheval_D Cavalier_I Cheval_F Cavalier_H Cheval_C
§ 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
Je viens de mettre à éxécution l'algorithme, cependant, je me retrouve avec un même cavalier passant deux fois.
cf pièce jointe
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".cependant, le problème a été résolu pus haut avec les 4 tableaux. je dois maintenant transformer cet algorithme sous excel
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.
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
Je viens de mettre tout cet algorithme sous code excel, cependant, des cavaliers apparaissent deux fois d'affilé dans l'ordre final de passage :/
N_ORDRE = Concaténation de N_CAVALIER et N_CHEVAL
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.
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.
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.
§ 1. Visualisation■ ■ ■ 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
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
Affecter un N_CAVALIER croissant de 1 à n aux cavaliers montant plusieurs chevaux
Cavalier_A Cheval_A Cavalier_A Cheval_B Cavalier_A Cheval_C Cavalier_B Cheval_D Cavalier_C Cheval_D Cavalier_D Cheval_D Cavalier_E Cheval_E Cavalier_E Cheval_F Cavalier_F Cheval_G Cavalier_G Cheval_A Cavalier_H Cheval_C Cavalier_H Cheval_E Cavalier_I Cheval_F
§ 1.2. 2ème étape : Renseigner N_CHEVAL
Tri : NOM_CHEVAL, NOM_CAVALIER
Cavalier_A Cheval_A Cavalier_G Cheval_A Cavalier_A Cheval_B Cavalier_A Cheval_C Cavalier_H Cheval_C Cavalier_B Cheval_D Cavalier_C Cheval_D Cavalier_D Cheval_D Cavalier_E Cheval_E Cavalier_H Cheval_E Cavalier_E Cheval_F Cavalier_I Cheval_F Cavalier_F Cheval_G
§ 1.3. 3ème étape : Renseigner N_ORDRE
Tri : NOM_CHEVAL, NOM_CAVALIER
Cavalier_A Cheval_A Cavalier_G Cheval_A Cavalier_A Cheval_B Cavalier_A Cheval_C Cavalier_H Cheval_C Cavalier_B Cheval_D Cavalier_C Cheval_D Cavalier_D Cheval_D Cavalier_E Cheval_E Cavalier_H Cheval_E Cavalier_E Cheval_F Cavalier_I Cheval_F Cavalier_F Cheval_G
§ 1.4. 4ème étape : Numéroter N_PASSAGE
Tri : N_ORDRE, NOM_CAVALIER
Cavalier_A Cheval_A Cavalier_B Cheval_D Cavalier_E Cheval_E Cavalier_F Cheval_G Cavalier_C Cheval_D Cavalier_G Cheval_A Cavalier_H Cheval_C Cavalier_I Cheval_F Cavalier_D Cheval_D Cavalier_A Cheval_B Cavalier_E Cheval_F Cavalier_H Cheval_E Cavalier_A Cheval_C
§ 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
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
§ 2.2. Version N° 2
N_ORDRE = (N_CHEVAL * 10) + N_ CAVALIER
Tri : N_ORDRE, NOM_CAVALIER
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
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
Les étapes de ma réflexion
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.
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
§ 3.2. Algorigramme N_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 │ ϕ │ └─────────────────────────────┘
► Tri : NOM_CHEVAL, NOM_CAVALIER
§ 3.3. Algorigramme N_ORDRE = N_CAVALIER * 10) + N_CHEVAL┌─────────────────────────────┐ 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 │ ϕ │ └─────────────────────────────┘
► Tri : NOM_CHEVAL, NOM_CAVALIER
§ 3.4. Algorigramme NB_TOURS = N_CAVALIER + N_CHEVAL┌─────────────────────────────┐ D-PROG │ ϕ │ └──────────────┬──────────────┘ │◄─────────────────┐ ┌──────────────┴──────────────┐ │ T_NOM_CHEVAL │N_ORDRE = (N_CAVALIER*10) + 1│ │ │ PRINT N_ORDRE │ │ └──────────────┬──────────────┘ │ ●──────────────────┘ ┌──────────────┴──────────────┐ F-PROG │ ϕ │ └─────────────────────────────┘
► 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 BLOGOrdre de passage d'une épreuve de concours équestre
Il était du niveau de mon Devoir de vacances :
Discussion
[ACTUALITÉ]
BILLET de BLOG
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
comprend tu mieux le problème qu'il peut se produire11 +10*10 = 111
1 +11*10 = 111
je dis cela, je dis rien ...
N_CAVALIER et N_CHEVAL ne sont pas des identifiants
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É].
l'algorithme je l'avais compris depuis longtemps
j'ai simplement oublié les limite qui son imposé
j'avais en tête ceci :
et oublié la limite fixe pour les cavaliers1 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
Effectivement, on ne pourra pas, dans cette configuration, dépasser.1 cavalier ne peut monter que 5 fois par concours
la multiplication du second membre par 10 est donc tout à fait recevable autant pour moi
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
Comprendre les critères de tri
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 (#32)
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 :
- N°_PASSAGE (Du plus grand au plus petit)
- N_ORDRE (Du plus petit au plus grand)
- 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" : Concours équestre (FFE).xlsx
Répondre avec citation
Partager