Au Pied Levé - À Main Levée

Exercice corrigé d’algorithmique (Force 6/7)

Public :

• étudiants
• débutants
• utilisateurs Excel
• et pourquoi pas, enseignants

Contenu :

• la logique séquentielle
• la logique combinatoire
• la structure itérative
• la structure alternative
• la structure complexe

TUTORIEL

Ordre de passage d'une épreuve de concours équestre

■ ■ ■ SOMMAIRE DU BILLET ■ ■ ■

AVANT-PROPOS

1. La problématique
2. la logique séquentielle
   
   1. 1ère étape : Renseigner N_CAVALIER
   2. 2ème étape : Renseigner N_CHEVAL
   3. 3ème étape : Renseigner N_ORDRE
   4. 4ème étape : Renseigner NB_TOURS
   5. 5ème étape : Renseigner N°_PASSAGE
   6. Algorigramme général
3. Fonctionnalité « INTERVALLE »
   
   1. ALGORIGRAMME INTER_CAVALIER
   2. ALGORIGRAMME INTER_CHEVAL
   3. ALGORITHMES
4. Remerciements
5. ANNEXES
   
   1. Ordre de passage de la 1ère épreuve (FFE)
   2. Ordre de passage de la 2ème épreuve (FFE)
   3. Tutoriel
6. COMMENTAIRES
   
   1. La logique séquentielle
   2. Logique combinatoire vs Logique séquentielle
   3. Démarche Top-down vs Démarche Bottom-up

§ ■ AVANT-PROPOS

• Présentation du sujet et du type de document
  
  Ce billet s’inspire de la discussion sur le Forum Algorithmes et structures de données :
  
  
  Algorithme pour établir un ordre de passage
  
  Cette discussion s’est développée dans deux directions, l’une algorithmique et l’autre philosophique voire psychologique. La démarche algorithmique s’étant affinée en plusieurs étapes, ce tutoriel synthétise pédagogiquement ces étapes.
  
  L’algorithme de cet exercice se distingue par deux originalités :
  
  
  • Il s’inspire de la logique séquentielle et non de la logique combinatoire,
  • Il résout la problématique à lui seul sans qu’il soit nécessaire de coder.
  
  
• Motivations et raisons ayant poussé à étudier le sujet
  
  La problématique de maxime_nrgt a constitué un défi passionnant à la logique informaticienne :
  
  
  • en opposant la réflexion méthodique, cartésienne à la réflexion inventive, intuitive,
  • en opposant la pensée rationnelle à la pensée out of the box,
  • en opposant la logique combinatoire à la logique séquentielle,
  • en opposant la démarche top-down à la démarche bottom-up.
  
  Ce n’est pas la même chose d’adapter la problématique à sa technicité et adapter sa technicité à la problématique.
  
  
• Précision de l’objectif poursuivi
  
  Faciliter la compréhension de la démarche algorithmique adoptée au cours de la discussion en publiant une synthèse pédagogique sous forme de Billet et de Tutoriel Word.
  
  Ci-joint la version Word au format "PDF" qui a servi de support à la publication de ce billet :
  
  
  [TUTORIEL] Ordre de passage d'une épreuve de concours équestre.PDF
  
  Ce Tutoriel Word comprend 20 pages. Les items du menu sont dotés de liens hypertextes vers leurs paragraphes respectifs. En bas de page, deux liens hypertextes permettent de revenir soit au « SOMMAIRE », soit à la première page du tutoriel.
  
  PS : La version "PDF" de ce Tutoriel Word permet une utilisation plus facile des liens hypertextes.
  
  
• Difficultés rencontrées
  
  La discussion a mis en évidence la disparité des démarches entreprises par les intervenants. Cette disparité a donné matière à l’analyse des interventions d'un point de vue philosophique et psychologique. Bien que très instructive, cette analyse n’a pas forcément été bien perçue par les protagonistes pourtant pris en flagrant délit d’égarement.
  
  Cet aspect de la discussion fait l’objet d’un billet spécifique dans mon blog logique FORUMS :
  
  
  [Discussion] Ordre de passage d'une épreuve de concours équestre

---

§ 1. La problématique

Envoyé par maxime_nrgt

Bonjour,

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

Je n’attends pas particulièrement du code Excel prêt à l’emploi mais juste un algorithme en bon langage français pour établir cet ordre de passage. 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 (cavalier/cheval) ne peut participer qu'une seule fois,
• 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 pouvoir 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,
• Un cavalier ne monte pas forcément 3 chevaux et il peut y avoir autant de chevaux que de cavaliers.

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 !

Maxime_nrgt

---

§ 2. Logique séquentielle

L’ordre de passage d’une épreuve de concours équestre ne peut pas s’obtenir par un algorithme d’équivalence entre l’état des entrées et l’état des sorties. En se référant à quels attributs, d’ailleurs ?

Quel qu’il soit, un passage doit bien se situer chronologiquement par rapport aux autres, en respectant les contraintes du règlement. Or on ne dispose que d’une liste d’inscriptions cavaliers-chevaux, soit une seule table constituée de deux attributs. Pas la moindre petite relation entre deux entités. Il est donc impossible de réfléchir « Modèle Conceptuel des Données » ainsi qu’on nous l’enseigne. Par ailleurs, cette seule table est dépourvue d’identifiant, un non-sens pour les informaticiens que nous sommes ! La problématique se situe hors cadre habituel et déroute la réflexion classique d’une démarche de développement Top-down fondée sur la logique combinatoire.

Le Fichier Logique d’Entrée (FLE), tel qu’il est constitué - Inscriptions cavaliers-chevaux - mène la réflexion dans une impasse. C’est le signe d’un FLE inadéquat, qui nécessite d’être enrichi de nouveaux attributs efficients. La démarche consiste donc à créer ces nouveaux attributs en adoptant la logique séquentielle associée à la démarche de développement Bottom-up.

L’Algorithmique séquentielle ou logique séquentielle correspond à la conception d’une succession d’étapes appelées sous-états dont chacun est en interaction avec les sous-états qui le précèdent. L’algorithmique séquentielle conçoit, construit cette interdépendance entre les sous-états.

Contrairement à la logique combinatoire dont les résultats sont fonction et seulement fonction des données traitées dans l'instant, la logique séquentielle est un type de logique dont les résultats ne dépendent pas seulement des données traitées dans l'instant mais aussi des données traitées précédemment.

■ Une logique en 3D

La 1ère dimension : C’est l’état initial. Les attributs sont statiques. Ils sont considérés tels qu’ils existent dans la BDD. On parle de logique combinatoire.

La 2ème dimension : C’est l’ordre de tri. C’est le mouvement, la dynamique ; les items sont traités dans un ordre chronologique déterminé.

La 3ème dimension : C’est le temps. L’état suggère qu’au temps T+1, un nouvel attribut à valoriser constitue une étape vers la solution.

La logique séquentielle consiste à visualiser la BDD en cours de construction.

Dans le cas de la problématique "Ordre de passage d’une épreuve de concours équestre", chaque nouvelle étape vers son État Futur d’Achèvement conceptualise un nouvel attribut exploitant les sorties des états précédents.

■ Les étapes

1ère étape : N_CAVALIER

À l’évidence, un cavalier pouvant monter jusqu’à trois chevaux au cours de la même épreuve, il est nécessaire d’identifier chaque passage du cavalier. Un nouvel attribut N_CAVALIER pouvant prendre les valeurs de 1 à 3 doit donc être associé à chaque cavalier.

2ème étape : N_CHEVAL

De même, un cheval pouvant être monté par trois cavaliers différents au cours de la même épreuve, il est nécessaire d’identifier chaque passage du cheval. Un nouvel attribut N_CHEVAL pouvant prendre les valeurs de 1 à 3 doit donc être associé à chaque cheval.

3ème étape : N_ORDRE

Pour un même cavalier ou un même cheval, un passage N_CAVALIER / N_CHEVAL ne peut exister qu’une seule fois et les seules combinaisons possibles sont : 11, 12, 13, 21, 22, 23, 31, 32, 33.

Associé à chaque passage, un nouvel attribut N_ORDRE (constitué par concaténation de N_CAVALIER avec N_CHEVAL et trié en ordre croissant) affichera d’abord les passages N° 1, puis les passages N° 2 et enfin les passages N° 3.

4ème étape : NB_TOURS

Afin d’imposer une priorité d’ordre de passage, un nouvel attribut "NB_TOURS = N_CAVALIER + N_CHEVAL" trié en majeur par ordre décroissant va permettre de privilégier chronologiquement les cavaliers et chevaux concourant plusieurs fois.

§ 2.1. 1ère étape : Renseigner N_CAVALIER

Objectif :

• Affecter un N_CAVALIER croissant de 1 à 3 aux cavaliers montant plusieurs chevaux afin de créer un identifiant unique « NOM_CAVALIER - N_CAVALIER »
• Repérer par des cellules de couleurs différentes les cavaliers montant plusieurs chevaux.

Sélection rapide du tableau : Sélectionner n’importe quelle cellule du tableau puis "Ctrl/*"

Tri : NOM_CAVALIER, NOM_CHEVAL

N°_PASSAGE	NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE	NB_TOURS
	ANAIS MI	LINDWUDE RHIA	1
	CECILE EN	CEKORIA DES BERTAINES	1
	CECILE EN	DAPPLE RASI	2
	CLARA CO	BLACK LASS	1
	CLARA CO	VOYELLE DE LAVARDIN	2
	CYRIELLE L H	BLACK LASS	1
	CYRIELLE L H	DAPPLE RASI	2
	EMILIE KO	ARAGONE DU MOULIN	1
	EMILIE KO	SULTAN DE FOURNIERE	2
	EUGENIE DE	ATLANTIC WHITE HEATHER	1
	EUGENIE DE	DAPPLE RASI	2
	EUGENIE DU	SOOLMOY POLLY	1
	EUGENIE DU	SULTAN DE FOURNIERE	2
	LENA CA	ARAGONE DU MOULIN	1
	LENA CA	ATLANTIC WHITE HEATHER	2
	LILOU MA	CEKORIA DES BERTAINES	1
	LILOU MA	VOYELLE DE LAVARDIN	2
	MARINE FA	STAUFEN	1
	MARINE HA	ARAGONE DU MOULIN	1
	MARINE HA	BLACK LASS	2
	MORGANE GR	CEKORIA DES BERTAINES	1
	MORGANE GR	SOOLMOY POLLY	2
	SUZANNE RA	ATLANTIC WHITE HEATHER	1
	SUZANNE RA	VOYELLE DE LAVARDIN	2
	VALENTINE MI	SOOLMOY POLLY	1
	VALENTINE MI	SULTAN DE FOURNIERE	2

                                   ┌─────────────────────────────┐
                            D-PROG │   NOM_CAVALIER (˄)          │
                                   │   NOM_CHEVAL   (˄)          │
                                   ├─────────────────────────────┤
                                   │   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 │              ϕ              │
                                   └─────────────────────────────┘

---

§ 2.2. 2ème étape : Renseigner N_CHEVAL

Objectif :

• Affecter un N_CHEVAL croissant de 1 à 3 aux chevaux montés par plusieurs cavaliers afin de créer un identifiant unique « NOM_CHEVAL - N_CHEVAL »
• Repérer par des cellules de couleurs différentes les chevaux montés par plusieurs cavaliers.

Tri : NOM_CHEVAL, NOM_CAVALIER

N°_PASSAGE	NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE	NB_TOURS
	EMILIE KO	ARAGONE DU MOULIN	1	1
	LENA CA	ARAGONE DU MOULIN	1	2
	MARINE HA	ARAGONE DU MOULIN	1	3
	EUGENIE DE	ATLANTIC WHITE HEATHER	1	1
	SUZANNE RA	ATLANTIC WHITE HEATHER	1	2
	LENA CA	ATLANTIC WHITE HEATHER	2	3
	CLARA CO	BLACK LASS	1	1
	CYRIELLE L H	BLACK LASS	1	2
	MARINE HA	BLACK LASS	2	3
	CECILE EN	CEKORIA DES BERTAINES	1	1
	LILOU MA	CEKORIA DES BERTAINES	1	2
	MORGANE GR	CEKORIA DES BERTAINES	1	3
	CECILE EN	DAPPLE RASI	2	1
	CYRIELLE L H	DAPPLE RASI	2	2
	EUGENIE DE	DAPPLE RASI	2	3
	ANAIS MI	LINDWUDE RHIA	1	1
	EUGENIE DU	SOOLMOY POLLY	1	1
	VALENTINE MI	SOOLMOY POLLY	1	2
	MORGANE GR	SOOLMOY POLLY	2	3
	MARINE FA	STAUFEN	1	1
	EMILIE KO	SULTAN DE FOURNIERE	2	1
	EUGENIE DU	SULTAN DE FOURNIERE	2	2
	VALENTINE MI	SULTAN DE FOURNIERE	2	3
	CLARA CO	VOYELLE DE LAVARDIN	2	1
	LILOU MA	VOYELLE DE LAVARDIN	2	2
	SUZANNE RA	VOYELLE DE LAVARDIN	2	3

                                   ┌─────────────────────────────┐
                            D-PROG │   NOM_CHEVAL   (˄)          │
                                   │   NOM_CAVALIER (˄)          │
                                   ├─────────────────────────────┤
                                   │     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 │              ϕ              │
                                   └─────────────────────────────┘

---

§ 2.3. 3ème étape : Renseigner N_ORDRE

Objectif :

• Créer un nuéro d'ordre « N_CAVALIER - N_CHEVAL » pour chaque candidature NOM_CAVALIER - NOM_CHEVAL
• N_ORDRE = concaténation N_CAVALIER et N_CHEVAL = ((N_CAVALIER * 10) + N_CHEVAL)

Tri : NOM_CHEVAL, NOM_CAVALIER

(l’ordre de tri n’a en fait pas d’importance car la logique est une logique combinatoire)

ƒx : =PRODUIT(G2;10)+H2

N°_PASSAGE	NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE	NB_TOURS
	EMILIE KO	ARAGONE DU MOULIN	1	1	11
	LENA CA	ARAGONE DU MOULIN	1	2	12
	MARINE HA	ARAGONE DU MOULIN	1	3	13
	EUGENIE DE	ATLANTIC WHITE HEATHER	1	1	11
	SUZANNE RA	ATLANTIC WHITE HEATHER	1	2	12
	LENA CA	ATLANTIC WHITE HEATHER	2	3	23
	CLARA CO	BLACK LASS	1	1	11
	CYRIELLE L H	BLACK LASS	1	2	12
	MARINE HA	BLACK LASS	2	3	23
	CECILE EN	CEKORIA DES BERTAINES	1	1	11
	LILOU MA	CEKORIA DES BERTAINES	1	2	12
	MORGANE GR	CEKORIA DES BERTAINES	1	3	13
	CECILE EN	DAPPLE RASI	2	1	21
	CYRIELLE L H	DAPPLE RASI	2	2	22
	EUGENIE DE	DAPPLE RASI	2	3	23
	ANAIS MI	LINDWUDE RHIA	1	1	11
	EUGENIE DU	SOOLMOY POLLY	1	1	11
	VALENTINE MI	SOOLMOY POLLY	1	2	12
	MORGANE GR	SOOLMOY POLLY	2	3	23
	MARINE FA	STAUFEN	1	1	11
	EMILIE KO	SULTAN DE FOURNIERE	2	1	21
	EUGENIE DU	SULTAN DE FOURNIERE	2	2	22
	VALENTINE MI	SULTAN DE FOURNIERE	2	3	23
	CLARA CO	VOYELLE DE LAVARDIN	2	1	21
	LILOU MA	VOYELLE DE LAVARDIN	2	2	22
	SUZANNE RA	VOYELLE DE LAVARDIN	2	3	23

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

---

§ 2.4. 4ème étape : Renseigner NB_TOURS

Objectif :

• Imposer une priorité dans l’ordre de passage.
• NB_TOURS = (N_CAVALIER + N_CHEVAL)

Tri : NOM_CHEVAL, NOM_CAVALIER

(l’ordre de tri n’a en fait pas d’importance car la logique est une logique combinatoire)

ƒx : =SOMME(G2;H2)

N°_PASSAGE	NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE	NB_TOURS
	EMILIE KO	ARAGONE DU MOULIN	1	1	11	2
	LENA CA	ARAGONE DU MOULIN	1	2	12	3
	MARINE HA	ARAGONE DU MOULIN	1	3	13	4
	EUGENIE DE	ATLANTIC WHITE HEATHER	1	1	11	2
	SUZANNE RA	ATLANTIC WHITE HEATHER	1	2	12	3
	LENA CA	ATLANTIC WHITE HEATHER	2	3	23	5
	CLARA CO	BLACK LASS	1	1	11	2
	CYRIELLE L H	BLACK LASS	1	2	12	3
	MARINE HA	BLACK LASS	2	3	23	5
	CECILE EN	CEKORIA DES BERTAINES	1	1	11	2
	LILOU MA	CEKORIA DES BERTAINES	1	2	12	3
	MORGANE GR	CEKORIA DES BERTAINES	1	3	13	4
	CECILE EN	DAPPLE RASI	2	1	21	3
	CYRIELLE L H	DAPPLE RASI	2	2	22	4
	EUGENIE DE	DAPPLE RASI	2	3	23	5
	ANAIS MI	LINDWUDE RHIA	1	1	11	2
	EUGENIE DU	SOOLMOY POLLY	1	1	11	2
	VALENTINE MI	SOOLMOY POLLY	1	2	12	3
	MORGANE GR	SOOLMOY POLLY	2	3	23	5
	MARINE FA	STAUFEN	1	1	11	2
	EMILIE KO	SULTAN DE FOURNIERE	2	1	21	3
	EUGENIE DU	SULTAN DE FOURNIERE	2	2	22	4
	VALENTINE MI	SULTAN DE FOURNIERE	2	3	23	5
	CLARA CO	VOYELLE DE LAVARDIN	2	1	21	3
	LILOU MA	VOYELLE DE LAVARDIN	2	2	22	4
	SUZANNE RA	VOYELLE DE LAVARDIN	2	3	23	5

                                   ┌─────────────────────────────┐
                            D-PROG │   NOM_CHEVAL   (˄)          │
                                   │   NOM_CAVALIER (˄)          │
                                   ├─────────────────────────────┤
                                   │              ϕ              │
                                   └──────────────┬──────────────┘
                                                  │◄─────────────────┐
                                   ┌──────────────┴──────────────┐   │
                      T_NOM_CHEVAL │NB_TOURS=N_CAVALIER+N_CHEVAL │   │
                                   │       PRINT N_ORDRE         │   │
                                   └──────────────┬──────────────┘   │
                                                  ●──────────────────┘
                                   ┌──────────────┴──────────────┐
                            F-PROG │              ϕ              │
                                   └─────────────────────────────┘

---

§ 2.5. 5ème étape : Renseigner N°_PASSAGE

Objectif :

• Déterminer l’ordre de passage de chaque candidature cavalier-cheval.

Tri : NB_TOURS (ordre décroissant), N_ORDRE (ordre croissant), NOM_CAVALIER ou NOM_CHEVAL (ordre croissant)).

Le troisième critère évite la possibilité d’avoir deux passages consécutifs ou trop rapprochés d’un cavalier ou d’un cheval, à la jointure de deux groupes N_ORDRE / NB_TOURS.

Le choix de ce troisième critère (NOM_CAVALIER ou NOM_CHEVAL) dépend du nombre de cavaliers montant plusieurs chevaux et du nombre de chevaux montés par plusieurs cavaliers. Il semble pertinent de choisir celui des deux avec le plus grand nombre de passages.

ƒx : =SOMME(D3;1)

Coller les valeurs sans leurs formules :

• Sélectionner les N°_passage (1 à n)
• Copier la sélection (Ctrl/C)
• Clic droit (ouverture du menu contextuel "Options de collage")
• Coller les valeurs sans leurs formules (123 : valeur (V))

N°_PASSAGE	NOM_CAVALIER	NOM_CHEVAL	N_CAVALIER	N_CHEVAL	N_ORDRE	NB_TOURS
1	EUGENIE DE	DAPPLE RASI	2	3	23	5
2	LENA CA	ATLANTIC WHITE HEATHER	2	3	23	5
3	MARINE HA	BLACK LASS	2	3	23	5
4	MORGANE GR	SOOLMOY POLLY	2	3	23	5
5	SUZANNE RA	VOYELLE DE LAVARDIN	2	3	23	5
6	VALENTINE MI	SULTAN DE FOURNIERE	2	3	23	5
7	MARINE HA	ARAGONE DU MOULIN	1	3	13	4
8	MORGANE GR	CEKORIA DES BERTAINES	1	3	13	4
9	CYRIELLE L H	DAPPLE RASI	2	2	22	4
10	EUGENIE DU	SULTAN DE FOURNIERE	2	2	22	4
11	LILOU MA	VOYELLE DE LAVARDIN	2	2	22	4
12	CYRIELLE L H	BLACK LASS	1	2	12	3
13	LENA CA	ARAGONE DU MOULIN	1	2	12	3
14	LILOU MA	CEKORIA DES BERTAINES	1	2	12	3
15	SUZANNE RA	ATLANTIC WHITE HEATHER	1	2	12	3
16	VALENTINE MI	SOOLMOY POLLY	1	2	12	3
17	CECILE EN	DAPPLE RASI	2	1	21	3
18	CLARA CO	VOYELLE DE LAVARDIN	2	1	21	3
19	EMILIE KO	SULTAN DE FOURNIERE	2	1	21	3
20	ANAIS MI	LINDWUDE RHIA	1	1	11	2
21	CECILE EN	CEKORIA DES BERTAINES	1	1	11	2
22	CLARA CO	BLACK LASS	1	1	11	2
23	EMILIE KO	ARAGONE DU MOULIN	1	1	11	2
24	EUGENIE DE	ATLANTIC WHITE HEATHER	1	1	11	2
25	EUGENIE DU	SOOLMOY POLLY	1	1	11	2
26	MARINE FA	STAUFEN	1	1	11	2

                                   ┌─────────────────────────────┐
                            D-PROG │   NB_TOURS     (˅)          │
                                   │   N_ORDRE      (˄)          │
                                   │   NOM_CAVALIER (˄)          │
                                   ├─────────────────────────────┤
                                   │       N°_PASSAGE = 0        │
                                   └──────────────┬──────────────┘
                                                  │◄─────────────────┐
                                   ┌──────────────┴──────────────┐   │
                      T_N°_PASSAGE │ N°_PASSAGE = N°_PASSAGE + 1 │   │
                                   │      PRINT N°_PASSAGE       │   │
                                   └──────────────┬──────────────┘   │
                                                  ●──────────────────┘
                                   ┌──────────────┴──────────────┐
                            F-PROG │              ϕ              │
                                   └─────────────────────────────┘

---

§ 2.6. Algorigramme général

                                   ┌─────────────────────────────┐
                            D-PROG │   NOM_CAVALIER (˄)          │
                                   │   NOM_CHEVAL   (˄)          │
                                   ├─────────────────────────────┤
                      D-ETAPE N° 1 │   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-ETAPE N° 1 │              ϕ              │
                                   ├─────────────────────────────┤
                      D-ETAPE N° 2 │   NOM_CHEVAL   (˄)          │
                                   │   NOM_CAVALIER (˄)          │
                                   ├─────────────────────────────┤
                                   │     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-ETAPE N° 2 │              ϕ              │
                                   ├─────────────────────────────┤
                      D-ETAPE N° 3 │   NOM_CHEVAL   (˄)          │
                                   │   NOM_CAVALIER (˄)          │
                                   ├─────────────────────────────┤
                      D_NOM_CHEVAL │              ϕ              │
                                   └──────────────┬──────────────┘
                                                  │◄─────────────────┐
                                   ┌──────────────┴──────────────┐   │
                      T_NOM_CHEVAL │N_ORDRE = (N_CAVALIER*10) + 1│   │
                                   │       PRINT N_ORDRE         │   │
                                   └──────────────┬──────────────┘   │
                                                  ●──────────────────┘
                                   ┌──────────────┴──────────────┐
                      F-NOM_CHEVAL │              ϕ              │
                      F-ETAPE N° 3 │                             │
                                   ├─────────────────────────────┤
                      D-ETAPE N° 4 │   NOM_CHEVAL   (˄)          │
                                   │   NOM_CAVALIER (˄)          │
                                   ├─────────────────────────────┤
                    D_NOM_CAVALIER │              ϕ              │
                                   └──────────────┬──────────────┘
                                                  │◄─────────────────┐
                                   ┌──────────────┴──────────────┐   │
                    T_NOM_CAVALIER │NB_TOURS=N_CAVALIER+N_CHEVAL │   │
                                   │       PRINT N_ORDRE         │   │
                                   └──────────────┬──────────────┘   │
                                                  ●──────────────────┘
                                   ┌──────────────┴──────────────┐
                    F-NOM_CAVALIER │              ϕ              │
                      F-ETAPE N° 4 │                             │
                                   ├─────────────────────────────┤
                      D_ETAPE N° 5 │   NB_TOURS     (˅)          │
                                   │   N_ORDRE      (˄)          │
                                   │   NOM_CAVALIER (˄)          │
                                   ├─────────────────────────────┤
                      D_N°_PASSAGE │       N°_PASSAGE = 0        │
                                   └──────────────┬──────────────┘
                                                  │◄─────────────────┐
                                   ┌──────────────┴──────────────┐   │
                      T_N°_PASSAGE │ N°_PASSAGE = N°_PASSAGE + 1 │   │
                                   │      PRINT N°_PASSAGE       │   │
                                   └──────────────┬──────────────┘   │
                                                  ●──────────────────┘
                                   ┌──────────────┴──────────────┐
                      F_N°_PASSAGE │                             │
                      F_ETAPE N° 5 │              ϕ              │
                            F-PROG │                             │
                                   └─────────────────────────────┘

---

§ 3. Fonctionnalité « INTERVALLE »

Afin d’évaluer la qualité de l’ordre de passage et afin d’informer les cavaliers, deux nouveaux attributs INTER_CAVALIER et INTER_CHEVAL sont ajoutés, calculant le nombre de passages prévus entre deux passages d’un même cavalier ou d’un même cheval pour leur permettre de s’échauffer ou de récupérer.

Ces deux attributs ne sont renseignés que pour les 2èmes et 3èmes passages d’un cavalier et d’un cheval.

L’algorithme peut se concrétiser par un simple calcul mental. Le résultat est intéressant :

• Pour le 1er concours équestre de la FFE (26 inscriptions), le nombre de passages entre deux passages d’un même cavalier s’échelonne de 2 à 22 et entre deux passages d’un même cheval, de 5 à 12.
  
  
• Pour le 2ème concours équestre de la FFE (33 inscriptions), le nombre de passages entre deux passages d’un même cavalier s’échelonne de 8 à 21 et entre deux passages d’un même cheval, de 7 à 21.

ƒx : =SI(G4=G3;D4-D3-1;"")

§ 3.1. ALGORIGRAMME INTER_CAVALIER

Tri : NOM_CAVALIER, N°_PASSAGE

ƒx : =SI(G4=G3;D4-D3-1;"")

NOM_CAVALIER.bak = sauvegarde de NOM_CAVALIER
N°_PASSAGE.bak   = sauvegarde de N°_PASSAGE

                                   ┌─────────────────────────────┐
                                   │                             │
                            D-PROG │  NOM_CAVALIER.bak = ""      │
                                   │                             │
                                   └──────────────┬──────────────┘
                                                  │◄───────────────────────────────────────────────┐
                                   ┌──────────────┴──────────────┐                                 │
                                   │          NOM_CAVALIER.bak   │                                 │
                 D_ INTER_CAVALIER │              ::             │                                 │
                                   │          NOM_CAVALIER       │                                 │
                      <>           └──────────────┬──────────────┘            =                    │
                    ┌─────────────────────────────●─────────────────────────────┐                  │
     ┌──────────────┴──────────────┐                             ┌──────────────┴──────────────┐   │
     │        NOM_CAVALIER.bak     │                             │         INTER_CAVALIER      │   │
     │              =              │                             │              =              │   │
     │        NOM_CAVALIER         │                             │(N°_PASSAGE-N°_PASSAGE.bak)-1│   │
     └──────────────┬──────────────┘                             └──────────────┬──────────────┘   │
                    └─────────────────────────────┬─────────────────────────────┘                  │
                                   ┌──────────────┴──────────────┐                                 │
                 F_ INTER_CAVALIER │ N°_PASSAGE.bak = N°_PASSAGE │                                 │
                                   └──────────────┬──────────────┘                                 │
                                                  ●────────────────────────────────────────────────┘
                                   ┌──────────────┴──────────────┐
                            F-PROG │              ϕ              │
                                   └─────────────────────────────┘

---

§ 3.2. ALGORIGRAMME INTER_CHEVAL

Tri : NOM_CHEVAL, N°_PASSAGE

ƒx : =SI(H4=H3;D4-D3-1;"")

NOM_CHEVAL.bak = sauvegarde de NOM_CHEVAL
N°_PASSAGE.bak = sauvegarde de N°_PASSAGE

                                   ┌─────────────────────────────┐
                                   │                             │
                            D-PROG │    NOM_CHEVAL.bak = ""      │
                                   │                             │
                                   └──────────────┬──────────────┘
                                                  │◄───────────────────────────────────────────────┐
                                   ┌──────────────┴──────────────┐                                 │
                                   │          NOM_CHEVAL.bak     │                                 │
                   D_ INTER_CHEVAL │              ::             │                                 │
                                   │          NOM_CHEVAL         │                                 │
                      <>           └──────────────┬──────────────┘            =                    │
                    ┌─────────────────────────────●─────────────────────────────┐                  │
     ┌──────────────┴──────────────┐                             ┌──────────────┴──────────────┐   │
     │         NOM_CHEVAL.bak      │                             │         INTER_CHEVAL        │   │
     │              =              │                             │              =              │   │
     │         NOM_CHEVAL          │                             │(N°_PASSAGE-N°_PASSAGE.bak)-1│   │
     └──────────────┬──────────────┘                             └──────────────┬──────────────┘   │
                    └─────────────────────────────┬─────────────────────────────┘                  │
                                   ┌──────────────┴──────────────┐                                 │
                   F_ INTER_CHEVAL │ N°_PASSAGE.bak = N°_PASSAGE │                                 │
                                   └──────────────┬──────────────┘                                 │
                                                  ●────────────────────────────────────────────────┘
                                   ┌──────────────┴──────────────┐
                            F-PROG │              ϕ              │
                                   └─────────────────────────────┘

---

§ 3.3. ALGORITHMES

1. Vérifier que les fonctions de calcul des N°_PASSAGE ont été supprimées.
   
   Sinon refaire la 5ème étape : Numéroter N°_PASSAGE.
   
   
2. Trier sur :
   
   
   • NOM_CAVALIER (Ordre croissant)
   • N°_PASSAGE (Ordre croissant)
   
   
3. Si NOM_ CAVALIER de la ligne = NOM_ CAVALIER de la ligne précédente :
   INTER_CAVALIER = (N°_PASSAGE de la ligne - N°_PASSAGE de la ligne précédente) – 1
   
   Colonne INTER_CAVALIER :
   
   
   • ƒx : =SI(G4=G3;D4-D3-1;"")
   • Puis coller les valeurs sans les formules.
   
   
4. Trier sur :
   
   
   • NOM_CHEVAL (Ordre croissant)
   • N°_PASSAGE (Ordre croissant)
   
   
5. Si NOM_CHEVAL de la ligne = NOM_CHEVAL de la ligne précédente :
   INTER_CHEVAL = (N°_PASSAGE de la ligne - N°_PASSAGE de la ligne précédente) – 1
   
   Colonne INTER_CHEVAL :
   
   
   • ƒx : =SI(H4=H3;D4-D3-1;"")
   • Puis coller les valeurs sans les formules.
   
   
6. Après ces calculs, il faut bien sûr restituer l’ordre de tri final du tableau :
   
   
   • NB_TOURS (Ordre décroissant)
   • N_ORDRE (Ordre croissant)
   • NOM_CAVALER (Ordre croissant)
   
   
7. Touche finale : l’amplitude de l’écart entre deux passages d’un même cavalier ou d’un même cheval n’étant pas gérée, il est possible de déplacer manuellement un passage par un "couper/insérer les cellules coupées" sans impacter imprudemment l’ordre établi. Penser dans ce cas à actualiser manuellement l’INTERVALLE et les N°_PASSAGE.

---

§ 4. Remerciements

Merci à maxime_nrgt de nous avoir proposé ce sujet de réflexion original qui certes n’a pas fait l'objet d'un développement programmé mais qui aura été un défi captivant à notre logique informaticienne. Un retour d’expérience aurait sans doute permis d’enrichir et de valider la solution proposée.

Merci à Galet pour son impartialité et l'intérêt qu'il a porté à mes interventions.

Merci aux autres membres pour leur contribution ayant boosté ma réflexion philosophique et psychologique.

---

§ 5. ANNEXES

§ 5.1. Ordre de passage de la 1ère épreuve



§ 5.2. Ordre de passage de la 2ème épreuve



§ 5.3. Tableaux Excel

Concours équestre (FFE).xlsx (Fichier original de la FFE)

Concours équestre.xlsx (Fichier après traitement de l'algorithme)

1. Les deux épreuves de la FFE sur la même feuille de calcul (version originale) ont été séparées en deux feuilles :
   
   
   • 26 inscriptions
   • 33 inscriptions
   
   
2. La ligne titre de chaque feuille indique la chronologie (1 à 7) des colonnes traitées.
   
   
3. Sur chaque feuille de calcul, les trois premières colonnes sont des colonnes supplémentaires issues du fichier original de la FFE :
   
   
   • NB_TOURS_CAVALIER
   • NB_TOURS_CHEVAL
   • N°_PASSAGE_FFE
   
   
4. les cellules ont été colorisées pour visualiser et vérifier le classement.

---

§ 6. COMMENTAIRES

§ 6.1. La logique séquentielle

---