π
<-
Chat plein-écran
[^]

TI-z80 The Chicken Adventure I, nouveau Sokoban C TI-83 Premium CE

Nouveau messagede 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 ? :troll:

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. :p

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

10037Bienvenue dans
The Chicken Adventure I
, une création programmée avec amour, passion et talent par , 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 ? :p


Téléchargements
:
Lien vers le sujet sur le forum: The Chicken Adventure I, nouveau Sokoban C TI-83 Premium CE (Commentaires: 1)

NumWorks Mise à jour NumWorks 1.8.1 : 16K stockage scripts Python !

Nouveau messagede critor » 21 Nov 2018, 18:16

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


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 ! :bj:

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
( _ )
. :bj:
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. :bj:

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

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$
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
:
Lien vers le sujet sur le forum: Mise à jour NumWorks 1.8.1 : 16K stockage scripts Python ! (Commentaires: 21)

TI-z80 Module TI-Python: découverte fonctions builtins cachées !

Nouveau messagede 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
0
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...
991399359936993999389940994499379945


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 : :bj:
TI-Python a écrit:9980>>> 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'>
9983ImportError=<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'>
9985OverflowError=<class 'OverflowError'>
ReloadException=<class 'ReloadException'>
RuntimeError=<class 'RuntimeError'>
StopIteration=<class 'StopIteration'>
SyntaxError=<class 'SyntaxError'>
SystemExit=<class 'SystemExit'>
TypeError=<class 'TypeError'>
9982UnicodeError=<class 'UnicodeError'>
ValueError=<class 'ValueError'>
ZeroDivisionError=<class 'ZeroDivisionError'>
__build_class__=<function>
__import__=<function>
__name__=builtins
.count=<bound_method>
.endswith=<bound_method>
.find=<bound_method>
9998.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>
9999.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)
10000__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)
9964bytes=<class 'bytes'>
.count=<function>
.endswith=<function>
.find=<function>
.format=<function>
.index=<function>
.isalpha=<function>
.isdigit=<function>
.islower=<function>
.isspace=<function>
9976.isupper=<function>
.join=<function>
.lower=<function>
.lstrip=<function>
.replace=<function>
.rfind=<function>
.rindex=<function>
.rsplit=<function>
.rstrip=<function>
.split=<function>
.startswith=<function>
9969.strip=<function>
.upper=<function>
.Total: 22 item(s)
callable=<function>
classmethod=<class 'classmethod'>
dict=<class 'dict'>
.__delitem__=<function>
.__getitem__=<function>
9970.__setitem__=<function>
.clear=<function>
.copy=<function>
.fromkeys=<bound_method>
.get=<function>
.item=<function>
.keys=<function>
.pop=<function>
.popitem=<function>
.setdefault=<function>
9988.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'>
9994getattr=<function>
globals=<function>
hasattr=<function>
hash=<function>
help=<function>
help=<function>
hex=<function>
id=<function>
input=<function>
input=<function>
9990int=<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>
9973.clear=<function>
.copy=<function>
.count=<function>
.extend=<function>
.index=<function>
.insert=<function>
.pop=<function>
.remove=<function>
.reverse=<function>
.sort=<function>
.Total: 11 item(s)
9992locals=<function>
max=<function>
memoryview=<class 'memoryview'>
min=<function>
next=<function>
object=<class 'object'>
oct=<function>
open=<function>
10005ord=<function>
pow=<function>
print=<function>
property=<class 'property'>
.__deleter__=<function>
.__getter__=<function>
.__setter__=<function>
.Total: 3 item(s)
range=<class 'range'>
repr=<function>
9978round=<function>
set=<class 'set'>
.__contains__=<function>
.__add__=<function>
.__clear__=<function>
.__copy__=<function>
.__difference__=<function>
.__difference_update__=<function>
.__discard__=<function>
.__intersection__=<function>
9995.__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)
9993setattr=<function>
slice=<class 'slice'>
sorted=<function>
staticmethod=<class 'staticmethod'>
str=<class 'str'>
.count=<function>
.endswith=<function>
.find=<function>
.format=<function>
9997.index=<function>
.isalpha=<function>
.isdigit=<function>
.islower=<function>
.isspace=<function>
.isupper=<function>
.join=<function>
.lower=<function>
.lstrip=<function>
.replace=<function>
9979.rfind=<function>
.rindex=<function>
.rsplit=<function>
.rstrip=<function>
.split=<function>
.startswith=<function>
.strip=<function>
.upper=<function>
.Total: 22 item(s)
sum=<function>
10003super=<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 :
Casio
Graph 90+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()

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 :
  1. TI-Nspire
    et
    Casio Graph 35+E/75+E
    avec
    218
    entrées
  2. module
    TI-Python
    pour
    TI-83 Premium CE
    avec
    212
    entrées
  3. NumWorks
    avec
    210
    entrées
  4. 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 2nde place, deux cheveux devant la
NumWorks
, et laisse la
Graph 90+E
loin derrière ! :bj:

Mais quel dommage que ce module externe
TI-Python
apparemment aussi complet ne soit pas utilisable aux examens en France !... :'(
Lien vers le sujet sur le forum: Module TI-Python: découverte fonctions builtins cachées ! (Commentaires: 4)

Casio Maj majeure CasioPython Graph 35/75+E: flottants+longs+30K!

Nouveau messagede 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
9795Mais à côté de cela nous avons aussi plusieurs implémentations communautaires, bien évidemment inutilisables en mode examen à la différence :

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

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. :bj:
Code: Tout sélectionner
def prec(b):
  k=0
  while 1+b**-k-1:
    k=k+1
  return k


10026Les 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 ! :bj:
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 ! :bj:
À 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 :
  1. TI-Nspire
    avec
    2,046Mo
  2. Casio Graph 90+E
    avec
    1,027Mo
  3. Casio Graph 35+E/75+E
    avec
    30,147Ko
  4. calculatrice
    NumWorks
    avec
    13,658Ko
  5. logiciel web
    NumWorks
    avec
    5,946Ko
10028

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

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
Lien vers le sujet sur le forum: Maj majeure CasioPython Graph 35/75+E: flottants+longs+30K! (Commentaires: 9)

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

TI-z80 Holyxe World, monde perso à sensations Oiram CE !

Nouveau messagede critor » 17 Nov 2018, 13:16

7698Pour 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 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
:
Lien vers le sujet sur le forum: Holyxe World, monde perso à sensations Oiram CE ! (Commentaires: 1)

Divers Don de calculatrices par darthvader

Nouveau messagede 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 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 qui avait donné une
Casio fx-85GT PLUS
en 2016.

10023Nous sommes donc aujourd'hui transposés de joie à la réception d'un don de , et pas des moindres : :~o
  • sa
    TI-Nspire CX CAS
    en révision matérielle
    C
    :D
    fait donc partie des versions les plus sympas pour les bricoleurs
  • sa
    TI-84 Plus CE-T
    en révision matérielle
    C
    :bj:
    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 ; la communauté
TI-Planet
éternellement reconnaissante. :favorite:
Lien vers le sujet sur le forum: Don de calculatrices par darthvader (Commentaires: 2)

Divers Educatec/tice 2018 Paris: rencontre Casio et A4 Technologie

Nouveau messagede critor » 14 Nov 2018, 18:33

Tu as raté l'occasion ces dernières semaines d'aller voir
Casio
,
Hewlett Packard
,
NumWorks
et
Texas Instruments
aux journées
APMEP
ou au congrès
UdPPC
à Bordeaux ?

Et bien bonne nouvelle, ultime chance de l'année la semaine prochaine avec le salon
Educatec-Educatice
à
Paris Porte de Versailles
, les
mercredi 21
et
jeudi 22
de 9h à 18h, et le
vendredi 23
de 9h à 17h.

9384Tu pourras y rencontrer
Casio
et découvrir ou redécouvrir sa solution
Python
pour
Graph 90+E
.

Hewlett Packard
sera certes également présent, mais à la différence sans sa branche
HP Calculatrices
selon la description des exposants sur le site de l'événement.


Par contre tu pourras faire un tour chez
A4 Technologie
qui distribue l'ensemble de la gamme
TI-Innovator
, et conçoit en prime des accessoires dédiés.
A quand un pilotage du robot
TI-Innovator Rover
en
Python
?... ;)



Source
:
http://www.educatec-educatice.com
Lien vers le sujet sur le forum: Educatec/tice 2018 Paris: rencontre Casio et A4 Technologie (Commentaires: 8)

-
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.
450 utilisateurs:
>384 invités
>61 membres
>5 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)