Sujet d’algorithmie original : imprimer des numéros de table en piles
Petit devoir de vacances…
Juste pour vous faire partager le plus sympathique sujet d’algorithmie auquel j’ai été confronté.
Anecdote :
Nous sommes début mars 1992 et je développe l’application examens-concours depuis à peine plus d’un mois lorsqu’une gestionnaire vient s’installer en face de moi. Je la vois inscrire des chiffres avec un gros feutre noir sur des morceaux cartonnés découpés dans des intercalaires.
- « Vous faites quoi ? »
- « Je prépare des numéros de table pour le concours qui va avoir lieu la semaine prochaine, j’ai besoin de calme, les collègues sont trop bruyantes. »
- « Mais c’est fastidieux, ce travail ! Vous ne faites quand même pas ça pour tous les concours ? Si ?... Pour le prochain concours, je résous votre problème… »
Mais bien sûr, il n’est pas question de remplacer l’inconvénient d’inscrire des numéros par l’inconvénient de les trier. L’idée est donc d’imprimer ces numéros de table, quatre par page mais en piles, c’est-à-dire que sous le numéro « un » il y a le « deux », puis le « trois », etc. Deux coups de massicot, il ne suffit plus qu’à réunir les quatre piles, mettre un élastique autour et le tour est joué.
Et tant qu’à faire, plutôt que de se contenter d’un numéro sur un quart de feuille, autant y mettre le libellé du concours, la date, le lieu, la salle, les noms-prénoms et la consigne « Numéro de place à reporter sur votre copie ».
Avant l’envoi des convocations à un concours, un placement des candidatures par ordre alphabétique affecte un numéro de place à chaque candidat. Pour pouvoir imprimer en piles 4 numéros de place par page, il faut nécessairement affecter un nouveau numéro à chaque candidature de façon à ce que les candidatures triées sur ce nouveau numéro permettent au programme d’édition d’imprimer sur chaque page les quatre numéros de place qui conviennent.
Facile de créer ces nouveaux numéros ! Il suffit de connaître le nombre d’inscrits, de diviser par quatre et de prendre en compte l’éventuel reste.
Oui, mais… Car il y a toujours un « Oui, mais » ! Certains candidats peuvent s’inscrire aux deux concours interne et externe. Avant la date d’examen, ils doivent obligatoirement se déterminer pour l’un des deux concours. Cela implique la suppression d’une candidature dans l’un des deux, ce qui génère fatalement une place libre. Mais comment traiter une candidature qui n’existe plus dans la table des candidatures ?
Je vous laisse réfléchir à l’algorithme de création de ces nouveaux numéros… si toutefois cette problématique vous inspire.
Bonnes vacances !
20/07/2021, 16h39
mach1974
il faut une troisième table pour le nom qui a déjà candidaté
Il faut une table pour l' historique des noms des candidats qui ont déjà candidaté et à chaque nouvelle inscription parcourir cette liste et optimiser avec un tri à fusion pour optimiser la complexité
20/07/2021, 18h03
anapurna
salut
en fait il ne faut pas supprimer l’étudiant dans la table de Candidature mais le marquer comme valide ou non
ETABLESEMENT
IDETABLISEMENT
NOM
LIEU
FINTBL
SALLE
IDSALLE
NUMETABLISSEMENT
NOMSALLE
FINTBL
CONCOURS
IDCONCOURS
DTCONCOUR
NUMSALLE
FINTBL
ETUDIANT
IDETUDIANT
NOM
PRENOM
FINTBL
CANDIDATURE
IDCANDIDAT
NUMETUDIANT
NUMCONCOURS
VALIDE
FINTBL
PLACE
IDPLACE
NUMCANDIDAT
FINTBL
il te suffit de placer que les étudiants VALIDE
20/07/2021, 23h16
APL-AML
Le sujet n’a besoin que de deux tables et quatre attributs
Citation:
Envoyé par mach1974
Il faut une table pour l' historique des noms des candidats qui ont déjà candidaté et à chaque nouvelle inscription parcourir cette liste et optimiser avec un tri à fusion pour optimiser la complexité.
Le placement des candidats se réalise au dernier moment avant l’édition et l’envoi des convocations.
Les candidatures postérieures à la date limite d’inscription ne sont pas prises en compte (hors délais) mais une candidature émise avant la date limite d’inscription peut toujours être reçue accidentellement après le placement. L’application gère cette situation mais ce n’est pas le problème présentement. Pour être exhaustif, il y a également le cas des candidats dits COTOREP. Des places particulières doivent alors être attribuées à ces candidats si leur handicap nécessite un aménagement particulier. On leur attribue un numéro de place au-delà du nombre d’inscrits. Mais c’est vraiment pour l’anecdote.
Dans la BDD, il n’y a qu’une seule table des candidatures.
Le sujet que j’ai proposé est simple dans son énoncé :
Il y a une table des candidatures et une place est attribuée à chaque candidature suite à un placement par ordre alphabétique, rien de plus. Le problème consiste donc à partir des numéros de place à déterminer de nouveaux numéros de façon à ce que les candidatures triées sur ce nouveau numéro permettent d’imprimer les numéros de place en piles (4 numéros de place par page), sachant toutefois que certaines candidatures ont pu être supprimées après le placement suite à des désistements.
L’édition des numéros de table est réalisée au dernier moment, la veille ou l’avant-veille des épreuves. Entre la date d’édition des convocations et la date d’édition des numéros de tables, il peut se passer bien des événements qui peuvent venir perturber le bel ordre initial.
Pour en dire un peu plus sur le sujet, j’ai nommé « post_it », le nouveau numéro dans la table des candidatures. Vous en saurez davantage un peu plus tard.
Pour l’instant, le problème consiste à partir de la table des candidatures triée sur le numéro de table à générer un ficher avec :
l’identifiant de la candidature
le numéro de place
le numéro de post_it
Ce fichier sera traité par une requête SQL pour renseigner l’attribut post_it dans la table des candidatures.
Le nombre d’inscrits, ou plutôt la dernière place attribuée pour le concours est renseignée dans la table des concours.
Mes deux tables sont nommées :
ec pour examens-concours avec l’attribut : ec.place (dernier numéro de place)
cec pour candidatures examens-concours avec les attributs : cec.n_cec (numéro de candidature) cec.place (numéro de place) cec.post_it (numéro de post_it)
Je vous fais grâce de la description complète de ces deux tables, inutile pour résoudre l’algorithme de création des nouveaux numéros.
Chacun était libre de créer ses propres noms de tables et d’attributs pour créer son algorithme, soit sous forme d’algorigramme, soit sous forme de pseudocode, ou même encore de codage dans un langage de son choix.
J’ai proposé ce sujet car je pense que c’est un excellent exercice de réflexion bien que ce ne soit pas l’avis du membre qui m’a attribué un vote négatif.
La réflexion doit prendre en compte quatre informations :
Numéro de place,
Numéro de post_it,
Numéro de pile,
Numéro de page
Citation:
Envoyé par anapurna
en fait il ne faut pas supprimer l’étudiant dans la table des Candidatures mais le marquer comme valide ou non.
Il te suffit de placer que les étudiants VALIDES.
Une suppression logique génère des complications dans la conception de tous les écrans, de tous les états et nécessiterait un traitement d'épuration au final.
La fonctionnalité Numéros de table n'implique que 2 programmes et deux écrans.
Lorsque le placement est réalisé, toutes les candidatures sont valides. Les désistements éventuels interviennent entre la date à laquelle s'est fait le placement et la date à laquelle sont éditées les numéros de table. Les places libres font l'objet d'un numéro de table "Place libre" de façon à ne pas perturber le chef de salle et les surveillants qui préparent les salles.
L'algorithme à réaliser a plusieurs intérêts :
Trouver la formule pour déduire le nouveau numéro
Gérer un nombre total de places qui ne soit pas un multiple de 4
Gérer les places libres
Mais je vous en dis bien trop. Mon anecdote à l’origine de cette aventure aurait dû suffire à faire bouillir votre imagination et votre réflexion.
Il y avait trois ingrédients essentiels :
des candidatures placées par ordre alphabétique,
des désistements possibles,
et idée farfelue : imprimer des numéros de table en piles.
À partir de là, c’est rien que du bonheur, une passion, le job du développeur… Quoi !
Merci aux 6 votes positifs qui ont compris l’intérêt de ce petit sujet d’algorithmie à la simplicité trompeuse.
Si vous souhaitez mon corrigé tout de suite, vous dites.
21/07/2021, 10h51
anapurna
salut
donc on a un peu plus d'info ;)
c'est donc cec.post_it a déterminé et c'est lui qui défini la place final attribué
nous savons qu'il faut jouer avec les modulo pour connaitre la page
comme nous avons 4 concourant par page il nous faut donc 16 element pour remplir 1 page complètement
Code:
1 2 3 4 5 6 7 8 9 10
0 modulo 4 = 0 => Numero de page
1 modulo 4 = 1 => Numero de page
2 modulo 4 = 2 => Numero de page
3 modulo 4 = 3 => Numero de page
...
12 modulo 4 = 0 => Numero de page
13 modulo 4 = 1 => Numero de page
14 modulo 4 = 2 => Numero de page
15 modulo 4 = 3 => Numero de page
pour connaitre la position de celui-ci dans la page il suffit faire un division entière
Code:
1 2 3 4 5
0DIV4 = 0 => Position dans la page
4DIV4 = 1 => Position dans la page
8DIV4 = 2 => Position dans la page
12DIV4 = 3 => Position dans la page
j'aurais pu prendre la deuxieme page
Code:
1 2 3 4 5
1DIV4 = 0 => Position dans la page
5DIV4 = 1 => Position dans la page
9DIV4 = 2 => Position dans la page
13DIV4 = 3 => Position dans la page
le principe reste le même
compte tenu de ses element il est assez facile d'imprimer nos pages
PS : après réflexion => pour ta résolution de place libre c'est assez simple il suffit de décaler les suivants après la place libre
vu que les concurrents sont classés par ordre alphabétique cela revient a une translation d'indice comme pour un tableau ;)
21/07/2021, 14h26
APL-AML
Simuler pour comprendre
Citation:
Envoyé par anapurna
Donc on a un peu plus d'info ;)
C'est donc cec.post_it à déterminer et c'est lui qui défini la place finale attribuée.
Comme je l’ai dit, chacun était libre de faire à sa guise. Il fallait prendre ce sujet comme un sujet de DST, se mettre dans ma situation, partir de presque rien (trois éléments) et proposer une solution, créer des attributs si nécessaire en l’occurrence : le numéro de place maximum dans la table des examens-concours (ec.place pour moi) et un nouveau numéro dans la table des candidatures (cec.post_it pour moi) ; puis réaliser l’algorithme (le programme) permettant d’associer à une place, un nouveau numéro afin de permettre au programme d’édition d’imprimer les numéros de place, 4 par page et en piles. Ce nouveau numéro (cec.post_it pour moi) ne définit pas de place finale attribuée. Le placement des candidats a eu lieu, les candidats vont recevoir leur convocation avec leur numéro de place qu’ils trouveront facilement dans la salle où ils sont convoqués.
Mais je parle, je parle et le prochain concours a lieu dans huit jours… Vous serez prêts ? Il y a encore le programme d’édition à développer…
Citation:
Envoyé par anapurna
Nous savons qu'il faut jouer avec les modulos pour connaitre la page…
Je ne sais pas trop où tu vas avec tes modulos. Mais il n’y a pas forcément qu’une seule solution.
Je vous propose la deuxième partie de ma simulation (pas la plus capitale, je fais durer le plaisir) mais on voit bien que la première page imprimera les numéros de place 1, 7, 13 et 18, etc.
Tout le problème, c’est comment arriver à ça.
Pour un concours avec 22 candidatures (sans places libres mais non multiple de 4), la liste des candidatures triées sur le nouveau numéro (post_it) doit ressembler à ça :
Là, je vous ai déjà bien aidé. Moralité : commencer par une simulation.
Il y a encore du chemin à faire dans la réflexion pour arriver à l'algorithme complet. Tant pis, les gestionnaires continueront à faire leurs numéros de table à la mimine !
… C’est ce que me disaient les gestionnaires qui me voyaient trimer 15 heures par jours pour résoudre leurs problèmes :
- Vous savez, nous pouvons faire à la main, nous le faisions bien avant que vous vous intéressiez à nous.
- PAS QUESTION ! Demain matin vous trouverez vos résultats sur le coin de votre bureau.
21/07/2021, 16h47
anapurna
salut
le modulo c'est le reste de la division dans notre cas le diviseur c'est 4
si tu applique le modulo tels quel tu as un soucis d'indice pour palier a cela
tu applique un décalage de rang de 1
donc 1 mod 4 = 1 => ((1-1) mod 4)+1 = 1
2 mod 4 = 2 => ((2-1) mod 4)+1 = 2
3 mod 4 = 2 => ((2-1) mod 4)+1 = 3
4 mod 4 = 0 => ((4-1) mod 4)+1 = 4 // le décalage de rang ne sert que si le reste est égale a zéro
5 mod 4 = 1 => ((5-1) mod 4)+1 = 1
....
20 mod 4 = 0 => ((20-1) mod 4)+1 = 4
21 mod 4 = 1 => ((21-1) mod 4)+1 = 1
22 mod 4 = 2 => ((22-1) mod 4)+1 = 2
c'est très pratique pour trouver les coordonné dans un tableau
le plus compliqué et le moins compréhensible pour moi c'est ton passage
de Place a Post_it pour les piles et les Pages le reste de la division(modulo) et le quotient(Division entière) suffit a retrouver tes éléments
sous Excel les formule correspondant sont MODULO et QUOTIENT
Pile = MODULO($post_It-1;4) +1
page = QUOTIENT($post_It-1;4) +1
fait un essai sous Excel tu verra que cela fonctionne parfaitement tu récupère les piles et les pages en fonction de ton post_it
21/07/2021, 23h05
APL-AML
Pile et Page n’existent pas dans la BDD
Citation:
Envoyé par anapurna
Le plus compliqué et le moins compréhensible pour moi c'est ton passage de Place à Post_it.
C’est précisément ce qu’il faut élucider Et pas besoin d’Exel pour ça, juste une addition et une multiplication.
Citation:
Envoyé par anapurna
Pour les piles et les Pages le reste de la division(modulo) et le quotient(Division entière) suffit à retrouver tes éléments.
Mais ce n’est pas ce que l’on cherche et il faut d’abord connaitre l’information post_it. Les colonnes Pile et Page de mon extrait de simulation ne sont là que pour mieux visualiser l’évolution de chaque couple Place-Post_it. Ces informations Pile et Page n’existent pas dans la BDD (table cec des candidatures).
Le programme d’édition ne s’intéressera qu’aux informations :
post_it pour ce qui est du tri des candidatures et du traitement des places libres,
place pour ce qui est de l’édition proprement dite,
Et bien sûr aux informations à imprimer sur chaque numéro de table.
Places libres
Je n’ai pas concrétisé de place libre dans ma simulation mais c’est facile à faire. Il suffit par exemple de désister le candidat placé en 13. Il faut alors supprimer la place 13 et le post_it 3. On garde les informations Pile (3) et Page (1) pour visualiser notre simulation.
Le programme d’édition va s’apercevoir qu’il manque le post_it 3 et imprimera un numéro de table 13 avec « Place libre » comme nom-prénom.
Ça vaut un sudoku force maxi mon histoire d’impression de numéros de table en piles. Non ?
22/07/2021, 09h05
anapurna
salut ,
c'est pas très claire.
reprenons afin de comprendre correctement votre demande.
1°) un personne s'inscrit a un concourt (cec.n_cec)
2°) a la clôtures des candidature on affecte un numéro de place (cec.place) ordre par trie alphabetique
3°) a la mises en place du concours un affecte un nouveau numero de place - les doublon abandonnée cec.post_it
pour moi il n'y a rien de complique
Citation:
n_cec
place
post_it
Cmt
80
1
1
2
2
2
18
3
-1
// abandon pour un autre concours
4
4
3
25
5
4
122
6
-2
// abandon pour un autre concours
48
7
5
.....
place et post-it étant trié dans le même ordre il suffit simplement d'enlever les décrément
a l'Edition il te suffit de prendre les post_it positif ... une fois cette ordre trouvé
tu utilise les formule précité pour connaitre la pile et la page
22/07/2021, 15h05
APL-AML
Déterminer post-it à partir de pile et page
Citation:
Envoyé par anapurna
Ce n'est pas très clair. Reprenons afin de comprendre correctement votre demande.
Ce n’est pas une demande. Il s’agit d’une idée loufoque pour résoudre une fonctionnalité insolite que je voulais partager. Au départ, mais je me répète, j’avais trois éléments :
Des candidatures placées par ordre alphabétique,
Des désistements possibles,
L’idée saugrenue d’imprimer les numéros de table en piles.
Et c’est tout ! À partir de là, c’est à moi de prendre les initiatives pour développer la fonctionnalité.
En proposant ce sujet d’algorithmie, il s’agit donc pour ceux que cela intéresse de se mettre en situation, de s’approprier la problématique et de prendre les initiatives qui s’imposent. Pour cela, il est évident que le programme d’édition doit lire la table des candidatures dans un ordre qui lui permette d’imprimer en piles. Le sujet consiste donc à concevoir l’algorithme ad ’oc. Il n’est pas question pour l’instant du programme d’édition… C’est une autre histoire.
Tu sembles attendre des consignes, un cahier des charges peut-être ? Un MCD ? Un MCT ? Il ne s’agit pas d’appliquer une recette mais de concevoir. Le sujet ne fait appel qu’à ton imagination et à ta réflexion. Mais peut-être ne suis-je pas un très bon pédagogue ?
Citation:
Envoyé par anapurna
3°) À la mise en place du concours, on affecte un nouveau numéro de place - les doublons abandonnés cec.post_it.
Pas du tout. Tu interprètes mes propos. Il ne s’agit surement pas d’affecter un nouveau numéro aux candidats. Tu imagines… On les convoque dans une salle d’examen à la place indiquée sur leur convocation et entre temps on change leur place sans qu’ils le sachent. Certains concours comptent près de 5.000 candidats et sont convoqués dans 5 centres d’examens répartis dans 4 départements. Ce serait un fichu foutoir !
J’ai proposé une simulation de ce que les numéros de post_it doivent être par rapport aux numéros de place. Pourquoi inventer un numéro de post_it équivalent au numéro de place dont on ne peut rien en tirer.
Il n’y a pas de doublons abandonnés. Tu interprètes encore. Les éventuels désistements sont purement et simplement supprimés de la table des candidatures.
Le tri par ordre alphabétique des candidatures facilite tout simplement la gestion. Chaque gestionnaire a en charge une plage de candidatures. Pour les corrections par les membres du jury, il y a plusieurs façons d’attribuer un numéro d’anonymat. L’une des façons consiste tout simplement à couper en deux l’ensemble des candidatures et à mettre la première partie derrière la deuxième partie. Il n’y a que la personne responsable des concours qui sait où a été faite la césure… et le DBA, c’est-à-dire moi ! Il est impossible aux membres du jury de se fier à l’ordre des copies pour espérer en reconnaitre une.
… Mais je déborde du sujet !
Citation:
Envoyé par anapurna
place et post-it étant triés dans le même ordre il suffit simplement d'enlever les décréments
à l'édition il te suffit de prendre les post_it positifs... une fois cet ordre trouvé, tu utilises les formules précitées pour connaitre la pile et la page.
Mais que nenni ! « post_it » est un nouveau numéro dont l’objectif est de fournir au programme d’impression les numéros de table dans un ordre qui lui permette d’imprimer en piles. Il n’a rien à voir avec le numéro de place.
Que ferait-on de tes numéros de post_it ?
Tu sembles te focaliser sur pile et page qui n’existent pas dans la BDD. pile et page ne constituent pas une fin en soi. Leur intérêt est d’intervenir dans une opération permettant d’obtenir le numéro de post_it.
La question est : quelle est cette opération ?
Je vous propose ma simulation complète qui devrait vous permettre de poser cette opération.
La réflexion consiste à s’intéresser aux lignes avec le même numéro de page pour comprendre comment évolue le numéro de post-it par rapport au numéro de place.
Chacun est libre d'afficher ou non ma simulation pour en savoir plus tout de suite ou poursuivre sa réflexion sans aide.
L’opération posée, l’affaire n’est pas pliée pour autant… Mais chaque chose en son temps.
La prochaine étape, c’est l’algorigramme avec encore de la réflexion pour résoudre le cas d’un dernier numéro de place qui ne serait pas un multiple de 4 et bien sûr le cas des places libres suite à des désistements de candidats. Il me parait pertinent d’expliquer ces situations devant un algorigramme.
22/07/2021, 18h51
anapurna
salut
ok j'avais pas compris la question.
donc ton but pour une même position sur la feuille tu veut les noms par ordre alphabétique qui se suivent
on sais forcement qu'il va y avoir un incrément de 4 sur chaque valeur jusqu'a attendre le max recommencer de nouveau les increment de 4 en 4 en commence a 2 et ainsi de suite
il faut juste trouver l'équation permettant de connaitre le point
la premier chose c'est donc c'est d'incrémenter les valeur par 4
ensuite trouver une équation qui peut ressoudre notre soucis
je te livre le début de ma réflexion
Reste plus qu'a trouver le x et le y de façon automatique
24/07/2021, 21h18
APL-AML
Suite de mon anecdote, pour patienter
Je note beaucoup de connections mais aucune réaction. J'espérais une réponse à la question :
Comment décrypter le nouveau numéro (post_it) relatif à un numéro de place à partir du numéro de page et du numéro de pile ?
Mais non, rien !
Je donnerai la réponse le 25/07 avant 15:05, c'est-à-dire avant la limite des 72 heures au-delà desquelles on ne peut plus intervenir sur ses messages.
Pour patienter, je vous propose la suite de mon anecdote pour expliquer le nom de mon nouveau numéro "post_it".
Anecdote (suite) :
Cette problématique apparemment toute simple va inspirer la création de 4 programmes :
post_itBDD : création des numéros de post_it
post_itALL : impression des post_it
post_itMaJ : impression de post_it particuliers (candidature ajoutée ou transférée)
place_vide : liste des places libres
Pourquoi ces noms de programme « post_it… » ?
D’abord, pour respecter ma propre règle de développement, à savoir trouver des noms de 10 caractères maximum et le plus évocateurs possible.
Ensuite, fixer ces numéros sur les tables avec du scotch obligeait de le faire à deux, j’ai alors suggéré de les fixer avec de la colle repositionnable en bombe aérosol.
Lorsqu’on loue une salle, on a l’obligation de laisser les tables après le concours, dans leur état initial. L’opération pose et enlèvement des numéros de tables doit être simple et rapide, certains concours totalisent plus de 4.000 candidatures.
Finalement, si l’idée était intéressante, l’opération demande un certain doigté car il faut attendre juste ce qu’il faut pour que la colle sèche suffisamment avant d’appliquer le numéro sur la table. Surtout, en fait, on s’en met plein les doigts. Le procédé a été abandonné et les numéros sont finalement restés posés sur les tables sans être fixés, au risque que quelques uns s’envolent dans la bousculade des candidats cherchant leur place. Leur enlèvement s’est fait tout seul… Mes étiquettes ont tellement plu aux candidats qu’ils les gardaient en souvenir.
1ère difficulté : Déterminer post-it à partir de pile et page
Comprendre comment évolue le nouveau numéro (post-it) par rapport au numéro de place.
Déterminer le nouveau numéro (post_it) relatif à un numéro de place à partir du numéro de page et du numéro de pile.
Vous connaissez désormais la formule que je rappelle ci-après :
Code:
1 2 3
Numéro de post-it = Numéro de la pile + (Numéro de la page précédente * 4)
=> initialiser le numéro de page à zéro
L’un des termes de ma formule, c’est la page précédente.
Oui, mais ! Car il y a encore un « Oui, mais ! ». Pour les places de la première page à imprimer (1, 7, 13, 18), il n’y a pas de page précédente puisque c’est la première page.
Et non ! Il faut juste initialiser le compteur de pages à zéro avant le traitement d’une pile.
Bon ! Ça, c’est fait.
Il y avait 3 difficultés à résoudre :
Trouver la formule pour déduire le nouveau numéro (post_it pour moi)
Gérer un nombre total de places qui ne soit pas un multiple de 4
Gérer les places libres
Il reste à comprendre et à gérer les deux autres difficultés…
2ème difficulté : Gérer un nombre total de places qui ne soit pas un multiple de 4
Et oui ! Le nombre de pages n’est pas le même selon la pile que l’on traite. Dans ma simulation qui compte 22 candidatures, les deux premières piles nécessitent 6 pages alors que les deux suivantes n’en nécessitent que 5. Il est important de maitriser ce nombre de pages car c’est lui qui détermine le changement de pile.
3ème difficulté : Gérer les places libres
Le traitement itératif ne peut pas s’appuyer sur les candidatures puisque les candidatures désistées n’existent plus dans la table. Le programme doit donc gérer un numéro de place de référence qui s’incrémente de façon indépendante pour révéler l’absence éventuelle de numéros de place dans la table des candidatures. L’absence de places est aléatoire, au début, à la fin, consécutive ; tout est possible.
Une place libre ne doit pas empêcher le compteur de page de s’incrémenter car c'est l'un des termes de la formule de calcul qui permet de déterminer le nouveau numéro (post_it).
Algorigramme
Il reste à concevoir l’algorigramme ou à programmer directement.
Mon petit devoir de vacances ne suscitant aucune réaction, je continuerai mon monologue pour ceux qui suivent la discussion sans se manifester.
À très bientôt pour le corrigé.
31/07/2021, 12h00
APL-AML
Corrigé de mon Devoir de vacances
Citation:
■ ■ ■ SOMMAIRE ■ ■ ■
Simulation
Algorigramme LCP
Programme post_itBDD.ace
Méthodologie « Logique de Construction de Programme (LCP)
LCP et le programme post-itBDD.ace
Billets LCP
En l’absence de liens hypertexte intra-document, je propose comme palliatif d’utiliser la fonctionnalité de votre navigateur « Rechercher dans la page » : Ctrl/F.
Chaque chapitre correspondant à un item du menu est précédé d’un signet « § ».
Vous saisissez dans la fenêtre de recherche le symbole typographique Paragraphe "§" puis vous naviguer dans le message à l’aide des flèches de direction de la fenêtre ˄ / ˅ ou à l’aide des raccourcis clavier Ctrl+MaJ+G / Ctrl+G.
Le programme gère deux compteurs que l’on peut assimiler à des tables (voir la simulation ci-dessus) dont le contenu est leur rang (numéro), autrement dit leur indice courant (i_page et i_pile) :
une table des pages (nombre d’items = (nombre d’inscrits + 3) /4)
Cet exercice d’algorithmie n’est autre que le programme post_itBDD.ace d’une application Examens-Concours développée avec le SGBD Informix de 1992 à 2007.
Si le programme a été écrit le 10/03/1992, son logigramme a été réalisé le 26/06/2019 comme support pédagogique d’un billet de blog consacré à la Méthodologie de programmation LCP.
{================================= post_itBDD =================================}
{ }
{ ACE : post_itBDD.ace }
{ }
{ SHELL : ../shell_1/post_itBDD }
{ }
{ AUTEUR : APL-AML }
{ }
{ Objet : Création du fichier "$(LOGNAME).out" à loader dans la table tmp }
{ pour mise à jour de l'information cec.post_it }
{ à l'aide du sql "post_itBDD.sql" }
{ }
{ L'édition des post_it s'effectue à l'aide du shell "post_itALL" }
{ }
{ post_itBDD et post_itALL gèrent les places libres. }
{ Il est donc possible de relancer éventuellement cette chaine. }
{ }
{ Date : 10 Mars 1992 }
{ }
{==============================================================================}
{========================}
{==========================} DATABASE concours END {==========================}
{========================}
{================================} DEFINE {==================================}
{} {}
{} PARAM[1] p_c_ec CHAR(5) {}
{} PARAM[2] p_t_ec CHAR(2) {}
{} PARAM[3] p_s_ec CHAR(2) {}
{} PARAM[4] p_logname CHAR(8) {}
{} {}
{} VARIABLE j_page INTEGER {}
{} VARIABLE i_page INTEGER {}
{} VARIABLE i_pile INTEGER {}
{} VARIABLE v_post_it INTEGER {}
{} VARIABLE v_place INTEGER {}
{} VARIABLE v_reste INTEGER {}
{} {}
{==================================} END {===================================}
{================================== INPUT ===================================}
{} {}
{ PROMPT FOR v_dp USING " CONCOURS : " }
{} {}
{=================================== END ====================================}
{================================} OUTPUT {==================================}
{} {}
{ REPORT TO PRINTER }
{} REPORT TO PIPE "cat > ${LOGNAME}.out" {}
{} TOP MARGIN 0 {}
{} BOTTOM MARGIN 0 {}
{} LEFT MARGIN 0 {}
{} PAGE LENGTH 58 {}
{} {}
{==================================} END {===================================}
{=================================} SELECT {=================================}
ec.cts ec_cts,
ec.c_ec ec_c_ec,
ec.t_ec ec_t_ec,
ec.s_ec ec_s_ec,
ec.place ec_place,
cec.n_cec cec_n_cec,
cec.place cec_place
FROM ec,
cec,
ln
WHERE ec.c_ec = $p_c_ec
AND ec.t_ec = $p_t_ec
AND ec.s_ec = $p_s_ec
AND ec.cts = cec.cts
AND (cec.c_decision = "A" OR cec.c_decision = "C")
AND cec.place IS NOT NULL
AND ln.logname = $p_logname
AND (ln.service IS NULL OR ln.service = ec.service)
{===============================} ORDER BY {================================}
ec_cts,
cec_place
{==================================} END {===================================}
{=================================} FORMAT {=================================}
{------------------------} BEFORE GROUP OF ec_cts {-----------------------}
LET j_page = ec_place / 4
LET v_reste = ec_place - (j_page * 4)
LET j_page = (ec_place + 3) / 4
LET i_page = 0
LET i_pile = 1
LET v_place = 1
{---------------------------- FIRST PAGE HEADER ----------------------------}
{------------------------------ PAGE HEADER ------------------------------}
{------------------------------- PAGE TRAILER -------------------------------}
{------------------------------} ON EVERY ROW {------------------------------}
WHILE v_place < cec_place
DO BEGIN
IF i_page = j_page
THEN BEGIN
LET i_pile = i_pile + 1
LET i_page = 0
IF v_reste > 0
THEN LET v_reste = v_reste - 1
IF v_reste = 0
THEN LET j_page = ec_place / 4
END
LET i_page = i_page + 1
LET v_place = v_place + 1
END
IF i_page = j_page
THEN BEGIN
LET i_pile = i_pile + 1
LET i_page = 0
IF v_reste > 0
THEN LET v_reste = v_reste - 1
IF v_reste = 0
THEN LET j_page = ec_place / 4
END
LET v_post_it = i_pile + (i_page * 4)
PRINT cec_n_cec USING "<<<<<<<<<<<<", "||",
ec_c_ec CLIPPED, "|", ec_t_ec, "|", ec_s_ec, "|-|-|-|-|||",
cec_place USING "<<<<", "||", v_post_it USING "<<<<", "|||||||||"
LET i_page = i_page + 1
LET v_place = v_place + 1
{-------------------------- TRAITEMENT FIN DE PAGE --------------------------}
{------------------------ TRAITEMENT EN-TETE DE PAGE ------------------------}
{------------------------ TRAITEMENT LIGNE COURANTE ------------------------}
{------------------------- AFTER GROUP OF ec_cts -------------------------}
{------------------------------} ON LAST ROW {-------------------------------}
PRINT cec_n_cec USING "<<<<<<<<<<<<", "||",
ec_c_ec CLIPPED, "|", ec_t_ec, "|", ec_s_ec, "|-|-|-|-|||",
cec_place USING "<<<<", "||", v_post_it USING "<<<<", "||||||||-|"
{ - Reinitialisation de l'imprimante "HP LASERJET III Si" }
{==================================} END {===================================}
§ 04 : Méthodologie « Logique de Construction de Programme » (LCP)
LCP procède par structuration :
La structure hiérarchique d'un programme se déduisant logiquement de la structure des données utilisées (FLS/FLE), la construction du programme commence par la structuration des données qu'il doit produire en sortie.
Au-delà de la structuration hiérarchique du programme déterminée par la structure des données, le degré de décomposition algorithmique peut descendre jusqu’au niveau de l’instruction. Cela dépend de la capacité d’abstraction du programmeur. La seule règle qui régit la réflexion :
« Penser hiérarchiquement par traitements, autrement dit : raisonner du plus global vers le plus détaillé, par décompositions hiérarchiques successives sur la base des actions et non sur celle des conditions ».
Structuration du FLS, du FLE et du PRG
Concernant ce programme post_itBDD, la structuration classique LCP est rudimentaire puisqu’il s’agit de créer une seule information en sortie (post_it) à partir d’une seule information en entrée (place).
Structuration des données de sortie (informations présentes).
Les données de sortie ne sont pas exclusivement des données destinées à être imprimées. Ce peut être des données de la BDD (écran de saisie) ou le résultat d’un traitement particulier comme c’est le cas pour le programme post_itBDD proposé.
Structuration des données d’entrée (informations utiles).
LCP est une méthode de programmation conçue à l’origine dans un contexte batch où le Fichier Logique en Entrée (FLE) était constitué en amont du programme. Dans un contexte BDD, c’est le développeur qui constitue et structure le FLE dont le programme a besoin.
C’est la conception et la structuration préalable du FLS qui inspire la conception et la structuration du FLE.
Structuration du programme.
La structuration du programme se déduit de celle du FLE pour ce qui concerne les Ensembles De Données (EDD), mais la décomposition structurelle du programme peut devoir être poussée plus finement, au-delà des EDD, tout en respectant la logique LCP qui consiste à penser par traitements. C’est le cas pour ce programme post_itBDD.
§ 05 : LCP et le Programme post_itBDD.ace
Structuration des données de Sortie (FLS)
Représentation des Ensembles De Données (EDD) sous forme de patatoïdes :
Les candidatures supprimées n’apparaissent pas bien sûr dans le FLE. La structuration du programme prenant en compte les places libres générées par la suppression possible de certaines candidatures ne peut se réaliser que par la réflexion, tout comme la détermination du numéro de post_it. Symboliser cette réflexion sous forme d’un diagramme avec des accolades peut s’avérer très vite compliqué.
Traduction d’un début de cette réflexion sous forme d’un diagramme avec des accolades :
┌ ┌ ┌ ┌
│ D-PRG │ D-PLACE │ D-PLACE LIBRE │ D-PAGE
│ │ │ PLACE (0,1) │ T-PAGE (0,1)
│ │ PLACE LIBRE (PL) < PAGE (0,1) <
│ │ │ │ T-PAGE (0,1)
│ │ │ F-PLACE LIBRE │ F-PAGE
PRG < PLACE (P’) < INTER └ └
│ │
│ │ T-PAGE (0,1)
│ │ T-PAGE (0,1)
│ │
│ F-PRG │ F-PLACE
└ └
Niveau : Niveau 1 Niveau 2 Niveau 3 Niveau 4
Référentiel : Place CEC Place Référente Place libre Page
Algorigramme détaillé au niveau de l’instruction
Lorsque la Logique de Construction de Programme est acquise, les structurations et le logigramme restent à l’état de construction mentale quasi inconsciente. Le programme post_itBDD n’utilise qu'une vingtaine d'instructions, gère deux tables (page et pile) et 3 variables (v_post_it, v_place, v_reste).
Si le programme a été écrit le 10/03/1992, soit il y a près de 30 ans, son logigramme a été réalisé le 26/06/2019 pour créer un billet de blog, soit 27 ans plus tard. Dans un souci pédagogique plus rigoureux, les structurations FLS, FLE et PRG ont quant à elles été réalisées encore plus récemment en juillet 2021, suite à la découverte sur internet d’un ancien support de cours LCP qui se transforme progressivement en tutoriel : Logique de Construction des Programmes
Les traitements :
PLACE : Le traitement « PLACE » correspond au « CANDIDAT ». Un numéro de place a été affecté aux candidats lors du placement par ordre alphabétique avant l’envoi des convocations.
PLACE LIBRE : Le traitement « PLACE_LIBRE » est en fait le traitement d’un numéro de place référent qui palie les éventuelles candidatures supprimées.
PAGE : Lorsque la dernière place ne correspond pas à un multiple de 4, le nombre de pages n’est pas le même selon la pile.
PILE : C’est le nombre de pages qui détermine le changement de pile.
§ 06 : Billets LCP
Pour en savoir davantage sur LCP, vous trouverez trois billets dans mon blog dont le billet Méthodologie de programmation LCP qui m'a permis d'alimenter cette discussion. Ce billet est une ébauche de tutoriel LCP en cours de rédaction.
Adepte LCP, j’expose dans ce billet mon expérience de la méthode en respectant au mieux la pédagogie originelle. Certains aspects de cette pédagogie qui se réfèrent à des supports de cours des années 70 peuvent décourager le lecteur. Il suffit de les survoler ou de passer outre en utilisant la navigation internet « Rechercher dans la page ».
bon j'ai rien compris a ce que tu voulez nous expliquer ^^
jolie démonstration mais dans ma carrière de développeur j'ai rarement fait un truc pareil ;)
donc voila moi ce que j'aurais fait
en partant du postulat que nous utilisons une base relationnel (SGBD)
j'ai besoin de deux variable
NBPRPG = Nombre de print par page = 4 pour ton exemple
NBVAL = Nombre de Valeur = 22
voila tu as toutes les infos pour imprimer
trois requête de mise à jour suffisent dans SGBD, elle sera toujours plus rapide que de faire des boucles et des mises a jour unitaire
et une requête
Code:
1 2 3
Select PLACE
From MATABLE
Order by NUMPAGE,NUMPILE
Remarque que pour le post_it je ne cherche pas a ne pas dépasser
la valeur max, mon seul soucis est qu'il soit un multiple de 4
Pourquoi faire simple quand on peut faire compliqué
26/12/2021, 12h00
APL-AML
[ACTUALITÉ] et BILLET de BLOG
POST-SCRIPTUM
Cette discussion a fait l’objet d’une ACTUALITÉ sur le site, dans le cadre d’un concours multiple :
La taille des billets étant limitée, certains messages de la discussion ont été sacrifiés au profit d’un nouveau paragraphe concernant l’édition proprement dite. Trop conséquent et pas indispensable, le code source de ce programme d’édition ne peut être joint.
Ci-après, le menu de ce billet :
Devoir de vacances d'algorithmique (Force 6/7)
Citation:
Public :
étudiants
débutants
et pourquoi pas, enseignants
Contenu :
les tables
la pédagogie LCP
la structure complexe
la structure itérative
la structure alternative
TUTORIEL
Citation:
■ ■ ■ SOMMAIRE DU BILLET ■ ■ ■
Sujet d’algorithmie original : imprimer des numéros de table en piles
Simulation
Algorigramme LCP
Programme " post_itBDD.ace "
Les tables de la BDD sollicitées par le programme post_itBDD
Programme source " post_itBDD.ace "
La pédagogie LCP
Méthodologie « logique de Construction de programme » (LCP)
LCP et le programme post_itBDD.ace
Structuration des données de Sortie (FLS)
Structuration des données d’entrée (FLE)
Structuration du programme (PRG)
Algorigramme
Structuration in extenso du programme
Édition des numéros de table
post_itALL.ace
Algorigramme
Méthodologie de programmation LCP
Comme d’habitude, vous pouvez utiliser la fonctionnalité de votre navigateur « Rechercher dans la page » : Ctrl/F.
Chaque chapitre correspondant à un item du menu est précédé d’un signet « § ».
Vous saisissez dans la fenêtre de recherche le symbole typographique Paragraphe "§" puis vous naviguez dans le message à l’aide des flèches de direction de la fenêtre ˄ / ˅ ou à l’aide des raccourcis clavier Ctrl+MaJ+G / Ctrl+G.
Affichage du billet
Rechercher dans la page : Ctrl/F
Saisie du symbole typographique Paragraphe : "§"
[Entrée] ou ˄ / ˅ ou Ctrl+MaJ+G / Ctrl+G
Bonne lecture !
14/03/2023, 20h10
APL-AML
1 pièce(s) jointe(s)
Problème d'affichage de ma simulation dans l'actualité
14/03/2023 : Ce message se voulait être un commentaire de l'actualité qui affichait ma simulation de façon illisible mais il se retrouve dans le forum. Désolé !
15/03/2023 : Suite de l’histoire… L’actualité a été modifiée, merci à la personne qui est intervenu.
NB : Pour les blogueurs, chaque blog logique correspond à une page personnalisée (dans le tableau de bord du blog). On est limité à 5 pages personnalisées.
Création d’un jeu d’essai avec 22 candidatures (sans places libres)
Chaque même quart de feuille des pages à imprimer constitue une pile.
Deux tableaux permettent de spatialiser mentalement l’édition pour comprendre comment le NUMÉRO DE PLACE interagit avec le NUMÉRO DE POST-IT :
Tableau de gauche
La table des candidatures, triée sur le NUMÉRO DE PLACE, est traitée par le premier programme "post_itBDD.ace" afin de déterminer le rang des places (Post-it) qui permettra au deuxième programme d’imprimer en piles.
Ce tableau en trois dimensions (2 x 2 x n) représente l’impression de 4 numéros de table par page, "n" étant le nombre de pages, à savoir n = 6 pour ce jeu d’essai.
Deux compteurs Pile et Page modélisent les coordonnées spatiales - verticale et horizontale - des NUMÉROS DE PLACE et permettent de calculer Post-it pour chaque candidature :
Pile s'incrémente de 1 à 4
Page s'incrémente de 1 à n (n étant égal à 6 pour ce jeu d’essai)
Pile et Page ne sont finalement que les indices de deux tables virtuelles.
Sont surlignées les lignes correspondant aux NUMÉROS DE PLACE (1, 7, 13 et 18) à imprimer sur la première page.
La réflexion consiste à s’intéresser aux lignes avec un même numéro de page pour comprendre comment évolue POST-IT en fonction de Pile et Page.
Tableau de droite
La table des candidatures, triée sur le NUMÉRO DE POST-IT, permet au deuxième programme "post_itALL.ace" d’imprimer les NUMÉROS DE PLACE en piles.
Sont surlignées les lignes correspondant aux NUMÉROS DE PLACE imprimés dans la première pile.
Le placement des candidats se réalise au dernier moment avant l’édition et l’envoi des convocations. Le dernier numéro de place correspond à ce moment-là au nombre d'inscrits mais ce nombre d'inscrits pourra évoluer entre le placement des candidats et la date du concours.
Les candidatures postérieures à la date limite d’inscription ne sont pas prises en compte (hors délais) mais une candidature émise avant la date limite d’inscription peut toujours être reçue accidentellement après le placement. L’application gère cette situation mais ce n’est pas le problème présentement. Pour être exhaustif, il y a également le cas des candidats dits COTOREP. Des places particulières doivent alors être attribuées à ces candidats si leur handicap nécessite un aménagement particulier. On leur attribue un numéro de place au-delà du dernier numéro de place. Mais c’est vraiment pour l’anecdote.
Places libres
Je n’ai pas concrétisé de place libre dans ma simulation mais c’est facile à faire. Il suffit par exemple de désister le candidat N° 13. Il faut alors supprimer Place = 13 et Post-it = 3. On garde les informations Pile = 3 et Page = 1 pour visualiser notre simulation.
La candidature n’existant plus, le programme devra faire évoluer ces deux informations Pile et Page pour permettre de traiter correctement la candidature suivante.
Pour savoir s’il y a une place vide, le programme devra compter les candidatures traitées et comparer son compteur au numéro de place de la candidature en cours de traitement. Le programme devra évidemment prévoir le cas de plusieurs places vides qui se suivent, et qu’il y ait une ou plusieurs places vides au début comme à la fin de la table des candidatures à l’Examen-Concours.
Le programme d’édition, quant-à lui, va également s’apercevoir qu’il manque le Post-it N° 3 et imprimera un numéro de table 13 avec « Place libre » comme nom-prénom.
Édition du jeu d’essai
Ci-dessous, les six pages de l’édition des numéros de table du jeu d’essai :
