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 (701 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 structure complexe
La logique séquentielle

■ ■ ■ SOMMAIRE DU BILLET ■ ■ ■

  1. La problématique
  2. Logique squentielle
    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. Tableaux Excel
      • Ordre de passage de la 1ère épreuve
      • Ordre de passage de la 2ème épreuve
  6. COMMENTAIRES
    1. La logique séquentielle
Ce billet est inspiré 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’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 actuellement traitées, 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.

■ Démarche Top-down vs Démarche Bottom-up

Adapter la problématique de l’utilisateur à sa technicité n’est pas la même chose qu’adapter sa technicité à la problématique de l’utilisateur.

Dans le premier cas, la démarche de développement suggère une approche Top-down avec sa logique combinatoire et dans le second cas, elle suggère une approche Bottom-up avec sa logique séquentielle.

  • Soit la technicité pilote une démarche Top-down Développeur ◄- Utilisateur.

    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.
    Le développeur adapte la problématique de l’utilisateur à sa technicité.

    Citation Envoyé par seven7 Voir le message
    Généralement ça se passe comme ça : Pièce jointe 26557

  • Soit la philosophie pilote une démarche Bottom-up Développeur -► Utilisateur.

    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 MÉMOIRE ».

    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.
    Le développeur adapte sa technicité à la problématique de l’utilisateur. Il utilise sa technicité (L’Art) et sa philosophie (La Manière) pour comprendre et traduire informatiquement la solution que lui inspire la problématique.

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

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

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

Dans la liste globale des passages, 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.

Un nouvel attribut N_ORDRE peut donc être associé à chaque passage, ce nouvel attribut étant constitué par concaténation de N_CAVALIER avec N_CHEVAL.

Un tri en ordre croissant sur ce nouvel attribut N_ORDRE affichera d’abord les passages N° 1, puis les passages N° 2 et enfin les passages N° 3.

4ème étape : NB_TOURS

Créer un identifiant unique « NB_TOURS - N_ORDRE » afin d’imposer une priorité dans l’ordre de passage.

§ 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 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. Fonctionnalité « INTERVALLE »

Afin d’évaluer la qualité de l’ordre de passage et d'informer les cavalliers, j’ai ajouté deux nouveaux attributs INTER_CAVALIER et INTER_CHEVAL 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 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’algorigramme est simple mais mes compétences Excel ne me permettent pas de programmer l’algorithme. J’ai concrétisé l’idée 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 3 à 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.


§ 3.1. ALGORIGRAMME INTER_CAVALIER

Tri : NOM_CAVALIER, N°_PASSAGE

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

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. Désactiver momentanément voire même définitivement les fonctions dans les cellules de la colonne N°_PASSAGE :

    Onglet Formules -► Options de calcul -► Manuel

  2. Trier sur :

    • NOM_CAVALIER (Ordre croissant)
    • N°_PASSAGE (Ordre croissant)

  3. Lorsque 2ème ou 3ème passage d’un cavalier :

    INTER_CAVALIER = (N°_PASSAGE de la ligne - N°_PASSAGE de la ligne précédente) – 1

  4. Trier sur :

    • NOM_CHEVAL (Ordre croissant)
    • N°_PASSAGE (Ordre croissant)

  5. Lorsque 2ème ou 3ème passage d’un cheval :

    INTER_CHEVAL = (N°_PASSAGE de la ligne - N°_PASSAGE de la ligne précédente) – 1

  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. Réactiver éventuellement les fonctions dans les cellules de la colonne N°_PASSAGE :

    Onglet Formules -► Options de calcul -► Automatique

Idéalement, une fonction Excel dans les cellules INTER_CAVALIER et INTER_CHEVAL devrait peut-être pouvoir automatiser ces calculs ?

J’espère avoir bien exprimé cette nouvelle fonctionnalité… si ça intéresse quelqu’un de s’y coller.

Ci-joint ma dernière version du fichier Excel : Concours équestre (2022-08-17).xslx



§ 4. 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é.

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



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.



§ 5. ANNEXES

§ 5.1. Tableaux Excel

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

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

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

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



§ 6. COMMENTAIRES

§ 6.1. La logique séquentielle



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 30/08/2022 à 14h51 par APL-AML

Catégories
Programmation , ■ ALGORITHMIQUE

Commentaires

  1. Avatar de APL-AML
    • |
    • permalink


    § 6.1. La logique séquentielle

    En théorie des circuits électroniques, 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 MÉMOIRE ».

    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.

    Caractéristiques d’un système séquentiel

    Il n’y a plus, contrairement au cas des systèmes combinatoires, de relation d’équivalence entre l’état des entrées et l’état des sorties :

    • Une même cause (traduite par une combinaison d’entrées) peut produire des effets (traduits par la combinaison des sorties) différents,
    • Indépendamment de l’état des sorties, le temps peut être une cause de modification des sorties,
    • Un effet peut persister même après disparition des causes qui l’ont généré.

    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 est un type de logique en théorie des circuits électroniques, 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 26/08/2022 à 21h06 par APL-AML