Règles de participation

Article 1

La participation au concours sous-entend l’acceptation du présent
règlement. Tout participant ne vérifiant pas l’un ou l’autre des articles de ce
règlement sera irrémédiablement éliminé et ne pourra prétendre à aucun cadeau
 :-<.

Article 2

Le concours est gratuit et ouvert à toute personne physique ou morale
(association, club, école...). Dans le cas d’un groupement d’individus, une
personne physique doit être désignée comme représentant pour écrire ou recevoir
tout courrier ayant trait au concours. Un seul cadeau sera fourni par équipe
quel que soit le nombre de participant.

Article 3

Les dénommés Gaétan Ryckeboer (ASR), Frédéric Gautier (Fred) sont considérés comme arbitres. A ce titre, ils
ne peuvent pas participer aux épreuves du championnat, mais veilleront au bon
déroulement des courses dans le respect du règlement.

Article 4

Chaque participant doit adresser
 par courrier à : Gaétan Ryckeboer, 6 Allée Henri Bergson, 35200 Rennes,
 ou par e-mail à [clx-concours@clx.anet.fr].

avant le 31 Août 2003 (le cachet de la poste ou du serveur de mails clx.anet.fr
faisant foi), une enveloppe contenant :

 1) Sur disquette 3 pouces et demi, formatée DOS ou Linux 1,44 Mo, ou sur CD-ROM :

• a) Un programme exécutable ou interprété, dénommé "Pilote Logiciel",
  respectant les conditions suivantes :
  • Exécutable statique ou script utilisable sous Linux, OpenBSD, FreeBSD, ou
    MacOSX à l’exclusion de tout autre système d’exploitation ;
  • Mémoire maximum exploitable pour son exécution : 10 Mo de mémoire.
  • Le script ou exécutable ne peut excéder 5 Mo ;
  • Le programme ne peut faire faire appel à d’autres librairies que les
    bibliothèques (ou librairies) standard installées sur tous les Un*x ;
  • Le programme doit être interruptible par un simple appui sur une touche. Le
    temps maximum alloué pour la génération du fichier .F1 contenant les
    déplacements du bolide sur un circuit est limité à 2 min (sur la machine de
    référence, un P2-350 sous console Unix Debian 2.2). Lors des épreuves de
    qualifications, les arbitres devront pouvoir interrompre le logiciel si ce
    délai est dépassé. Un temps maximum de réaction de 10 secondes sera toléré
    entre l’instant ou une touche est pressée et la sortie effective du
    programme ;
  • Le programme doit fonctionner "en l’état" et ne doit donc comporter aucun
    dispositif d’installation ou de configuration ;
  • Le programme doit fonctionner uniquement en ligne de commande et ne pas
    faire appel à des menus ;
  • Le programme doit accepter en unique paramètre de ligne de commande le nom,
    avec son extension, d’un fichier circuit à traiter, se trouvant dans le
    répertoire courant ;
  • Le programme doit créer dans le répertoire courant, pour chaque circuit
    traité, un fichier de même nom que l’exécutable mais d’extension .F1
    respectant les règles d’évolution de la F1 et la
    syntaxe des fichiers résultat ;
  • la création de fichiers temporaires est tolérée à raison d’un seul présent
    sur le disque à la fois ne dépassant pas une taille de 1 Mo. Tous les
    fichiers temporaires devront obligatoirement être détruit par le programme
    avant la fin de son exécution, et stockés dans /tmp.
• b) Un fichier de description de circuit, d’extension .CIR, dénommé "Circuit"
  par la suite, considéré comme conforme par le programme de validation
  CREECIR.EXE fourni aux participants.

 2) Une lettre manuscrite datée et signée ou un e-mail signé par GPG ou PGP
comprenant :

• Le nom et les coordonnées (adresse) de la personne physique participant au
  concours, ou du représentant physique dans le cas d’une participation
  groupée ;
• faisant attestation :
  • que le participant est bien l’auteur du programme fourni ou dûment mandaté
    comme représentant d’un groupe d’auteurs le cas échéant ;
  • que le programme est certifié fonctionner sans risque de porter atteinte à
    l’intégrité de tout système informatique sur lequel il sera amené à être
    exécuté ;
• engageant l’auteur :
  • à autoriser la diffusion gratuite de son pilote logiciel auprès des
    participants en faisant la demande pour vérification du résultat des
    épreuves éliminatoires venant en clôture du concours.
  • à fournir et autoriser la parution du source de son pilote logiciel sur le
    site de CLX, protégé par une licence libre de son choix.

NB : Chaque participant reste propriétaire de tous les droits sur ses logiciels
et sources créés à l’occasion de ce concours.

Article 5

Lorsqu’un participant envoie, avant le délai final fixé au 20 Novembre 2003,
une nouvelle version de son pilote logiciel et/ou de son circuit, celui-ci (ou
ceux-ci) se substitue(nt) au précédent envoi. Seule donc la dernière version
reçue (le cachet de la Poste faisant foi) participera aux épreuves de
qualification venant clore le concours.

Article 6

Seuls pourront prétendre à un cadeau les 50 premiers participants (date du
dernier courrier faisant foi) :

 ayant respecté les règles énoncées ci-dessus ;
 et dont le pilote logiciel aura parcouru de bout en bout, dans les temps
impartis, 70% des circuits qui lui seront présentés lors des épreuves de
clôture du concours.

Article 7

L’envoi des cadeaux prendra effet à partir de la date de clôture du concours.

Article 8

A l’issue du concours, tout participant pourra vérifier les résultats des
courses en faisant la demande écrite à l’un des arbitres, soit en joignant une
enveloppe pré-affranchie ainsi qu’une disquette à Gaétan Ryckeboer pour que lui
soient transmis les circuits et pilotes logiciels concurrents, soit par simple
e-mail (voir adresses plus haut).

Article 9

Les épreuves de qualification et éliminatoires venant clore ce concours sont
détaillées au chapitre épreuves de qualification

Épreuves de qualification

L’ordinateur sur lequel se dérouleront les courses est muni d’un processeur AMD
P2 à 350 MHz.

Un programme arbitre, baptisé TESTF1, sert à établir les temps de chaque pilote
logiciel sur les circuits qu’il a traité, analyser le fichier résultat généré
par le pilote et vérifier que le chemin décrit vérifie bien les règles
d’évolution ainsi que la syntaxe du fichier résultat.

Le temps mis par un pilote pour parcourir un circuit donné, ainsi que la
vitesse moyenne, sont ceux indiqués par le programme arbitre TESTF1, considéré
comme chronomètre officiel du concours.

testf1.exe

L’outil utilisé pour vérifier la validité d’une course

Ce programme est fourni avec ce numéro afin de permettre à chacun d’évaluer et
tester son pilote avant envoi.

Classement provisoire avant clôture du concours :

Sur le site de CLX, nous ferons paraître les performances des pilotes logiciels
sur un circuit de référence, au fur et à mesure des envois.

Ce circuit est celui fourni à titre d’exemple : MONACO.CIR

monaco.cir

Le circuit de base (à renommer)

Ce classement sera établi grâce au chronomètre officiel TESTF1.EXE

Épreuves de qualification à la clôture du concours :

Tous les concurrents seront regroupés par "poules" comprenant entre 6 (minimum)
et 12 (maximum) participants. La formation des poules se fera conformément à la
procédure d’organisation des poules décrite en annexe.

Dans chaque "poule", le pilote logiciel de chacun des participants en faisant
partie devra générer un fichier .F1 pour chaque circuit fourni par ses
co-listiers et par lui-même.

Classement des pilotes par circuit de la poule :

Ces fichiers .F1 seront ensuite traités par le programme arbitre TESTF1 qui
générera pour chaque circuit un fichier .LOG permettant d’établir par circuit
un classement des pilotes dressé selon les deux critères décroissants :

 Rapidité de couverture du parcours - vitesse moyenne

Pour chaque circuit de la poule, il sera attribué un nombre de points aux
différents pilotes logiciel, en fonction de leur position dans le classement
précédemment obtenu :

En cas d’ex aequo sur un circuit, tous les pilotes classés à la même position
marquent les points de cette position. Les points des places suivantes qui
auraient dû être occupées ne sont pas attribués.

Exemple : 3 pilotes ex aequo à la deuxième place marquent tous 6 points, le
suivant marque 2 points (position 5).

Classement des pilotes dans la poule (tout circuits confondus) :

Lorsque toutes les courses d’une poule sont terminées, on procède, pour chaque
pilote, à l’addition des points obtenus sur chacun des circuits qu’il a
parcouru au sein de la poule. Ce cumul de points sert de classement de la
poule. (On procède de même pour toutes les poules de l’épreuve de qualification
en cours)

Exemple :

En cas d’égalité de points entre plusieurs participants de la poule, les règles
de départage suivantes seront appliquées, classées par ordre de priorité :

 1) On enlève le moins bon résultat supérieur à 0 des participants ex aequo et
on les reclasse. On répète l’opération précédente autant de fois que
nécessaire jusqu’à ce que l’un ait plus de point que l’autre.

Ce système d’arbitrage fait que, dans l’exemple ci dessus, il vaut mieux
marquer 30 points en terminant 5 fois deuxième (5*6=30) plutôt que de gagner 3
fois (3*10=30). En effet, dans ce cas, après avoir enlevé le moins bon
résultat, Titi se retrouve avec 24 points et Tutu avec 20 points.

Ce système d’arbitrage essaie de privilégier la régularité au détriment des
coups d’éclats.

 2) Si malgré cela des participants restent ex aequo, il sera fait appel à la
question subsidiaire :

Le temps moyen de toutes les courses valides de la poule sera calculé (Par
course valide on entend une course pour laquelle le pilote n’a pas été
éliminé).

Le temps moyen est donc la somme de tous les temps obtenus sur toutes les
courses valides de la poule, divisée par le nombre de courses valides de la
poule.

Les participants seront classés en fonction de la proximité du temps estimé
qu’ils ont donné par courrier avant le début des courses et ce temps
calculé. Plus l’estimation préalable du participant est proche de la réalité,
meilleur sera son classement.

Sélection des pilotes pour les qualifications suivantes :

Ne sont retenus pour les épreuves de qualification suivantes que la moitié des
participants de chaque poule (arrondi au chiffre supérieur si le nombre de
participants est impair) en fonction du classement obtenu dans leurs poules
respectives.

Le total des points de chaque pilote est remis à 0 à l’issue de de cette
sélection et avant l’épreuve de qualification suivante.

On procédera ainsi à de nouvelles séances de qualification par poules en ne
gardant à chaque fois que la moitié des pilotes logiciels les plus performants
dans la leur. Et ce jusqu’à ce que le nombre de participants restant soit
inférieur ou égal à 12.

Poule finale :

Les rescapés des épreuves de qualification s’affronteront dans une poule finale
dont le classement se fera selon les mêmes règles que celles décrites ci-avant.

Sera déclaré vainqueur, le participant dont le pilote est classé premier de la
poule finale.

Pourquoi organiser des poules ?

Par Stéphane Pineau
Pourquoi organiser des poules et diviser ainsi les participants ?

Ben, parce que nous ignorons totalement le nombre de participants qui
répondront.(Beaucoup j’espère !)

Imaginez qu’il y ait 32 participants et que l’on fasse tourner les pilotes de
tous les candidats sur tous les circuits.. Il y aurait alors 32*32 courses, et
à raison de 5 minutes par course, cela prendrait 85 heures (sans pause !).

Pour 64 participants, on aurait 341 heures, soit plus de 14 jours...

Bref, comme on compte sur vous pour que ce concours soit un véritable succès,
il fallait bien trouver une solution !

D’où l’idée de répartir les participants en poules...

Comme si, par exemple, il y avait plusieurs championnats de Formule 1, un en
Europe, un en Afrique, un en Asie et un en Amérique.

On organise des championnats ’régionaux’ et on sélectionne (qualifie) les
meilleures voitures de chaque région pour une finale.

Un championnat régional, c’est ce que l’on appelle une poule. Dans ce
championnat, chaque voiture tourne sur chacun des circuits.

Comme en Formule 1, pour chaque circuit, on attribue des points aux meilleurs
participants.

À l’issue du championnat, les meilleures voitures sont qualifiées, les autres
étant éliminées.

L’objet de ce chapitre est de vous décrire la méthode retenue pour diviser les
participants en poule.

Ce n’est pas très simple à comprendre, car on a veillé à ne pas trop éliminer
de candidats à chaque fois, quitte à être obligé de subdiviser encore plus si
nécessaire (championnat local, qualifiant pour un championnat régional,
lui-même qualifiant pour la poule finale...).

Les concurrents seront, en fonction du nombre de participants, divisés en
plusieurs poules. Le nombre de poules dépend du nombre de participants par la
formule :

nombre_de_poule= 1+ trunc(nombre_de_participants / 12)

trunc indique un arrondi à la valeur inférieure (exemple
trunc(3.9)=3). Ceci permet de définir des poules de 12 candidats maximum.
Ex. :
 8 participants -> 1 poule
 12 participants -> 2 poules (2 poules de 6 participants)
 15 participants -> 2 poules (une poule de 7 et une de 8)
 32 participants -> 3 poules (2 poules de 11 et une de 10)
 36 participants -> 4 poules (4 poules de 9)
 etc..

Ensuite les participants sont répartis dans les poules en fonction de la date
postale de leur premier envoi. Le premier envoi reçu allant dans la première
poule, le second dans la deuxième et ainsi de suite. Dès que l’on dépasse le
nombre de poules, on recommence à la première poule.

Exemple : 32 participants : 3 poules

On aura 2 poules de 11 participants et une de 10 participants.

La course sera organisée par poule et seront qualifiés au moins la moitié des
participants de la poule. Si le nombre de candidats dans la poule est pair,
c’est juste la moitié qui est qualifiée, si le nombre est impair, on arrondit
la moitié du nombre de participants au chiffre supérieur.

Dans notre exemple, on qualifiera 6 participants des 2 premières poules et 5
participants de la troisième. Le nombre de candidats restant en course après le
premier tour est donc de 17.

On reprend la procédure initiale, avec les seuls candidats qualifiés, et en les
plaçant dans les nouvelles poules suivant un balayage en ’zig-zag’.

Par exemple, si on appelle p1_1 à p1_6 les 6 qualifiés de la poule 1 du premier
tour, (et p2_x et p3_x respectivement ceux de la poule 2 et 3) la répartition
des 2 poules du deuxième tour se fera (toujours pour notre exemple initial à 32
participants) :

On répète l’opération de qualification et de mise en poule, jusqu’à ce qu’il
n’y ait plus qu’une seule poule, baptisée poule finale.

Le classement du concours est le classement de la poule finale.

Résumons par un exemple concret

Pour participer au concours, vous avez deux fichiers à fournir, en plus de la
lettre manuscrite :

 1) Un fichier décrivant un circuit, d’extension .CIR. C’est, entre autres, sur
ce circuit que votre voiture et celles de vos concurrents devront évoluer.

Pour créer ce circuit, il vous est possible d’utiliser l’outil fourni dans
les annexes, baptisé
CREECIR.EXE.

Pour dessiner votre circuit, il suffit de taper :

CREECIR mon_circuit

où mon_circuit est le nom que vous donnez à votre circuit.

Votre circuit ne peut pas être quelconque, il doit vérifier certaines règles
pour être conforme au règlement.

Un bouton, marqué OK, permet de vérifier dans CREECIR, si un circuit est
conforme au règlement.

Pour tester le programme CREECIR, nous avons joint au Reporter un circuit test
de démonstration (MONACO.CIR).

Ce fichier est le dessin d’un circuit conforme au règlement.

Pour autant que votre PC soit en mode VGA et dispose sous DOS d’un driver de
souris, vous pouvez visualiser, modifier le circuit, ainsi que vérifier sa
conformité au règlement, à l’aide du logiciel CREECIR.EXE :

<code185|center>

CREECIR monaco

Vous pouvez aussi visualiser, à l’aide d’un éditeur quelconque tel que EDIT, le
fichier .CIR généré. Il est au format ASCII et la piste est tout simplement
représentée par le caractère ’ ’ (espace).

Vous pouvez vous amuser à modifier le circuit MONACO.CIR afin de le rendre non
conforme et constater le verdict du programme de vérification.

 2) Le deuxième fichier à fournir est votre programme de pilote, celui qui
décrira l’évolution de votre voiture sur un circuit donné.

Il reçoit, comme paramètre d’entrée, le nom du circuit sur lequel la voiture
doit boucler un tour. En sortie, il génère un fichier ASCII, décrivant
l’évolution de la voiture et qui respecte les règles physiques du comportement
de la voiture sur la piste.

La syntaxe d’appel est, par convention :

votre_programme nom_de_circuit.CIR

et son action est de créer un fichier votre_programme.F1 à partir du circuit
nom_du_circuit.CIR.

Pour vous évitez de tester le principe du concours en écrivant dès maintenant
un pilote automatique, dans les annexes du concours, vous trouverez
un tel programme.

Ce pilote automatique de démonstration n’est pas du tout performant (vous
pourrez faire nettement mieux) car notre but est juste de montrer ce que nous
attendons des participants.

Ce programme de pilote automatique de démonstration est baptisé DEMO_2CV.EXE,
et il génère, à partir d’un fichier circuit .CIR conforme un fichier résultat
(d’extension .F1) qui vérifie la syntaxe des fichiers résultats.

Pour utiliser le pilote de démonstration tapez :

DEMO_2CV monaco

et le programme génèrera un fichier résultat MONACO.F1. Bien entendu, le
fichier résultat est en ASCII et est donc parfaitement lisible avec un éditeur
de textes...

Enfin, pour contrôler le fichier résultat d’une voiture, et effectuer un
chronométrage officiel de la voiture, utilisez le programme arbitre fourni :
TESTF1.EXE.

Grâce à ce programme, les temps réalisés sont vérifiables par TOUS !

En plus de son rôle de ’chronomètre’, TESTF1 vérifie que le résultat obtenu par
le programme pilote est correct, à savoir que la voiture respecte les règles
d’évolution et qu’aucune collision n’est constatée avec les bords de piste.

TESTF1 reçoit comme paramètre d’entrée le nom du fichier résultat (d’extension
F1) qu’il doit vérifier.

Pour visualiser la course qu’a effectuée le pilote automatique de démonstration
et connaître son chronométrage précis, il ne reste plus qu’à faire tourner le
programme arbitre, à savoir :

TESTF1 demo_2cv.F1