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 :

position	points
1	10
2	6
3	4
4	3
5	2
6	1
7 à 12	0

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 :

Position	Pilote	Points par Circuits		1	Toto	10+10+10+6+4+2=42
2	Titi	6+6+6+0+6+6 =30
3	Tutu	10+10+10+0+0+0=30
..	...	...
6	Tata	0+0+1+2+0+1 =04

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

poule 1	poule 2	poule 3
1	2	3
4	5	6
7	8	9
10	11	12
13	14	15
16	17	18
19	20	21
22	23	24
25	26	27
28	29	30
31	32

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) :

poule 1	rencontre	poule 2
p1_1	->	p1_2
p1_4	<-	p1_3
p1_5	->	p1_6
p2_2	<-	p2_1
p2_3	->	p2_4
p2_6	<-	p2_5
p3_1	->	p3_2
p3_4	<-	p3_3
p3_5

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 :

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