π
<-
Chat plein-écran
[^]

News 2019

News 2018
Août (11)
Juin (3)
Mai (10)
Avril (2)
Mars (4)

News 2017
Août (15)
Juillet (18)
Juin (1)
Mai (7)
Avril (4)
Mars (7)

News 2016
Août (17)
Juillet (16)
Juin (2)
Mai (2)
Avril (1)
Mars (5)

News 2015
Août (25)
Juin (4)
Mai (9)
Avril (4)
Mars (10)

News 2014
Août (4)
Juin (11)
Mai (12)
Avril (9)
Mars (12)
Janvier (13)

News 2013
Octobre (11)
Août (5)
Juin (9)
Mai (12)
Avril (10)
Mars (7)
Janvier (10)

News 2012
Août (12)
Juillet (10)
Juin (13)
Mai (22)
Avril (8)
Mars (5)

News 2011
Octobre (23)
Août (1)
Juin (29)
Mai (11)
Avril (5)
Mars (3)

News 2010
Août (2)
Juin (5)

News 2009
Août (1)
Juin (1)
Mai (1)
Avril (1)
Mars (1)

POTY 2018 : Elis le logiciel de l'année !

Nouveau messagede critor » 13 Jan 2019, 14:17

Après les TI-82+/83+/84+, la TI-84+CSE, les TI-83PCE/84+CE, les TI-89/92+/V200 et les TI-Nspire,
ticalc.org
, propose te maintenant la 6ème et dernière catégorie de son vote
POTY 2018
pour élire les meilleurs programmes de l'année 2018.

La catégorie de cette semaine concerne les logiciels pour ordinateur avec deux participations :

Pour voter, il faut d'abord créer un compte sur le site si on n'en a pas encore, puis le sondage est sur la page principale, en-dessous du flux Twitter.

Bon vote et à bientôt pour l'annonce des grands gagnants ;)


Source
:
https://www.ticalc.org/archives/news/ar ... 49237.html
Lien vers le sujet sur le forum: POTY 2018 : Elis le logiciel de l'année ! (Commentaires: 2)

Récapitulatif/Statistiques de l'année 2018 sur TI-Planet !

Nouveau messagede Adriweb » 07 Jan 2019, 00:46

C'est reparti comme en 2017 ! Voici l'habituelle news récapitulative de 2018 pleine de stats ;)

Comparaison 2018 vs 2017

Cette fois ci, les volumes de visites etc. sur TI-Planet en soit-même sont resté quasiment stable (delta < 0.5%) par rapport à l'année d'avant.

Mais détrompez-vous, c'est en fait
remarquable
, car nous avons scindé une (très) grosse partie de notre activité lors des examens (les ECE du Bac) à un nouveau site dédié, ECEBac.fr.
Et c'est pas peu dire, car comme mentionné dans un article dédié, celui-ci a enregistré dans sa période phare environ 230000 visiteurs en 3 semaines, avec un total d'environ 7,6 millions de pages vues, dont un pic à plus de 5 000 visiteurs connectés en simultané. Certes, TI-Planet a eu autant de visiteurs aussi en 3 semaines :troll: Mais ça reste sacrément impressionnant pour un site lancé juste quelques semaines avant, non ? 8-) En cumulant ceci + ToutMonExam, l'ensemble est alors en forte croissance, même si une partie des visiteurs doit être sur plusieurs de nos sites à la fois :)


Stats de base

  • Plus de
    1300 topics
    et plus de
    13000 posts
    créés
  • Plus de
    550 archives
    mises en lignes ou mises-à-jour (hors BAC/DNB...), dont 260 sur CE, puis 80 sur Nspire ! (puis HP Prime, Prizm, 82A, et le reste)
  • ... et les archives nouvelles ont cumulé plus de
    99000 téléchargements
    !
    (voir plus bas pour le top)
  • Environ
    550000 générations
    (si, si)
    créées grâce à nos éditeurs en ligne.
  • Plus de
    41500 membres
    (6500 de plus par rapport à l'année dernière) se sont inscrits sur le forum (il y a peu de robots/spam), dont environ
    43% via Facebook
    .
  • Top 10 des pays des visiteurs: France (68.9%), Etats-Unis (5.4%), Brésil (3.3%), Maroc (1.5%), Réunion (1.2%), Canada (1.2%), Allemagne,Pérou,Portugal,Mexique (≈ 1% chacun).
  • Durée moyenne de chaque visite : environ
    ≈5 minutes
    (visiteurs), et
    ≈14 minutes
    (membres connectés).
  • Bonus:
    TI a visité le site 16% de plus qu'en 2017, et pour environ 2 fois plus longtemps à chaque visite (merci ;))


Top 20 des news(/topics liés) les plus populaires
(hors BAC/DNB... et hors QCC, cf. juste après)

  1. KhiCAS: rajoute CAS + Python sur ta Graph 90+E :
    14600
    lectures
  2. Mise à jour Graph 90+E avec Python - rentrée 2018 ! :
    10450
    lectures
  3. OS 5.3.1 bloque le développement assembleur sur calculatrice :
    9580
    lectures
  4. HP Prime G2/D rentrée 2018 : spécifications astronomiques ! :
    8450
    lectures
  5. APMEP 2018 à Bordeaux avec Casio, HP, NumWorks, TI et KhiCAS :
    8350
    lectures
  6. Triconcours de rentrée 2018 - défi de Sagesse :
    7890
    lectures
  7. Triconcours de rentrée 2018 - défi de Force :
    6930
    lectures
  8. Rajoute l'arabe à ta TI-Nspire CX avec l'OS 3.3 :
    6870
    lectures
  9. TI-Boy CE: émulateur Game Boy pour 83 Premium CE/84 Plus CE! :
    6790
    lectures
  10. Triconcours de rentrée 2018 - défi de Courage :
    6780
    lectures
  11. Prof. de Maths/Sciences? Reçois une Graph 90+E avec Python ! :
    6620
    lectures
  12. Méga mise à jour HP Prime 13333: 3D Python étude fonction... :
    6370
    lectures
  13. TI-83 Premium CE avec Python - rentrée 2019 :
    6260
    lectures
  14. Test prototype clavier Nspire Simpkey A1-P à triplets :
    5880
    lectures
  15. TI-83 Francium X : processeur Nspire + Python - rentrée 2018 :
    5860
    lectures
  16. OS 5.3.1 avec super mode exam pour TI-83 Premium / 84+CE :
    5600
    lectures
  17. Test prototype clavier Nspire Simpkey A1 à triplets :
    5590
    lectures
  18. Nouvelle fx-92+ Spéciale Collège : programmation + tableur ! :
    5440
    lectures
  19. 83 Premium CE: Python via module externe; 1er trimestre 2019 :
    5410
    lectures
  20. La fx-92+ Spéciale Collège programmable déjà en magasin ! :
    5060
    lectures

QCC 2018
: notre grand comparatif / guide d'achat a été très apprécié, sans surprise, et a réuni plus de
52000
lectures à lui seul :bj:


Archives uploadées en 2018 avec 1000+ téléchargements
 (hors sujets/corrigés/témoignages BAC/DNB...)



Top 10 des images en galerie


9793
HP Prime G2/D

August 2018

Vue 2383 fois
9297
Prototype TouchPad DVT1

February 2018

Vue 1943 fois
9783
HP Prime G2/D

August 2018

Vue 1686 fois
9790
HP Prime G2/D

August 2018

Vue 1520 fois
9854
TI-83PCE + Attack of the Snails

October 2018

Vue 1373 fois
9296
Prototype TouchPad DVT1

February 2018

Vue 1364 fois
9295
Prototype TouchPad DVT1

February 2018

Vue 1354 fois
9792
HP Prime G2/D

August 2018

Vue 1341 fois
9607
TI-83 Premium CE + Columns CE

June 2018

Vue 1190 fois
9293
Prototype TouchPad DVT1

February 2018

Vue 1047 fois
9358
Casio Graph 90+E + Flight

March 2018

Vue 895 fois
9780
HP Prime G2/D

August 2018

Vue 792 fois




Top 25 des membres les plus actifs

  • Sur le forum :

    critor
    (3493 posts, soit 9.6 / jour),
    Adriweb
    (729 posts, soit 2.0 / jour),
    parisse
    (648 posts, soit 1.8 / jour),
    Hamza.S
    (429 posts, soit 1.2 / jour),
    Wistaro
    (371 posts, soit 1.0 / jour),
    parrotgeek1
    (349 posts, soit 1.0 / jour),
    Paneth
    (345 posts, soit 0.9 / jour),
    puppy65
    (315 posts, soit 0.9 / jour),
    Ti64CLi++
    (310 posts, soit 0.8 / jour),
    leJKnational
    (284 posts, soit 0.8 / jour),
    Lionel Debroux
    (234 posts, soit 0.6 / jour),
    UnCurieux
    (212 posts, soit 0.6 / jour),
    Clifward
    (197 posts, soit 0.5 / jour),
    Extra44
    (181 posts, soit 0.5 / jour),
    gam
    (168 posts, soit 0.5 / jour),
    Bisam
    (159 posts, soit 0.4 / jour),
    Hayleia
    (143 posts, soit 0.4 / jour),
    jean-baptiste boric
    (135 posts, soit 0.4 / jour),
    Thom986
    (107 posts, soit 0.3 / jour),
    majestyofgaia
    (100 posts, soit 0.3 / jour),
    kinkazma
    (99 posts, soit 0.3 / jour),
    blouson
    (88 posts, soit 0.2 / jour),
    Herlock
    (75 posts, soit 0.2 / jour),
    nbenm
    (71 posts, soit 0.2 / jour),
    Alvoko
    (68 posts, soit 0.2 / jour)
  • Sur le tchat :
    (tout compris):
    Paneth
    (57739 posts, soit 158.2 / jour),
    Hayleia
    (28564 posts, soit 78.3 / jour),
    noelnadal
    (21680 posts, soit 59.4 / jour),
    Clifward
    (19382 posts, soit 53.1 / jour),
    MMBC_Chris
    (16510 posts, soit 45.2 / jour),
    IAMISSAM
    (14433 posts, soit 39.5 / jour),
    TheMachine02
    (12262 posts, soit 33.6 / jour),
    GalacticPirate
    (10126 posts, soit 27.7 / jour),
    Alvoko
    (9491 posts, soit 26.0 / jour),
    critor
    (9017 posts, soit 24.7 / jour),
    V0id
    (8993 posts, soit 24.6 / jour),
    gam
    (8368 posts, soit 22.9 / jour),
    Hamza.S
    (8324 posts, soit 22.8 / jour),
    loupiot
    (8249 posts, soit 22.6 / jour),
    Wistaro
    (8118 posts, soit 22.2 / jour),
    Ruadh
    (6189 posts, soit 17.0 / jour),
    Ti64CLi++
    (5572 posts, soit 15.3 / jour),
    Syrusse
    (4615 posts, soit 12.6 / jour),
    Dark coco
    (4504 posts, soit 12.3 / jour),
    Rose Cerise
    (3182 posts, soit 8.7 / jour),
    Flalamèche
    (2754 posts, soit 7.5 / jour),
    leJKnational
    (2666 posts, soit 7.3 / jour),
    Jerome24
    (2242 posts, soit 6.1 / jour),
    ☭Riyusa☭
    (2143 posts, soit 5.9 / jour),
    Anonyme0
    (2136 posts, soit 5.9 / jour)

Merci à tous pour cette année 2018 sur TI-Planet, bonne année 2019 encore une fois, et qu'elle soit encore meilleure que 2018 ! :D


Image
Lien vers le sujet sur le forum: Récapitulatif/Statistiques de l'année 2018 sur TI-Planet ! (Commentaires: 9)

Montage kit pare-chocs TI-Innovator Rover par A4 Technologie

Nouveau messagede critor » 01 Jan 2019, 14:46

9049Le
TI-Innovator Rover
, robot pilotable via une interface
TI-Innovator Hub
depuis une
TI-83 Premium CE
ou
TI-Nspire CX
, est muni d'un sonar à l'avant.

Cela lui permet en théorie de connaître la distance le séparant d'un obstacle.

En pratique toutefois, l'on rencontre plusieurs problèmes :
  • D'une part cela ne donne aucune information sur comment contourner l'obstacle en question
    (par la droite ? par la gauche ?...)
    .
  • Et d'autre part le sonar détecte mal certains types d'obstacles. On peut citer notamment des objets de petites dimensions, ou encore des obstacles faits d'un matériau absorbant les ondes sonores
    (mousse, tissu...)
    .

10142Mais heureusement, dans son catalogue 2018-2019,
A4 Technologie
t'annonçait une solution, un kit pare-chocs dédié au robot
TI-Innovator Rover
.

Depuis, le kit a été listé sur leur site et donc maintenant disponible. Puisque nous en avons reçu un, nous allons le déballer et l'installer devant toi.

101491014310144Le kit comprend deux microrupteurs qui permettront de détecter donc un obstacle arrivant par la gauche ou par la droite, et ainsi de le contourner facilement.

Les deux microrupteurs sont vissés de deux plaques symétriques qui sont à fixer à l'avant-droite et à l'avant-gauche du robot
TI-Innovator Rover
grâce à ses empreintes compatibles
Lego Technic
.

1014610145Câblés au format
Grove
, ils sont donc à relier à deux des trois ports d'entrée de l'interface
TI-Innovator Hub
(
IN 1
,
IN 2
ou
IN 3
)
.

Il faudra bien sûr se trouver une astuce pour fixer les câbles afin d'éviter qu'ils ne s'accrochent à quelque chose et provoquent un accident pendant le fonctionnement du robot.

1014810147Le pare-chocs quant à lui vient avec deux clips amovibles qui permettent de le verrouiller sur les deux microrupteurs.

Notons enfin que le pare-chocs maintenant dans sa position finale se situe légèrement en-dessous du sonar et ne gêne donc pas son utilisation. :bj:

Le kit pare-chocs pour ton robot
TI-Innovator Rover
est disponible à
19,50€HT
soit
23,40€TTC
.

Si tu souhaites économiser un petit peu, tester avant de t'engager sur un volume plus important, ou encore si tu es pressé(e),
A4 Technologie
te met gracieusement à disposition les fichiers d'impression 3D des différents éléments en plastique
(le pare-chocs, la fixation qui va avec à imprimer en double, et le support microrupteur à imprimer en deux exemplaires symétriques)
.

Il te restera toutefois à te procurer séparément les deux microrupteurs, les câbler correctement au format
Grove
, et les visser.


Téléchargement
:
fichiers STL du kit pare-chocs
TI-Innovator Rover


Lien
:
https://www.a4.fr/ti-innovator-rover-kit-pare-choc.html
Lien vers le sujet sur le forum: Montage kit pare-chocs TI-Innovator Rover par A4 Technologie (Commentaires: 0)

Bonne année 2019 !

Nouveau messagede critor » 01 Jan 2019, 00:00

Avec les dernières secondes de l'année 2018, l'
Égalité
aux examens s'éteint officiellement. Espérons que
ce n'est qu'un au-revoir
...



2019 est effectivement l'année maudite de la mise en place du mode examen, une monstruosité sans nom qui en plus de n'apporter qu'une sécurité en carton comme maintes fois démontré ici, a été réglementée avec les pieds et se transforme ainsi en catastrophe pour les droits du candidat, scandale que nous ne manquerons pas de rappeler aussi souvent que possible à compter de la rentrée.

Mais que ces temps difficiles ne nous empêchent pas de continuer le combat pour une
B
o
n
n
e
A
n
n
é
e
2
0
1
9
!

Image
Lien vers le sujet sur le forum: Bonne année 2019 ! (Commentaires: 11)

(Un)Boxing week - day #3 : PocketMate 140 et 400

Nouveau messagede critor » 28 Déc 2018, 13:47

La
Boxing week
est une période de 6 jours débutant le 26 décembre. Le terme, inventé et popularisé dans les années 2000 en
Grande Bretagne
et dans les pays du
Commonwealth
, désigne une période de promotions où les différents distributeurs écoulent leur stock de
Noël
invendu, à l'origine à des prix intéressants.

Dans notre
(Un)Boxing week 2018
sur
TI-Planet
, nous te proposons donc, cette semaine uniquement, de te déballer tous nos cadeaux inédits à raison de 1 par jour, un petit avant-goût des recherches, tests et expériences à venir sur le site pour l'année 2019 ! ;)



Même si tu l'ignores,
Texas Instruments
n'a pas fait que des calculatrices comme produits électroniques grand public.

En 1987,
Texas Instruments
lance sa branche d'assistants électroniques de poche gérant les données personnelles
(répertoires téléphoniques et carnets d'adresses électroniques - en anglais data banks)
, avec le
TI-2700 Mini Data Bank
.

En 1991,
Texas Instruments
sépare cette branche en deux sous-branches qui évolueront en parallèle, avec une nouvelle gamme de produits : les agendas électroniques
(en anglais personal organizers)
. La nuance est qu'ils disposent en plus d'un calendrier permettant de créer des rendez-vous, et potentiellement de les associer aux données précédemment citées. Le premier du nom est le
PS-6200
, et à partir de ce moment-là les modèles sortis dans ces deux branches seront tous préfixés par
PS
pour
Pocket Solutions
.

En 1997,
Texas Instruments
rafraîchit la branche des
personal organizers
avec un éventail de trois nouveaux modèles pour lesquels il opte de plus pour un nouveau préfixe,
PocketMate
:
  • le
    PocketMate 200
  • le
    PocketMate 300
  • le
    PocketMate 400

En 1998,
Texas Instruments
fait de même avec la gamme des
data banks
, avec :
  • le
    PocketMate 100
  • le
    PocketMate 120
  • le
    PocketMate 140

Et c'est fini, en mai 2000
Texas Instruments
annonce sur son site l'abandon du développement des assistants électroniques de poche.

10126Nous avons l'honneur et le plaisir de disposer aujourd'hui de la version haut de gamme des toutes dernières créations de
TI
dans ses deux branches d'assistants personnels, le
PocketMate 140
avec boîte et manuel, ainsi que le
PocketMate 400
en
loose
.

D'éventuels liens avec le développement des calculatrices graphiques contemporaines de ces produits ? La réponse bientôt en 2019, et en attendant rendez-vous demain pour la prochaine surprise ! ;)
Lien vers le sujet sur le forum: (Un)Boxing week - day #3 : PocketMate 140 et 400 (Commentaires: 1)

Joyeux Noël 2018 !

Nouveau messagede critor » 25 Déc 2018, 00:00


A tous ceux qui nous lisent,

Et au nom de toute l'équipe,

J
o
y
e
u
x
N
o
ë
l
2
0
1
8
!


:ange:


Lien vers le sujet sur le forum: Joyeux Noël 2018 ! (Commentaires: 4)

Triconcours de rentrée 2018 - résultats défi de Courage

Nouveau messagede critor » 28 Nov 2018, 21:26

Voici les résultats du défi de Courage de notre Triconcours de rentrée 2018. Vous avez été pas moins de 17 à produire 57 participations.

Il s'agissait de chevaucher le nuage Kinto-un pour aller chercher les 8 fragments de la
Triforce du Courage
, bien évidemment le plus rapidement possible. Pour cela, un programme était fourni dans le langage de programmation historique de chaque modèle de calculatrice graphique conforme 2019 ainsi que les modèles antérieurs compatibles. Il permettait de piloter le nuage à l'aide de 3 touches fléchées, codant une liste de déplacements à fournir et auto-évaluant le score.

et sa
TI-83 Premium CE
arrivent
16ème
avec
3842
points.


/ se classe quant à elle
15ème
avec
3885
points.


Et maintenant les gagnants :
doté de sa
HP Prime
termine
14ème
avec
4556
points.
@nicodu95, comment as-tu fait ? ;)

nicodu95 a écrit:J'ai utilisé l'émulateur HP Prime. Armé de mon clavier et des flèches et après une bonne dose d'essais (et de re-essais) j'ai obtenu un score de 2800. J'ai ensuite tenté de comprendre un peu le fonctionnement de la "spirale", je suis arrivé à 4200 points. Puis j'ai copié la liste kinto pour pouvoir la modifier (et la sauvegarder), j'y ai rajouté quelques lignes de nombres avec un peu de raisonnement, 4555 points. Mais il m'a fallu surtout de la persévérance (et du temps).


aidé de sa
Casio Graph 35+E
prend la
13ème
place avec
7721
points.
@Disperseur, comment as-tu fait ? ;)

Disperseur a écrit:voila la petite explication de la maniere dont j'ai realise mon score (aussi petit soit-il):

Avant tout, sachez que j'ai cherché la solution vers le debut de l'epreuve. Le dernier envoi que j-ai effectué s'est fait la fin de la troisième ou quatrième semaine.
Au debut j'ai été un peut au hasard dans la liste 6. Puis j'ai fait une capture de l'ecran avec seulement les 8 pts et je l'ai imprimée en plusieurs exemplaires pour tester au crayon les chemins possibles. Puis au fur et à mesure que j'essayait des chemins je suis tombé sur une bonne methode (apres avoir fait un tas de tests pour comprendre comment le nuage se déplaçait aussi) qui consiste à tourner en mettant des "0" dans la liste 6 (ce qui ne me fait pas perdre de pts, eh oui :E )pour "viser" les pts et aller les chercher avec une grande valeur type "1" et en revenant à chaque fois en "0". Les trois derniers points, je les ais attrapés en tournant. C'est cette solution qui s'est avérée être la meilleure que j'etais capable de fournir.
Voila ! ;)


armé de sa
Casio Graph 35+E
décroche la
12ème
place avec
7746
points.
@Alexot, comment as-tu fait ? ;)

Alexot a écrit:La méthode que j'ai utilisé pour obtenir mon score est assez simple : j'ai essayé de comprendre comment fonctionnait le programme en expérimentant dans l'option "Manuel". J'en ai déduit une interprétation de ce qu'il se passait quand on appuyais sur les différentes touches: le point qu'on contrôle fonctionne un peu comme une fusée attirée par une sorte de gravité vers le centre de l'écran, et pouvant se propulser vers l'avant(par "vers l'avant", je veux dire vers la direction dans laquelle elle va déjà). Appuyer sur gauche baisse l'intensité des propulseurs, droite augmente cette intensité, et appuyer sur gauche, droite, ou haut fait avancer plus ou moins la fusée selon l'intensité des propulseurs, et attire un peu la fusée vers le centre. En regardant la liste 6 générée, les nombres contenus dans celle-ci pourraient correspondre à l'intensité des propulseurs. Même si je doute que le programme fonctionne comme ça, et que c'est pas très rigoureux, en ayant en tête ce fonctionnement, on peut plus ou moins arriver à contrôler kinto1.
Puis j'ai un peu tatonné pour essayer d'ajuster ma trajectoire et d'atteindre tous les fragments.


avec sa fidèle
Casio Graph 35+E
termine
11ème
avec
7794
points.
@Massena, comment as-tu fait ? ;)

Massena a écrit:Pareil que Shadow. :D

Je pense connaître enfin ce que c'est le karma. Le 4 Novembre, j'ai voulu ninja ma participation à 8500 pts. Juste pour créer un effet de surprise x) Mais je m'aperçois le lendemain que mon mail est envoyé à... Moi même. Seum.

https://www.planet-casio.com/Fr/forums/topic15439-1-Triconcours-et-l-epreuve-de-courage.html#159801


sur
HP Prime
se classe
10ème
après avoir atteint
8443
points.
@eried, comment as-tu fait ? ;)

eried a écrit:The description talks about
our hero
in a cloud having to visit spots in a map keeping the score as maximum possible. At first, it was difficult to understand, but you basically have a polar function that you modify with parameters and you have to go between specific points while completing the route.

I started analyzing the positions of the layout with a
Travelling Sales man Problem solver
.

But, then you have to restrict your solution to what is possible. Playing the game goes like this:

  1. Open the app
  2. Press Symb and enter a list
  3. See the updated map and score
  4. Press Symb again and modify the list
  5. Go to step 3
Some of the steps are quite slow, using the Calculator editor for lists is a pain, the brackets try to be smart, you have to copy the old list and change the ending of it to try different outcomes, etc.

So what was my solution this time?


A modified version of PrimeMon that also executed the code after you saved it in the HP Connectivity Kit. So you could have the list you were trying to edit and every time you hit Save, the HP Prime Virtual Calculator displayed the results instantly.

PrimeMon is a little tool that I wrote years ago, after PrimeComm (a much more complete toolset for the HP Prime) stopped working, that allows you to interface with the Virtual Prime for checking if you have syntax errors easily. This just exists because the HP Connectivity Kit editor is very primitive and does not check anything.


Using this little tool I was able to have a pleasant puzzle-like experience while watching a movie.

My score was again really poor, #10. But again, I had a lot of fun!

If I had to do it again, I would have coded a small routine to solve it in the calculator itself. That new modified app would wait for a screen tap and try to add elements (i.e. testing a range from -10 to 10) to the list keeping the distance as the minimum possible and stopping when is in radius of the tapped point.

https://erwin.ried.cl/post/180137142402/a-cool-calculator-challenge-triconcours-universel


Jean B.
a travaillé quant à lui sur
TI-83 Premium CE
. Il avait au départ exploité un bug présent sur certaines version du programme, en fournissant une liste complexe qui permettait de se téléporter directement d'un fragment à un autre. Malheureusement, le bug en question n'était pas présent sur la version
TI-Nspire
, et nous ne pouvions donc équitablement accepter cette astuce. Les programmes de participation concernés ont depuis été corrigés.

Il trône donc à la
9ème
place avec
8793
points pour une liste plus conventionnelle.
@Jean, comment as-tu fait ? ;)

Jean B. a écrit:A force de petits tests manuels en modifiant KINTO, j'ai remarqué, entre autres, que le tracé forme globalement une spirale allant dans le sens inverse de celui des aiguilles d'une montre. De là on peut en déduire le chemin optimal, alors que cela paraît contre-intuitif au début : comme vous le voyez sur l'image de ma participation, il faut faire un grand trait au début faisant beaucoup diminuer le score.


Astrostellar
toujours sur
TI-83 Premium CE
décroche la
8ème
place avec ses
8804
points.
@Astrostellar, comment as-tu fait ? ;)

Astrostellar a écrit:J'avais tout d'abord compris qu'entre chaque valeur de ma liste, je n'avais le droit que de rajouter ± 0.01, ou alors de ne pas changer sa valeur... J'ai donc envoyé une première participation avec cette contrainte à 6614 points.
Après avoir compris que je pouvais mettre les valeurs que je souhaitais, j'ai repris ma candidature en faisant passer mon chemin par un point qui me faisait avant faire un grand détour. J'ai envoyé cette participation et j'ai eu 7718 points.
Puis j'ai re-réfléchi en cherchant le chemin le plus court permettant de relier les points dans le sens inverse des aiguilles d'une montre. J'ai trouvé le chemin qu'on suivi une grande partie des autres participants. J'ai donc envoyé une dernière participation en suivant ce chemin à 8804.3258 points.
Je me doutais qu'il y avait un "truc" pour gagner encore plus de points, vu la différence entre les 4 premiers participants et les autres, mais je n'ai pas trouvé ce que c'était (en regardant à l'intérieur du programme et en voyant des e^i, j'ai pris peur et n'ai pas compris le système de points ;) ).
Les valeurs que j'ai mises dans ma liste, je les ai trouvées en tâtonnant : je rajoutais une dizaine de valeurs, je regardais ce que ça traçait, je modifiais ensuite certaines valeurs et je passais aux valeurs suivantes...


/ a pour sa part travaillé sur
Casio Graph 35+E
. Il a été le premier à exploiter la faille des listes complexes permettant le
déplacement instantané
d'un fragment à un autre.

Il est certes aujourd'hui administrateur de
Planète Casio
, mais seulement depuis ce 13 novembre dernier soit bien après la date limite de participation, et n'a bien évidemment bénéficié d'aucune information privilégiée, seules les administrateurs en poste ayant accès aux éléments en cours de préparation pour les concours.

Il s'accapare la
7ème
place à
8972
points avec une liste cette fois-ci bien réelle.
@Shadow15510, comment as-tu fait ? ;)

Shadow15510 a écrit:rectifie, je suis arrivé à 9500 mais aujourd'hui à 10h30... :lol:
Pour moi ma technique est je pense la plus longue et la moins rentable : tu entres un nombre tu regarde ce qu'il se passe... tu entre un autre nombres tu vois comment ça bouge et avec ça tu essaye de relier les 8 points sans histoire en optimisant les approches pour taper au coeur des ronds avec une précision au centième... ^^ Les optimisation m'on fait gagner presque 200 points mais je reste loin derrière avec mon 8900... :'(

https://www.planet-casio.com/Fr/forums/topic15439-1-Triconcours-et-l-epreuve-de-courage.html#159731


/ à nouveau sur
Casio Graph 35+E
se classe
6ème
avec ses
9133
points.
@NeOtuX, comment as-tu fait ? ;)

NeOtuX a écrit:Ce coup-ci je n'ai pas fait dans la finesse : j'ai repris l'algorithme génétique du défi force, remplacé la partie "problème" par celle des Dragon Balls et laissé tourné ce soir. Théoriquement ça ne devait pas du tout fonctionner puisque ce n'est vraiment pas du tout adapté comme technique (Nombre de gènes inconnu, le "croisement" n'a aucun sens, un individu peut-être meilleur si on lui enlève des gènes etc...). Mais comme c'est une méthode stochastique et que j'avais un trèfle à quatre feuilles sous le coude, à presque minuit j'avais dépassé les 9000 pts.

C'était un super défi encore, j'ai hâte d'avoir les explications de chacun. Merci à tous, organisateurs et participants ! :)

Je joins à nouveau mon code commenté, si quelqu'un a des remarques, qu'il n'hésite pas ! En particulier, j’aimerais comprendre comment j'ai réussi à trouver un bon score alors que sur le papier ça ne devait pas fonctionner (juste de la chance ?)

Fichier joint
:
https://tiplanet.org/forum/download/file.php?id=4266

https://tiplanet.org/forum/viewtopic.php?f=49&t=21886&start=100#p236505


/ cette fois-ci sur
Casio Graph 90+E
prend la
5ème
place après avoir culminé à
9431
points.
@Sentaro21, comment as-tu fait ? ;)

Sentaro21 a écrit:I did not completely understand the rule. :sry:

I noticed 1500 points of the bonus by chance. ;)
I understood that 1500*9=13500 points is maximam and the point given up is proportional to the length of the course.
I made trial and error to be able to link each cloud in the shortest.

However I thought that the movement every step had only 0 or +/-0.01. 0_0
I only made trial and error.
So,
I'm sorry. I did not have any high solving method. :sry:


BIDE is very convenient to watch a basic program. :D
Thanks very much. :D

https://www.planet-casio.com/Fr/forums/topic15439-1-Triconcours-et-l-epreuve-de-courage.html#159771


et sa fidèle
TI-83 Premium CE
terminent
4ème
avec leurs
10317
points.
@Ruadh, comment as-tu fait ? ;)

Ruadh a écrit:Ma méthode a été assez simple, j'ai utilisé un bruteforce pour relier les centres de chaque cercle entre eux dans le sens trigonométrique en un nombre d'étapes que je faisais varier de manière à trouver le chemin qui minimisait la distance parcourue. Cette méthode ne donne pas de solution optimale, les participants classés devant moi ayant trouvé une trajectoire que je n'aurais pas pu trouver avec cette méthode, de plus, il y a certains cas où on entre dans le cercle avant de pouvoir atteindre le centre, ce qui n'attribue pas le maximum de points, mais le score final est tout de même assez satisfaisant.


/ avait en dernier proposé une liste à plus de 30000 éléments à 10394 points selon lui, mais elle n'était testable sur aucune calculatrice, déclenchant une erreur de mémoire même sur les modèles haut de gamme, liste qui n'a donc pas pu être retenue. Il s'insère donc finalement
3ème
avec sa meilleure participation précédente à
10392
points.
@Zezombye, comment as-tu fait ? ;)

Zezombye a écrit:Premièrement j'aimerais dire que cette épreuve a été ma préférée, notamment car il était possible de la résoudre "à la main" sans nécessairement faire d'algorithmes compliqués ou même de programmer tout court (cf shadow qui a eu presque 9000 sur la calto).

J'avais testé vite fait la 3ème épreuve et... je n'avais rien compris aux commandes : j'allais à droite, ça allait à droite puis à gauche, et puis ça sortait de l'écran. De ce que les autres candidats disaient, il fallait contrôler une spirale, mais la trajectoire n'avait pas grand chose à voir avec une spirale.

Du coup j'ai ouvert le programme (casio) dans BIDE et j'ai commencé à l'étudier un peu. Il y a tout d'abord plusieurs variables :

- p et w, qui sont des constantes utilisées pour le PRNG (générateur aléatoire)
- a, seed du PRNG (c'est pas 42 là, bizarre)

Ces variables sont utilisées pour le PRNG qui est la fonction y9(), avec l'expression "y9(a) -> a".
La représentation de la fonction y9 est en "hachures" (/////////) ce qui confirme que c'est un PRNG.

Il y a ensuite les variables pour la spirale et les points :
- z, position actuelle
- t, position juste avant
- s, score
- v, modifieur de l'argument de z
- f, multiplicateur utilisé pour l'affichage uniquement
- b = 0.085, rayon de chaque point
- n = 9, nombre de points

Et quelques listes :
- list4 : positions de chaque point (en coordonnées polaires)
- list6 : liste de toutes les itérations de v

Hé oui : on fonctionne ici sur des coordonnées polaires (ce qui explique le déplacement en cercle/spirale dans le sens trigonométrique).

À chaque itération (appui sur une des flèches) :
- a devient l'itération suivante du PRNG (y9(a) -> a)
- L'argument de z (valeur réelle) augmente ou diminue de v
- L'angle de z (valeur imaginaire) est calculée par une formule qui dépend notamment de a (et est donc aléatoire).

Quant au calcul du score :
- À chaque itération, on enlève 500 * distance parcourue (déterminée avec des calculs chelous avec des e^i, mais c'est juste un calcul de distance entre z et t)
- Lorsqu'on atteint un point, on gagne 1500, mais avec 2 pénalités : pénalité de distance au centre (-500*distance) et pénalité d'argument (-500*différence d'argument) : la valeur réelle de z doit être le plus proche possible de l'argument du point. (chaque pénalité a une valeur maximum de 500, mais ça sert un peu à rien vu que si on a 500 de pénalité on risque pas d'être dans les premiers :E)
Par une coincidence mathématique, lorsqu'on se dirige vers le centre du point, la pénalité d'argument diminue ; pas besoin donc de faire attention à la respecter, il suffit de viser le centre.

Le problème pour obtenir le meilleur score, c'est qu'une fois rentré dans le point, on gagne les 1500 (moins les pénalités), et bien sûr on ne peut pas gagner 2 fois la récompense d'un même point. Il faut donc que l'itération (qui dépend de a, donc de l'aléatoire) place z le plus proche possible du centre, ce qui n'est pas toujours possible...

Voici pour le fonctionnement, maintenant ma méthode :

Comme la trajectoire était assez imprévisible, j'ai fait une simulation en java pour notamment prédire les trajectoires.

4h plus tard, la simulation était presque prête, mais il y avait quelques erreurs de trajectoire : un score sur ma simulation différait du programme par 4 points. Je ne me suis pas laissé avoir par la pensée que c'était une erreur de précision : je sais depuis galactik que les erreurs de précision, c'est de l'ordre du millionième, et ce n'était pas la cause de la différence de 4 points.

Je regarde attentivement le code (c'était juste une retranscription de celui de casio), et l'erreur venait de la ligne transcrite "`Z + V + i(.04 + A / W) / (9Abs ReP Z + 1) -> Z`", que j'avais séparée en 2 parties :
Code: Tout sélectionner
z.re = z.re+v;
z.im = z.im+(0.04+a/w)/(9*Math.abs(z.re)+1);


Mais comme le calcul de la partie imaginaire prenait en compte la partie réelle, et que je calculais la partie réelle avant l'imaginaire, ça causait des petites erreurs (le z.re étant déjà à l'itération suivante). La solution est simple : calculer la partie imaginaire avant la partie réelle.

La simulation étant maintenant parfaite (une liste donne le même score sur la simulation et sur la calto), il ne restait qu'à l'améliorer.

Tout d'abord, la calto limite les possibilités : l'appui sur les flèches droite/gauche fait une itération, et il n'est pas possible d'augmenter ou diminuer v de plus que 0.01.
De ce fait, j'ai modifié le code pour qu'une itération ne se fasse que lorsqu'on appuie sur la flèche haute ; ainsi on peut modifier la valeur de v à sa guise. J'ai également mis comme incrément une puissance de 2 (0.0078125/4), pour éviter les pertes de précision dues au floating-point.

Mon "prédicteur", qui traçait le chemin suivi pour un v donné, prédisait au départ également le chemin suivi pour v +/- incrément, mais j'ai enlevé ça suite à la modification du code permettant de modifier v comme on veut. Il prédisait aussi les 200 prochaines itérations, mais ce n'était pas très utile étant donné que, pour faire une ligne droite, on était obligé de changer v à chaque fois. La version finale du prédicteur prédit donc l'emplacement de z (en rouge) et la direction prise (en vert), pour mieux l'aligner sur le centre du point visé.

Maintenant, quel chemin prendre ? On pourrait croire que c'est tout simplement un problème du voyageur, où il faut trouver le chemin le plus court entre tous les points. Mais un problème de taille se pose : il est absolument impossible d'aller en contresens du cercle trigonométrique sans repasser par le centre (qui fait perdre assez beaucoup de points). On ne peut pas aller de 4 vers 9, par exemple. Du coup mon bruteforce du problème du voyageur avait juste trouvé une solution impossible.

Pas grave, il suffit de faire manuellement : un petit script python avec la matrice des coûts (générée avec 500*distance entre les points), et une fonction chemin(j,k,l,m,n,o,p,q) qui calcule les coûts, et il est possible de trouver le chemin le plus court en faisant des essais manuels. Il faut prendre ce résultat avec des pincettes car il ne prend pas en compte les rayons (le coût étant moins grand si on vise le bord des points) mais c'est un bon outil de comparaison.

Code: Tout sélectionner
mat = [[0.0, 639.8758650193196, 71.10442060204466, 423.95186425858145, 331.14380293171877, 161.45686697021324, 373.03170861562603, 261.0731151968173, 586.4373544809774], [639.8758650193196, 0.0, 709.368357885116, 462.70974506153203, 382.82839628019946, 725.8710101543168, 941.7930688633227, 645.1635101630433, 1027.648437944569], [71.10442060204466, 709.368357885116, 0.0, 464.44722453447923, 400.08940513293805, 160.6728290075972, 340.4323542215803, 296.6436795055611, 546.9575199959714], [423.95186425858145, 462.70974506153203, 464.44722453447923, 0.0, 464.176892264874, 579.9797778530555, 796.9239745409624, 614.0147428390028, 577.5250505787424], [331.14380293171877, 382.82839628019946, 400.08940513293805, 464.176892264874, 0.0, 362.74137436674374, 565.403951395421, 262.4540702256918, 872.1724054160846], [161.45686697021324, 725.8710101543168, 160.6728290075972, 579.9797778530555, 362.74137436674374, 0.0, 226.3899318570202, 163.5532072741689, 701.1504907088186], [373.03170861562603, 941.7930688633227, 340.4323542215803, 796.9239745409624, 565.403951395421, 226.3899318570202, 0.0, 312.42883353647136, 800.2366772401842], [261.0731151968173, 645.1635101630433, 296.6436795055611, 614.0147428390028, 262.4540702256918, 163.5532072741689, 312.42883353647136, 0.0, 842.72080016074], [586.4373544809774, 1027.648437944569, 546.9575199959714, 577.5250505787424, 872.1724054160846, 701.1504907088186, 800.2366772401842, 842.72080016074, 0.0]]

def chemin(j,k,l,m,n,o,p,q):
   j-=1
   k-=1
   l-=1
   m-=1
   n-=1
   o-=1
   p-=1
   q-=1
   print(mat[0][j]+mat[j][k] + mat[k][l] + mat[l][m] + mat[m][n] + mat[n][o] + mat[o][p] + mat[p][q])


Avec le script python, on trouve que le meilleur chemin est 3->9->4->2->5->8->6->7. En faisant ce chemin manuellement, à l'aide du prédicteur, j'ai un score de 9213. Pas mal, mais très loin de 10 444, et un peu loin du 2ème qui était à 9303. Je me dis que le 1er doit avoir une technique secrète, car c'était impossible de gagner plus de 1000 points uniquement avec de l'optimisation de chemin, il y avait un autre chemin que le mien. Mais je n'arrivais pas à voir lequel.

En faisant mon algorithme pour tracer des droites parfaites, je suis nonchalamment resté appuyé sur la flèche haute, pour regarder le tracé de la spirale. Je faisais ça à partir de ma liste de 9213 (j'avais donc déjà les 8 points), puis la spirale passe par le centre, et puis... plus rien. Ma simulation ne répondait plus. Je pensais initialement que c'était à cause d'une division par 0 ou quelque chose d'autre, mais la console affichait "score increased by 1500". J'ai su alors comment arriver au club des 10 000 : il suffisait de repasser par le centre après être passé par les 8 points.

En rétrospective, j'aurais dû le voir : la boucle principale avait une condition de sortie de list4[1] > n, lorsque j'ai recopié le code je me disais que le programme s'arrêtait lorsqu'on était passé par les 8 points, mais quand je suis passé par les 8 points le programme ne s'était pas arrêté... (et je me suis même dit que c'était bizarre car il n'y avait que 8 points donc la condition n'était pas remplissable)

Du coup, retour sur mon script python pour choisir un chemin se terminant par 1, et je trouve que le meilleur chemin est 3->9->4->2->5->8->7->6->1, suivi de près par 3->9->4->2->5->8->6->7->1.

Une coincidence, ou un choix machiavélique de Critor (car les positions des points sont générées aléatoirement) mais il est quasiment impossible de passer de 7 à 6 : il faut s'arrêter pile sur le bord de 7, puis avoir un segment suffisamment petit (la longueur étant déterminée par l'aléatoire) pour passer au ras du 6 sans le dépasser. C'est donc totalement dépendant de l'aléatoire, et coincidence de plus, la seed par défaut donnait un segment assez petit pour faire le 7->6. J'ai alors un score de 10392. On voit par exemple ci-contre que j'effleure le 6, mais je ne peux pas le toucher parce que je ne suis pas bien positionné.

Car oui, il était possible d'influencer l'aléatoire : en itérant alors qu'on était toujours au centre, seule la valeur de l'angle changeait (avec des 0 ajoutés à la liste pour chaque itération). Il suffisait donc de choisir un nombre d'itérations qui donne un angle de départ proche de 0 (pour aller directement sur 3), et l'aléatoire était changé. Un petit bout de code plus tard, et j'obtiens la liste suivante :

Code: Tout sélectionner
      ArrayList<Integer> listeIter = new ArrayList<Integer>();
      double j = 0;
      for (int i = 0; i < 100000; i++) {
         a = y9(a);
         j += (0.04+a/w);
         if (j%(2*Math.PI) < 0.001 || j%(2*Math.PI) > (2*Math.PI-0.001) ) {
            System.out.println("angle de "+j%(2*Math.PI)+" pour "+i+" iterations");
            
            listeIter.add(i);
            
            //System.out.println(sb.toString());
         }
      }
      System.out.println(listeIter.toString());
      System.exit(0);

[683, 6611, 7308, 10065, 11146, 16614, 24882, 31202, 33105, 39926, 55024, 56161, 57800, 61276, 62248, 62356, 67729, 85818, 87519, 91454, 97464]


J'ai testé manuellement et j'obtiens un 7->6 possible pour 31202 itérations initiales, avec un score de 10394... mais malheureusement, la nSpire ne supportant pas une liste de 31000 nombres, ma participation est invalide. :E

J'agrandis la tolérance d'angle en me limitant cette fois à 10000, et je fais un algorithme qui trace automatiquement le chemin le plus droit possible en passant par les points donnés :

Code: Tout sélectionner
int[] listeIter = {506, 683, 730, 911, 924, 1052, 1277, 1348, 1373, 2175, 2198, 3168, 3211, 3462, 3734, 3980, 4869, 5533, 5558, 5974, 6567, 6611, 7308, 7427, 7805, 8748, 8869, 9413, 9795, 9805};
      
      for (int i = 0; i < listeIter.length; i++) {
         nbIterations = listeIter[i];
         init();
         if (auto()) {
            System.out.println("score final = "+s);
            System.out.println(nbIterations + "x{0} + "+list6.toString().replaceAll("\\[", "{").replaceAll("\\]", "}"));
         }
      }


Mais la valeur d'argument variant beaucoup de 3 vers 9, faire une ligne droite vers 9 est impossible car cela résulte en des segments très longs... je modifie alors mon algorithme pour que, lorsque la ligne droite est impossible, il aille vers le bord du point. Mais ça ne suffit pas toujours à passer le 3->9, et dans tous les cas testés l'algorithme n'arrive pas à passer le 7->6. Il faut un facteur humain.

(la vidéo a une assez mauvaise qualité, mais bon ça vous donne une idée de l'algo)
https://i.imgur.com/SvZTDLk.mp4

Je fais donc un prédicteur amélioré en me basant sur l'algorithme : il règle la valeur de v de telle sorte à se diriger vers le centre du point visé (c'est en fait mon algorithme, mais qui n'agit pas automatiquement). Mais me diriger vers le bord du 9 rend le chemin trop court, et je ne peux pas faire le 7->6 car le segment est trop long. Je place donc mon chemin au même endroit du 9 (à peu près à la moitié du rayon), j'arrive à faire le 7->6, mais... je ne gagne que 0.5 points. Les lignes droites n'auront pas vraiment amélioré mon score.

Comprenant que pour atteindre les 10444 il me fallait un algorithme chelou, et que je ne savais pas faire de tel algorithme, je suis parti jouer à overwatch. :E

(le code utilisé est ici : https://pastebin.com/Xw4BiRvu)

https://www.planet-casio.com/Fr/forums/topic15439-1-Triconcours-et-l-epreuve-de-courage.html


armé de sa
TI-Nspire
monte à la
2nde
place avec
10400
points.
@Stefan, comment as-tu fait ? ;)

Stefan Bauwens a écrit:Je vais faire de mon mieux pour expliquer comment j’ai obtenu mon score.
J'ai d'abord téléchargé le programme sur ma TI-83 +, mais j'ai vite compris c'était trop lent si je voulais vraiment faire une bonne tentative. Donc, j'ai téléchargé la version de TI-Nspire et je l'ai exécutée sur l'émulateur. C'était beaucoup plus rapide, en plus, c'était plus “pixel perfect” :P

J'ai joué avec les commandes et me suis rendu compte qu'il y avait un mouvement de fibonacci / circulaire en cours. Ma première tentative a été d'essayer de suivre "le flux naturel" et de collecter toutes les boules (de dragon). Chaque fois que j'en réussissais un, je copiais la liste kinto dans un fichier texte et je partais de là.
Cela s'est bien passé, mais il restait encore un long chemin à parcourir. J'ai ensuite essayé de modifier la liste manuellement avec des valeurs et de voir comment elle réagirait. Et effectivement, il y avait une certaine logique là-bas. Les valeurs plus petites produisent des mouvements plus courts et la valeur définit également la direction de l'angle. La modification manuelle de ces valeurs à l’aide d’essais et erreurs me permettrait très "facilement" d’obtenir des lignes relativement droites. J'ai aussi remarqué que toucher le centre de la balle donnait plus de points. À l'aide d'un papier et d'un stylo, j'ai recherché le chemin le plus court entre les balles (sans prendre en compte le dernier, car je ne l'avais pas encore découvert). J'ai modifié la liste pour suivre ce chemin de près. Cette méthode a très bien fonctionné et mon chemin a été assez efficace, mais en regardant le classement, je savais qu'il devait y avoir quelque chose de radicalement différent qui me manquait. Mon frère Jim a jeté un coup d'œil au code source et nous avons effectivement découvert une autre balle finale au centre après avoir traversé la 8e balle.
En continuant sur le chemin que j'avais déjà, j'ai obtenu un score autour de 10348. Pas mal, mais j'en voulais plus.
Jim a créé un petit programme d'amour pour dessiner plus rapidement un chemin au lieu de modifier manuellement la liste. (J'étais trop paresseux pour programmer moi-même: P) Alors j'ai joué avec et j'ai ensuite découvert que je pouvais obtenir un meilleur score en modifiant la séquence des 3 dernières balles. J'ai eu un score autour de 10370. Jim a également créé un petit programme pour itérer sur les valeurs de la liste et les modifier légèrement pour essayer d’améliorer la valeur finale. C’est ainsi que j’ai obtenu mon score final.

Merci pour ce défi amusant!


Et enfin / arrive
1er
après avoir majoré à
10444
points.
@Pavel, comment as-tu fait ? ;)

Pavel a écrit:Après m'être beaucoup amusé avec le mode interactif de ce simulateur de nuage magique sur ma Casio Graph 90+E, j'ai essayé de comprendre le code derrière ce jeu et j'ai trouvé que pour moi c'est beaucoup plus facile avec le code en Python pour la calculatrice NumWorks.

En analysant le code, j'ai remarqué les points suivants:
- un système de coordonnées polaires est utilisé pour le calcul de la position du nuage magique
- on ne contrôle que la coordonnée radiale
- la coordonnée angulaire est augmentée à chaque déplacement
- la vitesse angulaire a une composante aléatoire

Autrement dit, on pilote un nuage magique dans un cyclone.

Le calcul du score est assez simple:
- on gagne jusqu'à 1500 points pour chaque fragment trouvé
- il faut bien viser le centre des fragments pour maximiser les points
- on paie 500 points par unité de distance parcourue

Pour réaliser le meilleur score, j'ai découpé le problème en sous-problèmes suivants:
- trouver un plus court chemin qui visite chaque fragment et qui se termine au point de départ
- manoeuvrer le nuage magique en essayant de suivre ce chemin

Le premier sous-problème est le problème bien connu du voyageur de commerce.

En cherchant "salesman python" sur google, j'ai trouvé ce petit programme de dix lignes.

J'ai juste ajouté à ce programme les calculs des coordonnées des fragments. Ci-contre le code et le chemin que j'ai obtenu.

La longueur de ce chemin est approximativement 6. On peut estimer que le score maximal devrait se situer quelque part autour de 10500 (9 * 1500 - 6 * 500).

Pour résoudre le deuxième sous-problème (manoeuvrer le nuage magique en essayant de suivre ce chemin), je l'ai aussi découpé en sous-sous-problèmes:
- trouver des instructions pour diriger le nouage magique d'un fragment au suivant
- optimiser ces instructions en utilisant une méthode d'optimisation stochastique
- répéter les deux étapes précédentes jusqu'à revenir au point de départ

Pour chaque déplacement entre deux fragments A et B, j'analyse les valeurs des instructions variant entre -1 et 1 et je choisis celle qui minimise l'angle entre la ligne AB et la ligne AN, ou N est la position du nuage magique.

S'il est possible d'atteindre un fragment après K ou K+1 instructions, je choisis les instructions qui maximisent le score.

Pour optimiser les instructions, je varie légèrement les valeurs une par une et je choisis les valeurs maximisant le score. Pour sortir d'un maximum local, j'applique une petite variation aléatoire aux plusieurs valeurs.

Cet algorithme fonctionne bien pour les 7 premiers fragments et il trouve automatiquement 81 instructions. Les deux dernières instructions sont ajoutées à la liste manuellement.

Après avoir ajusté différents paramètres de cet algorithme, j'ai réussi à trouver une solution à 10 444 points. Voici un lien vers la version finale de mon code.


Merci à tous ! :)


Référence
:
https://www.planet-casio.com/Fr/forums/ ... p?id=15489
Crédit image
:
Queen-Zelda
Lien vers le sujet sur le forum: Triconcours de rentrée 2018 - résultats défi de Courage (Commentaires: 127)

Triconcours de rentrée 2018 - résultats défi de Force

Nouveau messagede critor » 18 Nov 2018, 19:31

9806Voici les résultats du défi de Force de notre Triconcours de rentrée 2018. Vous avez été pas moins de 15 à produire 120 participations.

Il s'agissait d'éclairer un projecteur à 252 lampes de façon maximale et optimale à l'aide de 30 potentiomètres, implémentés par un script
Python
évaluant automatiquement le score.

arrive
13ème
en nous allumant 215 lampes pour
188,1
points.


muni de sa fidèle
HP Prime
termine quant à lui
12ème
en éclairant 236 lampes ce qui lui vaut
210,9
points.


se classe
11ème
en illuminant 239 lampes évaluées à
216,4
points.


Et maintenant les gagnants :
termine
10ème
en faisant briller 242 lampes valant
217,7
points.


prend la
9ème
place en embrasant 243 lampes et récoltant
219
points.


/ à sa
8ème
nous ensoleille de 244 lampes avec
221,3
points.

@Zezombye, comment as-tu fait ? ;)

Zezombye a écrit:j'ai fait des entiers de 0 à 93 au lieu d'utiliser des fractions.

J'ai tout d'abord essayé une approche avec peu de potentiomètres : essayer toutes les combinaisons de 1, 2, 3, 4 potentiomètres et regarder laquelle allume plus d'ampoules. Mais si je me souviens bien, on peut allumer un maximum de 212 ampoules avec 4 potentiomètres (et mon bruteforce allait pas au delà) : comme le score peut pas être supérieur au nombre d'ampoules allumées, il fallait forcément alimenter tous les potentiomètres.

Du coup après j'ai essayé (comme le disait hackcell) en mettant tous les potentiomètres à une valeur : un peu de bruteforce et on trouve que le score atteint un sommet pour 8 ou 9 (fractions de 93). Du coup je fais un bruteforce pour mettre tous les potentiomètres à 8 ou 9 : j'atteins 215 maximum, pas assez...

Après j'ai fait une fonction "convergeuse" qui prend une combinaison (celle générée avec les 8 et 9) et diminue un potentiomètre de 1, en choisissant ce potentiomètre de telle sorte à ce qu'il fasse perdre le moins de score (ou gagner le plus). Avec ça je crois que je suis allé dans les 217/218.

Enfin, j'ai fait une boucle infinie qui prend des valeurs aléatoires pour chaque potentiomètre entre 7 et 12, avec ensuite ma fonction convergeuse qui traite chaque combinaison. Là je suis allé facilement dans les 220, avec un score à 221.274 (mon final) après quelques dizaines de minutes (mais j'ai été chanceux).

Sur les conseils de DS, j'ai fait un algo pseudo-génétique qui génère 100 combinaisons, prend les 30 meilleures et change quelques valeurs : j'atteins 221.3, mais toujours pas assez. (si je m'y étais pas pris le jour même, j'aurais peut être pu le laisser tourner un peu plus longtemps :D)

https://www.planet-casio.com/Fr/forums/topic15371-2-Triconcours-et-l-epreuve-de-force.html#159394


/ décroche la
7ème
place toujours avec 244 lampes, mais à la différence arrive à n'en griller aucune autre ce qui lui fait récolter
221,6
points.

@Hackcell, comment t'y es-tu prise ? ;)

Hackcell a écrit:
Hello tout le monde, depuis peu, à débuté l'épreuve de force (non plutôt bien choisi, vous verrez pourquoi plus tard ^^ ) en python du tri-concours de la rentrée 2018.


Le but, obtenir un score maximal, envoyer la réponse et décrocher un lot... Plus sérieusement, c'est un poil plus complexe, il s'agit de régler virtuellement 30 potentiomètre pour allumer jusqu'à 252 ampoules (21 * 12). Pour ce faire, vous utilisez la fonction pot en indiquant le numéro du potentiomètre (de 0 à 29) à régler et la valeur du potentiel que vous souhaitez lui assigner(entre 0 et 1), faîtes ceci pour les 30 potentiomètre (ou pas, chaque potentiomètre est réglés de base sur 0) regarder le résultat et envoyé ce dernier a Planète TI.

Jusqu'ici, c'était les informations disponibles sur l'annonce du concours, maintenant, passage aux données Secret Défense que j'ai pu obtenir via un poil de rétro-engineering et que je vous partage au péril de ma vie...

Tout d'abord, le calcul des scores, pour l'instant, j'ai déterminé que votre score vaut : Amp_all - (Alim + Amp_grill/2 + Gaspi/5 + pertes/10)
avec:
-Amp_all le nombre d'ampoules allumées
-Alim l'alimentation utilisée
-Amp_grill le nombre d'ampoules grillées
-Gaspi l'énergie gaspillée
-Pertes l'énergie perdue

Ces différentes fonctions sont calculées comme suit:
-Alim est la simple somme du potentiel assigné à chaque potentiomètre
-Gaspi est l'énergie de l'alimentation utilisé pour allumer les ampoule déjà allumé (avec 252 ampoules, ça peut monter très vite)
-Pertes est cette fois ci l'énergie utilisé mais qui ne suffit pas à allumer une ampoule

La définition de perte peut vous sembler étrange, à moins que vous ayez connaissance de l'élément suivant :
-Chaque potentiomètre est 'relié' à un certain nombre d'ampoules, ainsi chaque ampoule reçoit de l'énergie de différentes potentiomètres
-Pour savoir si une ampoules s'allume, elle regarde donc la somme de l'énergie reçue par les différents potentiomètre qui lui sont attaché, ensuite, la loi est simple, moins de 1, éteinte, entre 1 et 2 (bornes incluses) allumée, plus de 2, grillée.

Un autre point intéressant à noter, est ce que l'on pourrait appeler la discrétisation des valeurs prise par le potentiomètre, en effet, il s'agit ici d'un programme informatique, le potentiel ne peux donc pas être continue, il est discret, ainsi il n'admet qu'un nombre finis de valeurs entre 0 et 1 (bornes incluse), plus précisément, 101 valeurs, avec un écart de un centième entre chaque.

A partir de là, on peut calculer le nombre de possibilités, attention.... 30 potentiomètre, avec 101 possibilités, ça fait, ça fait... Bravo, ça fait bien 101^30, soit un ordre de grandeur de 10^31.. Oui oui, un 1 et 31 zéros derrière, pour vous donner une idée, voici sa tête :

1347848915332905650585522351309777516867383425202804564353001
(tapez donc 101**30 dans votre console python)


C'est donc bien une épreuve de force ^^ , même si le brute force ne me semble pas être une bonne idée

Cependant, il existe un grand nombre de possibilités qu'il n'y aurait pas besoin de chercher, ce sont celles où la somme des potentiels est strictement inférieure à 1, dans de telles conditions, aucune lampe ne pourrait s'allumer.

Ainsi, on fait de plutôt bon score en mettant tous les potentiomètres à la valeur X avec 1≤ 30X ≤ 2, ça peut paraître barbare, mais on peut obtenir de plutôt bon score sans se fouler...

Enfin, si jamais je m'appelais 3blue1brown, je vous parlerai sans doute du fait qu'il s'agit là de trouver le maximum d'une fonction dans un espace à 30 dimensions, fonction qui n'est pas continue sur cette espace, même si je la soupçonne d'être continue par morceau (mais le démontrer....) et qu'il existe des méthodes pour trouver des maximum pour ces fonctions, mais c'est pas tout à fait mon niveau, donc on vas s'arrêter là (malheureusement pour vous ^^).

Pour ma part, il est minuit vingt le 20 septembre 2018, et je pense avoir trouvé une solution à presque 212 points.

Bon, le miracle attendu n'a pas eu lieu (j'ai gagné environ 0.2 point).

J'avais pour intention de bricoler un autre algorithme de recherche de maximum basé sur une sorte de gradient à 30 dimensions, mais je me suis arrêtée 5 minutes pour regarder la suggestion de DS, un algorithme génétique, résultat, j'en ai codé un en une bonne heure, la page Wikipédia qui explique comment réaliser un telle algorithme est plutôt bien faite, donc au final j'ai pas eu tant besoin de réfléchir, j'ai pas eu besoin de café, en revanche, j'aurais sans doute besoins de chance ^^

Donc merci DS pour ta suggestion.

Pour être plus précis, voici les paramétrés de mon algo:
— Population : 100 individus
— Génome : 30 chiffre de 0 à 1
— Système de score : Celui de base pour le concours
— Sélection : Trie des individus par score en commençant par le meilleur, choix des accouplements via un (np.random.random()*10)**2 (pas optimal, je pourrais gérer ça de manière plus souple, mais ça ira pour l'instant). Je réalise 49 accouplements, puis j'ajoute le meilleur de la génération précédente s'il ne s'est pas reproduit et complète avec des individus aléatoires.
— Empattement : 70%
— Mutation : 1% (Avec du recul, je devrai l'augmenter un poil)

Et puis c'est tout, pour l'instant ça grimpe gentiment et j'en suis à 210,7 points

L'algorithme commence à sortir des maximum, sauf qu'il a un peu de mal a s'extraire de ces maximum locaux, il est temps de tourner les boutons pour voir ce que ça fait ^^

Et puis je mets également mon code en pièce jointe ^^

Fichier joint
:
https://www.planet-casio.com/files/forums/gene-159509.py

https://www.planet-casio.com/Fr/forums/topic15371-1-Triconcours-et-l-epreuve-de-force.html https://www.planet-casio.com/Fr/forums/topic15371-1-Triconcours-et-l-epreuve-de-force.html#158330 https://www.planet-casio.com/Fr/forums/topic15371-2-Triconcours-et-l-epreuve-de-force.html#159509


Erwin R.
en
6ème
position et bien que pourvu d'une
HP Prime
n'allume que 243 lampes, mais à la différence de façon bien plus écologique car gaspillant moins d'énergie, ce qui lui fait atteindre
221,8
points.

@Erwin, how did you do it ? ;)

Erwin R. a écrit:From what I can say from the description indicates that you control 30 potentiometers with weird interconnections, with the goal of lighting the maximum amount of lights. Playing the game in your calculator goes like this:

  1. Run the app
  2. Type pot(number,value)
  3. See results/score
  4. Go to step 2
Of course it goes really slow. So the optimal solution is descramble the app code to understand the function they are using… but this is a lot of work! so I just decided to use bruteforce, starting with a random seed and iterating per potentiometer in increments of 1/34:

The script dumps the best combinations as .txt files. It was very exciting to check the new scores every morning. Like scratching a lottery ticket.

This is also slow, but is not
THAT
slow if you use multiples machines with multiple instances of the script running. You can even use your
cluster
made of old laptops that nobody wants in your office, laptops in beautiful racks made of cardboard:

My score was not the best or near the first places, in fact was #6, but I had a lot of fun. Next time I will try to use less brute-force.

Even when my solutions were lazy and poorly executed, I think this is the real nature behind the love for the calculators. Having doses of entertainment in a restricted environment.

It is so special to be in 2018 and still have contest like these french ones. I am happy for that today.

https://erwin.ried.cl/post/180137142402/a-cool-calculator-challenge-triconcours-universel


Mention honorable pour / , administrateur
Planète Casio
qui bien que désormais à la retraite était encore en fonctions lors du lancement du concours, et ne peut donc pas être classé. Il nous fait scintiller 245 lampes pour
222,9
points.

@Darks, comment as-tu procédé ? ;)

Dark storm a écrit:Pour ma part, je suis parti sur un algo génétique assez "brut", dont je pouvais faire varier les paramètres en live à chaque génération, pour introduire de grosses modifications du génome, ajouter des configurations intéressantes, ou bien recentrer autour d'un point.

Ça a tourné sur le VPS pendant deux ou trois jours, j'arrive à un score de 225 et des poussières.

Les derniers rapports générés sont dispo sur mon VPS : https://files.darks.fr/concours/

https://www.planet-casio.com/Fr/forums/topic15371-2-Triconcours-et-l-epreuve-de-force.html#159786


Poursuivons avec les grand gagnants :
/ à la
5ème
place nous fait resplendir 247 lampes ce qui lui fait encaisser
225,7
points.

@Nemh, explique-nous ! ;)

Nemhardy a écrit:Après avoir tapé un peu trop d'une traite, je me rends compte que c'est peut-être
un poil
long, pour pas grand chose non plus… mais je voulais présenter un peu toute ma démarche, qui peut rester intéressante si vous n'avez jamais entendu parler de programmation linéaire, ou d'utilisation de
glpk
… Ne serait-ce que pour voir comment ça peut servir… On va dire que ça va dans le sens de PC qui peut servir à introduire à différents concepts autour de l'informatique ! ^^ Un jour je mettrai ce genre de post trop long dans un blog qui n'existe pas encore… :p)

Donc, personnellement, j'ai atteint un score de 225,699.

Mon approche a été encore une fois (comme l'an dernier déjà… :p) pas d'une extrême intelligence d'analyse de l'instance qui nous était donnée, mais c'était un premier jet et je voulais voir jusqu'où on pouvait aller avec, avant de passer à autre chose… ce que je n'ai pas fait par une lecture trop peu lucide des modalités du concours… Enfin, passons là dessus !

Déjà pour ceux qui connaissent, l'intitulé rappelle bien vite le problème Illumination dispo sur http://www.primers.xyz, où le but est aussi d'allumer un maximum d'interrupteurs à l'aide d'un ensemble d'interrupteurs branchés en va-et-vient ; ici la nuance c'est l'aspect continu dans l'actionnement des interrupteurs, puisqu'on passe de boutons dans
Illumination
à des potentiomètres ici.

Même s'il semble que ça peut rendre le problème plus compliqué (l'espace des configurations augmentant alors de manière assez incontrolée), il s'avère que pas mal de problèmes sont en fait plus facile à résoudre lorsqu'on vit dans un espace continu (typiquement dans un tel espace, on peut «glisser» d'une configuration l'autre sans soucis, et, avec un peu de chance, avoir notre fonction objectif continue le long du glissement, nous ouvrant alors la voie à de l'optimisation en glissant de manière maligne parmi les configurations, là où dans un espace certes plus réduit, mais discontinu, il est plus difficile de lier deux configurations différentes, puisque ça revient à faire des sauts, et un peu tout comme n'importe quoi peut se passer lors de ces sauts).

Dans un premier temps j'ai essayé de résoudre des versions simplifiées du problème, pour voir les scores qu'on peut tout de même en tirer. En lisant l'analyse faite par Hackcell plus haut (encore une fois, c'était chouette de partager ça ! :) ), un problème simplifié qui vient à l'esprit peut être le suivant :

On cherche à allumer toutes les ampoules (
ie.
à faire passer
la valeur des ampoules au dessus de 1, chacune), tout en minimisant la
somme des valeurs des interrupteurs (ça peut paraître un premier moyen
de limiter le gaspillage).

On n'a aucune garantie que ce problème simplifié va donner quoi que ce soit de bon vis à vis du problème initial, mais ça me semblait un bon début pour prendre le tout en main. ^^

Si on étudie un peu le fonctionnement des ampoules et de leurs potentiomètres, on s'aperçoit que la valeur de chaque ampoule n'est autre que la somme des valeurs des potentiomètres qui la commandent, en particulier c'est une combinaison linéaire de ces valeurs. La fonction que l'on cherche à minimiser l'est aussi : bingo ! On a en fait là un programme linéaire à résoudre, et ça, et bien on sait bien faire ! Des solveurs efficaces existent déjà, et normalement on n'a plus qu'à encoder notre problème pour un de ces solveurs et voir ce qu'il nous sort. C'est ce que j'ai fait pour ce premier problème simplifié, en utilisant le solveur glpk. Mon encodage du problème en MathProg ressemble à ça :

Code: Tout sélectionner
set potentiometres := (0 .. 29);
var pot{p in potentiometres};

set ampoules := (0 .. 251);
var amp{a in ampoules};

param amp_vers_pot{a in ampoules, p in potentiometres};

minimize consommation: sum{p in potentiometres} pot[p];
    s.t. reseau{a in ampoules}:
        amp[a] = sum{p in potentiometres} amp_vers_pot[a,p]*pot[p];
    s.t. allume{a in ampoules}:
        amp[a] >= 1;
    s.t. plage_potentiometre{p in potentiometres}:
        0 <= pot[p] <= 1;
solve;

printf 'config = [';
printf '%.3f', pot[0];
for {p in (1..29)}
    printf ', %.3f', pot[p];
printf ']\n';

data;

param amp_vers_pot: 0 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 :=
    0 1 1 0 0 1 1 0 1 0 1 0 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0
    1 1 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 0 1 0 0 1 0 0 1 1 0 0 0 0 1
    2 0 0 1 1 1 0 1 1 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 1 1 1 1 0 1
    3 1 1 0 1 1 1 1 0 1 1 1 1 1 1 1 1 1 0 0 1 1 0 1 1 0 0 0 0 1 0
    4 1 0 1 0 1 1 0 1 1 0 1 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1 0
    5 0 0 1 1 0 1 1 0 0 1 0 0 1 1 1 1 1 1 1 1 0 0 0 1 0 0 1 1 0 0
    6 0 0 0 1 1 1 0 1 1 1 1 0 1 1 0 1 0 0 1 0 1 1 1 0 0 1 1 1 1 1
    7 0 0 1 0 0 1 1 1 1 0 0 0 1 0 1 1 1 0 0 1 0 0 1 1 0 0 0 0 0 1
    8 1 0 1 1 0 0 0 1 0 0 0 0 0 1 1 1 0 1 0 0 1 1 1 1 1 0 0 0 0 1
    9 0 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 0 1 0 1 1 1 0 0 0 0 0 1 0
    10 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0 1 0 1 1 0 1 1 0 1 1 0 0 0
    11 1 1 0 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0 0 0 1 1 0 0 0 0 1 0 1 1
    12 1 0 1 1 0 0 0 1 1 0 1 0 0 0 0 1 0 1 0 0 0 1 0 1 1 0 0 1 1 1
    13 0 1 0 1 0 0 0 1 1 0 0 1 0 0 0 0 0 1 1 1 0 1 1 1 0 0 1 1 1 0
    14 0 0 0 0 1 1 0 1 0 1 0 0 1 1 1 0 0 0 1 0 1 1 0 1 1 1 1 1 0 0
    15 0 1 1 1 1 0 1 1 0 0 0 1 0 0 0 1 1 0 1 0 1 0 1 1 1 1 1 1 0 0
    16 1 0 0 0 1 1 1 1 0 1 1 1 0 1 0 1 0 0 1 1 0 0 0 0 0 0 1 1 0 0
    17 1 0 1 0 0 1 1 0 0 1 1 0 1 0 1 0 1 0 0 0 1 1 0 1 0 0 1 0 1 0
    18 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 1 1 1 1 1 0 0 1 0 1 1 0 0 0
    19 1 0 1 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 0 1 1 1 0 0 1 1
    20 1 1 0 0 0 1 1 1 1 0 0 1 0 0 1 1 1 1 0 0 1 1 0 0 0 1 0 0 0 1
    21 1 1 0 0 1 1 1 0 0 0 0 1 0 0 0 1 1 1 0 1 0 0 0 0 0 1 1 0 1 1
    22 1 0 1 1 1 1 0 1 1 0 0 0 1 0 1 0 1 1 0 1 0 1 0 0 1 1 1 1 0 1
    23 0 0 1 1 1 1 1 0 1 1 1 0 0 1 1 0 1 1 0 0 0 0 0 0 1 0 1 0 0 0
    24 1 0 0 1 0 0 1 0 1 0 0 0 0 1 0 0 1 1 1 1 1 1 1 0 0 1 0 0 0 1
    25 0 0 1 0 0 1 0 0 0 1 0 0 1 1 1 0 0 1 0 0 0 1 1 0 0 0 0 1 0 0
    26 0 0 0 1 0 0 1 1 1 0 1 1 1 0 0 1 1 1 0 0 1 1 0 0 1 1 1 0 1 1
    27 1 1 0 1 1 0 0 1 0 1 0 0 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 0
    28 0 0 0 0 1 1 0 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1 0 0 0 1 1 1 1 0
    29 1 0 0 0 0 1 0 1 1 0 0 0 0 1 1 1 0 0 1 1 0 0 1 1 0 0 1 1 1 0
    30 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 1 0 0 0 1 1 1 1 0 1 1 1 0 0
    31 0 1 0 1 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 1 0 0 1 1 0 0 0 0 0 0
    32 1 0 1 1 0 1 1 1 0 0 0 0 0 0 1 0 1 0 0 1 1 1 1 0 1 0 0 0 0 0
    33 1 1 1 1 0 1 0 0 1 0 0 1 0 1 0 1 1 0 1 0 1 0 0 1 1 1 1 1 1 1
    34 1 0 0 1 1 0 0 0 0 1 1 1 0 0 0 1 0 1 1 0 1 0 0 1 0 1 0 1 1 1
    35 1 1 0 1 1 0 1 0 1 0 0 1 0 1 0 0 1 1 0 1 0 0 1 0 0 1 0 0 1 1
    36 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0 0 0 1 0 0 0 1 0 0 1 0 0 1
    37 0 0 0 0 0 1 0 0 0 0 1 1 1 1 0 0 1 1 0 1 1 1 0 0 1 0 0 0 1 1
    38 1 1 0 0 1 1 1 1 0 1 0 0 1 0 0 1 0 0 0 1 0 1 1 1 1 1 1 0 0 1
    39 0 0 0 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 1 0 0 0 0 0 0 1 1 0 1 0
    40 0 0 0 0 1 0 1 1 1 1 1 1 1 0 1 0 0 1 0 1 0 0 0 0 0 0 0 1 1 0
    41 0 0 1 0 0 0 0 0 1 0 1 1 1 0 1 0 0 0 0 1 1 0 0 0 1 0 0 0 1 0
    42 0 0 1 0 1 1 0 0 1 1 0 1 1 0 1 1 0 1 0 0 0 0 0 1 0 1 1 0 1 0
    43 1 1 1 0 1 1 1 0 0 1 1 1 1 1 0 0 1 0 1 0 0 0 0 0 1 0 0 1 0 1
    44 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 0 0 0 0 1 0 0 1 0 1 1 1 0 1 0
    45 0 1 1 0 1 1 1 1 0 0 0 0 1 1 0 0 1 0 0 0 0 1 1 0 1 1 0 0 0 0
    46 1 0 0 1 0 0 0 0 1 0 0 1 0 0 0 1 1 0 1 0 1 0 1 1 1 0 0 0 0 1
    47 1 0 0 1 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 0 1 0 0 0 0 1 0 1 0 0
    48 1 1 1 1 0 1 0 0 1 0 1 1 1 0 1 0 1 1 0 1 0 0 0 0 1 0 1 1 1 0
    49 0 1 0 0 0 1 1 0 0 0 0 1 0 1 1 1 0 1 0 0 1 0 0 0 1 0 1 0 1 0
    50 1 0 1 1 1 1 0 1 0 0 1 0 0 0 0 1 0 1 1 0 1 0 1 0 0 0 1 1 0 0
    51 1 1 1 1 1 0 0 1 0 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 0 0 1 0 0 0
    52 0 0 0 1 1 0 1 1 0 1 1 1 1 1 0 0 1 1 0 0 0 1 0 0 1 1 1 1 1 1
    53 1 0 1 1 1 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 1 1 1 1 0 1 0 0 0 1
    54 1 1 0 1 0 1 0 1 0 1 0 1 0 0 1 0 0 0 1 0 1 1 0 1 1 0 1 0 0 0
    55 1 0 1 1 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 1 0 0 1 1 1 1 1 1 1
    56 0 1 1 0 1 0 1 1 1 1 0 1 1 1 0 0 0 1 0 0 0 0 1 1 1 1 0 1 1 0
    57 0 1 1 0 1 0 1 1 0 0 1 1 0 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 1
    58 1 0 1 0 1 1 1 0 1 0 1 1 0 0 0 1 1 1 0 0 1 1 1 1 1 1 0 1 0 0
    59 0 0 1 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 1 0 0 0 1
    60 0 0 1 0 0 0 0 1 1 1 1 1 1 0 0 0 1 0 1 0 1 1 0 1 1 1 1 1 1 1
    61 0 0 1 1 1 0 0 1 0 0 1 0 1 0 1 0 0 0 0 1 0 1 0 0 0 0 1 1 0 0
    62 1 1 0 0 1 0 1 1 0 0 1 0 1 1 1 1 0 1 0 1 0 0 1 1 1 1 0 1 0 1
    63 0 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 1 1 0 0 1 1 0
    64 1 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 1 1 1 0
    65 1 1 0 0 1 1 0 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0 1 1 1 1 1 1 0 1
    66 0 1 0 1 0 0 1 1 0 0 1 1 1 1 1 0 1 0 1 0 0 1 1 0 1 1 0 1 0 0
    67 1 0 0 0 1 1 1 0 0 0 0 1 1 0 1 1 1 1 0 0 0 1 1 1 1 1 0 0 1 1
    68 1 1 1 0 0 1 0 0 0 1 1 1 1 0 0 0 1 1 1 0 1 0 0 1 1 1 0 0 1 1
    69 0 1 0 1 1 1 0 1 1 0 1 1 0 0 1 1 0 0 1 1 1 1 0 0 0 1 1 0 0 0
    70 0 0 1 1 1 0 1 0 0 1 0 0 1 0 0 1 0 1 1 0 0 1 1 1 1 0 0 0 0 0
    71 1 0 0 0 1 0 1 1 1 1 1 0 1 1 1 1 0 1 0 0 1 0 0 1 0 0 0 1 0 0
    72 0 0 1 1 1 1 0 1 0 1 1 1 1 1 0 1 1 1 0 1 0 0 1 1 0 0 0 1 0 1
    73 0 0 1 0 0 1 1 0 0 1 1 1 1 0 1 0 1 1 1 0 1 0 1 0 0 0 0 1 1 0
    74 0 0 0 1 1 1 0 1 1 1 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 1 1 0 0
    75 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 1
    76 0 1 1 0 1 0 1 0 1 1 1 0 0 1 0 1 0 1 0 1 1 0 1 0 1 0 0 0 0 1
    77 1 0 0 1 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 1 0 1 0 1 1 0 0 0
    78 0 0 1 0 0 0 1 0 1 0 0 1 0 0 1 0 1 1 0 0 1 1 1 1 0 1 1 1 1 1
    79 1 0 0 1 1 1 1 0 0 0 0 0 1 0 1 0 1 1 1 1 0 0 1 0 0 1 1 0 1 0
    80 0 0 0 0 0 1 1 0 1 1 0 0 0 0 1 0 0 0 1 1 0 1 0 0 1 0 0 0 1 1
    81 0 0 0 1 1 0 1 1 0 0 1 1 0 1 1 0 1 1 0 1 1 1 1 1 0 0 0 0 1 0
    82 1 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 1 1 1 0 0 1 0 1 0 1 0 1 0 1
    83 1 1 1 0 1 0 0 1 0 1 1 1 1 0 1 0 1 0 0 0 1 0 0 1 0 1 0 1 1 1
    84 1 1 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1 0 0 1 1 0 1 1 1 0 1 1 1 0
    85 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 0 0 1 1 0 1 1 0 0 0 0 1 1 1 0
    86 0 0 1 1 1 0 1 1 1 1 0 0 1 1 0 1 0 0 0 1 1 1 1 1 0 1 0 1 1 1
    87 1 1 0 0 0 0 1 1 0 1 1 1 0 0 1 0 0 0 0 1 0 1 1 1 1 0 1 1 1 0
    88 1 1 0 1 0 0 0 1 1 1 0 0 1 1 1 1 0 1 0 1 0 0 0 1 0 1 1 1 1 1
    89 0 0 1 0 1 0 0 1 1 1 0 1 0 1 1 0 1 1 0 1 1 1 1 0 0 0 1 0 1 0
    90 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 0 0 1 0 1 1 0 1 0 0 1 1
    91 1 0 1 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 1 0 0 1 1 0 1 1 1 0 1 1
    92 0 0 1 1 0 1 0 1 1 1 0 1 0 1 1 0 1 1 1 0 0 0 0 1 1 1 1 1 0 1
    93 0 0 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 1 1 1 0 1 0 1 1 1 0 0 0 1
    94 0 0 1 1 0 1 0 1 0 1 1 1 0 0 1 1 1 0 0 1 0 1 1 1 0 0 1 0 1 1
    95 1 1 1 0 1 0 1 0 1 0 0 1 1 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1
    96 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 1 0 1 0 1 1 1 0 0 1 0
    97 0 1 1 0 0 0 0 1 0 0 0 1 0 0 0 0 1 1 0 1 1 1 1 1 1 0 1 0 1 0
    98 1 1 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 1 1 0 1 1 1 1 1 0 0 1 0
    99 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 1 0 1 0 0 1 0 0 1 1 1 0
    100 0 0 1 1 1 1 1 1 0 0 0 1 0 1 1 1 1 0 1 0 0 0 1 0 0 0 1 0 0 1
    101 0 1 1 1 1 1 1 1 0 1 0 1 0 0 0 0 1 1 0 0 0 0 1 1 1 0 0 1 0 1
    102 1 0 0 0 1 1 1 1 1 1 1 1 1 0 1 1 0 1 1 0 0 0 0 0 0 0 1 0 0 0
    103 1 1 1 0 0 0 1 0 1 0 0 1 0 0 1 0 0 0 0 1 1 0 1 0 1 1 1 1 1 0
    104 0 0 0 1 1 1 0 0 1 0 1 0 0 0 0 0 1 1 0 0 1 1 0 0 1 0 1 1 1 0
    105 0 1 0 0 0 0 0 1 0 1 1 1 0 1 0 1 1 1 0 1 1 0 0 1 0 0 0 0 0 0
    106 1 0 1 1 1 0 0 0 1 0 0 1 1 0 1 1 1 0 1 1 1 0 1 1 0 0 1 1 0 1
    107 1 0 0 0 0 0 1 1 0 1 1 0 1 1 0 0 1 0 0 1 1 0 1 1 0 0 0 1 1 0
    108 1 0 0 1 1 1 1 0 0 1 1 0 0 1 1 1 1 0 0 1 1 0 0 1 0 0 1 1 1 0
    109 0 1 0 1 1 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 1 1 1 1 0 1 1 1
    110 1 0 0 0 1 1 0 0 1 0 1 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0
    111 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 1 1 0 1 1 0 1 1 0
    112 0 0 0 0 0 1 0 1 0 0 1 1 0 1 0 1 0 0 0 1 1 1 0 1 0 1 0 0 1 0
    113 1 0 1 1 0 0 1 1 0 1 1 0 0 1 1 0 1 0 1 1 0 0 1 0 0 1 0 1 1 0
    114 0 0 1 1 0 0 0 0 1 1 0 1 0 0 1 0 0 0 0 1 1 0 0 1 1 1 1 1 0 0
    115 1 1 0 0 1 0 1 1 0 0 0 1 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 0 1 0
    116 1 0 0 1 1 1 1 0 1 0 0 0 0 0 0 1 0 0 1 0 1 1 1 0 1 0 1 1 0 1
    117 1 1 1 1 1 1 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 1 1 1 1 1 0 1 1 1
    118 1 1 1 1 0 0 1 1 0 0 0 0 1 1 1 1 1 1 0 0 0 1 0 0 1 0 0 0 0 0
    119 0 1 1 1 1 0 0 1 0 1 1 0 0 1 0 1 0 1 1 0 1 0 0 1 0 1 1 1 1 0
    120 1 0 1 0 1 0 0 1 1 1 1 1 1 1 1 1 0 0 1 0 1 0 0 1 0 0 1 0 1 1
    121 0 1 1 1 1 1 1 1 0 1 0 1 0 0 1 1 1 1 1 0 1 0 0 0 0 1 0 0 0 1
    122 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0
    123 0 0 0 0 1 1 1 0 1 1 0 1 0 0 1 1 0 1 1 1 1 0 0 1 1 0 0 1 1 0
    124 1 1 1 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1 1 1 1 0 0 0 0 0 1 0 0
    125 0 1 1 1 1 0 0 1 0 0 1 1 1 1 0 1 0 1 1 1 1 1 1 1 1 1 0 0 1 1
    126 0 0 0 0 1 0 0 1 0 0 1 0 0 1 1 0 1 0 0 0 1 0 0 0 1 0 0 1 1 0
    127 1 1 1 1 1 0 0 1 1 1 1 0 1 0 1 0 1 0 0 0 0 1 1 1 0 0 1 0 0 0
    128 1 0 0 1 1 1 0 0 0 1 0 1 0 0 0 1 1 1 1 1 1 1 0 0 0 1 1 0 0 1
    129 0 0 0 0 0 1 0 1 0 0 0 1 1 0 1 1 1 1 0 1 0 0 0 1 1 0 1 0 1 0
    130 0 0 0 0 0 0 1 0 0 0 1 1 1 0 0 0 1 1 0 1 1 1 0 0 0 0 0 0 1 0
    131 0 1 1 0 0 1 1 1 0 1 1 0 1 0 1 1 1 1 0 1 1 1 0 1 0 0 0 1 1 0
    132 1 0 1 1 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 1 1 0 0 0 0 0 1 0 1 0
    133 0 1 0 1 0 0 1 0 0 0 0 1 0 1 1 0 1 0 1 0 1 1 1 0 1 1 1 0 0 1
    134 1 1 0 0 0 0 0 1 0 1 1 0 0 1 1 1 1 0 0 0 1 0 0 0 1 0 1 1 0 0
    135 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 1 0 0 1 0 1 1 0 0 0 1 0 0 1 0
    136 1 0 1 0 1 0 0 0 0 0 1 1 0 0 1 1 1 0 1 1 0 0 1 0 1 1 1 1 1 1
    137 1 1 0 1 0 1 0 0 1 1 1 0 1 0 0 1 1 0 0 0 1 0 0 1 0 0 1 1 0 0
    138 1 1 1 1 1 1 1 0 0 1 1 1 0 0 0 1 1 1 0 1 1 0 1 0 0 1 0 1 0 1
    139 0 1 0 0 1 0 0 1 1 0 0 1 0 0 1 0 0 0 0 1 0 1 1 1 0 0 0 0 0 1
    140 0 1 0 0 1 1 1 1 1 0 0 0 0 0 1 0 0 1 1 0 1 1 0 0 0 1 0 0 1 1
    141 1 1 1 1 1 0 0 1 0 0 0 0 1 0 0 1 1 1 0 0 0 1 0 0 0 0 0 1 0 0
    142 1 0 1 0 0 1 1 1 0 1 0 1 1 1 0 1 1 1 0 1 0 1 1 1 0 1 1 0 1 0
    143 0 0 0 1 1 1 1 1 0 0 1 1 1 1 0 0 1 1 0 1 1 1 0 0 0 1 1 1 0 0
    144 0 0 1 0 1 0 0 0 1 0 1 0 0 0 1 1 1 1 1 1 1 0 0 0 1 1 0 0 1 0
    145 0 1 1 1 0 1 0 1 0 1 1 1 0 0 1 1 1 1 0 0 0 0 1 1 0 1 0 1 0 0
    146 0 1 0 1 1 0 1 1 1 1 1 0 0 1 0 0 0 1 1 0 1 1 0 0 1 0 1 1 1 1
    147 0 1 1 1 0 1 1 0 1 0 0 1 1 0 0 1 0 1 0 0 1 1 1 0 0 1 1 1 0 1
    148 0 0 0 1 0 1 1 0 1 0 1 1 1 1 0 0 1 1 1 0 1 1 0 1 1 0 1 0 0 1
    149 0 0 0 0 1 1 0 0 0 1 0 1 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 1
    150 1 0 1 1 0 0 1 0 0 1 1 0 0 1 1 0 0 0 0 0 1 0 1 0 1 1 1 1 1 0
    151 0 1 1 1 1 0 0 0 0 1 0 1 1 1 1 0 0 0 1 1 0 1 1 0 1 1 1 0 1 0
    152 1 0 1 0 1 0 0 1 1 1 0 0 1 0 1 0 1 0 1 0 0 0 1 1 0 1 0 0 1 0
    153 1 1 1 0 0 1 0 1 1 0 1 0 0 0 0 1 0 1 0 0 1 1 1 1 0 0 0 1 1 0
    154 0 0 1 1 1 1 0 1 1 1 0 0 0 1 0 1 0 0 1 0 0 1 0 0 0 1 0 1 1 0
    155 0 0 0 0 0 1 1 1 1 0 0 1 1 1 0 1 1 0 0 1 1 1 1 0 1 1 0 1 1 0
    156 1 1 1 0 1 1 0 0 1 1 1 1 0 1 0 0 0 1 0 1 1 0 0 1 0 0 1 0 1 0
    157 1 0 1 0 0 0 1 0 1 1 1 1 0 1 1 1 1 0 0 0 1 0 0 1 0 1 1 0 1 0
    158 0 1 0 1 0 1 1 0 1 1 1 0 0 0 1 1 1 1 0 0 1 1 1 1 0 1 1 0 0 0
    159 0 1 1 0 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 1 0 1 0 1 1 1 0 1
    160 0 0 1 1 1 1 1 0 0 1 0 1 1 0 1 1 0 1 0 0 1 1 0 0 0 1 0 1 1 0
    161 0 0 1 0 1 0 1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1 0 1 0 0 0 0 0 0
    162 1 0 0 0 0 1 0 0 1 1 0 1 1 1 1 1 1 0 0 1 1 1 1 0 0 1 1 0 1 0
    163 0 1 1 1 0 0 0 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 1 0 0 1 0 0 0 1
    164 0 1 1 1 1 1 0 1 1 0 0 0 0 0 1 1 1 0 1 0 0 0 1 0 0 0 1 1 0 0
    165 0 0 0 0 1 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 1 1 0 1 1 1 1 0 1 1
    166 0 0 1 0 1 0 1 1 1 1 1 1 0 0 1 1 0 0 1 1 0 1 1 0 0 1 0 1 1 1
    167 0 1 1 0 1 0 0 0 0 1 1 0 0 1 0 1 0 0 0 0 0 0 1 1 1 0 1 1 1 1
    168 1 0 0 1 1 0 1 1 0 1 1 1 0 1 0 0 0 0 0 1 1 0 1 1 0 1 0 0 1 1
    169 0 1 1 0 1 1 1 0 1 1 0 0 0 1 1 1 1 1 0 1 0 1 1 1 0 1 1 1 0 0
    170 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 1 0 0 0 0 0 1
    171 0 0 1 1 1 1 0 0 1 0 0 0 1 1 1 0 1 1 1 1 1 0 0 1 0 0 1 1 0 0
    172 0 0 0 0 1 1 1 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 1 1 1 1 1 0 1 1
    173 1 0 1 1 1 1 1 0 1 0 1 1 1 0 1 0 1 0 1 1 1 1 1 1 1 1 0 0 1 1
    174 1 0 1 0 1 1 0 0 0 0 1 0 1 0 1 1 0 0 1 0 0 0 0 0 1 1 1 1 1 1
    175 1 0 1 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 1 0
    176 1 1 0 0 0 0 0 1 1 1 0 1 1 0 1 1 1 1 1 0 1 1 0 0 0 0 0 1 0 1
    177 1 0 1 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0 1 1 0 1 0 0 1 1 0 1 0 1
    178 1 1 0 1 0 1 0 1 1 1 1 1 1 0 0 1 1 0 1 1 1 0 0 0 1 0 0 1 1 1
    179 0 0 0 1 1 0 1 1 0 0 0 0 1 1 0 1 1 0 1 1 1 0 1 1 1 1 1 0 0 0
    180 0 0 1 0 0 0 1 1 1 0 0 1 1 0 1 0 1 0 1 0 0 0 0 1 1 1 0 1 0 1
    181 0 1 1 1 0 1 0 0 1 0 0 1 0 1 1 0 0 0 0 1 0 0 1 1 1 1 1 1 1 1
    182 0 0 0 1 1 1 0 1 1 1 0 1 0 1 1 0 1 0 0 0 1 1 1 0 0 1 1 1 1 1
    183 0 1 0 0 0 1 1 1 1 0 1 1 1 1 0 0 1 1 1 0 1 0 1 0 0 0 0 1 0 0
    184 0 0 0 1 0 0 0 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 0 1 0
    185 1 0 0 1 0 1 0 1 0 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 0 1 0 0 0 0
    186 0 1 1 0 0 1 1 0 1 0 0 1 0 0 0 1 0 1 1 1 1 1 0 1 0 1 0 0 0 1
    187 0 0 1 1 1 0 1 0 1 0 0 1 1 0 0 1 0 1 1 1 0 1 0 0 1 1 0 1 0 0
    188 0 0 0 0 0 0 1 1 0 0 1 1 0 1 1 0 0 1 1 0 1 0 1 0 0 0 0 0 0 1
    189 0 1 1 0 1 0 1 1 1 0 0 0 0 0 1 1 1 0 1 1 1 1 1 1 1 0 0 1 0 0
    190 1 0 0 1 1 1 0 1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 1 1 0 1 0 0 1 1
    191 0 1 0 1 0 0 0 1 1 1 1 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0
    192 1 1 1 1 0 0 0 0 0 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 0 1 1 0 0
    193 0 0 0 1 1 1 0 1 0 1 0 0 1 1 1 1 0 1 0 1 1 0 0 1 1 0 1 0 1 0
    194 0 0 1 1 1 0 0 0 1 0 0 1 1 0 0 0 1 0 1 0 1 1 0 1 1 1 1 1 0 1
    195 1 1 1 1 0 0 0 1 0 1 1 0 1 1 0 1 1 1 0 0 0 0 0 1 0 1 0 1 1 0
    196 1 0 1 0 1 1 0 1 0 0 1 0 1 0 0 1 0 1 1 0 0 0 1 0 1 0 1 1 1 1
    197 0 0 1 0 1 0 1 0 1 1 1 0 1 1 0 0 1 0 1 1 0 0 1 1 0 0 1 0 0 1
    198 0 0 1 1 0 1 0 1 0 1 1 1 1 1 1 0 1 1 0 1 0 1 1 1 0 0 1 1 1 0
    199 1 0 0 1 0 0 0 0 1 0 1 1 1 0 1 0 1 0 0 1 0 0 1 1 0 0 0 1 0 1
    200 0 1 0 1 0 0 1 1 0 1 1 1 0 0 0 0 1 1 0 1 1 1 1 1 1 1 0 1 1 1
    201 1 0 0 1 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 1 1 1 1 1 1 0
    202 0 1 1 1 1 0 1 0 1 0 1 0 1 1 1 0 0 1 0 0 1 1 1 0 1 0 1 1 1 0
    203 0 0 0 0 0 0 1 0 0 1 1 1 1 0 0 1 1 1 1 0 1 1 1 0 1 0 1 0 0 0
    204 1 0 1 1 0 0 0 1 0 1 1 1 1 1 1 0 0 1 1 0 1 1 0 0 0 0 0 0 1 1
    205 1 0 0 1 0 0 0 1 0 0 1 0 1 0 0 1 0 1 1 1 0 1 0 1 1 0 0 1 0 0
    206 0 1 1 0 1 0 1 0 1 1 0 0 1 1 0 1 1 0 0 1 1 0 0 1 0 0 1 0 0 1
    207 1 1 1 1 1 0 1 1 1 0 1 0 0 1 1 1 0 0 1 1 0 0 1 1 0 1 1 0 0 1
    208 1 1 0 0 1 1 0 0 0 0 0 1 0 0 1 1 1 1 1 0 0 0 0 0 0 1 1 0 1 0
    209 1 0 0 0 1 0 0 1 1 1 1 0 1 0 0 1 0 0 0 1 0 1 1 1 0 0 0 1 1 0
    210 1 0 0 0 1 1 0 0 0 1 1 1 1 0 1 1 0 1 1 0 1 1 0 0 0 1 1 1 0 0
    211 1 0 0 0 0 0 1 0 0 1 0 1 0 1 1 0 1 0 1 0 1 1 0 0 0 0 1 0 1 1
    212 0 1 1 1 0 1 0 0 0 0 1 1 0 1 1 1 0 1 0 0 1 0 1 1 0 1 1 1 1 0
    213 1 0 0 0 1 0 1 1 1 1 1 1 0 0 1 1 1 1 1 1 0 0 0 1 1 0 0 1 0 1
    214 0 0 0 1 0 1 0 1 1 1 1 0 1 1 0 1 0 0 1 0 1 0 0 1 0 0 0 0 0 1
    215 0 1 1 1 0 0 1 0 1 1 1 0 0 0 0 1 1 0 1 0 0 1 0 1 1 1 0 0 0 0
    216 0 0 0 0 0 0 1 1 1 1 0 0 1 0 0 0 0 1 1 0 1 0 1 0 0 0 0 1 0 1
    217 1 1 0 0 0 0 1 1 1 1 1 0 1 0 1 1 0 1 0 1 0 1 0 0 1 1 0 1 0 1
    218 0 0 1 1 0 1 0 0 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 1 0 0 1 0 0
    219 1 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 1 0 1 0 1 1 0 0 1 1
    220 1 0 1 0 1 0 0 0 0 1 0 0 1 0 1 1 0 1 1 0 0 1 0 1 1 0 1 1 0 0
    221 1 1 1 0 0 0 0 1 0 0 0 1 0 0 0 1 0 1 0 1 0 1 0 0 1 1 0 0 0 0
    222 0 0 0 0 1 1 0 1 0 0 0 1 1 0 1 0 1 0 0 1 0 1 1 0 1 0 1 1 1 0
    223 1 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 0 0 1 1 1 1 0 1
    224 1 0 0 1 0 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 0 1 1 0 1 1 1 1
    225 1 0 1 0 1 1 1 0 0 1 0 1 1 1 1 0 1 1 1 0 0 0 1 0 0 1 0 0 0 1
    226 0 0 0 1 0 1 1 1 0 0 0 1 0 1 0 1 0 0 0 1 1 1 0 1 0 1 0 0 0 0
    227 1 0 1 1 1 1 0 1 0 0 0 1 1 0 0 0 1 0 0 1 1 0 1 0 1 0 0 1 0 1
    228 0 0 0 0 0 0 0 1 1 0 1 0 1 1 0 0 1 1 1 0 0 1 1 0 0 0 0 1 1 0
    229 0 0 1 0 0 0 0 0 1 1 0 0 1 1 1 0 1 0 0 1 0 1 1 1 1 1 1 1 1 0
    230 0 1 0 1 1 1 1 1 1 1 0 1 1 0 0 0 0 1 1 1 1 1 1 0 1 1 1 0 1 0
    231 0 1 0 0 0 1 0 0 0 1 1 0 0 0 1 1 0 1 1 1 1 0 1 0 0 0 0 1 1 0
    232 1 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 1 0 0 0 1 0 0 0 1 1 0 1 1
    233 0 1 0 1 0 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 0 1 1 0 1 1
    234 0 0 0 0 0 0 1 0 0 1 1 1 0 1 0 1 0 0 0 1 0 0 0 1 0 1 0 1 1 1
    235 1 0 1 0 0 0 1 1 1 0 0 1 0 0 0 0 0 0 0 1 0 1 1 0 1 1 0 0 0 1
    236 1 1 1 1 1 1 1 0 1 1 1 0 1 0 0 1 1 0 0 1 1 0 1 0 1 1 0 0 0 0
    237 0 0 1 0 0 1 1 0 1 0 1 0 1 1 0 0 1 0 0 1 0 1 1 1 0 1 1 1 0 1
    238 1 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 1 0 1 0 0 0 0 1 0
    239 1 1 1 1 0 0 1 0 1 0 1 0 1 0 0 1 1 1 1 0 0 1 1 0 1 1 1 0 0 1
    240 0 1 0 0 1 0 0 1 0 1 0 1 0 1 0 1 1 1 0 1 1 1 1 0 1 0 0 0 0 0
    241 0 0 1 0 1 0 1 1 0 0 0 1 1 1 1 0 1 1 0 1 1 1 1 1 1 0 1 1 1 0
    242 0 0 1 1 0 1 0 1 1 0 1 0 1 1 0 1 1 0 0 1 1 1 0 1 0 0 0 1 0 1
    243 0 1 0 1 0 1 1 1 0 0 1 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 0 1 1 1
    244 0 1 1 0 1 0 1 0 0 0 1 1 1 1 1 0 1 1 0 1 0 0 0 1 1 0 1 0 1 0
    245 0 1 0 1 1 1 1 1 1 0 1 1 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 1 1 1
    246 0 0 0 1 1 0 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 1 0 1 1 0 1 1 1 1
    247 1 1 1 0 1 0 0 0 1 1 0 1 0 0 0 1 1 1 0 0 0 1 1 1 0 0 1 1 1 0
    248 0 1 0 0 1 0 1 1 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1 0 1 1 1 1 0
    249 1 1 0 0 0 0 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 1 1 1
    250 0 0 1 0 0 1 0 0 1 1 1 0 1 1 1 0 1 0 0 1 1 0 0 1 1 0 0 0 0 0
    251 0 1 1 1 0 0 1 0 1 0 1 1 1 0 1 1 0 0 1 1 1 0 1 0 0 1 0 0 0 0;

end;


Je détaille rapidement ce qu'il se passe là, je me dis que ça peut toujours servir à quelqu'un qui aurait un bout de programme linéaire à encoder et résoudre un jour. ^^

Donc, sans détailler trop la syntaxe, on déclare là les tableaux potentiometres et ampoules qui contiennent juste la liste des indices des ampoules et potentiomètres en jeu dans le problème, qui vont permettre d'itérer avoir à hardcoder les plages (0 .. 29) et (0 .. 251) à chaque fois… question de bon goût juste ! Ensuite on déclare les variables pot et amp, qui sont en fait des familles de variables respectivement indexées par potentiometres et ampoules, et qui vont permettre d'encoder la valeur à laquelle on règle chaque potentiomètres et les valeurs correspondantes des ampoules. On ajoute aussi un gros tableau de paramètres qui permet de lier chaque ampoule aux interrupteurs qui la contrôlent (à bien sûr ne pas taper à la main, mais bidouiller un peu le script forcecas.py pour le générer ^^). Ne reste plus alors qu'à décrire le programme linéaire que l'on veut résoudre :

Code: Tout sélectionner
minimize consommation: sum{p in potentiometres} pot[p];
    s.t. plage_potentiometre{p in potentiometres}:
        0 <= pot[p] <= 1;
    s.t. reseau{a in ampoules}:
        amp[a] = sum{p in potentiometres} amp_vers_pot[a,p]*pot[p];
    s.t. allume{a in ampoules}:
        amp[a] >= 1;
solve;


Comme on l'a dit plus tôt, on veut minimiser l'intensité totale en sortie des potentiomètres, c'est ce qu'indique la première ligne : on minimise la somme des pot[p] pour p qui décrit potentiometres. On indique ensuite les contraintes qui spécifient notre problème (les s.t. sont à lire comme
such that
, c'est à dire
tel que
en français) : on veut que chaque potentiomètre ait une valeur entre 0 et 1 (ce sont les contraintes plage_potentiometre{p}, on a une telle contrainte par potentiomètre), que chaque ampoule ait la valeur qui lui soit attribuée par le réseau de potentiomètres (contrainte reseau, on utilise à cet endroit notre gros tableau de correspondance et calcule simplement la bonne combinaison linéaire des valeurs des potentiomètres) et enfin que chaque ampoule soit allumée (donc de valeur supérieure ou égale à 1) (ce sont les contraintes allume{a}). L'important est que toutes nos contraintes ainsi que ce que l'on veut maximiser ou minimiser soit linéaire en les variables que l'on a déclarées.

Je ne sais si c'est très clair ou utile à tous tout ça, mais je voulais montrer un peu la tête d'un fichier en MathProg, je trouvais ça sympa ! ^^

Les quelques lignes restantes sont juste là pour formater la sortie du programme (je voulais récupérer une ligne que je n'avais plus qu'à coller dans un fichier python et qui spécifierait les valeurs de chaque interrupteurs) et ne sont pas très intéressantes.


Il ne reste plus qu'à lancer le solveur sur notre programme avec glpsol --math programme_simple.mathprog. On obtient instantanément la ligne

config = [0.023, 0.223, 0.023, 0.000, 0.164, 0.132, 0.139, 0.191, 0.115, 0.146, 0.081, 0.094, 0.359, 0.083, 0.038, 0.159, 0.000, 0.000, 0.000, 0.001, 0.242, 0.158, 0.064, 0.156, 0.078, 0.105, 0.000, 0.000, 0.123, 0.068]

Là tout content on se décide à tester cette solution du problème simplifié comme solution du problème initial et là, déception… On obtient un score d'à peine un peu plus de 204. Plus en détail, on a :

Code: Tout sélectionner
All+Grill:232+20/252
Alimentat:2.989247311827957
Pertes   :0.0
Gaspillag:123.46236559139786


On constate que l'on allume bien toutes les ampoules, comme prévu, enfin en tout cas elles sont toutes à une valeur plus grande que 1, mais certaines sont grillées (on pouvait s'y attendre, vu qu'on a jamais dit à notre programme de faire attention à ça). En plus, malgré notre minimisation de la valeur totale en sortie des interrupteurs, le gaspillage reste significatif : c'est normal, puisque le gaspillage dépend de ce que font les ampoules du courant en sortie, et non simplement de la valeur de la sortie. Il va falloir raffiner.

Premier raffinement assez intuitif qui vient à l'esprit : éviter de griller des ampoules. Pour ce faire, il suffit
a priori
juste de changer s.t. allume{a in ampoules}: amp[a] >= 1; en s.t. allume{a in ampoules}: 1 <= amp[a] <= 2;. On relance le solveur, et obtient là la sortie suivante LP HAS NO PRIMAL FEASIBLE SOLUTION. Bon. En gros, ça nous apprend qu'il n'existe aucune configuration de potentiomètre telle qu'on puisse allumer les 252 ampoules en même temps sans en griller aucune, même si ça ne nous avance pas vraiment, je trouve intéressant qu'on puisse obtenir ce genre d'information aussi facilement. ^^

À partir de là, on peut penser à plusieurs pistes : on peut essayer de déterminer le nombre minimal d'ampoule que l'on accepte de griller tel qu'on puisse allumer toutes les autres. On sait que ce nombre est plus grand que 0, et inférieur à 20 (on a trouvé qu'on pouvait tout allumer en en grillant 20, avec notre premier programme). Si ce nombre est entre 1 et 5, on peut espérer le trouver relativement rapidement en bruteforcant les cas possibles (c'est à dire en testant toutes les configurations où on autorise explicitement telle et telle ampoule à être grillées), mais s'il est plus grand, ça me paraît plus délicat en passant par un bruteforce du genre. Je n'ai pas fait cette analyse comme ça, mais je me dis
a posteriori
que ça doit être intéressant !

J'ai plutôt petit à petit intégré les aspects du problème initial dans mon problème réduit. Je ne vais pas tout détailler, mais notamment si on regarde un peu plus en détail, le problème initial n'est pas non plus si continu (et donc pas si linéaire…) que ça, le score étant calculé différemment selon des paliers de valeurs pour les ampoules (entre 0 et 1, entre 1 et 2 puis entre 2 et l'au-delà). En fait on peut ruser un peu pour encoder ce genre de notions dans le programme linéaire : en MathProg, on peut forcer certaines variables à valoir soit 0 soit 1, par exemple avec var est_allume{a in ampoules}, binary;. Il faut toujours se rappeler que l'on a pas le droit d'utiliser des conditions ou des fonctions comme min ou max ou autre dans un programme linéaire, ou tout doit être… et bien linéaire ! On peut ruser comme je le disais : si vous maximisez la somme des est_allume[⋅], avec les contraintes est_allume[a] <= amp[a], lorsque amp[a] sera supérieure à 1 (donc l'ampoule allumée), et bien comme on cherche à ce que la somme des est_allume[⋅] soit maximale, on aura tout intérêt à mettre toutes les variables correspondant à des ampoules allumés à une valeur la plus grande possible, ici 1. En revanche lorsque l'ampoule est éteinte, c'est que amp[a] est inférieure strictement à 1, et donc est_allume[a] ne pourra pas prendre d'autre valeur que 0. En revanche abuser de telles valeurs booléennes tend à augmenter la complexité du problème, pour les raisons décrites plus tôt (le solveur doit encaisser les «sauts», ce qui revient globalement à énumérer des possibilités, même s'il est assez malin pour pouvoir faire ça assez vite dans pas mal de cas, il ne peut pas tout faire, en particulier pas résoudre des problèmes NP-complets plus vite que la musique ! ^^)

Le programme qui m'a permis d'atteindre la solution que j'ai soumise est le suivant (je ne l'ai pas trop nettoyé, donc il est peut-être pas très très lisible, mais bon, il reprend grosso modo les idées décrites plus tôt), avec quelques trucs hardcodés parce-que sur le moment ça me semblait intéressant… sûrement… x)

Code: Tout sélectionner
set switches := (0 .. 29);

var s{k in switches};

set bulbs := (0 .. 251);

param b2s{i in bulbs, k in switches};

var b{i in bulbs};
var sig{i in bulbs}, binary;

var alpha{i in bulbs};

maximize score: sum{i in bulbs}sig[i] - sum{i in switches}alpha[i];#s[i];
    s.t. alp{i in bulbs}: alpha[i] >= 0;
    s.t. alpi{i in bulbs}: alpha[i] >= b[i]-1.66;
    s.t. foo{i in bulbs}: b[i] = sum{k in switches} b2s[i,k]*s[k];
    s.t. lit{i in bulbs}: b[i] >= sig[i];
    s.t. still{i in bulbs}: b[i] <= 1.9;
    s.t. rest{k in switches}: 0 <= s[k] <= 1;
solve;

printf 'aff = [';
printf '%.3f', s[0];
for {k in (1..29)}
    printf ', %.3f', s[k];
printf ']\n';

data;

param b2s: 0 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 :=
    0 1 1 0 0 1 1 0 1 0 1 0 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0
    1 1 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 0 1 0 0 1 0 0 1 1 0 0 0 0 1
    2 0 0 1 1 1 0 1 1 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 1 1 1 1 0 1
    3 1 1 0 1 1 1 1 0 1 1 1 1 1 1 1 1 1 0 0 1 1 0 1 1 0 0 0 0 1 0
    4 1 0 1 0 1 1 0 1 1 0 1 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1 0
    5 0 0 1 1 0 1 1 0 0 1 0 0 1 1 1 1 1 1 1 1 0 0 0 1 0 0 1 1 0 0
    6 0 0 0 1 1 1 0 1 1 1 1 0 1 1 0 1 0 0 1 0 1 1 1 0 0 1 1 1 1 1
    …
    …
    …
    248 0 1 0 0 1 0 1 1 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1 0 1 1 1 1 0
    249 1 1 0 0 0 0 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0 1 1 1
    250 0 0 1 0 0 1 0 0 1 1 1 0 1 1 1 0 1 0 0 1 1 0 0 1 1 0 0 0 0 0
    251 0 1 1 1 0 0 1 0 1 0 1 1 1 0 1 1 0 0 1 1 1 0 1 0 0 1 0 0 0 0;

end;


Le score 225,699 que l'on obtient n'est pas trop mal, et on l'obtient en quelques secondes, mais il faut savoir qu'il y a quelques soucis qui font que l'approche que j'ai développée jusque là ne permettrait pas je pense de faire bien mieux. Déjà le côté continu des potentiomètres est en fait discutable puisque, notamment pour les raisons qu'a bien et gentiment décrites Critor plus tôt, ceux-ci prennent en fait leurs valeurs dans une plage de 94 valeurs possibles, ça peut sembler suffisant pour approximer du continu, mais cela adjoint aux paliers pose un soucis : globalement on va essayer de faire coller les valeurs des ampoules le plus possibles à la valeur 1.0, le truc c'est que lorsqu'on ajoute des arrondis, et bien on peut avoir tendance à passer très légèrement en dessous de 1.0, et même si c'est peu, c'est suffisant pour changer de palier (l'ampoule n'est plus allumée, et donc le calcul du score erroné). Si on voulait tout de même tout encoder on s'approcherait de plus en plus de la résolution d'un problème vraiment NP-Complet, encodé dans un programme linéaire, et donc un truc qui prend beaucoup trop de temps, en tout cas on ne gagne pas grand chose à passer par un solveur linéaire.

Je me suis amusé à lancer une version plus précise sur une grosse machine pendant un week-end, pas grand chose n'a eu le temps d'en sortir, sinon de la RAM occupée…

Comment ça je squatte la RAM du serveur ? :E


Enfin voilà, sans tous les petits détails, c'était globalement mon approche, je suis curieux de voir ce qu'on pu faire les autres, surtout que le score optimal semble être bien approché (puisqu'on a deux soumissions à 227,647 par deux personnes différentes)… ^^

https://www.planet-casio.com/Fr/forums/topic15371-2-Triconcours-et-l-epreuve-de-force.html#159282


en
4ème
n'arrive qu'à 245 lampes allumées, mais de façon bien plus économique à
225,9
points.

@Ruadh, dis-nous tout ! ;)

Ruadh a écrit:En lisant le programme, j'ai compris que chaque potentiomètre pouvait avoir 94 valeurs distinctes, qui sont les entiers de 0 à 93 divisés par 93. J'ai donc utilisé les nombres entiers par la suite. J'ai ensuite cherché quel est l'entier qui permettait d'avoir le meilleur score si tous les potentiomètres avaient la même valeur, il s'agissait de 8. J'ai utilisé un programme qui modifiait légèrement les valeurs de chaque potentiomètre autour de cette valeur et j'ai finalement réalisé un score de plus de 218.
Voyant que je ne parviendrai pas à monter plus haut avec cette méthode, j'ai utilisé un algorithme génétique assez basique. J'ai supposé que les potentiomètres ne pouvaient pas avoir une valeur supérieure à 20, en effet, les ampoules ont tendance à griller au-delà. Cela a permis à mon algorithme de converger très rapidement vers mon dernier score de presque 226.


/ achève
3ème
avec un éclairage à 245 lampes avec encore moins de pertes énergétiques et se voit récompensé de
226,3
points.

@Neo, nous avons hâte de lire tes explications ! ;)

NeOtuX a écrit:Pour ma part j'ai eu la même approche que Hackcell : les Algorithmes Génétiques. Je n'y connais pas grand chose dans ce domaine, puisque je n'en avais jusqu'alors jamais développé (J'en avais juste parlé lors d'un pitch pour une application qui devait faire de la réalité augmentée). De ce que j'en avais compris les AG permettent de trouver 'une' solution pas trop mauvaise (mais pas LA solution, à moins d'avoir de la chance) en un temps raisonnable. Ce qui m'a lancé c'est le fait que le nombre d'entrées et de sorties était connu et lui aussi raisonnable.

Bref j'ai lu la page Wikipédia et... c'est tout. J'ai pondu un code, je ne sais pas trop ce que ça vaut. J'avoue que la partie qui chamboule la population si l'algorithme est bloqué dans un maximum local est du pur bricolage. Si quelqu'un connait une méthode robuste pour gérer ça je suis preneur. J'ai vu sur la page Wikipédia qu'il était question du recuit simulé en alternative, mais je ne connais pas du tout : ce sera l'occasion d'apprendre une prochaine fois !

A toute fin utile je vous mets mon code en Python en PJ. Je prends toutes vos remarques si vous en avez, comme je disais je suis néo(tux)phyte.

Fichier joint
:
https://www.planet-casio.com/files/forums/AG_Potars-159484.py


avait au départ envoyé une participation à
227,7
points, mais pas de chance puisque quelqu'un d'autre avait déjà soumis exactement la même configuration.

Il se rabat donc sur une configuration de 247 lampes à
227,6
points qui lui fait décrocher la
2nde
place.

@Jacobly, how did you manage to achieve such a high score ? ;)

Jacobly a écrit:I just used the same simulated annealing program that I had used for Galaktik, but between the search space being discrete and therefore minuscule in comparison, and the maximization function being much more well-behaved, I had the global maximum within 6 hours of finding out about the contest. In the end, I had a ~140 line program that can find the best score with no starting information in under 4 minutes with a maybe a 5-10% probability. The only thing of note that I did was I scaled the score function so that it could be computed using only integer math which meant that I didn't have to worry about floating point error.


Et voici donc en
1ère
place la fameuse configuration avec 247 lampes à
227,7
points, découverte par / .

@Pavel, éclaire-nous de tes lumières ! ;)

Pavel a écrit:Je vais essayer d'expliquer comment j'ai obtenu 227,647 points.

J'ai commencé par légèrement simplifier le code. J'ai modifié la fonction pot() pour qu'elle marche avec les valeurs entières de 0 à 93 et j'ai ajouté une fonction (score()) pour calculer les points. Voici un lien vers le code après ces modifications.

En jouant avec ce code, j'ai remarqué deux comportements de ce problème potentiellement utiles pour trouver une solution:

  1. En tournant les potentiomètres un par un de 0 à 93, il est possible de trouver quelque chose qui ressemble à un maximum local:

    Code: Tout sélectionner
    for j in range(30):
      pot(j, 8 + j % 2)

    print(score())

    while True:
      smax = score()
      kmax = -1
      vmax = -1
      for k in range(30):
        backup = ls[k]
        for v in range(94):
          pot(k, v)
          s = score()
          if smax < s:
            smax = s
            kmax = k
            vmax = v
        pot(k, backup)
      if kmax >= 0:
        pot(kmax, vmax)
        print(smax)
      else:
        break

  2. Pour sortir d'un maximum local, il suffit de tourner juste un tout petit peu quelques potentiomètres:

    Code: Tout sélectionner
    for k in range(30):
      v = ls[k] + mrandint(-1, 1)
      if v < 0: v = 0
      if v > 93: v = 93
      pot(k, v)

Ensuite, j'ai fait un peu de lecture sur des méthodes d'optimisation stochastiques et j'ai essayé quelques méthodes de ce livre.

Le recuit simulé a donné les meilleurs résultats en moins de temps par rapport aux autres méthodes.

Enfin, voici un lien vers le code en C qui converge à la solution en quelques heures.

https://www.planet-casio.com/Fr/forums/topic15371-2-Triconcours-et-l-epreuve-de-force.html#159391


Référence
:
https://www.planet-casio.com/Fr/forums/ ... 471&page=1
Lien vers le sujet sur le forum: Triconcours de rentrée 2018 - résultats défi de Force (Commentaires: 56)

-
Rechercher
-
Sujets à la une
"NumWorks++": Challenge de modification matérielle pour rajouter une puce de mémoire Flash !
Offre TI-Planet/Jarrety pour avoir la TI-83 Premium CE avec son chargeur pour 79,79€ port inclus !
Offre TI-Planet/Jarrety pour avoir la TI-Nspire CX CAS à seulement 130€ TTC port inclus!
Jailbreake ta TI-Nspire avec Ndless et profite des meilleurs jeux et applications !
Transforme ta TI-Nspire CX en console Game Boy Advance!
12345
-
Donations/Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...
PayPal : paiement en ligne sécurisé - secure online payments
Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partenaires et pub
Notre partenaire Jarrety 
-
Stats.
343 utilisateurs:
>308 invités
>31 membres
>4 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Autres sites intéressants
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)