TI-Planet | News

de **critor** » 15 Nov 2018, 22:58

Crois-le ou pas, malgré la travail colossal que nous abattons chaque année, il est extrêmement rare que des membres nous proposent leurs calculatrices fonctionnelles une fois qu'ils n'en ont plus besoin. Et pourtant, même de simples modèles d'entrée de gamme nous feraient très plaisir, car bien pratiques pour divers tests et développements.

Il y a eu DarkGrunt qui avait donné deux TI-81 en 2009 soit avant le renommage de la communauté en TI-Planet, calculatrices qui avaient l'avantage de disposer de versions ROM non dumpées à l'époque, ce que nous nous sommes empressés de faire.
Puis il y a eu Neo qui avait donné une Casio fx-85GT PLUS en 2016.

Nous sommes donc aujourd'hui transposés de joie à la réception d'un don de darthvader, et pas des moindres :

sa TI-Nspire CX CAS en révision matérielle C
fait donc partie des versions les plus sympas pour les bricoleurs
sa TI-84 Plus CE-T en révision matérielle C
modèle très rare en France et qu'ils nous a ici ramené d'Allemagne; le modèle qui remplace notre TI-83 Premium CE française chez nos voisins européens, mais en nettement plus cher et sans le calcul exact

Données pour aider, je cite, aux "cadeaux de concours".

Merci donc darthvader; la communauté TI-Planet éternellement reconnaissante.

de **critor** » 17 Nov 2018, 13:16

Pour te détendre en ce week-end très jaune, pourquoi ne pas essayer Holyxe World, le monde perso à sensations pour Oiram CE, le moteur de jeu Mario-like pour ta TI-83 Premium CE ?

Son créateur Holyxe nous démontre une fois de plus toute l'étendue de sa créativité et de son talent. Prépare-toi à affronter à travers 7 niveaux les plus hautes tours et plus profonds abysses :

Pour fonctionner correctement, Oiram CE a obligatoirement besoin des bibliothèques C téléchargeables ci-dessous. Mais rien de bien compliqué, il suffit juste de les transférer.

Téléchargements :

de **critor** » 18 Nov 2018, 19:31

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

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

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

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

Et maintenant les gagnants :

Alexmaster350 termine 10^ème en faisant briller 242 lampes valant 217,7 points.

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

Zezombye / Zezombye à 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 )

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

Hackcell / Hackcell 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 :

Show/Hide spoilerAfficher/Masquer le spoiler

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:

Run the app
Type pot(number,value)
See results/score
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 Dark-Storm / Dark storm, 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 :

Nemhardy / Nemhardy à 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… )

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

Mon approche a été encore une fois (comme l'an dernier déjà… ) 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 :

Show/Hide spoilerAfficher/Masquer le spoiler

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)

Show/Hide spoilerAfficher/Masquer le spoiler

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

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

NeOtuX / Ne0tux 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

jacobly 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 2^nde 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 / Pavel.

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

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

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

de **critor** » 19 Nov 2018, 21:37

A la rentrée 2019 comme déjà annoncé le Python sera le seul langage de programmation préconisé pour l'enseignement de l'algorithmique au lycée en Seconde et Première.

Plusieurs calculatrices graphiques intègrent déjà une implémentation Python officielle dans leur dernière mise à jour, plus ou moins complète, fidèle et réussie selon le cas :

NumWorks avec MicroPython 1.9.4
Casio Graph 90+E avec MicroPython 1.9.4
HP Prime avec l'écriture Python de Xcas
le module externe TI-Python pour TI-83 Premium CE avec peut-être CircuitPython, mais nous en reparlerons

Mais à côté de cela nous avons aussi plusieurs implémentations communautaires, bien évidemment inutilisables en mode examen à la différence :

TI-Nspire avec MicroPython 1.4.6
Casio Graph 90+E avec l'écriture Python de KhiCAS
Casio Graph 35+E/75+E avec MicroPython 1.9.4

CasioPython, l'application communautaire portant MicroPython 1.9.4 pour les Graph 35+E/75+E est sortie pour la rentrée 2018.

Toutefois l'application n'était pas encore au point, n'étant que fort peu utilisable, si bien que nous n'avons pas pu à la différence la mettre en avant pour la catégorie Python de notre concours de rentrée malgré notre bonne volonté.

En effet l'application ne gérait pas les entiers longs et échouait donc dès la première ligne de notre script sur le paramètre du moteur aléatoire intégré.

Même si ce n'était pas gênant pour ce concours ça le restait pour bien d'autres choses : l'application ne gérant pas non plus les nombres flottants ni complexes.

L'opérateur : de découpage (slicing) d'objets composés n'était pas géré non plus.

La touche

DEL

ne fonctionnait pas dans la console Python, pas plus que les flèches, et toute erreur de saisie impliquait donc de recommencer entièrement.

Et enfin l'application était extrêmement limitée en mémoire de travail, quelques lignes de définition de fonctions suffisaient à déclencher une erreur.

Malgré son emploi du temps d'étudiant fort bien rempli, Zezombye de Planète Casio nous sort cette semaine une mise à jour majeure de CasioPython transfigurant complètement cette application. Comme tu vas pouvoir en juger, nous passons enfin à quelque chose d'utilisable !

Déjà, les nombres flottants sont enfin gérés. Rappelons qu'un nombre flottant s'écrit sous la forme

$mathjax$M\times 10^E$mathjax$

avec M la mantisse et E l'exposant. Et Zezombye n'a visiblement pas fait les choses à moitié, puisque d'après le script ci-dessous les mantisses sont codées sur 53-bits (permettant au mieux 16 chiffres significatifs). Il s'agit donc d'une gestion des flottants dite en double précision (sur 64-bits avec les bits restants codant le signe et l'exposant, au lieu de 32-bits), augmentant significativement la fiabilité des résultats.

Code: Tout sélectionner: def prec(b): k=0 while 1+b**-k-1: k=k+1 return k

Les nombres complexes ainsi que les entiers longs (au-delà de 32-bits) sont maintenant gérés et la compatibilité est excellente comme le prouve notre script de concours qui marche sans la moindre altération !

Notons par contre que le défilement de l'historique de la console semble avoir quelques problèmes, ne permettant pas de remonter au-delà de quelques lignes. Et quand ce n'est pas ça, nous avons de temps en temps des lignes parasites du module mémoire gc venant écraser les affichages consoles...

Mais puisque l'on parle de gc, quels sont donc les modules Python intégrés dans l'application CasioPython ? Quelques commandes import nous apprennent que nous disposons de :

builtins et __main__ comme dans toute implémentation qui se respecte
math (comme sur Graph 90+E, NumWorks, TI-Nspire et module TI-Python)
cmath (comme sur NumWorks et TI-Nspire)
random (comme sur Graph 90+E, NumWorks et module TI-Python)
array (comme sur TI-Nspire)
sys (comme sur TI-Nspire)
gc (comme sur TI-Nspire)

Même si il manquerait un module graphique pour les nouveaux programmes 2019, nous n'en avons pas moins quelque chose de très complet niveau modules, comparable en fonctionnalités à la version TI-Nspire tout en étant bien plus à jour !

À la différence les implémentations officielles ont jusqu'à présent extrêmement limité le nombre de modules intégrés, peut-être pour des raisons sécuritaires ou de délais de validation, ces modules se comptant à ce jour dans tous les cas officiels sur les doigts d'une seule main.

Mais le fonctionnement de notre script de concours prenant déjà pas moins de 2,627Ko avec rien que le chargement en mémoire (avant même son exécution et donc la création des grosses listes) prouve également que la mémoire de travail de l'application a été nettement améliorée. Tentons de déterminer cet espace de travail avec un script remplissant la mémoire. L'application n'offre pas la fonction sys.getsizeof(), donc nous allons nous baser sur les tailles constatées sur ordinateur pour le script suivant :

64 octets pour une liste vide
8 octets par élement de liste supplémentaire
24 octets pour un entier nul
28 octets pour un entier court non nul
49 octets pour une chaîne vide
1 octet par caractère de chaîne supplémentaire

Code: Tout sélectionner: def mem(): try: l=[] try: l+=[0] l+=[""] l[1]+="x" while True: try: l[1]+=l[1][l[0]:] except: if l[0]<len(l[1])-1: l[0]=len(l[1])-1 else: raise(Exception) except: print("+",len(l)>1 and len(l[1])) return 64+8*len(l)+(len(l) and 24+4*(l[0]>0)+(len(l)>1 and 49+len(l[1])))+mem() except: return 0

Nous obtenons donc 30,147Ko de mémoire de travail Python, ce qui nous permet d'établir le classement suivant :

TI-Nspire avec 2,046Mo
Casio Graph 90+E avec 1,027Mo
Casio Graph 35+E/75+E avec 30,147Ko
calculatrice NumWorks avec 13,658Ko
logiciel web NumWorks avec 5,946Ko

CasioPython n'est pas parfait mais a franchi un cap et est désormais utilisable dans une contexte scolaire.

Il conviendra aussi bien aux Graph 35+E/75+E conformes 2019/2020 qu'aux anciens modèles Graph 35+USB et Graph 75/85/95.

Nous invitons justement les lycéens et enseignants concernés à l'utiliser et à faire des retours afin qu'il soit parfait pour la rentrée 2019.

Attention, pour une utilisation sur Graph 35+E / 35+USB, il faudra commencer par installer un système Graph 75 en suivant notre tutoriel.

Téléchargements :

Source : https://www.planet-casio.com/Fr/forums/ ... ast#152951

de **critor** » 20 Nov 2018, 19:40

Cet article au sujet du module TI-Python est rédigé a posteriori et illustré à l’aide des photos de tests prises sur le stand de Texas Instruments aux journées APMEP 2018 puis congrès UdPPC 2018. Nous ne disposons pas à ce jour du module.

Certaines photos ne correspondront pas exactement à ce qui est décrit, car nous avons amélioré le script utilisé entre les deux événements. Or malheureusement, il était beaucoup plus compliqué de prendre de bonnes photos au congrès UdPPC de par l'affluence nettement supérieure, le fait que seulement un module au lieu de deux était disponibles sur le stand pour tous ces visiteurs, ainsi que le fait que les stands ne disposaient cette fois-ci pas de cloisons à la différence mais consistaient en de simples tables alignées le long d'une allée et bien remplies - pas vraiment d'espace pour se poser.

Dans tous les cas, notez que ces tests ont été réalisés sur un prototype non final, et que des choses évoquées peuvent changer d'ici la livraison, en bien ou en mal d’ailleurs.

En vous priant donc de bien vouloir excuser les imprécisions éventuelles.

Dans un article précédent nous t'avons présenté le TI-Python, module externe permettant l'exécution de scripts Python sur ta TI-83 Premium CE.

Et peut-être as-tu été déçu(e) que le catalogue alphabétique accessible via

2nde

ne contienne apparemment que 95 éléments, surtout que parmi ces éléments sont inclus ceux des deux modules intégrés math et random. A priori très décevant par rapport à la concurrence...

Et bien non, en fait chez Texas Instruments le catalogue est très loin de tout lister. Par exemple, la commande try: fonctionne alors qu'elle n'est pas au catalogue.

Comment donc faire pour savoir ce que vaut vraiment le module TI-Python ?

Tentons d'explorer le module builtins à l'aide du script suivant :

Code: Tout sélectionner: #platforms: (0)TI-Nspire (1)NumWorks (2)Graph 90+E (3)Graph 75+E (4)TI-Python plines=[29,12, 7, 9,11] pcols =[53,99,509,32,32] try: import sys try: if sys.platform=='nspire': platform=0 if sys.platform=='TI-Python Adapter': platform=4 except: platform=3 except: try: import kandinsky platform=1 except: platform=2 nlines=plines[platform] ncols=pcols[platform] curline=0 def mprint(*ls): global curline st="" for s in ls: if not(isinstance(s,str)): s=str(s) st=st+s stlines=1+int(len(st)/ncols) if curline+stlines>=nlines: input("Input to continue:") curline=0 print(st) curline+=stlines def explmod(obj,hd="",obs="",reset=True): global curline if(reset): curline=0 c=0 for itm in sorted(dir(obj)): c=c+1 try: if obs=="": try: obs=obj.__name__ except: obs=str(obj) obs=obs[obs.find("'")+1:obs.rfind("'")] its=obs+"."+str(itm) itv=eval(its) mprint(hd+str(itm)+"="+str(itv)) if itv!=obj: c=c+explmod(itv,hd+".",its,False) except: mprint(hd+str(itm)) if c>0: mprint(hd+"Total: "+str(c)+" item(s)") return c

Le script nous liste alors pas moins de 212 entrées retranscrites ci-dessous :

TI-Python a écrit:>>> from explmod import *
>>> import builtins
>>> explmod(builtins)
ArithmeticError=<class 'ArithmeticError'>
AssertionError=<class 'AssertionError'>
AttributeError=<class 'AttributeError'>
BaseException=<class 'BaseException'>
.__init__=<function>
.Total: 1 item(s)
EOFError=<class 'EOFError'>
Ellipsis=Ellipsis
Exception=<class 'Exception'>
GeneratorExit=<class 'GeneratorExit'>
ImportError=<class 'ImportError'>
IndentationError=<class 'IndentationError'>
IndexError=<class 'IndexError'>
KeyError=<class 'KeyError'>
KeyboardInterrupt=<class 'KeyboardInterrupt'>
LookupError=<class 'LookupError'>
MemoryError=<class 'MemoryError'>
NameError=<class 'NameError'>
NotImplementedError=<class 'NotImplementedError'>
OSError=<class 'OSError'>
OverflowError=<class 'OverflowError'>
ReloadException=<class 'ReloadException'>
RuntimeError=<class 'RuntimeError'>
StopIteration=<class 'StopIteration'>
SyntaxError=<class 'SyntaxError'>
SystemExit=<class 'SystemExit'>
TypeError=<class 'TypeError'>
UnicodeError=<class 'UnicodeError'>
ValueError=<class 'ValueError'>
ZeroDivisionError=<class 'ZeroDivisionError'>
__build_class__=<function>
__import__=<function>
__name__=builtins
.count=<bound_method>
.endswith=<bound_method>
.find=<bound_method>
.format=<bound_method>
.index=<bound_method>
.isalpha=<bound_method>
.isdigit=<bound_method>
.islower=<bound_method>
.isspace=<bound_method>
.isupper=<bound_method>
.join=<bound_method>
.lower=<bound_method>
.lstrip=<bound_method>
.replace=<bound_method>
.rfind=<bound_method>
.rindex=<bound_method>
.rsplit=<bound_method>
.rstrip=<bound_method>
.split=<bound_method>
.startswith=<bound_method>
.strip=<bound_method>
.upper=<bound_method>
.Total: 22 item(s)
__repl_print__=<function>
abs=<function>
all=<function>
any=<function>
bin=<function>
bool=<class 'bool'>
bytearray=<class 'bytearray'>
.append=<function>
.extend=<function>
.Total: 2 item(s)
bytes=<class 'bytes'>
.count=<function>
.endswith=<function>
.find=<function>
.format=<function>
.index=<function>
.isalpha=<function>
.isdigit=<function>
.islower=<function>
.isspace=<function>
.isupper=<function>
.join=<function>
.lower=<function>
.lstrip=<function>
.replace=<function>
.rfind=<function>
.rindex=<function>
.rsplit=<function>
.rstrip=<function>
.split=<function>
.startswith=<function>
.strip=<function>
.upper=<function>
.Total: 22 item(s)
callable=<function>
classmethod=<class 'classmethod'>
dict=<class 'dict'>
.__delitem__=<function>
.__getitem__=<function>
.__setitem__=<function>
.clear=<function>
.copy=<function>
.fromkeys=<bound_method>
.get=<function>
.item=<function>
.keys=<function>
.pop=<function>
.popitem=<function>
.setdefault=<function>
.update=<function>
.values=<function>
.Total: 14 item(s)
dir=<function>
divmod=<function>
enumerate=<class 'enumerate'>
eval=<function>
exec=<function>
filter=<class 'filter'>
float=<class 'float'>
getattr=<function>
globals=<function>
hasattr=<function>
hash=<function>
help=<function>
help=<function>
hex=<function>
id=<function>
input=<function>
input=<function>
int=<class 'int'>
.from_bytes=<bound_method>
.to_bytes=<function>
.Total: 2 item(s)
isinstance=<function>
issubclass=<function>
iter=<function>
len=<function>
list=<class 'list'>
.append=<function>
.clear=<function>
.copy=<function>
.count=<function>
.extend=<function>
.index=<function>
.insert=<function>
.pop=<function>
.remove=<function>
.reverse=<function>
.sort=<function>
.Total: 11 item(s)
locals=<function>
max=<function>
memoryview=<class 'memoryview'>
min=<function>
next=<function>
object=<class 'object'>
oct=<function>
open=<function>
ord=<function>
pow=<function>
print=<function>
property=<class 'property'>
.__deleter__=<function>
.__getter__=<function>
.__setter__=<function>
.Total: 3 item(s)
range=<class 'range'>
repr=<function>
round=<function>
set=<class 'set'>
.__contains__=<function>
.__add__=<function>
.__clear__=<function>
.__copy__=<function>
.__difference__=<function>
.__difference_update__=<function>
.__discard__=<function>
.__intersection__=<function>
.__intersection_update__=<function>
.__isdisjoint__=<function>
.__issubset__=<function>
.__issuperset__=<function>
.__pop__=<function>
.__remove__=<function>
.__symetric_difference__=<function>
.__symetric_difference_update__=<function>
.__union__=<function>
.__update__=<function>
.Total: 18 item(s)
setattr=<function>
slice=<class 'slice'>
sorted=<function>
staticmethod=<class 'staticmethod'>
str=<class 'str'>
.count=<function>
.endswith=<function>
.find=<function>
.format=<function>
.index=<function>
.isalpha=<function>
.isdigit=<function>
.islower=<function>
.isspace=<function>
.isupper=<function>
.join=<function>
.lower=<function>
.lstrip=<function>
.replace=<function>
.rfind=<function>
.rindex=<function>
.rsplit=<function>
.rstrip=<function>
.split=<function>
.startswith=<function>
.strip=<function>
.upper=<function>
.Total: 22 item(s)
sum=<function>
super=<class 'super'>
tuple=<class 'tuple'>
.count=<function>
.index=<function>
.Total: 2 item(s)
type=<class 'type'>
zip=<class 'zip'>
Total: 212 item(s)
212
>>>

Tout ça c'est bien joli, mais qu'est-ce que ça donne par rapport à la concurrence ?
Et bien voilà, nous avons lancé le même script sur les autres calculatrices disposant du Python à ce jour :

TI-Nspire	Casio Graph 90+E	Casio Graph 35+E Graph 75+E	NumWorks	TI-Python pour TI-83 Premium CE
ArithmeticError AssertionError AttributeError BaseException EOFError Ellipsis Exception GeneratorExit ImportError IndentationError IndexError KeyError KeyboardInterrupt LookupError MemoryError NameError NotImplemented OSError OverflowError RuntimeError StopIteration SyntaxError SystemExit TypeError UnicodeError ValueError ViperTypeError ZeroDivisionError __build_class__() __import__() __repl_print__() abs() all() any() bin() bool bytearray bytes callable() chr() classmethod compile() complex dict dir() divmod() enumerate eval() exec() filter float frozenset getattr() globals() hasattr() hash() hex() id() input() int isinstance() issubclass() iter() len() list locals() map max() memoryview min() next() object oct() open() ord() pow() print() property range repr() reversed round() set setattr() sorted() staticmethod str sum() super tuple type zip	ArithmeticError AssertionError AttributeError BaseException EOFError Ellipsis Exception GeneratorExit ImportError IndentationError IndexError KeyError KeyboardInterrupt LookupError MemoryError NameError NotImplementedError OSError OverflowError RuntimeError StopIteration SyntaxError SystemExit TypeError ValueError ZeroDivisionError __build_class__() __import__() __name__='builtins' __repl_print__() abs() all() any() bin() bool bytes callable() chr() classmethod complex dict dir() divmod() eval() exec() float getattr() globals() hasattr() hash() hex() id() input() int isinstance() issubclass() iter() len() list locals() map max() min() next() object oct() open() ord() pow() print() range repr() round() set setattr() slice sorted() staticmethod str sum() super tuple type zip	ArithmeticError AssertionError AttributeError BaseException EOFError Ellipsis Exception GeneratorExit ImportError IndentationError IndexError KeyError KeyboardInterrupt LookupError MemoryError NameError NotImplementedError OSError OverflowError RuntimeError StopIteration SyntaxError SystemExit TypeError ValueError ZeroDivisionError __build_class__() __import__() __name__='builtins' __repl_print__() abs() all() any() bin() bool bytearray bytes callable() chr() classmethod complex dict dir() divmod() enumerate eval() exec() filter float frozenset getattr() globals() hasattr() hash() hex() id() input() int isinstance() issubclass() iter() len() list locals() map max() memoryview min() next() object oct() open() ord() pow() print() property range repr() reversed round() set setattr() slice sorted() staticmethod str sum() super tuple type zip	ArithmeticError AssertionError AttributeError BaseException EOFError Ellipsis Exception GeneratorExit ImportError IndentationError IndexError KeyError KeyboardInterrupt LookupError MemoryError NameError NotImplementedError OSError OverflowError RuntimeError StopIteration SyntaxError SystemExit TypeError ValueError ZeroDivisionError __build_class__() __import__() __name__='builtins' __repl_print__() abs() all() any() bin() bool bytes callable() chr() classmethod complex dict dir() divmod() enumerate eval() exec() filter float frozenset getattr() globals() hasattr() hash() hex() id() input() int isinstance() issubclass() iter() len() list locals() map max() min() next() object oct() open() ord() pow() print() range repr() reversed round() set setattr() slice sorted() staticmethod str sum() super tuple type zip	ArithmeticError AssertionError AttributeError BaseException EOFError Ellipsis Exception GeneratorExit ImportError IndentationError IndexError KeyError KeyboardInterrupt LookupError MemoryError NameError NotImplementedError OSError OverflowError ReloadException RuntimeError StopIteration SyntaxError SystemExit TypeError UnicodeError ValueError ZeroDivisionError __build_class__() __import__() __name__='builtins' __repl_print__() abs() all() bin() bool bytearray bytes callable() chr() classmethod dict dir() divmod() enumerate eval() exec() filter float getattr() globals() hasattr() hash() help() hex() id() input() int isinstance() issubclass() iter() len() list locals() map max() memoryview min() next() object oct() open() ord() pow() print() property range repr() round() set setattr() slice sorted() staticmethod str sum() super tuple type zip
Total: 218	Total: 197	Total: 218	Total: 210	Total: 212

D'où le classement suivant :

TI-Nspire et Casio Graph 35+E/75+E avec 218 entrées
module TI-Python pour TI-83 Premium CE avec 212 entrées
NumWorks avec 210 entrées
Casio Graph 90+E avec 197 entrées

Avec pas moins de 212 éléments présents à ce jour dans son module builtins, l'implémentation Python du module externe TI-Python n'est certes pas la plus complète. Toutefois elle se classe quand même honorablement parmi les plus complètes à la 2^nde place, deux cheveux devant la NumWorks, et laisse la Graph 90+E loin derrière !

Mais quel dommage que ce module externe TI-Python apparemment aussi complet ne soit pas utilisable aux examens en France !...

de **Admin** » 21 Nov 2018, 18:16

La nouvelle version 1.8.1 pour ta calculatrice NumWorks est maintenant disponible. Découvrons ensemble les améliorations :

Application Python :Go to top

Une première nouveauté concerne ce qui avait déjà été annoncé dans le contexte de la diffusion de la version bêta 1.8.0.

Un défaut de la calculatrice NumWorks était son espace de stockage ridicule pour les scripts Python, 2.946Ko, extensible jusqu'à 4,094Ko en supprimant les scripts d'exemple préchargés.

Déjà insuffisant rien que pour faire tenir simultanément en mémoire les deux scripts Python de notre concours de rentrée.

Avec la version 1.8.1 tu n’es plus à l'étroit, l'espace de stockage passe à 15.234Ko extensible jusqu'à 16.382Ko; un quadruplement donnant quelque chose d’enfin comparable à la concurrence d'entrée de gamme !

Notons que l’espace disponible sur la calculatrice se consulte à ce jour exclusivement en ligne sur https://workshop.numworks.com/python/calculator.

Autre chose de très bien sur NumWorks, c’est que lors de l’exécution d’un script Python la liste Fonctions et variables accessible avec la touche

var

était automatiquement préremplie avec l’ensemble des fonctions et variables globales définies par le script.

Cela pouvait toutefois être embêtant avec certains scripts, donnant une liste surchargée avec plusieurs entrées peu utiles.

Désormais, plutôt que de s’embêter avec des artifices alphabétiques peu confortables pour les renvoyer en fin de liste, il suffira tout simplement au développeur de préfixer les noms des variables globales dont il juge l’ajout à la liste peu utile avec le caractère tiret-bas ( _ ).

Code: Tout sélectionner: #public global variables n=3 platform=”numworks” #hidden global variables _key=3.24 _implementation=”micropython”

Application Calculs :Go to top

Le moteur de calcul a été entièrement réécrit avec en interne une meilleur gestion des éventuelles erreurs de mémoire, et en ce qui nous concerne pour la partie visible de nouvelles possibilités.

Déjà, comme sur les modèles formels haut de gamme il y a désormais la possibilité de faire des calculs avec l’infini notamment dans le contexte d’un travail sur les limites, le nombre infini étant à écrire inf.

Mais ce n’est pas tout, les fonctions logarithmes, trigonométriques inverses et hyperboliques inverses sont maintenant étendues aux nombres complexes !

La simplification des logarithmes pouvait être problématique lorsque le paramètre était un nombre puissance de la base.

$mathjax$log_b(a)$mathjax$

avec

$mathjax$a=b^k$mathjax$

où k est un entier positif. Dans ce cas la ‘simplification’ effectuée par la machine consistait à factoriser le nombre a sans tenir compte de la base du logarithme, ce qui pouvait conduire à des formes mal simplifiées, et dont l’écriture décimale pourtant exacte était de plus adjointe avec un symbole environ. Dorénavant, la simplification tiendra compte de la base.

Autre chose de remarquable sur la NumWorks dans le cadre des sciences expérimentales (Physique-Chimie notamment), c’est la possibilité de choisir un format de résultats selon la règle des chiffres significatifs. Mais la règle en question n’était pas toujours respectée, notamment pour les nombres dont l’écriture commençait par un ou plusieurs chiffres zéro, zéro étant dans ce cas comptabilisé à tort comme un chiffre significatif. Cette erreur est maintenant corrigée.

Un autre avantage exceptionnel sur la NumWorks c’est, lorsque approprié, la présentation des résultats sous deux formes, exacte et décimale, liées selon le cas par un symbole de relation adéquat, égale ou environ. Un problème arrivait par contre au changement d’applications, où toutes les relations dans l’historique de calcul étaient alors réaffichées systématiquement avec le symbole environ. Ce problème est dès à présent corrigé.

Application Paramètres :Go to top

Enfin dans l’application Paramètres les choix offerts pour la personnalisation des formats d’angles, nombres réels, saisies et nombres complexes sont à présent illustrés et de façon intuitive.

Notons également comme déjà remarqué dans la bêta qu'il s'agit de la toute première mise à jour firmware où l'on ne fonce plus dans le mur des 1024Kio de la mémoire Flash. Des optimisations ont permis d'en diminuer nettement la taille, libérant ainsi pas moins de 89Ko d'espace en mémoire Flash pour coder de futures améliorations - peut-être un module tortue pour Python ?

Liens :

Mise à jour (suivre les instructions)
Simulateur en ligne
Code source

de **critor** » 23 Nov 2018, 16:26

Un esprit malin a pris le contrôle mental de la Lune et lui ordonne de s'écraser sur la Terre. Un scénario digne d'un Zelda et donc des plus grands noms vidéoludiques, n'est-ce pas ?

Mais cette fois-ci, oublie les facilités scénaristiques enfantines de Zelda Majora's Mask : pas d'Ocharina du Temps, de magie ou autre Deus ex machina pour éviter la catastrophe.

Non non, bienvenu dans le monde réel des adultes, l'astre lunaire s'écrase effectivement sur Terre, et l'esprit malin Super Poulet fait des humains ses esclaves, les métamorphasant tous en poulets.
93623 ans plus tard, les plus éminents parmi ces galinacés ont retrouvé les traces d'une ancienne légende ramenant l'espoir à toute la basse-cour... Pour rompre l'enchantement, il suffirait de remettre en place les statuettes dans le Temple de la Lune...

Bienvenue dans The Chicken Adventure I, une création programmée avec amour, passion et talent par PoulpoGaz, lycéen de Seconde, pour ta TI-83 Premium CE.

Dans ce nouveau jeu de type Sokoban comme BillyBox, tu devras donc remettre en place les statuettes à travers les 50 salles du temple. Prépare donc tes biceps et l'huile de coude, et prends garde à ne pas les coincer.

Le jeu est programmé en C, comme quoi aux âmes bien nées la valeur n'attend point le nombre des années, et le code source est disponible et consultable en ligne pour ceux qui souhaiteraient s'en inspirer pour d'autres créations.

Pour fonctionner correctement, le jeu aura besoin des bibliothèques C téléchargeables ci-dessous. Mais rien de bien compliqué, il suffit juste de les transférer.

De quoi passer agréablement le temps dans les barrages ce week-end peu importe ta couleur, merci PoulpoGaz !

Alors, cap d'atteindre et résoudre l'énigme de la 50ème salle, ou bien es-tu une poule mouillée ?

Téléchargements :

de **critor** » 23 Nov 2018, 23:58

mViewer GX2 est notre solution de conversion de documents PDF ou séries d'images pour ta calculatrice HP Prime.

Toutefois, comme signalé par nbenm, les documents convertis n'étaient pas affichés correctement sur la nouvelle HP Prime G2. Pour un document de 20 pages, le lecteur affichait dans l'ordre :

l'icône de l'application certes illustrée avec la page 1 mais totalement illisible si zoomée
la page 20
la page 19
...
la page 3
la page 2

Le document était donc défilé à l'envers, et sans sa première page.

La cause de ce problème vient de la HP Prime G2 qui se comporte différemment de la HP Prime G1. Si la HP Prime G1 liste les fichiers associés à une application du premier au dernier, cette coquine de HP Prime G2 les liste à l'envers, du dernier au premier, et commence donc par le fichier d'icône de l'application.

mViewer GX2 est dès ce soir mis à jour dans une version 1.2 qui se veut compatible à la fois HP Prime G1 et HP Prime G2. L'application ne fait plus confiance à la calculatrice et effectue désormais un tri systématique de la liste de fichiers associés qui lui est communiquée.

Merci nbenm pour avoir rendu cette correction possible !

Pour les documents traités avant ce soir, il faudra les convertir à nouveau. Tu n'es pas forcément obligé de retourner chercher les fichiers originaux, il te suffira d'accéder aux conversions de ton compte pour y éditer et revalider chaque document, ce qui suffira pour lui intégrer le nouveau code compatible HP Prime G2.

Lien : editgx.php?mode=46