IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Voir le flux RSS

Au Pied Levé - À Main Levée

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

Noter ce billet
par , 27/05/2021 à 12h00 (465 Affichages)
Ordre de passage d'une épreuve de concours équestre (Force 6/7)

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

Contenu :
  • la logique séquentielle
  • la structure itérative
  • la structure alternative
La logique séquentielle

■ ■ ■ SOMMAIRE DU BILLET ■ ■ ■

  1. La problématique
  2. Logique squentielle
    • 1ère étape : Renseigner N_CAVALIER
    • 2ème étape : Renseigner N_CHEVAL
    • 3ème étape : Renseigner N_ORDRE
    • 4ème étape : Renseigner NB_TOURS
    • 5ème étape : Renseigner N°_PASSAGE
    • Algorigramme général
  3. Conclusion
  4. ANNEXES
    • Tableaux Excel
      • Ordre de passage de la 1ère épreuve
      • Ordre de passage de la 2ème épreuve
    • La logique séquentielle
    • Penser out of the box
Ce billet est inspré de la discussion : Algorithme pour établir un ordre de passage

§ 1. La problématique

Citation Envoyé par maxime_nrgt Voir le message

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 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 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.

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 !


§ 2. Logique séquentielle

L’informatisation de la problématique examens-concours de mon administration m’a confronté à ce genre de situation. Je souhaitais affecter un N° de place à tous les candidats en tenant compte des 5 lieux d'examens répartis sur 4 départements, du lieu d'habitation de chaque candidat et de leur participation probable à un deuxième concours organisé le jour même.

J’avais remarqué qu’un des candidats habitait en face de l'un des lieux d'examen. Un ordre alphabétique l'aurait convoqué loin de chez lui, dans un département différent du sien, alors qu’il pouvait n’avoir que sa rue à traverser.

Par ailleurs, 80 % des candidats à ce concours organisé le matin étaient inscrits à un deuxième concours organisé l’après-midi. Planifier deux concours le même jour permettait de générer une économie substantielle car les tables d’examen sont louées à la journée et l’ensemble de ces deux concours totalisait environ 5.000 candidats uniques. Les candidats aux deux concours devaient donc nécessairement être convoqués dans le même lieu d’examen.

Sans entrer dans les détails, l’affectation d’un numéro de place à chaque candidat a nécessité une démarche algorithmique séquentielle (étape par étape) qui semble convenir à l’élaboration de l’ordre de passage d’une épreuve de concours équestre. C’est-à-dire que cet ordre de passage comme ce numéro de place ne peut pas s’obtenir par un algorithme d’équivalence, programmé classiquement ; en se référant à quelles données, d’ailleurs ? Quel qu’il soit, un passage doit bien se situer chronologiquement par rapport aux autres, en respectant les contraintes du règlemement. Or on ne dispose que d’une liste d’inscriptions cavaliers-chevaux.

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 dans une logique séquentielle.

Ce que j’appelle "Algorithmique ou logique séquentielle" correspond à la conception d’une succession d’étapes appelée 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.

Pour penser avec une logique séquentielle, il faut être libre dans sa réflexion, accepter de ne pas tout maitriser, ne pas rester figer dans la certitude de sa bien-pensance, faire confiance à son intuition, s’adapter, être inventif, se projeter.

5. ANNEXE : La logique séquentielle (en commentaire de ce billet car nombre de caractères maximum atteint pour le billet)


§ 2.1. 1ère étape : Renseigner N_CAVALIER

Objectif :

  • Affecter un N_CAVALIER croissant de 1 à n 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.

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 à n 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.
  • Le deuxième critère de tri N_CAVALIER plutôt que NOM_CAVALIER est important. Cela agit sur les valeurs de N_ORDRE et évite deux passages consécutifs d'un même cavalier ou d'un même cheval.

Tri : NOM_CHEVAL, N_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 identifiant unique « N_CAVALIER - N_CHEVAL » pour un même NOM_CAVALIER
  • 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)

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 :

  • Créer un identifiant unique « NB_TOURS - N_ORDRE » pour un passage NOM_CAVALIER / NOM_CHEVAL.
  • Imposer une priorité dans l’ordre de passage
  • NB_TOURS = (N_CAVALIER + N_CHEVAL)

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
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 : Numéroter N°_PASSAGE



Objectif :

  • Imprimer l’ordre de passage des cavaliers

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

Le troisième critère évite l’éventuelle 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.

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. Conclusion

Citation Envoyé par Mat.M Voir le message
Vous êtes en train de perdre votre temps à faire des tableaux totalement inutiles "à la main".
Faire du code prend autant de temps que de faire ce genre de tableaux.

Je conseille donc de faire du code ; j'en ai fait une ébauche quitte à le rectifier et à l'améliorer pour obtenir les bons résultats.
Programmer du code fonctionnel permet de produire des tableaux de sortie susceptibles de vérifier l'intégrité de l'ensemble des données.

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 comprend 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.

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 sinon que cela allait devoir se faire étape par étape. Je l’ai découvert au fur et à mesure, par tâtonnement, en martyrisant un jeu d’essai sous Excel. Je n’explique même pas, du moins à priori, peut-être à postériori… et encore, cet algorithme que je qualifie de séquentiel pour le distinguer des algorithmes classiques, statiques, sans sous-états, avec une relation d’équivalence entre l’état des entrées et l’état des sorties, tels que l’envisage Mat.M.

Moralité :

“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

Remerciements

Merci à maxime_nrgt de nous avoir proposé ce sujet de réflexion Excel qui mérite d’être promu comme [ACTUALITÉ], même si au final il ne fait pas l'objet d'un développement programmé.



Ci-joint le fichier Excel issu du fichier original "test_ffe.xlsx" : Concours équestre (FFE).xlsx

Ce fichier est à l'origine des cinq tableaux de ce billet. 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

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

Les cellules ont été colorisées pour visualiser et vérifier le classement.



§ 4. ANNEXES

§ 4.1. Tableaux Excel

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

Nom : Concours équestre_FFE (1ère épreuve).jpg
Affichages : 22
Taille : 200,5 Ko

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

Nom : Concours équestre_FFE (2ème épreuve).jpg
Affichages : 47
Taille : 252,5 Ko



§ 4.2. La logique séquentielle

Voir les Commentaires ci-après...



§ 4.3. Penser out of the box

Penser out of the box



FIN - Ordre de passage d'une épreuve de concours équestre (Force 6/7)

Envoyer le billet « Ordre de passage d'une épreuve de concours équestre » dans le blog Viadeo Envoyer le billet « Ordre de passage d'une épreuve de concours équestre » dans le blog Twitter Envoyer le billet « Ordre de passage d'une épreuve de concours équestre » dans le blog Google Envoyer le billet « Ordre de passage d'une épreuve de concours équestre » dans le blog Facebook Envoyer le billet « Ordre de passage d'une épreuve de concours équestre » dans le blog Digg Envoyer le billet « Ordre de passage d'une épreuve de concours équestre » dans le blog Delicious Envoyer le billet « Ordre de passage d'une épreuve de concours équestre » dans le blog MySpace Envoyer le billet « Ordre de passage d'une épreuve de concours équestre » dans le blog Yahoo

Mis à jour 12/04/2022 à 12h26 par APL-AML

Catégories
Programmation , ■ ALGORITHMIQUE

Commentaires

  1. Avatar de APL-AML
    • |
    • permalink


    § 4.2. La logique séquentielle


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

    Logique combinatoire : Un système logique est dit combinatoire si à tout instant, il est possible d’écrire l’équation logique de chaque sortie, en fonction seulement des entrées. Le résultat logique en sortie peut donc être représenté par une table de vérité ou un tableau de Karnaugh.

    Logique séquentielle : Un système est dit séquentiel si à une même combinaison des variables d’entrée peut correspondre plusieurs combinaisons différentes des variables de sortie. La combinaison des variables de sortie dépend des entrées mais également de l’état antérieur des variables de sortie.

    La logique séquentielle fait intervenir le temps. Autrement dit dans un système séquentiel, la valeur d'une variable logique à l'instant donné T dépend de celles qu'avaient les variables logiques aux instants précédents (instant T-1). C’est ce que l’on appelle « l’effet MEMOIRE ».

    On retrouvera les mêmes états des entrés à plusieurs étapes, alors que les sorties seront différentes. Il est donc impossible de les représenter par un tableau de Karnaugh.

    Décomposition en macros

    De façon à rendre compréhensible et lisible l’algorigramme de description d’un système, il est judicieux de décomposer le comportement en tâches élémentaires qui seront décrites par un algorigramme simple.

    L’algorigramme général fera alors appel à ces différents algorigrammes simples, appelés macros.



    PS : La logique séquentielle ne concerne en principe que les systèmes, mais le concept ne peut-il pas s’appliquer également au traitement des BDD ? J'ose le parallèle…

    Tout ce discours n’engage que moi. Mais comment expliquer ma démarche ? De quel algorithme s’agit-il ? Pour répondre à ce questionnement, je me suis inspiré des cours sur la Logique séquentielle trouvés sur internet. Notamment :

    Mis à jour 22/01/2022 à 09h34 par APL-AML