Casse-Tetes | Dr. Goulu

Le cadran des trois neufs

Tue, 03 Jun 2014 00:00:00 +0000

(Mises à jour du 4+5 juin: Bravo à ced, Danakh et Groug dont les commentaires m’ont convaincu que j’aurais du … Je me vois contraint de mettre à jour l’article avec leurs découvertes. Et j’en profite pour tester pour le rendu des formules. C’est nettement plus joli qu’avant, non ?)

Emmanuel m’a envoyé la photo ci-contre en me demandant si on peut graduer ainsi un cadran d’horloge avec d’autres chiffres que le 9.

Ce qu’il y a d’assez fort, c’est que chaque heure du cadran est obtenue avec trois 9, sauf le 1 qui en n’en utilise que deux. Pourtant il existe une solution avec trois 9 (

\[mathjax\]

$1=9^{9-9}$ ), donc on va considérer considérer que le jeu consiste à obtenir les 12 heures du cadran en utilisant trois fois les mêmes chiffres, et les opérations suivantes:

les 4 opérations de base
la racine carré et la racine x-ième
la (il y a d’ailleurs une erreur : $5= \sqrt{9}!-9/9$ et pas $\sqrt{9!}-9/9$ comme sur la photo)
le noté $\overline{.x}$ et valant x/9. Et oui, $\overline{.9} = 1$ (voir )
la concaténation. C’est un peu tiré par les cheveux mais on accepte xx = 11*x

Avec ceci on peut mettre au point quelques recettes pour obtenir certaines “heures” facilement:

$1 = x^{x-x}$
$2 = (x+x)/x$
$x-1 = x-x/x$
$x = \sqrt \[x\]{x^x}$, parmi plusieurs autres possibilités
$x+1 = x+x/x$
$11 = xx/x$, où xx désigne la concaténation de deux x
$3x = x+x+x$
$9-x = x/\overline{.x} -x$
$x+3 = x+\sqrt{x/\overline{.x}}$
$x-3 = x-\sqrt{x/\overline{.x}}$ (trouvé par ced…)
$9 = \sqrt{x*x}/\overline{.x}$ (bravo ced !)
$2x = x+\sqrt{x*x}$ (encore ced !)
$3 = \sqrt{\sqrt{x*x}/\overline{.x}}$ (bien vu Danakh)

Voici le tableau indiquant les heures que je suis parvenu les commentateurs et moi-même avons pu définir avec trois et uniquement trois utilisations de chaque chiffre. Les lettres entre parenthèses rapportent aux recettes ci-dessus et les formules sont les solutions “hors-recettes” que j’ai trouvées :

x/heure	1	2	3	4	5	6	7	8	9
1	(a)	(a)	(a)	(a)	(a)	(a)	(a)	(a)	(a)
2	(b)	(b)	(b)	(b)	(b)	(b)	(b)	(b)	(b)
3	(g)	(e)	(d)	(c)	(m)	(h)	(m)	(m)	$\sqrt{9}+9-9$
4	(i)	(l)	(e)	(d)	(c)	$\sqrt{66}\overline{.6}$	(j)	$8-\sqrt{8+8}$	$\sqrt{9}+9/9$
5	$\sqrt{1/\overline{.1}}! -1$	(i)	$3!-3/3$	(e)	(d)	(c)		(j)	$\sqrt{9}!-9/9$
6	$(1+1+1)!$	(g)	$3!+3-3$	$(4-4/4)!$	(e)	(d)	(c)	$8-\sqrt{\sqrt{8+8}}$	(j)
7	(h)	$3!+3/3$	$(4!+4)/4$		(e)	(d)	(c)	$9-\sqrt{9}+\overline{.9}$
8	(h)	$222$	$(3!/3)^3$	$4!-4*4$	(i)	$(6+6)*\overline{.6}$	(e)	(d)	(c)
9	(k)	(k)	(g)	(k)	(k)	(k)	(k)	(e)	(d)
10	$11-1$			$4+4+\sqrt{4}$	(l)	$6+6*\overline{.6}$	(i)	$8+\sqrt{\sqrt{8+8}}$	(e)
11	(f)	(f)	(f)	(f)	(f)	(f)	(f)	(f)	(f)
12	$11+1$	$(2+2)!/2$	$3*3+3$	(g)	$5!/(5+5)$	(l)		$8+\sqrt{8+8}$	$9+9/\sqrt{9}$

Grâce aux contributions de géniaux et persévérants commentateurs, de nombreuses cellules ont pu être remplies:

En remplaçant un seul chiffre par deux grâce à $x = \sqrt{x*x}$ comme remarqué par ced, on peut remplir la ligne 9 et plusieurs autres cases en utilisant trois répétitions de x au lieu de deux. Et Danakh a complété la ligne du 3 en ajoutant une racine…

Donc à part le cadran du 9 les seuls autres cadrans possibles avec 3 répétitions sont:

le cadran du 4. El Jj avait d’ailleurs il y a longtemps.
ceux du 1 et du 6, obtenus grâce à la sagacité de Danakh. Bravo² !
celui du 8, brillamment terminé par Groug grâce à un de plus. Bravo !

En autorisant quatre répétitions, on peut:

remplir les lignes 8 et 10 grâce aux recettes $8 = x/\overline{.x} - x/x$ et $10 = x/\overline{.x} + x/x$, ce qui complète le cadran du 2 et celui du 3
et celui du 5 avec 7 = 5+(5+5)/5

Il faut quand même qu’on vous laisse un os à ronger… Combien de répétitions faut-il pour le cadran du 7 ?

Bits en vrac

Wed, 09 Apr 2014 00:00:00 +0000

Quelques découvertes informatiques en vrac

Les formulaires Google Drive

Le m’a permis d’expérimenter la puissance et la facilité d’utilisation des . C’est simplement génial :

dans , on crée un document de type formulaire
on se retrouve dans un éditeur permettant de composer le formulaire. On peut définir le type de chaque champ : texte, choix multiple, cases à cocher, échelle d’évaluation, tout y est. On peut ajouter des règles de validation et des actions à effectuer en fonction des réponses

Editeur de Formulaire Google Drive
En cliquant le bouton “afficher le formulaire en ligne” on peut voir à quoi ça ressemble pour les utilisateurs et même tester le système, car la collecte des réponses est immédiate : rien à faire de particulier !
Lorsque le formulaire est prêt, il suffit d’envoyer le lien disponible par “Envoyer le formulaire” à des personnes choisies, ou d’intégrer la page sur un site web dans un . Plusieurs blogs du C@fé des sciences l’ont même fait simultanément sans aucun problème car le formulaire n’existe en réalité (virtuelle…) que chez Google.
Les réponses sont automatiquement collectées dans un document “tableur” sur Google Drive : une ligne est créée pour chaque formulaire rempli, chaque colonne correspondant à un champ. Notez la colonne “horodateur” remplie automatiquement, bien utile.

Table des résultats

Ce que j’ai trouvé assez impressionnant est que l’on peut modifier le tableau sans perturber les votes suivants. Apparemment chaque champ du formulaire est attaché à une colonne par un lien invisible, mais solide : même si on ajoute ou déplace des colonnes, les réponses suivantes restent cohérentes avec les réponses précédentes. Pour le quiz, j’ai ajouté la ligne 2 avec les bonnes réponses ainsi que la colonne D Score. Notez au passage la géniale formule qui compte le nombre de réponses correctes avec et sumproduct. Elle n’est pas de moi, et il parait qu’elle est possible aussi en Excel…
résumé des réponses

Une petite dernière pour la route : dans le menu “Formulaire” on peut “afficher le résumé des réponses” qui présente les résultats sous une forme graphique qui peut être bien utile.

Les formulaires Google Drive permettent de réaliser facilement des sondages, quiz et concours divers avec toute la puissance et la sécurité (…) de l’infrastructure Google. Ca fait déjà des dans le C@fé …

Curation V.3.0‎

Rien à faire, il n’y a toujours pas mieux pour suivre les sites intéressants que les . J’ai longtemps utilisé avec lequel j’ai commencé à faire de la . En effet, en cochant simplement les articles que je trouvais intéressants, Google Reader les agrégeait dans un flux RSS “de sortie” que je pouvais publier sur .

Puis Google a annoncé la fermeture de Reader (toujours incompréhensible pour moi) et j’ai utilisé . C’était une bonne idée : Scoop.it permet d’agréger non seulement des flux RSS, mais aussi des tweets, le contenu de pages Facebook et de recherches Google. On peut créer ainsi plusieurs “topics” thématiques, et de jolis widgets comme celui ci-contre à droite. Mais le point fort de Scoop.it, c’est ses possibilités de partage : chaque contenu “scoopé” peut être partagé automatiquement sur Twitter, Facebook, Gogle+ et Tumblr, entre autres.

Scoop.it, c’est vraiment bien, mais … il y a un problème rédhibitoire : les liens du contenu partagé sont modifiés pour conduire les visiteurs sur la page Scoop.it du topic, et pas directement vers l’article original. Ceci a trois conséquences que je trouve gênantes:

La première n’est pas trop grave : les lecteurs doivent cliquer deux fois pour arriver à l’article qui les intéresse, une fois sur la page où ils voient le contenu partagé, puis une seconde fois sur la page Scoop.it.
La seconde fausse les analyses de trafic, qui semble provenir de Scoop.it plutôt que du site de partage. Ainsi par exemple mon site a accueilli plus de 2000 visiteurs passés par Scoop.it en un an sans qu’il me soit possible de déterminer où ces 2000 personnes ont initialement découvert l’article qui les intéressait.
La troisième touche le droit d’auteur : les outils de partage qui changent les liens diffusent le contenu d’autrui en coupant le lien vers la source, qui est parfois le seul élément identifiant l’auteur. Je me suis soudain aperçu que “rebloguait” automatiquement les articles que je trouvais intéressants, parfois en me les attribuant implicitement puisqu’il n’y avait plus de mention du site original.

Je me suis donc mis en chasse de nouveaux outils de curation, et après quelques essais j’ai choisi le “trio de la curation V.3” :

comme agrégateur de flux. Il offre grosso-modo les fonctionnalités de Google Reader, une , plus une (en fait un plugin d’un agrégateur plus général). Chaque jours je parcours une centaine d’articles en sautant d’un à l’autre en pressant la touche \[j\], et si je le trouve intéressant je le lis et je presse \[s\]comme “star”. Ca le marque comme favori et l’ajoute à mon .
Je pourrais utiliser directement CommaFeed pour partager le contenu sur Facebook, Twitter, Google+ et autres (mais pas Tumblr). Mais surtout, il me faudrait le faire manuellement : 6 ou 8 clicks de plus, c’est trop. Alors j’ai utilisé , un service qui permet d’automatiser des tâches internet en créant des “recettes” de la forme If This Then That . J’ai ainsi créé des “recettes” qui partagent automatiquement le contenu de mon flux de sortie vers mes pages Facebook, Google+, App.net et Tumblr. Automatiquement. Rien d’autre à faire :-) (Pour Twitter j’hésite encore…)
Et j’utilise toujours Scoop.it pour atteindre les utilisateurs de cette plateforme et profiter des beaux widgets, mais je n’utilise plus les outils de partage. En attendant qu’IFTTT permette de “scooper” automatiquement, j’utilise le flux de sortie comme unique source dans Scoop.it et je “scoope” à la main tout ce que j’ai préalablement sélectionné dans CommaFeed.

Tout ça ne me demande en définitive pas plus d’efforts que de tourner les pages d’un journal en papier, et je peux me concentrer sur la lecture tout en gardant une trace dont vous pouvez profiter où vous le souhaitez.

NetworkX

est une librairie Python permettant de représenter et traiter des problèmes de graphes. Je l’utilise professionnellement assez intensivement ces temps-ci pour un , mais l’autre jour il m’a permis de résoudre le du en quelques lignes seulement. En fait la plupart servent à lire le fichier des données, puis la partie intéressante tient en une seule ligne :

\[source lang="Python"\]

print G.size(weight=‘weight’) - minimum_spanning_tree(G, weight=‘weight’).size(weight=‘weight’)

\[/source\]

Fort non ? Hélas il me semble que peu de problèmes du Project Euler concernent les graphes, donc je ne vais pas pouvoir améliorer mon score rapidement …

2048

Cet article serait paru il y a trois jours si je n’étais pas tombé sur , le jeu addictif du moment. C’est un jeu tellement simple qu’il aurait du être inventé avant Pac-Man. Et on voit tout de suite comment faire : placer les puissances de 2 les unes à côté des autres pour former une chaîne croissante et propager ainsi les sommes pour arriver à former enfin, après 1024 coups au minimum, la tant convoitée pièce 2048. Il m’a fallu 3 jours. Enfin 3 soirs. 3 nuits…

A un certain moment j’en ai eu marre et voulu utiliser la bonne vieille méthode pour résoudre les problèmes compliqués : programmer. Mais Matt Overlan a été plus rapide et efficace : et est très instructif. Je crois que c’est la première fois de ma vie qu’un ordinateur m’apprend à résoudre un casse-tête plutôt que l’inverse. Peu après avoir observé le solveur parvenir au 2048, j’ai appris à dominer ma tentation d’additionner coûte que coûte les nombres les plus élevés et à conserver des lignes ou des colonnes de 4 cases “bloquées”, et j’ai gagné.

Après certains passent au voire au , mais je crois que je vais plutôt attaquer la version “ ” de Valentine. Un peu déroutant de prime abord, mais j’aime beaucoup l’idée un peu holiste qu’il y a là derrière… Bravo !

Le postier chinois de Königsberg

Fri, 22 Nov 2013 00:00:00 +0000

Les ponts de Königsberg

(Ce paragraphe d’introduction est une traduction de l’article “ ” paru sur Plus Maths)

Au 18ème siècle, la ville que nous connaissons sous le nom de Kaliningrad s’appelait Königsberg et se trouvait en Prusse. Comme beaucoup d’autres grandes villes, Königsberg se trouve sur une rivière, la Pregel. Elle comportait deux îles et il y avait sept ponts reliant les différentes terres. Un fameux casse-tête de l’époque était de trouver un chemin à travers la ville qui passait une seule fois par chaque pont. Plusieurs personnes disaient avoir trouver un tel chemin, mais lorsqu’on leur demandait de le reproduire, personne n’y arrivait. En 1735 le mathématicien suisse expliqua pourquoi : il démontra qu’un tel chemin n’existait pas.

La solution d’Euler est étonnamment simple, une fois que vous considérez le problème sous le bon angle. Le truc est d’éliminer toute information inutile. Le chemin parcouru sur terre n’a pas d’importance. La forme de ces terres n’a pas d’importance, ni le trajet de la rivière ou la forme des ponts. Donc vous pouvez simplement représenter chaque terre par un point et chaque pont par une ligne liant deux points. Vous n’avez pas du tout besoin de respecter la géographie : aussi longtemps que vous ne modifiez pas la connectivité des points, lequel est connecté auxquels, vous pouvez déformer votre dessin autant que vous voulez sans changer le problème.

Transformation du problème (source : Wikipédia)

Une fois que vous avez représenté le problème de cette façon, ses caractéristiques sont bien plus simples à voir. Après avoir un peu joué avec, vous constaterez ceci : en arrivant sur un point, et à moins que ce soit la dernière étape de votre chemin, vous devrez repartir par une ligne différente de celle d’arrivée puisque c’est la règle du jeu. Ca signifie que chaque point à l’exception du départ et de l’arrivée de votre chemin doit avoir un nombre pair de lignes le connectant aux autres : pour chaque lien entrant il doit y en avoir un pour en repartir.

Donc pour qu’un chemin qui passe une et une seule fois par chaque ligne existe, il ne doit pas y avoir plus de deux points avec un nombre impair de lignes connectées. En fait il ne peut y avoir que deux points impairs ou pas du tout. Dans le premier cas les deux points impairs sont forcément les points de départ et d’arrivée, alors que dans le second, le chemin est un circuit fermé. Or dans le problème de Königsberg, tous les points ont un nombre impair de connexions, donc un chemin ne passant qu’une seule fois par chaque pont est impossible.

Ce résultat d’Euler marque le début de la , l’étude de réseaux de points connectés par des liens. Euler a d’ailleurs aussi démontré que si la condition mentionnée plus haut est respectée, à savoir que le nombre de points avec un nombre impairs de liens est soit deux soit zéro, alors il existe toujours un chemin qui passe par chaque lien exactement une fois.

Voyageur de commerce et postier chinois

(à partir de là c’est du pur Dr. Goulu)

A part dans les casse-tête, on trouve très souvent en pratique des problèmes pouvant être résolus grâce à la théorie des graphes. Par exemple, avec le (TSP), j’avais eu l’occasion de le rencontrer dans l’optimisation des mouvements d’une machine à percer les circuits électroniques.

Dans le TSP, le but est de trouver le circuit (fermé) dit “ ” passant par tous les points d’un graphe, et dont le coût soit minimum, en pratique celui dans lequel la distance totale à parcourir (ou mieux encore le temps nécessaire) est minimum. A Königsberg, un voyageur de commerce aurait l’embarras du choix d’un circuit lui permettant de visiter ses clients sur les 4 terres, mais s’il devait s’acquitter de péages différents selon les ponts, un petit calcul lui serait nécessaire. Pour des problèmes de taille réelle, trouver le minimum absolu est horriblement difficile voire impossible, mais il existe des méthodes itératives qui convergent assez rapidement vers des solutions raisonnablement proches de l’optimum.

Etapes de l’optimisation TSP du trajets d’une perceuse de circuits imprimés

Plus récemment j’ai rencontré le , ainsi nommé parce qu’il s’agit d’un problème que connaissent tous les postiers, mais qui a été étudié mathématiquement par un chinois, Mei-Ko Kwan en 1962. Il s’agit de trouver le plus court circuit qui permette à un postier de parcourir toutes les rues de sa zone au moins une fois. Il est clair que s’il existe un permettant de ne passer qu’une et une seule fois par chaque ligne, ce circuit serait en même temps la solution du postier chinois. Mais quand ce n’est pas le cas, il faut forcément parcourir plusieurs fois certaines rues.

Si le postier doit desservir des échoppes situées sur chacun des ponts de Königsberg, combien de traversées de ponts au total sont nécessaires à sa tournée? Arrive-t-on à réduire ce nombre en employant deux postiers? Et si on construisait un nouveau pont? (Pas deux, ce serait trop facile.)

En gros j’ai ce problème avec environ 200 rues dispersées dans plusieurs villages, plusieurs postiers, et pour couronner le tout il y a du vent : il est plus facile de parcourir les rues dans un sens que dans l’autre. Mais avec Python, et un peu de lecture , je devrais m’en sortir…

Références

E. Aoyama, T. Hirogaki, T. Katayama, and N. Hashimoto, “Optimizing drilling conditions in printed circuit board by considering hole quality” J. Mater. Process. Technol., vol. 155, pp. 1544–1550, 2004.
E. Benavent, A. Corberan, I. Plana, and J. M. Sanchis, “Min-Max k-vehicles windy rural postman problem” Networks, vol. 54, no. 4, pp. 216–226, Dec. 2009 \[[pdf](http://www.uv.es/sestio/TechRep/tr09-07.pdf)\]
Grötschel, M., & Yuan, Y.“Euler, Mei-Ko Kwan, Königsberg, and a Chinese Postman”, 2012 \[[pdf](http://www.math.uiuc.edu/documenta/vol-ismp/16_groetschel-martin-yuan-ya-xiang.pdf)\]
Grötschel, M. (Ed.) “Optimization Stories (Extra Volume)”, 2012, 21st International Symposium on Mathematical Programmng (p. 460). Berlin: Documenta Mathematica: Journal der Deutschen Mathematiker-Vereinigung. ISBN 3936609586 / 978-3936609585 (Excellent recueil d’articles sur l’histoire de la théorie des graphes) \[[pdf](https://www.zib.de/groetschel/publications/OptimizationStories.pdf)\]

Comment dire 33 avec 3 cubes ?

Wed, 20 Jun 2012 00:00:00 +0000

Le gars qui m’a pourri ma dernière soirée du printemps s’appelle Mike Croucher. il a négligemment posé le problème suivant:

Il est possible d’écrire beaucoup d’entiers comme la somme des cubes de 3 entiers, par exemple: 99 = (-5)^{3 + 2}3+ 6^3 Un exemple plus compliqué est: 91 = (-67134)^{3 + (-65453)^{3+(83538)^{3 Votre tâche est de trouver les entiers x,y, et z tels que: 33 = x}3 + y}3 + z}3

Comme j’ai bien vu que la solution pour 91 impliquait de grands entiers, je me suis dit que 33 demanderait probablement des nombres encore plus grands, mais j’ai quand même vite pondu le programme Python suivant pour voir:

\[sourcecode lang="Python"\]

res={} #dictionary of results def store(n,x,y,z): if n>=0 and n<100 and n not in res: res

\[n\]

=(x,y,z) print n,res

\[n\]

cube=[] x=0 while True: x3=x*x*x cube.append(x3) for y in range(x+1): y3=cube

\[y\]

for z in range(x+1): z3=cube

\[z\]

store(x3+y3+z3,x,y,z) store(x3-y3+z3,x,-y,z) store(x3+y3-z3,x,y,-z) store(x3-y3-z3,x,-y,-z) store(-x3+y3+z3,-x,y,z) store(-x3-y3+z3,-x,-y,z) store(-x3+y3-z3,-x,y,-z) # store(-x3-y3-z3,-x,-y,-z) #you’re right Neamar, it’s useless x+=1 if x==50: #show “small” results for n in range(100): if n in res: print n,res

\[n\]

else: print n,’?’

\[/sourcecode\]

En moins d’une seconde il trouve les 69 des 100 premiers entiers qui sont des sommes de cubes d’entiers inférieurs à 100. Le plus “compliqué” est 78=-55³+53³+26³ .

Ensuite il mouline pendant des heures pour trouver 51=-796³+659³+602³ et 16=1626³-1609³-511³, et pendant ce temps j’ai exploré les liens émaillant les premiers commentaires .

Il s’avère que le problème soumis par Mike Croucher est extrêmement difficile, voire impossible. liste les solutions trouvées par mon programme, et d’autres qui ont nécessité des algorithmes beaucoup plus fûtés que le mien pour résoudre cette :

87 = 4271³ - 4126³ - 1972³ , découvert en 1964
96 = -15250³ + 13139³ + 10853³
91 = 83538³ - 67134³ - 65453³
80 = -112969³ + 103532³ + 69241³
39 = -159380³ + 134476³ + 117367³ découvert en 1991
75 = - 435203231³ + 435203083³ + 4381159³ découvert en 1993
84 = 41639611³ - 41531726³ - 8241191³ découvert en 1994
30 = 2220422932³ - 2218888517³ - 283059965³ ainsi que 52 = -61922712865³ + 60702901317³ + 60702901317³ par la même équipe, qui a mis au point l’algo le plus performant du moment
24 =15584139827³ - 15550555555³ - 2901096694³ a été découvert avec l’algo précédent en 2001 par D. J. Bernstein, dont la page est consacrée à ce problème et son historique

A part ça, les matheux démontrent (essayez…) que les nombres de la forme 9n+4 et 9n+5 ne peuvent pas être la somme de trois cubes, ce qui règle le cas de 4,5,13,14,22,23 etc.

Bon… je n ai pas vraiment le droit d’utiliser ce dessin, mais il va tellement bien là que j espère que vous ne m en voudrez pas, cher Docteur G…

Reste 33 (et 42 et beaucoup d’autres), qui résistent effrontément aux informaticiens cherchant à les obtenir, ainsi qu’aux mathématiciens essayant de prouver que c’est peine perdue…

C’est énervant qu’un petit problème tout bête comme celui-ci puisse résister ainsi aux ordinateurs les plus puissants. Et motivant de penser qu’une solution est peut-être à la portée d’amateurs éclairés. Des idées ?

Références:

Gardiner, V. L., Lazarus, R. B., & Stein, P. R. “ . “, 1964, Mathematics of Computation, 18, 408-413
Heath-Brown, D. R., Lioen, W. M., & te Riele, H. J. J." ”, 1993, Mathematics of Computation, 61, 235-244
Andrew Bremner, “ ”, 1993
B. Conn and L. Vaserstein, “On sums of three integral cubes”, 1994, Contemp. Math. 166, 285-294.
Eric Pine, Kim Yarbrough, Wayne Tarrant and Michael Beck, Noam D. Elkies, “ ”, 2000, ANTS IV
Michael Beck, Eric Pine, Wayne Tarrant, Kim Yarbrough Jensen “New integer representations as the sum of three cubes”, 2007, Math. Comp. 76, 1683-1690 ( )
Wacław Sierpiński (1988). Elementary theory of numbers. North-Holland. ( )

"jeu de l'année" 2012 et autres : c'est fini.

Wed, 18 Jan 2012 00:00:00 +0000

(mis à jour plusieurs foirs après correction de bugs et améliorations, cf commentaires…)

Je m’apprêtais à passer une soirée tranquille quand je suis tombé sur un tweet de disant: “Qui va me battre au “jeu de l’année” ? ”.

Python bouffant du matheux

Un seul click m’a torpillé non pas une, mais trois soirées et un certain nombre d’heures de réflexion la journée. Mais ma vengeance est terrible : ni ElJj ni aucun autre mathématicien ne passera plus jamais des heures à former les entiers de 1 à 100 en n’utilisant que les chiffres de l’année (2,0,1,2) une et une seule fois chacun, les opérations de base +,-,*,/,^ et quelques autres. Fi-ni. Et c’est rapé aussi pour toutes les années futures ou passées, parce que j’ai fait un programme qui résout ce problème une fois pour toute. Amis , je vous fais ci-dessous économiser des milliers d’heures que vous allez pouvoir utiliser pour résoudre de (Pensez à moi si vous en résolvez un, merci…)

Pour être honnête, la première soirée a été grillée à péniblement trouver 50 formules, ce qui m’a à la fois décidé à faire autrement et inspiré beaucoup de respect pour ElJj et les autres fous qui sont parvenus à obtenir des scores de 4000 et quelques points à la main. Bravo !

Pour 2012, mes solutions sont donc :

\[1, '(((2\*0)-1)^2)', 0\] \[2, '(((2-0)-1)\*2)', 0\] \[3, '(((2-0)-1)+2)', 0\] \[4, '(((2-0)^1)^2)', 0\] \[5, '(((2-0)+1)+2)', 0\] \[6, '(((2-0)+1)\*2)', 0\] \[7, '((2^0)+((1+2)!))', 0\] \[8, '(2^(0+(1+2)))', 0\] \[9, '(((2-0)+1)^2)', 0\] \[10, '((((2+0!)!)-1)\*2)', 0\] \[11, '(((2+0!)!)+(1/.2))', 1\] \[12, '((((2-0)+1)!)\*2)', 0\] \[13, '(2+sqrt((0!+((1/.2)!))))', 1\] \[14, '((((2+0!)!)+1)\*2)', 0\] \[15, '(((2-0)+1)/.2)', 1\] \[16, '(((2+0!)+1)^2)', 0\] \[17, '(((((2+0!)!)-1)!!)+2)', 5\] \[18, '(((2+0!)!)\*(1+2))', 0\] \[19, '((2^0)+(((1+2)!)!!!))', 5\] \[20, '(((2^0)/.1)\*2)', 1\] \[21, '(((((2+0!)!)!!!)+1)+2)', 5\] \[22, '((((2+0!)+1)!)-2)', 0\] \[23, '((.2^(-(0!+1)))-2)', 1\] \[24.0, '((((2-0)^1)^2)!)', 0\] \[25, '((((2+0!)!)-1)^2)', 0\] \[26, '((((2+0!)+1)!)+2)', 0\] \[27, '((2+0!)^(1+2))', 0\] \[28, '(((2+0!)/.1)-2)', 1\] \[29, '(((2+0!)/\[.1\])+2)’, 30] \[30, '((((2-0)+1)!)/.2)', 1\] \[31, '(((2+0!)/.1)+(Gamma(2)))', 31\] \[32, '(2^(-(0!-((1+2)!))))', 0\] \[33, '((((2+0!)!)!!)-((1/.2)!!))', 11\] \[34, '(sqrt((2^(0!/.1)))+2)', 1\] \[35, '((((2+0!)!)+1)/.2)', 1\] \[36, '((((2-0)+1)!)^2)', 0\] \[37, '(0!+(((1+2)!)^2))', 50\] \[38, '(((((2+0!)!)!!!)+1)\*2)', 5\] \[39, '(((.2^(-0!))!)-(\[.1\]^(-2)))’, 31] \[40, '(((2-0)/.1)\*2)', 1\] \[41, '(0!+(2/(.1/2)))', 51\] \[42, '((((2+0!)!)!!)-((1+2)!))', 5\] \[43, '((((2+0!)!)!!)-(1/.2))', 6\] \[44, '(-((.2-(0!/\[.1\]))/.2))’, 32] \[45, '(((((2+0!)!)!!)-1)-2)', 5\] \[46, '(((((2-0)+1)!)!!)-2)', 5\] \[47, '(((((2+0!)!)!!)+1)-2)', 5\] \[48, '((((2+0!)+1)!)\*2)', 0\] \[49, '((((2+0!)!)+1)^2)', 0\] \[50, '((.2^(-(0!+1)))\*2)', 1\]

\[51, '((.2+(0!/.1))/.2)', 3\] \[52, '(2+(0!/(.1\*.2)))', 2\] \[53, '((((2+0!)!)!!)+(1/.2))', 6\] \[54, '((((2+0!)!)!!!)\*(1+2))', 5\] \[55, '(sqrt((((.2^(-0!))!)+1))/.2)', 2\] \[56, '(((((2+0!)!)+1)!!!)\*2)', 5\] \[57, '((((2+0!)!)!!)+sqrt((\[.1\]^{(-2))))’, 35] \[58, '((((2+0!)!)/.1)-2)', 1\] \[59, '((((2+0!)!)/.1)-(Gamma(2)))', 31\] \[60, '(((((2+0!)!)-1)!)/2)', 0\] \[61, '((((2+0!)!)/.1)+(Gamma(2)))', 31\] \[62, '((((2+0!)!)/.1)+2)', 1\] \[63, '((((2+0!)!)!!)+((1/.2)!!))', 11\] \[64, '(2^((0+(1+2))!))', 0\] \[65, '(0!+(2^((1+2)!)))', 50\] \[66, '((((2+0!)!)!!)+(((1+2)!)!!!))', 10\] \[67, '((((.2^(-0!))!!)-\[.1\])/\[.2\])’, 66] \[68, '(20+(((1+2)!)!!))', 15\] \[69, '((((0!+2)!)!!)+21)', 65\] \[70, '(((((2+0!)!)!)\*.1)-2)', 1\] \[71, 'sqrt((((((2+0!)!)+1)!)+(Gamma(2))))', 30\] \[72, 'sqrt((((((2+0!)!)!)\*.1)^2))', 1\] \[73, '(((((2+0!)!)!)\*.1)+(Gamma(2)))', 31\] \[74, '(((((2+0!)!)!)\*.1)+2)', 1\] \[75, '(((((2+0!)!)-1)!!)/.2)', 6\] \[76, '(-((.2^(-0!))-(\[.1\]}(-2))))’, 31] \[77, '((((2^2)!!)!!!)-sqrt((0!/\[.1\])))’, 90] \[78, '((((-2)+(0!/.1))!!!)-2)', 6\] \[79, '(-(2-(0!/(\[.1\]^{2))))’, 30] \[80, '(-((.2-0!)/(.1^2)))', 2\] \[81, '((((.2^(-0!))!!!)-1)^2)', 6\] \[82, '(2+(((0!/.1)-2)!!!))', 6\] \[83, '(2+(0!/(\[.1\]^{2)))’, 30] \[84, '((((.2^(-0!))!!!)!!!)\*(.1+.2))', 13\] \[85, '(((((2+0!)!)!!!)-1)/.2)', 6\] \[86, '((.2^(-0!))+(\[.1\]}(-2)))’, 31] \[87, '(((2+0!)!)+(\[.1\]}(-2)))’, 30] \[88, '(-((((2+0!)!)!)\*(.1-\[.2\])))’, 31] \[89, '(-((.2-((sqrt((0!/\[.1\]))!)!!!))/.2))’, 37] \[90, '(((((2-0)+1)!)!!!)/.2)', 6\] \[91, '(((.2^(-0!))!!!)+(\[.1\]^(-2)))’, 36] \[92, '(2\*(((sqrt((0!/\[.1\]))!)!!)-2))’, 35] \[93, '93', 500\] \[94, '(-(((2+0!)!)-(.1^(-2))))', 1\] \[95, '(-((.2^(-0!))-(.1^(-2))))', 2\] \[96, '(-((.2-0!)\*((1/.2)!)))', 2\] \[97, '(-(2+(0!-(.1^(-2)))))', 1\] \[98, '(-(2-(0!/(.1^2))))', 1\] \[99, '(-((2^0)-(.1^(-2))))', 1\] \[100, '(((2^0)/.1)^2)', 1\]

C’est un peu “brut de décoffrage” et mérite quelques explications. Chaque triplet comporte le nombre à obtenir, la “meilleure” formule qui le donne, et le coût de cette formule en points calculés selon les règles décrites dans l’article d’El Jj. Les formules qui utilisent les chiffres 2,0,1,2 dans l’ordre et les opérations arithmétiques de base et la factorielle (saviez-vous que 0!=1 ?) ont le coût minimum de 0. L’utilisation du point décimal bien utile avec une division ne coute qu’un point. Les formules qui utilisent des opérateurs plus compliqués comme les (notées !! et !!!) et la sont pénalisées de 5 points.

La formule pour 77 est la plus coûteuse (90 points) car elle utilise les chiffres dans le désordre (50 points), le développements décimal périodique

\[.1\]

= 0.11111111… = 1/9 qui vaut 30 points chacun, plus deux multifactorielles. A noter que l’on a eu besoin d’inverser l’ordre des chiffres que dans 4 cas seulement.

Et enfin, les nombre pour lesquels on ne trouve pas de solution sont pénalisés de 500 points, ce qui n’est le cas pour 93, pour lesquel je suis quasi certain qu’il n’existe pas de solution avec les opérations autorisées. Mais seulement “quasi”, pour des raisons que j’explique plus loin.

Le total des pénalités que j’obtiens est de 1637 points

Enfin, les formules ne sont pas très jolies d’une part à cause d’une “surparenthésation” qui simplifie l’écriture du programme (pas besoin de gérer la ), et d’autre part car le choix de la “meilleure” formule lorsqu’on en trouve plusieurs de score égal se fait par la longueur de la chaîne, sans tenir compte de l’ordre d’insertion ou de la priorité des opérateurs. Donc (((2*0)-1)^2) peut paraître plus compliqué que (((2*0)-1)+2) pour obtenir 1, mais pour une machine, c’est le même prix.

Comme il se fait tard je coupe/colle le programme ci-dessous, je le commenterai plus tard (comme d’hab…)

\[code lang="python" collapse="true"\]

# -*- coding: utf-8 -*- """ Created on Mon Jan 16 17:19:27 2012

@author: Philippe Guglielmetti solves """

import sys

from math import sqrt,pow from scipy import factorial,factorial2,factorialk from itertools import permutations

class f: “““a formula””” def __init__(self, m,p=0,v=None,parenthesis=False): #print m,’=’, self.isdigit=isinstance(m, (int, long)) self.math=str(m) #convert to string in case it’s a digit self.points=p if v is None: v=eval(self.math) self.isint=isinstance(v, (int,long)) if isinstance(v, float): #try to convert to int self.isint=abs(v-round(v))<1e-9 if self.isint: v=int(round(v)) if isinstance(v, long): #we don’t want bignums, for performance if abs(v)<sys.float_info.max: v=float(v) self.isint=True self.value=v

if parenthesis: self.math=’(’+self.math+’)’ #print self.value

def __cmp__(self,other): if self.value<other.value:return -1 if self.value>other.value:return +1 if self.points<other.points:return -1 if self.points>other.points:return +1 if len(self.math)<len(other.math):return -1 if len(self.math)>len(other.math):return +1 return 0

def __repr__(self): return str(

\[self.value,self.math,self.points\]

);

class results(dict): “““dictionary of formulas indexed by their result. we keep only the simplest entry for each result”””

def __init__(self): dict.__init__(self)

def add(self, f): if f.value in self.keys() and f>self

\[f.value\]

: pass else: self

\[f.value\]

def merge(self,d): for i in d.itervalues(): self.add(i)

def score(self): return sum(map(lambda x: x.points,self.itervalues()))

def notfound(self,p=500): return

\[i for (i,v) in self.iteritems() if v.points>=p\]

def refine(self,recurse=2): “““add combinations of monadic operators””” r=results() for a in self.itervalues(): if recurse0 and a.value<>0: r.add(f(’-’+a.math,a.points,-a.value,True)) if a.isint: if a.value0: r.add(f(a.math+’!’,a.points,1)) # 0! == 1 is very useful… if a.value>1: s=f(‘sqrt(’+a.math+")",a.points,sqrt(a.value)) if s.isint: r.add(s) if a.value>1 and a.value<19: r.add(f(a.math+’!’,a.points,factorial(int(a.value),True),True)) r.add(f(‘Gamma(’+a.math+’)’,a.points+30,factorial(int(a.value)-1,True),True)) if a.value>3 and a.value<29: r.add(f(a.math+’!!’,a.points+5,factorial2(int(a.value),True),True)) if a.value>4 and a.value<39: r.add(f(a.math+’!!!’,a.points+5,factorialk(int(a.value),3,True),True)) self.merge(r) if recurse>0: self.refine(recurse-1)

class monadic(results): “““combinations of monadic operators around a formula”””

def __init__(self, a): results.__init__(self) self.add(a) if a.value!=0: if a.isdigit: self.add(f(’.’+a.math,a.points+1)) if a.value<10: self.add(f(’

\[.'+a.math+'\]

’,a.points+30,a.value/9.)) self.refine();

class diadic(results): “““combinations of diadic operators of 2 operands”””

def __init__(self, a,b): results.__init__(self) for i in a.itervalues(): for j in b.itervalues(): if i.isdigit and j.isdigit: if i.value!=0: self.add(f(int(i.math+j.math),10)) self.add(f(i.math+’.’+j.math,11)) self.add(f(i.math+’+’+j.math,i.points+j.points,i.value+j.value,True)) self.add(f(i.math+’-’+j.math,i.points+j.points,i.value-j.value,True)) self.add(f(i.math+’*’+j.math,i.points+j.points,i.value*j.value,True)) if j.value!=0: self.add(f(i.math+’/’+j.math,i.points+j.points,float(i.value)/float(j.value),True)) try: #so many things can go wrong with next line… self.add(f(i.math+’^’+j.math,i.points+j.points,pow(i.value,j.value),True)) except: pass if i.isint: try: #so many things can go wrong with next line… self.add(f(‘root(’+i.math+’,’+j.math+’)’,i.points+j.points+5,pow(j.value,1./i.value),True)) except: pass if i.isint and j.isint and i.value>=0 and j.value>0 and i.value/j.value<10: try: #so many things can go wrong with next line… self.add(f(i.math+’!’+j.math,i.points+j.points+5,factorialk(i.value,j.value),True)) except: pass

self.refine();

print ‘building list of monadics’ m=map(monadic,map(f,range(0,10))) #list of all monadics of digits

#use @Memoized here to improve performance def d(a,b): return diadic(a,b)

def year(n,display=True,verbose=True): solution=results() for i in range(1,101): solution.add(f(i,500))

def addresults(a,p): if verbose : print ‘formulas’,len(a), improved=0 found=0 for (i,v) in a.items(): if isinstance(i, (int, long)) and i>0 and i<101: v.points+=p if v<solution

\[i\]

: if solution

\[i\]

.points==500: found+=1 else: improved+=1 solution

\[i\]

=v if verbose: print(‘found :’+str(found)+’ improved :’+str(improved)+’ score:’+str(solution.score()))

def combine (a,p): m0=m

\[a\[0\]

]; m1=m

\[a\[1\]

]; m2=m

\[a\[2\]

]; m3=m

\[a\[3\]

] if solution.notfound():addresults(d(d(d(m0,m1),m2),m3),p) if solution.notfound():addresults(d(d(m0,d(m1,m2)),m3),p) if solution.notfound():addresults(d(m0,d(m1,d(m2,m3))),p) if solution.notfound():addresults(d(m0,d(d(m1,m2),m3)),p) if solution.notfound():addresults(d(d(m0,m1),d(m2,m3)),p)

\[int(i) for i in str(n)\]

combine(y,0) y.sort() for i in permutations(y): combine(i,50)

if display: for i in solution.itervalues():print i print n,solution.score(),solution.notfound()

year(2012)

\[/code\]

Sculptures et science

Thu, 16 Sep 2010 00:00:00 +0000

Art et sciences peuvent faire bon ménage, comme le montrent trois sculpteurs repérés sur le web ces derniers temps.

est une artiste américaine qui produit de nombreux objets directement inspirés d’objets , ou . Il utilise l’ en métal ou en , ce qui lui permet de vendre ses œuvres à des prix très abordables. Mais je crois que je vais craquer plutôt pour un cristal gravé au laser comme celui-ci, qui représente le champ magnétique terrestre :

"Geodynamo" en cristal, de Bathsheba

A noter aussi ses “ ” dont on peut télécharger les modèles 3D.

Dans un autre style, Francis Tabary est un illusionniste français qui réalise d’étonnantes “ ” comme celle-ci:

"Trident" en aluminium éclairé par des leds, de Francis Tabary

Cest la photo d’un objet bien réel, vous pouvez le mettre dans votre salon, mais peut-être qu’il faut le regarder sous un certain angle pour que l’impossibilité apparaisse dans toute sa splendeur…

Dans cette autre oeuvre, il faut que l’éclairage soit bien dirigé et qu’il n’y ait pas de courant d’air, mais le résultat est saisissant :

Enfin, , qui fait des choses très colorées en bois, dont le lien avec la science ne saute pas forcément aux yeux :

"Warm Winter" de Nathalie Miebach

Son idée est de représenter des données numériques par des perles de couleur et des vecteurs matérialisés par des bâtonnets. Dans la sculpture ci-dessus, elle a pris les données météo mesurées pendant un mois par les bouées de Herring Cove, dans le golfe du Maine. Il y a les températures de l’air, du sol et de l’eau, la direction et la vitesse du vent ainsi que les marées et la phase de la Lune.

Ca change des plots x-y, et je trouve que Nathalie arrive bien à traduire à la fois le rythme et le chaos de la nature dans son œuvre. Il faut aller jusqu’à New-York pour voir ses œuvres, pour l’instant.

Icosien, le nouveau jeu de Neamar

Thu, 24 Jun 2010 00:00:00 +0000

Il l’avait annoncé, il l’a fait : Neamar a ajouté un nouveau jeu à sa : . Et c’est un excellent jeu. En réalité il y a même deux jeux pour le prix d’un seul:

Dans les 10 premiers tableaux, il s’agit de reproduire le motif gris d’un seul mouvement de souris, sans repasser deux fois sur le même trait (mais les croisements de fil sont autorisés). En termes techniques, il s’agit de vérifier que ces tableaux sont des . Pas trop difficile une fois qu’on a trouvé le truc.
Dans les 10 tableaux suivants, il faut passer une et une seule fois par chaque noeud, en utilisant uniquement les traits disponibles (mais on n’est pas obligé de passer sur tous les traits). Pour les matheux, il s’agit de trouver des . Là, la difficulté passe de “petit casse-tête sympa” à “horrible arrache neurones énervant”…

J’en suis là. C’est dur. Regarder la soluce de Neamar serait déshonorant. A l’aide Python !

De plus, je décerne à Icosien le titre envié de “plus beau jeu de graphes du web” pour deux raisons:

Le design de Licoti ( ) est vraiment réussi. Bravo !
L’interface utilisateur est tout simplement géniale. Quand Neamar avait pondu un , je n’avais pas compris à quel point son système est simple et efficace. Je réalise maintenant que sans ça, ce beau jeu aurait été injouable.

Enfin, mentionnons qu’Icosien peut être instructif. “Peut” car on n’est pas obligé de connaitre la théorie des graphes pour y jouer, mais qu’y jouer peut inciter à la lecture des nombreuses informations figurant sur la page du jeu, et suivre les liens conduit vers pleins d’infos intéressantes.

A voir aussi:

le “ ” (spoiler alert ! cetta page contient la solution de certains tableaux, dont le 19, argh! )
le en Action Script 3
la version 1857 de l’ “ ” par Hamilton himself, en vrai bois d’arbre
“ ” sur MathWorld

Jeu-concours électrique

Mon, 17 May 2010 00:00:00 +0000

Amateurs de casse-têtes, de maths et d’algorithmes, oyez, oyez !

La et la avec l’appui de Réseau de Transport d’Electricité organisent un concours doté de 2000 Euros de prix et ouvert jusqu’au 30 juin 2010.

Il s’agit de concevoir le réseau de lignes électriques nécessaires pour alimenter les villes d’un pays à partir de centrales :

le pays du concours, carré malgré les apparences

Pour ne rien arranger, les centrales sont de puissances différentes et fournissent de la THT, et les villes consomment également des puissances différentes (listées dans la ), mais doivent être alimentées en HT via des transformateurs à placer à volonté, mais à au moins 1km des villes et pas dans les zones protégées marquées en pointillés.

Pour relier tout ceci, on peut construire des lignes THT de 1GW à 1M€/km (c’est même “obligatoire de mettre une ligne THT lorsque c’est possible”, mais cette contrainte me parait peu claire). On doit utiliser des lignes HT de 1 GW à 300K€/km pour alimenter les villes, et dans les zones protégées, on n’a droit qu’à des lignes HT enterrées de 0.3 GW à 1 M€/km.

De plus le tout doit être résistant à une panne : si une centrale, une ligne ou un transfo flanche, les villes doivent toujours être alimentées.

Le vainqueur sera celui qui proposera le réseau satisfaisant à toutes ces contraintes et coutant le moins cher avant le 30 juin, mais mon petit doigt me dit qu’il ne faut pas attaquer le problème le 29…

Et avant de vous lancer dans de p’tits dessins ou de gros calculs, notez encore que tout ce qui précède peut être potentiellement faux et/ou incomplet (je décline toute responsabilité etc etc). Seul le fait foi.

Pour la petite histoire, j’ai trouvé ce concours sur “ ”, un blog intéressant découvert au moment de la rédaction de

le retour de l'âge du capitaine

Sun, 25 Apr 2010 00:00:00 +0000

Trouvé encore un de ces merveilleux problèmes qui semble impossible et qui est pourtant délicieusement simple :

Le Xème jour du Yème mois de l’année 1900 + Z, un bateau ayant U hélices, V cheminées et W hommes d’équipage est lancé.

Sachant que le produit UVWXYZ plus la racine cubique de l’âge du capitaine, qui est grand-père, est égal à 4002331, trouver l’âge du capitaine ainsi que toutes les caractéristiques du bateau.

Si, si … il y a une solution, et une seule ! Pour décourager les recherches sur internet et les solutions copiées/collées, je veux non seulement la solution, mais savoir comment vous avez fait le seul calcul nécessaire.

La saga des graphes

Sat, 06 Mar 2010 00:00:00 +0000

Découvert grâce à Patric quelques de plus : la . 3 jeux en Flash attendent impatiemment vos neurones :

AGraphe

est le plus facile en apparence : il s’agit d’allumer le noeud supérieur du graphe, qui ne peut l’être que si tous ses noeuds enfants sont allumés. L’astuce est qu’on ne peut avoir plus de N noeuds allumés simultanément, donc qu’il faut aussi éteindre judicieusement les noeuds. Mais il reste facile.

BGraphe

Dans , il faut déplacer les noeuds de façon à ce que les arêtes ne se coupent pas. Une fois qu’on a compris le truc on passe quelques tableaux assez facilement, puis ça devient vraiment trop difficile.

CGraphe

est une implantation du “ ” qui se joue à 2:

le “Paintre” doit relier les deux noeuds marqués en rouge en allumant une arête à chaque tour
le “Couhpeur” doit l’en empêcher en supprimant carrément une arête à chaque tour.

On joue alternativement chaque rôle, et l’ordinateur l’autre. Les premiers tableaux permettent de mettre au point la stratégie de chaque rôle, et les tableaux suivants sont là pour l’éprouver…

Sur chaque page, n’omettez pas de lire le texte en dessous de chaque jeu. On y apprend des choses intéressantes sur les graphes et sur le processus de développement de ces jeux très bien réalisés. On en trouve même le code source. Et Neamar y explique aussi comment fabriquer nos propres tableaux pour ses jeux en attendant le DGraphe qu’il nous nous prépare.

En fouillant un peu, on trouve que ce Neamar fait plein d’ , dont un . Hop, un flux RSS de plus.

Petits jeux intelligents

Sat, 19 Dec 2009 00:00:00 +0000

Bientôt Noël… Un peu de temps à tuer ou des jeunes à occuper intelligemment quelques heures ? Explorez les petits jeux gratuits découverts sur le web.

Un peu de

Le canon tire des billes portant des chiffres qui s’insèrent dans un petit train roulant inéluctablement vers le trou de la défaite. Lorsque deux billes en contact forment une somme de 10, elles disparaissent. Simple ? Essayez… Puis tentez de créer des réactions en chaine pour marquer plus de points.

Un peu de Physique: et

Ne vous fiez pas au look enfantin de pour en conclure qu’ils s’adresse aux tout petits. Construire un pont, même virtuel, exige d’avoir quelques connaissances… ou de les acquérir par l’expérience.

Les casse-têtes mécaniques d’ se résolvent à coup de sabre virtuel, en tranchant des cordes et des blocs de glace. Addictif et marrant.

Un peu de nostalgie : les Lemmings

Je vous parle d’un temps que les moins de vingt ans ne peuvent pas connaître, mais devraient : le temps des , un des jeux les plus géniaux de l’histoire. On peut jouer en ligne à la version quasi originale . D’accord, le graphisme est d’époque, mais le challenge reste actuel : amener des hordes de bestioles suicidaires à la porte du salut.

(En fait c’est un , mais la performance vaut un coup de chapeau : réécrire le …)

Beaucoup d’originalité :

Ce jeu de plateforme en noir et blanc est l’un de mes préférés. A chaque pression de la touche

\[Shift\]

, un renversement de situation total permet de progresser vers la porte de sortie, ou de tomber dans un piège fatal. Un jeu absolument excellent.

Une fois que vous aurez fini Shift, vous pourrez vous attaquer à , , , … Il existe aussi sur Android, iPhone et facebook

Dans le genre jeu de plateforme revisité, il y a aussi l’excellent que je viens de découvrir . Dès que j’ai fini cet article, j’y retourne!

En fait, pour finir plus vite, je colle ci-dessous un vieux brouillon d’article que j’avais commencé sur…

Encore un jeu en noir/blanc au look des années 70, et en plus tellement simple que j’hésite à le qualifier d’ “intelligent”. Il suffit de cliquer au bon moment pour qu’un canon oscillant régulièrement tire un boulet qui s’immobilise après quelques rebonds et enfle alors jusqu’à toucher un boulet voisin ou le cadre de jeu. Chaque boulet est initialement marqué du chiffre 3, chiffre qui se décrémente à chaque choc avec un boulet en mouvement. Heurté 3 fois, le boulet disparait et le joueur marque un point. Si le boulet rebondit en bas de l’écran, on a perdu.

(video un peu barbante : , ce sera plus clair)

Ça à l’air tout bête, mais il s’avère extrêmement difficile de marquer plus de 10 points. Après des heures passées sur , la version pour , mon record est de 17 points, assez loin des 37 points nécessaires pour figurer dans le Top25 des meilleures scores sur internet et très loin du record de 62 points détenu par CBC…

La difficulté du jeu tient essentiellement à la difficulté de prévoir les rebonds du boulet contre les autres : comme le savent les joueurs de billard, on peut assurer le résultat d’un choc entre 2 billes, en risquer un second, mais à partir de 3 on entre dans le royaume du chaos.

Pour visualiser ceci, j’ai utilisé pour la première fois pour montrer les rebonds possibles d’une toute petite balle qui rebondirait entre 2 grosses en fonction de l’angle de tir :

est un jeu qui cache son jeu : en le prenant comme un jeu d’adresse, vous n’avez aucune chance de faire un bon score. C’est un jeu de minimisation des risques. Il ne faut absolument pas tirer une bille qui ait le moindre risque de revenir derrière la ligne, et éviter à tout prix de boucher un angle de tir “sur” futur. C’est à l’usage qu’on s’aperçoit que Gimme Friction est un jeu de stratégie redoutable.

Sources de jeux intelligents

la rubrique
, le blog des jeux basés sur la physique

Combien de nombres palindromes < N ?

Sat, 26 Sep 2009 00:00:00 +0000

Les problèmes du devenant vraiment très ardus, j’ai été content de trouver un petit challenge intéressant : déterminer rapidement le nombre de nombres palindromes inférieurs à un maximum donné.

un nombre palindrome

Un se lit indifféremment de gauche à droite ou de droite à gauche, comme 1234321 ou 567765. Outre leur aspect esthétique, ces nombres ont aussi des .

La première idée qui vient à l’esprit est de les compter (c’est du ):

\[sourcecode language="delphi"\]

function NumberOfPalindromes(const maxNumber : integer) : integer; var i:Integer; s:string; begin Result:=0; for i := 1 to maxNumber do begin s:=IntToStr(i); if s=ReverseString(s) then Inc(Result); end; end;

\[/sourcecode\]

Ca marche, mais c’est très lent : pour maxNumber=1000000000, il faut un milliard de conversions en chaine de caractères, un milliard d’inversions de chaîne, et un milliard de comparaisons. Or le résultat n’est que de 109998. Comme l’ (mais c’est de moi) :

Si ta boucle ne fait rien 99% du temps, c’est que tu n’utilises pas le bon algorithme.

De plus, notre boucle génère tous les nombres palindromes sous forme de chaine, et on les jette.

Si tu jettes 99% des résultats, c’est que tu n’utilises pas le bon algorithme.

Une autre approche, que beaucoup utilisent avant même de programmer, voire de réfléchir, est de . C’est une excellente approche. On trouve immédiatement une , avec une formule qui offre sur un plateau le nombre a(n) de nombres palindromes inférieurs à 10n

La formule n’est valable que pour n entier, mais on peut tout de même la convertir en une petite fonction Delphi:

\[sourcecode language="delphi"\]

function NumberOfPalindromes(const maxNumber : integer) : integer; const pow10:array

\[0..9\]

of integer=(1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000); var n:Integer; begin n:=Round(log10(maxNumber)); if Odd(n) then Result:=11*pow10

\[(n-1)div 2\]

-2 else Result:=2*pow10

\[n div 2\]

-2; end;

\[/sourcecode\]

Comme il s’avère que le ne teste les algorithmes proposés qu’avec une puissance de 10, vous avez ci dessus une solution victorieuse, mais typique de la programmation agile : elle ne fonctionne (bien) que pour les tests ;-)

Tentons maintenant de rendre notre programme correct quel que soit N, si possible sans le ralentir. On va même commencer par le rendre encore plus rapide en poussant le vice de la programmation agile (= paresse) encore plus loin:

\[sourcecode language="delphi"\]

function NumberOfPalindromes(const maxNumber : integer) : integer; const A050250:array

\[0..9\]

of integer=(0,9, 18, 108, 198, 1098, 1998, 10998, 19998, 109998); begin Result:=A050250

\[Round(log10(maxNumber))\]

; end;

\[/sourcecode\]

Le vecteur contient directement les résultats de la formule pour n=(0),1,2,..,9. Son nom provient de .

L’algorithme ci-dessous commence par utiliser cette série pour compter les palindromes inférieurs à la puissance de 10 juste inférieure à maxNumber, puis considère successivement les chiffres de maxNumber en partant du plus significatif et compte le nombre de palindromes possibles sur les digits intermédiaires.

Par exemple pour maxNumber=5832476 :

on compte 1998 palindromes inférieurs à 1000000, le plus grand étant 999999
on ajoute (5-1) fois le nombre de palindromes de 5 chiffres, soit 1000 (de 000|00 à 999|99), ce qui donne le nombre de palindromes jusqu’à 4999994
on ajoute 8 fois le nombre de palindromes de 3 chiffres, soit 100. On a donc compté les palindromes jusqu’à 5799975
on ajoute 2 fois les 10 nombres possibles au centre, ce qui compte jusqu’à 5829285
reste à ajouter les (2+1) nombres palindromes obtenus en changeant le chiffre central : 5830385, 5831385 et 5832385

\[sourcecode language="delphi"\]

function NumberOfPalindromes(const maxNumber : integer) : integer; const A050250:array

\[0..18\]

of integer =(0,9, 18, 108, 198, 1098, 1998, 10998, 19998, 109998, 199998, 1099998, 1999998, 10999998, 19999998, 109999998, 199999998, 1099999998, 1999999998); const pow10:array

\[0..9\]

of integer =(1,10,100,1000,10000,100000, 1000000,10000000,100000000,1000000000); var n,i,j,k:Integer; d:array

\[0..18\]

of integer; // digits begin i:=0; n:=maxNumber; while n>0 do begin // extract digits d

\[i\]

:=n mod 10; n:=n div 10; inc(i); end; n:=i-1; // n=Trunc(log10(maxNumber)) Result:=A050250

\[n\]

; i:=n; j:=0; k:=n div 2; dec(d

\[n\]

); // because we counted palindromes to 1000..00 while i-j>=2 do begin // loop from outer digits to inner Result:=result+d

\[i\]

*(pow10

\[k\]

); dec(i); inc(j); dec(k); end; inc(Result,d

\[i\]

); // handle 1 or 2 center digits if d

\[j\]

>=d

\[i\]

then inc(Result); end;

\[/sourcecode\]

Cet algorithme étant nettement plus rapide et compact que les solutions existantes du challenge, je viens de le soumettre au bien qu’il y ait encore une petit bulle… Pour certains maxNumber “rares”, le résultat est 1 de trop. Saurez-vous trouver pourquoi avant moi ?

1,2,6,42,1806, Combien ?

Wed, 10 Jun 2009 00:00:00 +0000

Vous avez peut-être reçu un e-mail vous garantissant un QI > 120 si vous arrivez à trouver le terme suivant de la suite entière 1,2,6,42, 1806. Et vous avez peut-être été tout fier de remarquer que puisque 42/6=7, peut-être que 42*43=1806 … calculatrice … gagné!

Donc le prochain terme est 1806*1807=3263442 et hop! QI > 120, vous vous sentez intelligent et heureux d’un coup.

Pourtant 3270666. En effet, chaque entier de la suite est aussi égal au précédent multiplié par le nombre premier qui lui est juste supérieur, et comme le nombre premier suivant 1806 est 1811, 1806*1811=3270666. Quel QI je mérite pour ça ? Au moins 130, à vue de nez.

On peut aussi soutenir qu’il n’y a pas de terme suivant. En effet 1,2,6,42 et 1806 sont les seuls entiers n tels que m^(n+1) = m modulo n quel que soit m. Il n’y en a pas d’autre. Pour démontrer ça, je dirais qu’un QI de 140, ça aide…

Mais pas besoin d’un QI élevé pour ;-)

Programmer pour le fun

Mon, 23 Feb 2009 00:00:00 +0000

Amis des casse-tête mathématiques ardus et de la programmation d’algorithmes optimisés, bonjour!

Je viens de découvrir , et j’ai honte de ne pas l’avoir trouvé avant. Ce site propose 233 problèmes (et environ un de plus chaque semaine environ) pouvant parfois être résolus avec un papier et un crayon propulsé par un cerveau en ébullition, mais pour la plupart requièrent quelques lignes de code bien pensées et un stupide esclave électronique pour les exécuter.

Une fois inscrit sur le site, vous pouvez soumettre vos solutions aux problèmes dans l’ordre qui vous plait et chaque bonne réponse vous apporte instantanément:

la possibilité d’accéder à un forum où les solutions sont comparées et discutées. C’est en général là qu’on commence à avoir mal au front, quand on découvre des algorithmes 1000x plus rapides que ceux qu’on s’est escrimé à mettre au point, ou pire, la petite formule qui tue…
un bon point. Après 25 bonnes réponses vous entrez dans le tableau des et pouvez espérer rejoindre un jour la qui ont résolu tous les problèmes jusqu’ici.

Il faut dire que les premiers problèmes sont relativement simples, par exemple les 17 que j’ai déjà résolus sont :

additionner tous les entiers intérieurs à 1000 qui sont multiples de 3 ou 5
trouver la somme de tous les nombres pairs de la inférieurs à 4'000'000
trouver le plus grand facteur premier de 600'851'475'143
trouver le plus grand palindrome formé par le produit de 2 nombres de 3 chiffres
quel est le plus petit nombre divisible par tous les entiers de 1 à 20 ? (facile. celui là je l’ai fait à la main)
quelle est la différence entre le carré de la somme des 100 premiers entiers et la somme du carré de ces même nombres ?
trouver le 10001ème nombre premier
trouver le plus grand produit de 5 chiffres consécutifs dans un nombre à 1000 chiffres
trouver le seul dont la somme a+b+c=1000
calculer la somme des nombres premiers inférieurs à 2'000'000
quel est le premier ayant plus de 500 diviseurs ?
quels sont les 10 premiers chiffres de la somme de 100 nombre de 50 chiffres donnés?
trouver le nombre inférieur à 1'000'000 générant la plus longue
en partant d’un coin d’une grille de 20x20, combien y’a-t-il de chemins au coin opposé ? ( …)
quelle est la somme des chiffres de 21000?
quel est le premier terme supérieur à 101000 de la suite de Fibonacci ? (et si je vous disais qu’on peut le trouver sans calculer les termes précédents ?)
trouver la somme des chiffres de 100! (factorielle…)

Certains de ces problèmes exigent de pouvoir manipuler de grands nombres, ce qui est une force du langage , que j’aime de plus en plus. On peut par exemple obtenir la somme des chiffres de la factorielle de 100 en une seule ligne* combinant la et la fonction

reduce(lambda x, y: x + y, [int(i) for i in str(reduce(lambda x, y: x * y, range(1, 100)))])

Bon, jusqu’ici j’ai fait le facile : même avec une approche un peu brutale, on s’en sort. Mais rapidement la complexité fait son apparition au carré : au niveau mathématique et au niveau algorithmique, condamnant le programmeur peu subtil à patienter des minutes, des heures ou des siècles devant un sablier virtuel …

Je vois encore quelques problèmes liés à des sujets déjà abordés sur Dr.Goulu comme:

trouver le polynôme _n_² + an + b, où|a| < 1000 et|b| < 1000 qui produit le plus de
quel nombre premier inférieur à 1'000'000 est la ?
combien existe-t-il de inférieurs à 10'000 ?

Il y a encore environ entre 20 et 50 problèmes que j’espère pouvoir résoudre à raison d’un par soirée.

Après, ce sera l’enfer mais j’espère vous y retrouver, ami lecteur … (insérer un rire ici)

Note* dans le forum on découvre une solution en 13 caractères seulement, en évidemment: +/".“0”:!100x

Soluces de Noël

Sun, 22 Feb 2009 00:00:00 +0000

Voici enfin quelques solutions aux

le jeu des nénuphars

Pour gagner à , j’ai commencé par “tricher” en examinant le petit programme JavaScript qui s’occupe de tout. On y trouve ceci :

//positions gagnantes
var gagnant = new Array(777,667,557,447,337,227,456,236,135);

En codantla position de chaque grenouille par un chiffre de 0 à 7, la position de départ est notée 024 et la position gagnante finale 777. (On remarque au passage que les positions obtenues en permutant les lignes de nénuphars sont stratégiquement équivalentes, donc on peut représenter toutes ces permutations par un seul code dont les 3 chiffres sont triés dans l’ordre croassant )

Pour y arriver, si on a une grenouille sur 7, il faut s’assurer que les deux autres restent au même niveau : les positions 227,337,447,557 et 667 sont gagnantes parce que l’adversaire n’arrive jamais à faire 777 en un coup alors qu’on peut dans tous les cas se remettre en position gagnante.

Le début de la partie est plus compliqué, et c’est là que tout se joue. Pour comprendre pourquoi 135, 236 et 456 sont des positions gagnantes, j’ai fait ce graphe.

(cliquer pour agrandir)

On y voit:

que comme les positions xx7 , les positions 135, 236 ou 456 sont bien gagnantes car tout mouvement depuis ces positions permet ensuite à un adversaire jouant bien de revenir à une position gagnante.
il y a encore 3 autres positions gagnantes : 025, 034 et 124, et celles-ci sont accessibles à partir de la position de départ 024. Ca signifie qu’en suivant le graphe**, celui qui commence le jeu est sur de gagner !**

Merci et Bravo à , qui m’a soumis par mail son analyse de ce problème sans “tricher” en lorgnant le code. Cet article est le résultat de la combinaison de nos idées.

Les boulets de canon

les aux problèmes des quarts de finales de la FFJM sont disponibles. J’ai surtout ramé au problème No 16 pour lequel je n’ai pas trouvé de méthode, et au dernier, celui des boulets de canon, qui est très beau.

Une pile de boulets formée sur une base rectangulaire se termine par une couche ne contenant qu’une ligne de m boulets. La couche juste inférieure contient 2 lignes de m+1 boulets, la suivante 3 lignes de m+2 boulets et ainsi de suite. La i-ème couche contient donc i.(m+i-1) boulets et le nombre de boulets d’une pile contenant c couches est de

$n= sum_{i=1}^{c} i.(m+i-1) = m.sum_{i=1}^{c} i + m.sum_{i=1}^{c} i^2 -c$

En utilisant la formule de la somme des premiers entiers et celle de la , on obtient n=c.(c+1).(3m+2c-2)/6, résultat que l’on retrouve déjà dans un “ ” de 1813!

Dans le problème posé, la largeur de la pile de base étant égale à m, on a c=m et donc n=m.(m+1).(5m-2)/6 . Reste à trouver la valeur de m donnant un n qui soit un carré parfait. C’est vite fait à la main : m=6 donne 14^2=196 boulets. Mais il existe une autre solution: m=49 donne 99'225 boulets, le carré de 49. Sans Python, j’ai raté celle là …

Casse-tête binaire

Tue, 03 Feb 2009 00:00:00 +0000

Je viens d’inventer le problème suivant, qui est en fait une variation informatique d’un membre du C@fé des Sciences.

Un registre de microprocesseur contient un mot de 32 bits quelconque, mais dont exactement 8 bits sont à 1, les autres à 0 (par exemple 01001000000000111000010000101000)

Comment faire pour modifier les premiers 8 bits du mots de façon à ce qu’ils comportent autant de bits à ‘1’ qu’il n’y en a au total dans les 24 bits suivant (soit 6 dans l’exemple ci-dessus), et ceci en une seule instruction du processeur ?

Si vous n’êtes pas familier avec l’ , disons que vous disposez des mêmes opérations qu’une calculatrice, mais en binaire : addition, soustraction, ansi que des . Une instruction, c’est une de ces opérations suivie d’une .

Maths de Noël

Tue, 23 Dec 2008 00:00:00 +0000

Trop mangé ? trop dépensé ? trop dormi ? trop culpabilisé ? Prenez de bonnes résolutions et nourissez votre cerveau et celui de vos enfants avec quelques casse-tête et jeux amusants trouvés pour vous sur le Web.

Pour les petits dès 4 ans et jusqu’à 10, 15, 20, 30, 45 , offre une ribambelle de jeux intelligents à jouer seul ou à deux. Certains jeux de Lulu sont directement en rapport avec l’activité scolaire, d’autres développent simplement une réflexion logique, comme “ ”. En fait, le de ce jeu tout simple m’énerve un petit peu car je n’ai pas encore réussi à colorier les 51 boules après quelques essais… Je finis l’article et j’y retourne…

Pour les plus grands, il y a , site créé par un enseignant suisse. on y trouve de nombreux jeux assez scolaires, mais aussi une vers de nombreux jeux de logique trouvés sur le web. Il y a les classiques Reversi, Solitaire, Tetris et autres Pentominos, mais aussi les excellents Rush Hour, et “La Bonne Face”, un exercice de vision dans l’espace indispensable aux futurs mécaniciens.

Au bas de la page, les 5 “jeux pour bien s’arracher les cheveux” méritent un détour, avec mention spéciale pour “ ”, un petit casse-tête très énervant sur lequel j’ai perdu déjà un jour de vacances (merci J.-C…)

On joue contre l’ordinateur. Chacun son tour on peut faire avancer une grenouille d’autant de cases que l’on veut vers la droite. Le joueur qui place la dernière grenouille à droite a gagné. Le problème c’est qu’on perd tout le temps, et qu’on n’arrive même pas à comprendre la stratégie suivie par l’ordinateur pour gagner (à moins de visualiser le code JavaScript du programme… et encore…). Mais là je commence à comprendre. Solution bientôt.

Plusieurs liens de renvoient sur le merveilleux site . Ce site est bourré d’explications, mais aussi d’animations et de programmes en Java illustrant une foultitude de problèmes plus ou moins connus et plus ou moins liés aux maths. Il y a tellement de choses là que je l’ajoute immédiatement à et je vous en recause. (Un magnifique site de plus qui mériterait d’être modernisé, doté d’un flux RSS, d’un système de commentaires, bref “bloguifié”…)

Le niveau au dessus, c’est “ ”, qui porte bien son nom. Les problèmes proposés “dans nos classes” sont déjà bien corsés, mais la catégorie “remue-méninges” est clairement réservée aux pros des maths…

Si vous avez lu l’article jusque là, vous êtes un adepte des jeux mathématiques et donc un compétiteur en puissance. Quel que soit votre niveau en maths, que vous soyez à l’école primaire ou Docteur ès Sciences, vous pouvez encore vous inscrire au Championnat International de Jeux Mathématiques organisé par les fédérations , (et autres ?). Il suffit de résoudre une correspondant à votre catégorie et de renvoyer avant le 1er janvier si vous êtes Français, et avant le 15 janvier si vous êtes Suisse (on n’est pas plus lents, on est plus rapides à dépouiller les résultats…)

Python : un petit Sudoku pour commencer

Sun, 12 Oct 2008 00:00:00 +0000

Ces temps-ci, je découvre , un langage de programmation très apprécié en particulier dans la communauté scientifique. Ce “ ” intègre des concepts développés dans plusieurs langages récents, ce qui en fait peut-être le langage le plus complet disponible actuellement.

Pour une première approche de ce langage, je vous propose l’analyse du…

Plus Court Solveur de Sudoku

Voici un programme en Python de 173 caractères seulement qui serait le plus court connu actuellement :

\[sourcecode lang="python"\]

def r(a): i=a.find(‘0’) if i<0:print a

\[m in\[(i-j)%9\*(i/9^j/9)\*(i/27^j/27|i%9/3^j%9/3)or a\[j\]

for j in range(81)]or r(a

\[:i\]

+m+a

\[i+1:\]

)for m in`14**7*9`]r(raw_input())

\[/sourcecode\]

Ce programme est extrêmement compact et condensé, voire cryptique à l’instar des . Ce n’est pas forcément la meilleure façon de programmer, mais ça révèle souvent la puissance cachée de certains langages. Ce programme est décrit en anglais et en détail , mais voici son principe en gros et en français:

def r(a): ... r(raw_input()) // définit la fonction “r” qui résout le sudoku, puis on l’appelle en passant en paramètre ce que l’utilisateur a entré au clavier. Ca doit être une chaine de 81 caractères contenant ligne par ligne les chiffres de 1 à 9 donnés, et des 0 aux emplacements vides.

i=a.find('0') if i<0:print a // au début de la fonction, on cherche le premier emplacement vide. Si on ne le trouve pas, on imprime le sudoku résolu

la partie principale de la fonction utilise deux concepts puissants de Python:

la “lazy evaluation” qui fait que l’expression “a or b” est équivalente à “if not(a):b”
la “compréhension de liste” qui permet de créer une liste en écrivant une boucle à l’intérieur de \[crochets\]. Par exemple “l = \[x\*\*2 for x in range(10)\]” crée la liste des carrés des 10 premiers nombres entiers

ainsi cette expression [(i-j)%9*(i/9^j/9)*(i/27^j/27|i%9/3^j%9/3)or a[j]for j in range(81)] fournit la “liste d’exclusion” contenant les chiffres qui ne peuvent pas figurer dans le trou à la position i. On l’obtient en parcourant toutes les celllules et en ajoutant à la liste la valeur des cases a

\[j\]

situées sur la même ligne, la même colonne ou dans le même bloc que i. Le grand test compliqué détermine ces conditions en utilisant les opérateurs modulo (%), ou binaire (|) et ou exclusif (^).

Finalement, le [m in [...] or r(a[:i]+m+a[i+1:])for m in`14**7*9`] remplit successivement la grille avec les chiffres possibles en utilisant la ’lazy evaluation’ une fois de plus : ce n’est que si le chiffre m n’est pas dans la liste d’exclusion qu’on execute la partie droite du or, laquelle appelle récursivement la fonction r en lui passant la grille en paramètre la grille a[:i]+m+a[i+1:]. Ici , l’opérateur + sert à concaténer des listes : d’abord les i-èmes premières cases, puis le chiffre m proposé pour la case vide, puis les cases à partir de la i+1 ème.

Ce programme utilise donc une approche “force brute” loin d’être optimale en temps de calcul : on essaie les chiffres possibles dans chaque case vide jusqu’à ce que ça marche.

Reste à découvrir une astuce de geek que je ne connaissais pas : 14**7*9 vaut 948721536, un nombre qui contient les chiffres 123456789, dans le désordre, mais ça va aussi pour notre application. Les backquotes ´…´ servent à former une chaine, comme d’ailleurs la fonction str(). L’avantage de ´14**7*9´sur ´123456789´ ? ben c’est évident : il faut deux bytes de moins …

Sommes Egales de Nombres Premiers Consécutifs

Tue, 03 Jun 2008 00:00:00 +0000

Le quatrième et dernier problème de la mérite un article à lui tout seul. (J’ai parlé des trois autres dans )

Il s’agit de trouver le plus petit P qui soit en même temps :

la somme de 9 nombres premiers consécutifs
la somme de 119 nombres premiers consécutifs
la somme de 215 nombres premiers consécutifs
et la somme de 675 nombres premiers consécutifs !

(les nombres 9, 119, 215 et 675 sont différents pour chaque concurrent…)

C’est étonnant, mais beaucoup de nombres premiers sont des sommes de nombres premiers consécutifs (abrégé SNPC ci après), par exemple :

5+7+11+13+17 = 53 7+11+13+17+19 =67 11+13+17+19+23 =83

De plus, il est fréquent qu’un même nombre premier soit égal à plusieurs SNPC. Par exemple sur on mentionne:

34421 = 269 + … + 709 (71 nombres premiers) 34421 = 1429 + … + 1571 (23 nombres premiers) 34421 = 3793 + … + 3853 (9 nombres premiers) 34421 = 4889 + … + 4937 (7 nombres premiers) 34421 = 11467 + … + 11483 (3 nombres premiers)

Le nombre P recherché n’est donc peut-être pas très grand, d’autant que la somme des 675 premiers nombres premiers ne vaut que 1'578'242. Il n’y a probablement pas besoin de calculer en “bigint”, les entiers sur 32 bits, voire 64 disponibles avec n’importe quel langage de programmation devraient suffire. Par contre, il est pratique de disposer de fonctions prédéfinies pour manipuler des nombres premiers, c’est pourquoi j’ai choisi d’utiliser .

Les fonctions suivantes suffisent pour résoudre le problème posé: (code modifié le 4/6/8 suite aux commentaires de b0z0)

\[gist id="0e35207dedf4e337c937"\]

La fonction SCP (Sum of Consecutive Primes) renvoie la somme des n nombres premiers consécutifs en commençant par le i-ème nombre premier en utilisant la fonction prédéfinie Prime

\[j\]

qui renvoie directement le j-ème nombre premier.

Cette somme n’étant pas forcément un nombre premier, la fonction PSP (Prime Sum of Primes) appelle répétitivement SCP en augmentant i jusqu’à ce que la somme soit un nombre premier, vérifié grâce au test de primalité , une fonction non triviale bien utile ici. Pour une raison expliquée plus bas, PSP renvoie une paire de résultats : la somme, et l’indice du premier nombre premier de la somme.

Enfin, la fonction CPSP (Compound Prime Sum of Primes) implante l’algorithme que j’ai inventé pour la circonstance. Elle prend en paramêtre la liste des nombres de nombres premiers consécutifs sommés. Pour résoudre notre problème, on appellera CPSP

\[{675, 215, 119, 9}\]

on initialise une liste p avec les n résultats de PSP obtenus pour chacun des nombres de nombres premiers consécutifs à additioner. Ainsi, pour CPSP \[{675, 215, 119, 9}\], p est initialisé à {{1583291,2},{149993,15},{41641,10},{127,2}}. Autrement dit, 1583291 est le plus petit nombre premier qui soit la somme de 675 nombres premiers consécutifs, et cette somme commence avec le 2ème nombre premier. 149993 est le plus petit nombre premier qui soit la somme de 215 nombres premiers, en commençant par le 15ème, et ainsi de suite
par paresse (qualité indispensable chez les programmeurs…) , la détection de la fin de l’algorithme est réduite au minimum vital : dès que la liste p n’est plus modifiée par l’algorithme, on arrête
Pour chaque élément de la liste p en commençant par le deuxième, on regarde si la somme est inférieure à la somme du premier indice. Si c’est le cas, on calcule une somme supérieure en incrémentant l’indice correspondant, jusqu’à ce que la somme soit égale à la première, ou la dépasse. Après cette étape, la liste p devient {{1583291,10},{1600981,840},{1589563,1526},{1584829,15997}} : on voit que les sommes 2,3 et 4 ont dépassé la somme 1
Si la somme 1 est plus petite que la somme 2, on augmente la somme 1 jusqu’à ce que’elle atteigne ou dépasse la somme 2. On arrive ainsi à {{1623917,10},{1600981,840},{1589563,1526},{1584829,15997}}. On boucle au point 2

Les trois dernières boucles donnent les listes suivantes qui montrent bien le fonctionnement de l’algorithme:

{{8256361,1127},{8112103,3883},{8115539,6728},{8112787,71376}} {{8275409,1130},{8259353,3947},{8264171,6833},{8256383,72536}} {{8275409,1130},{8275409,3954},{8275409,6841},{8275409,72696}}

et voilà : 8'275'409 est égale à la somme des:

675 nombres premiers consécutifs à partir du 1130-ème (9109)
215 nombres premiers consécutifs à partir du 3954-ème (37339)
119 nombres premiers consécutifs à partir du 6841-ème (68821)
9 nombres premiers consécutifs à partir du 72696-ème (919421)

Quelques minutes pour choisir le bon outil (Mathematica) + quelques minutes de programmation + 30 secondes de calcul, c’est gagné !

Recrutement et Casse-Tête

Sat, 17 May 2008 00:00:00 +0000

Si vous souhaitez travailler chez Google ou facebook, voici un petit tuyau : cultivez l’art de résoudre des casse-tête, et montrez vos talents sur internet.

, on testera votre raisonnement logique dès les premières minutes du premier interview téléphonique, puis on vous cuisinera sur de nombreux autres problèmes plus mathématico-informatiques lors des interviews suivants. En parallèle, vous recevrez un e-mail qui vous incitera à participer aux , un site extraordinaire sponsorisé par de nombreuses entreprises qui recherchent à la fois des solutions originales à des problèmes très pointus et des développeurs de haut niveau. Un très bon endroit pour se faire remarquer (pas seulement par Google) si vous êtes un mordu d’algorithmes. Dommage qu’on doive s’engager à ne pas parler des problèmes à l’extérieur du site TopCoder, parce qu’ils sont très jolis.

Google lance aussi des “chasses au trésor” sur internet. Là je viens de commencer à participer à , qui commence très fort: si le robot ci-dessous ne peut aller que vers la droite ou vers le bas, combien y’a-t-il de chemins distincts qui le mènent au but ?

Vous avez trouvé ? En comptant à la main ? Bien. Mais en fait, pour la chasse au trésor, il faut répondre pour un damier de 56x32 cases (le nombre change pour chaque participant) … Dans ce cas, la réponse est 232059241971866600926656, ce qui suppose de et de disposer d’une bonne calculatrice …

Si c’est facebook qui vous tente, il faut visiter , chosir un des jolis problèmes qui s’y trouvent, le résoudre avec un programme en C++, Java, JavaScript, OCaml/SML, Perl, PHP ou Python, ce qui montre bien que les langages de programmation n’ont que peu d’importance pour ceux qui savent ce qu’est un algorithme, et que toutes ces jolis sites web ne sont que du vernis. Ensuite, il faut envoyer la réponse à { (0xFACEB00C » 2) en décimal } @ facebook.com. .

Jeux math'

Tue, 08 Apr 2008 00:00:00 +0000

(cliquer pour le sommaire)

le de ce mois regorge d’articles passionnants, dont plusieurs sur des sujets abordés précédemment sur Dr. Goulu.

Alexandre Dewdney réédite un ancien article qui présente des “calculateurs analogiques” théoriquement capables de surclasser les plus puissants ordinateurs sur des problèmes spécifiques. Par exemple, les meilleurs algorithmes sont capables de trier N données en un temps proportionnel à N.log(N), log(N) étant le logarithme base 2 de N. Ainsi, pour trier 1000 nombres, il faut faire environ 10'000 comparaisons, alors qu’en utilisant 1000 spaghettis comme indiqué 2x1000+1 opérations suffisent, soit un temps proportionnel à N.

L’article présente d’autres “machines” toutes simples permettant de résoudre simplement des problèmes connus pour être difficiles à résoudre par informatique, comme trouver le chemin le plus court entre deux noeuds d’un graphe avec des ficelles, ou utiliser des films de savon pour déterminer le réseau de routes le plus court reliant N points.

Dans un autre article, Michel Criton parle des problèmes de pesées et ça m’a fait très plaisir d’apprendre que pour résoudre ce type de casse-têtes est la bonne, même si elle n’est pas vraiment nouvelle.

Il y a encore d’autres articles sur des sujets comme la cryptographie, les carrés magiques, les nombres taxicabs (1729 est mon nombre préféré), la stratégie dans les jeux, les labyrinthes, la découpe de formes, l’origami et une douzaines d’autres choses dont je vous parlerai ici dès que j’ai le temps.

Mais vous pouvez aussi acheter le journal, c’est du tout bon.

Shift

Sat, 23 Feb 2008 00:00:00 +0000

j’ai passé un excellent moment à jouer sur le web à un petit jeu très chouette :

C’est un jeu de plate-forme d’apparence très classique : on se déplace avec les flèches, on peut sauter avec space, et il faut atteindre les clés pour pouvoir accéder à la porte de sortie sans tomber sur les piques.

Le truc qui fait toute la différence, c’est la touche shift. Je n’en dis pas plus : jouez-y et vous verrez qu’on peut encore avoir des idées géniales en matière de jeux video.

Blokus

Mon, 04 Feb 2008 00:00:00 +0000

est un jeu de stratégie qui existe “en dur”, et maintenant : vous pouvez y jouer gratuitement sur le web, en affrontant des joueurs du monde entier. Il en existe différentes versions, mais le principe est de placer tout à tour des pièces genre Tetris ou Pentominos pour occuper la plus grande surface possible du plan de jeu. Les pièces d’un même joueur, de la même couleur, ne peuvent se toucher que par les angles, ce qui permet à un adversaire futé de traverser un barrage. Une partie à 4 ressemble à ceci:

La difficulté est à la fin de la partie : il faut vraiment tenir compte des pièces à disposition de l’adversaire pour l’empêcher de jouer plutôt que de tenter de placer de grosses pièces soi-même, ce qui résulte souvent en un auto-bloquage.

Excellent jeu !

Eternity II

Sat, 12 Jan 2008 00:00:00 +0000

est un puzzle spécialement étudié pour être extrêmement difficile, au point que son éditeur offre au premier qui parviendra à placer correctement ses 256 pièces carrées de façon à ce que les côtés de chacune correspondent à ceux de ses 4 voisins, comme sur ce petit exemple avec 16 pièces seulement :

(cliquer sur l’image pour jouer à la version 4x4 en ligne)

D’après l’éditeur, il existe 20'000 solutions au puzzle, et il nous “aide” en nous indiquant la position d’une pièce (la 139) , et fournit 2 indices de plus si l’on résout un puzzle 6x6 et un 12x6 avec des pièces indiquées dans la boite. Il n’est pas clair si ces indices (“hints” en anglais) facilitent réellement la résolution du puzzle, où s’ils servent à limiter le nombre de solutions admises comme victorieuses à beaucoup moins de 20'000, tout en rendant la programmation d’une solution informatique plus compliquée.

Mais avant d’attaquer la résolution informatique d’Eternity II, petit flash-back sur Eternity(I)

Eternity

En 19xx, un challenge similaire avait été posé pour le puzzle “Eternity” premier du nom, dans lequel il fallait disposer 209 pièces dans un dodécagone. 2 solutions ont été trouvée, en mai 2000 par et Oliver Riordon " et quelques ordinateurs", ce qui leur valut de se partager £1'000'000. Un mois plus tard, Guenter Stertenbrink a trouvé la seconde solution présentée ci-dessous:

A l’époque, Pierre-François avait programmé un logiciel de résolution du puzzle et l’avait rendu disponible sur le web à la condition de partager le prix avec lui si le programme permettait de trouver une solution. C’était une excellente idée, malheureusement il a du retirer son logiciel car il contenait la description des pièces du jeu, protégées par le copyright de l’éditeur …

Résolution informatique d’Eternity II

J’ai recensé plusieurs logiciels de résolution d’Eternity II, qui évitent tous ces problèmes de copyright en obligeant l’utilisateur à décrire lui-même les 256 pièces du jeu qu’il est censé avoir acheté au magasin :

était le plus ambitieux : basé sur , il permettait d’utiliser la puissance combinée de milliers d’ordinateurs. Le projet a été , officiellement par désespoir de trouver une solution avec un algorithme “brute force” et en raison des couts du serveur. Le code source de ce programme a été rendu disponible … sur leur serveur qui ne répond plus !
est aussi un solveur distribué, et le site (en français) est plein d’informations utiles, avec également un forum très actif. Le logiciel que vous téléchargez après inscription sur le site se synchronise avec le serveur pour calculer des configurations qui n’ont pas encore été évaluées. Si une solution est trouvée, l’auteur du logiciel s’engage à vous verser la moitié des $2M…
est basé sur le “ ”, un client peer-to-peer qui non seulement partage les fichiers, mais aussi le processeur… Le en Delphi de ce projet est disponible, ce qui est intéressant pour voir comment il est fait …
est un shareware à $10 qui vous propose de garder les $2M pour vous tout seul, mais n’utilise qu’un seul processeur pour faire tourner un algorithme présenté comme mystérieusement exclusif, mais dont les résultats montrent qu’il est très “brute force” (voir ci-dessous)
Il y a un code source en C++
et un en Java . (lien restauré le 19.3.2015)

Algorithmes utilisés

Tous ces programmes utilisent faute de mieux un approche “brute force” : on place des pièces correspondantes les unes à côté des autres jusqu’à ce qu’on ne puisse plus le faire, puis on fait du “backtracking” en enlevant la dernière pièce et en essayant d’en mettre une autre qui permette de continuer, et si on n’y arrive pas on enlève encore la pièce précédente etc. La de cet algorithme est monstrueuse : la probabilité de trouver une solution de cette manière en une année est très faible.

annnonce une performance de son algorithme de 15'000'000 de pièces disposées / seconde ! Une option permet de visualiser son fonctionnement dans une fenêtre graphique bougeant à toute vitesse. Une capture donne ceci :

On voit que, comme souvent dans ce genre de casse-tête, tout va bien presque jusqu’à la fin : ce sont les dernières pièces qui font la différence, et si on n’y arrive pas, c’est peut être les premières qui sont mal placées …

Un petit doute me tarabuste à propos d’Eternity2.fr : les anomalies cerclées de rouge : avec un vrai programme de backtracking, il ne devrait pas y avoir de pièce mal placée dans le puzzle. Peut-être est-ce un problème graphique, l’affichage étant partiellement désynchronisé …

Tetravex II a aussi une interface graphique et aborde le problème de manière identique, ligne par ligne. Je me demande si c’est judicieux car les pièces formant les bords sont connues, donc autant tenter de les placer le plus tôt possible, non ?

Je vais encore y réfléchir et peut-être me lancer dans un solveur moins “brute force”…

Références:

sur Vox-Populi

Lecteur de pensée

Wed, 12 Dec 2007 00:00:00 +0000

, je vais expliquer à Yves comment marche le truc du . C’est pas pour retourner le couteau dans la plaie, mais un minimum de maths, ça aide, dans la vie. Il m’a fallu 10 secondes pour deviner à l’avance que le symbole qui allait apparaître en cliquant sur le carré serait le Ø quelque soit le nombre que j’avais choisi.

La raison c’est que 10.x + y -x - y = 9x

Autrement dit, quand vous choisissez un nombre entre 01 et 99 et que vous appelez x les dizaines et y les unités, votre nombre est “xy” est égal à 10.x + y. En enlevant les dizaines et les unités, les unités ne jouent plus aucun rôle et le nombre que vous obtenez est un multiple de 9 inférieur à 90. Et en examinant la table on voit que tous les multiples de 9 inférieurs à 90 correspondent au même symbole, le “Ø” quand j’ai essayé.

Danseuse et Cerveau

Mon, 10 Dec 2007 00:00:00 +0000

J’aime bien cette petite danseuse qui me rappelle le à Las Vegas… Mais dans quel sens tourne-t-elle ?

D’après cet , ça dépend de votre hémisphère cérébral préférentiel, droit ou gauche. Si vous arrivez à la voir tourner dans les deux sens, bonne nouvelle : votre cerveau a deux hémisphères …

Je n’arrive pas à la faire changer de sens en regardant, mais en la quittant des yeux, en pensant à une direction et en la re-regardant, elle m’obéit presque toujours. Mais le plus souvent elle tourne « anti-clockwise », un terme très négatif, je préfère « trigonométrique positif »…

l'Enigme des Trois Interrupteurs

Sat, 17 Nov 2007 00:00:00 +0000

Julia m’a collé avec un petit problème de logique. Il est que j’ai hésité à lui consacrer un article, mais après avoir donné ma “langue au chat”, j’ai eu tellement honte que je dois expliquer pourquoi. Vous allez comprendre.

Le problème : dans une pièce se trouvent 3 interrupteurs, dont un seul allume ou éteint une ampoule placée dans une autre pièce. On n’a le droit d’aller dans cette autre pièce qu’une seule foi, et pas moyen de voir autrement si l’ampoule est allumée ou éteinte. La question : comment savoir quel interrupteur commande la lampe ?

Le problème dans ces articles sur les casse-tête, c’est de savoir s’il faut donner la solution, ou pas, ou un indice avant, et comment forcer le lecteur à réfléchir plutôt que de se précipiter sur la solution en cliquant un lien …

Alors ici, je vous propose de lire que je venais d’écrire et qui contient l’indice, d’où ma honte à ne pas y avoir pensé… Et si vous ne trouvez toujours pas, , qui présente le problème, un indice et la solution d’une manière intelligente.

Portal, le jeu hyperspécial

Sun, 11 Nov 2007 00:00:00 +0000

Noël approche, et les jeux qui:

ne sont pas trop idiots
ne demandent pas des PC flambant neufs avec cartes graphiques d’enfer

ne seront pas légion. J’en ai déjà trouvé un : Portal

Portal est un jeu de plates-formes en 3D, ou plutôt un jeu de casse-tête en 4 dimensions basé sur une idée toute bête : à l’aide d’un engin futuriste, on peut percer des trous dans l’hyper-espace, en créant un portail entre deux lieux distincts du décor.

Ca permet évidemment de passer certains obstacles directement, mais aussi de faire plein de choses amusantes permettant de passer chacun des 19 tableaux.

Le moyen le plus simple, le plus rapide et le (presque) moins cher de vous le procurer est d’utiliser la plateforme .

L’ainée est blonde

Wed, 20 Jun 2007 00:00:00 +0000

Un superbe problème mathématico logique que j’ai bien envie d’élever au rang de “mon préféré” à la place du “ ” :

Un facteur fait la causette à un prof de maths : “Au fait, quels âges ont vos filles ?”
“Le produit de leurs âges fait 36, et leur somme est le numéro de la maison d’en face.” répond le papa taquin.
Le facteur réfléchit, puis dit “vous n’oubliez pas quelque chose ?”
Ah si, dit le prof_, vous avez raison j’ai oublié de préciser que l’ainée est blonde._
C’est bon, dit le facteur, je sais leurs âges alors!

Quels âges ont les 3 filles ?

Je précise que ce n’est pas un gag : le fait de savoir que l’ainée est blonde est effectivement utile à la résolution du problème !

Vous pouvez trouver la solution bêtement en la cherchant sur internet, il y a des dizaines de sites qui parlent de ce problème.

Ou vous pouvez attaquer tranquillement la résolution du problème étape par étape. Ce n’est pas difficile, il suffit d’être systématique:

chercher les combinaisons de 3 âges possibles dont le produit fasse 36
écrire les sommes correspondantes
vous demander pourquoi le facteur pense qu’il manque une indication
réfléchir en quoi “l’ainée est blonde” lève son doute.

A vos cerveaux!

Colonnes ou Lignes ?

Fri, 15 Jun 2007 00:00:00 +0000

En perdant un peu de temps sur un , je me suis rendu compte de quelque chose de bizarre. Avant de vous dire quoi, faites rapidement le Sudoku le plus facile du Net : cherchez dans le tableau ci-joint les 9 chiffres manquant de manière à ce que chaque chiffre de 1 à 9 n’apparaisse qu’une fois dans chaque ligne et dans chaque colonne.

Attention :

disposez bien votre fenêtre pour voir le Sudoku en entier.
pour les Belges, pensez à utiliser un feutre effaçable si vous écrivez sur votre écran …

### 5	### 4	### 9		### 7	### 3	### 8	### 6	### 2
### 8	### 3	### 1	### 5	### 6		### 7	### 4	### 9
### 6	### 2	### 7	### 8	### 4	### 9		### 1	### 5
### 7	### 1	### 8	### 2		### 4	### 9	### 3	### 6
### 3	### 5		### 6	### 9	### 7	### 2	### 8	### 1
### 9		### 2	### 3	### 1	### 8	### 5	### 7	### 4
	### 8	### 6	### 9	### 3	### 5	### 4	### 2	### 7
### 2	### 7	### 5	### 4	### 8	### 6	### 1		### 3
### 4	### 9	### 3	### 7	### 2	### 1	### 6	### 5

Et maintenant, une question :

Avez-vous cherché les chiffres manquants plutôt par lignes ou plutôt par colonnes ?

Je me suis surpris à avoir une préférence pour les colonnes : je vois plus rapidement les chiffres manquant en parcourant la table de haut en bas/bas en haut qu’en lisant normalement les lignes. Et vous ? suis-je anormal ?

Professor Fizzwizzle

Tue, 05 Jun 2007 00:00:00 +0000

de est encore un de ces petits jeux touts bêtes où l’on passe de longues minutes à se gratter l’occiput et à se fourvoyer lamentablement avant d’avoir, enfin, l’éclair de génie permettant de “passer le tableau”, et de recommencer…

La est assez longue pour se faire une idée assez précise de la difficulté progressivement diabolique des tableaux, qui se suivent sans aucune pitié pour vos neurones surchauffés, ensuite ça coûte $20 pour achever de les griller.

Multiplication graphique

Wed, 18 Apr 2007 00:00:00 +0000

J’avais déjà vu cette vidéo qui montre une drôle de manière de multiplier deux nombres, mais Yves m’a demandé si “c’est un gag, ou il y a une once de vérité dans la méthode ?”, alors je l’ai regardée encore une fois :

En fait c’est tout bêtement une multiplication en colonne déguisée :

Dans le premier exemple 21 x 13, les intersections de gauche représentent le produit des dizaines (2x1), celles de droite le produit des unités (1x3) et celles du milieu les 2 produits dizaines x unités (1x3 + 1x1 ). On retrouve directement le principe de la multiplication à la main, d’autant qu’il n’y a pas de retenues:

 2 1
x 1 3
--------
2 1
+ 6 3
--------
2 7 3

De même dans le second exemple 123 x 321 :

 1 2 3
 x 3 2 1
 ----------
3 6 9
+ 2 4 6
+ 1 2 3
-------------
3 8 14 8 3

qui sont les nombres d’intersections de chaque colonne du graphique. Reste à gérer les retenues, facile dans ce cas où il n’y a qu’un 1 à reporter à un endroit.

Au début j’ai pensé que la méthode est limitée aux petits chiffres comme 1,2,3 dont les produits sont inférieur à 10, mais il n’y a aucune raison : on peut très bien multiplier 978 par 689 ainsi. La connaissance du livret évite même de compter les points un à un… Il faut juste être prudent avec les 0, en les traçant quand même pour éviter les bulles, par exemple comme un trait pointillé dont toutes les intersections sont omises …

Comment faire 4 triangles équilatéraux avec 6 allumettes ?

Fri, 26 Jan 2007 00:00:00 +0000

“Il faut penser différemment” écrit dans “Les Fourmis” quand il propose ce petit casse-tête.

Quand vous serez convaincu qu’il faut casser les allumettes (interdit!) , reprenez le problème à zéro en chronométrant combien de temps il vous faut pour “penser différemment” .

Le plaisir de l’éclair “haha” combiné à une certaine honte m’avaient frappé après environ 2 minutes. Et vous ?

Vous pouvez aussi lire directement la suite dans laquelle figure la solution, mais ça serait dommage…

\[expand title="cliquer la langue au chat..."\]

Très peu de gens pensent immédiatement en 3D et trouvent la solution : le tétraèdre. La majorité abordent le problème “à plat”, et ne parviennent pas à élargir leur approche et à penser dans l’espace.

Même certains, expérience faite, dont le boulot consiste à convaincre les ingénieurs de quitter leurs outils de dessin 2D pour passer aux outils de Conception Assistée par Ordinateur (CAO) en 3D …

\[/expand\]

Oulipo

Sun, 30 Oct 2005 00:00:00 +0000

l’ est un groupe d’auteurs (Raymond Quenenau et Georges Perec sont les plus connus) explorant l’ “écriture sous contrainte”.

Les contraintes les plus connues sont:

Le lipogramme, dans lequel on s’interdit d’utiliser certaines lettres. Le plus spectaculaires est le roman “La Disparition”, de Georges Perec dans lequel n’apparaît pas une seule fois la lettre E, la plus fréquente de la langue française !
L’antistrophe, appellée couramment “contrepèterie”. Il existe un !
Le pangramme consiste à utiliser toutes les lettres de l’alphabet dans un texte aussi court que possible, par exemple:
- Portez ce vieux whisky au juge blond qui fume
- Peux-tu m’envoyer du whisky que j’ai bu chez le forgeron ?
Les aides mémoire, permettant de se rappeller certains nombres ou séries:
- Pi:Que (3) j’(1) aime (4) à (1) faire 5) apprendre (9) un (2) nombre (6) utile(5) aux (3) sages (5)
- e : Tu(2) aideras(7) à(1) rappeler(8) ta (2) quantité(8) à (1) beaucoup (8) de (2) docteurs (8) amis(4)
- Les planètes : Monsieur vous tirez mal - je suis un novice pitoyable
Palindromes : textes pouvant être lus à l’endroit et à l’envers.
- radar, ressasser etc.
- marchand de savon en finlandais : siappuakivikauppais
Anagrammes (voir )
- Rose au coeur violet

Se vouer à toi, ô cruel!
A toi, couleuvre rose
O vouloir être la cause
Couvre-toi, la rue ose
Ouvre-toi, ô la sucrée!
Va ou surréel côtoie
O l’oiseau crève-tour
Vil os écoeura route
Coeur violé ose tuer…

Mots croisés

Créer des mots croisés sans case noire est également une discipline Oulipienne. Voir la , où se trouve également la solution au mot croisé d’une seule case avec pour définition:

horizontalement : voyelle
verticalement : consonne…

Les records à battre sont

Sudoku

Wed, 26 Oct 2005 00:00:00 +0000

Ce jeu “à la mode” n’est en fait pas très difficile si on suit une méthode systématique.

Les 2 “solveurs en ligne” suivants montrent la méthode en résolvant un Sudoku pas à pas :

celui-ci permet d’imprimer un sudoku pour le résoudre à la main

Il est à mon avis plus difficile de créer un Sudoku, en étant sur qu’il n’admette qu’une seule solution d’une part, et ayant une difficulté donnée d’autre part.

Les générateurs de Sudoku que j’ai trouvé sont :

DicoLib

Wed, 14 Sep 2005 00:00:00 +0000

DicoLib est une librairie C++/STL pour les jeux de mots, que j’ai développé initialement pour résoudre le casse-tête “ ”

Complexité

L’algorithme “force brute” pour résoudre “ ” consiste à chercher les n mots de 8 lettres du dictionnaire (O(N)), puis pour chacun d’eux, enlever successivement chaque lettre et vérifier s’il est présent dans le dictionnaire (O(N.log N) pour liste triée), et recommencer s’il y est. La complexité est environ O(N+n.100.N.log N). Le facteur 100 est une estimation du nombre de recherches dans le dictionnaire pour chaque mot avant d’arriver à une impasse. Avec typiquement N=30’000 et n=5’000, on se retrouve avec ‘240 milliards de comparaisons’ de chaînes de caractères à effectuer si l’on veut trouver toutes les solutions. Compter une petite heure…

On pourrait se satisfaire de ceci et se demander pourquoi passer des heures à programmer une solution plus futée. Et bien, si on est capable de retrouver rapidement les mots qui ne se distinguent d’un autre que par une seule lettre, ou deux ou trois, on obtient un correcteur d’orthographe rapide et efficace. Mais pour une telle application, la complexité mentionnée ci-dessus serait inacceptable.

Conception

Comment accélérer très sérieusement la recherche de mots “semblables” a un autre dans un dictionnaire ?

Quelques idées :

grouper les mots par tailles. Si on cherche un mot de 6 lettres, on ne le cherchera que parmi ceux-là.
construire une “signature” du mot sous la forme d’un ensemble de 26 bits indiquant quelles lettres sont présentes dans le mot, et grouper les mots ayant la même signature (donc composés des mêmes lettres) dans une liste. 26 bits, c’est moins que 32, donc très pratique à manipuler par le processeur pour des opérations logiques. Mais c’est trop pour être utilisé comme clé dans une table de hachage, qui aurait dans les 64 millions d’entrées.

Je me suis dont mis à réfléchir à une structure de donnée permettant de stocker un dictionnaire de mots sous une forme permettant la recherche rapide de mots similaires (avec une lettre en plus ou en moins), des anagrammes (mots obtenus par permutation des lettres) ou selon les lettres qui les composent (pour le scrabble).

J’ai alors eu une idée simple, dont je ne sais pas encore si elle est originale, mais en tout cas elle est très efficace, et j’ai écrit un ensemble de classes C++ “Dico.lib”,une librairie permettant de réaliser en quelques lignes des programmes de résolution de divers jeux de lettres.

L’idée principale de DicoLib est de stocker les mots dans une structure permettant d’y accéder rapidement sur la base de 2 informations simples :

la longueur du mot
une clé de 26 bits (letterset) codant la présence de chaque lettre de l’alphabet dans le mot. par exemple le mot “alphabet” donne

11001001000100000001000000
abcdefghijklmnopqrstuvwxyz

Structure de données

dico.lib définit la hiérarchie de classes suivantes :

class Word // mots du dictionnaire
class letterset : public std ::bitset<26> // clé d’accès
class WordList : public std ::list // liste de mots
class Anagrams : public WordList // liste d’anagrammes
class AnagramsList : public list // liste de listes d’anagrammes
class SameLetters : public vector // mots formés des même lettres, organiséss par longueurr
class Dico : public std ::map // dictionnaire utilisant les letterset comme clé primaire

Liens

, d’où vous pouvez télécharger le code et contribuer à le développer
, article sur
des dictionnaire en mode texte sont disponibles ici:

Word Downsizing

Wed, 14 Sep 2005 00:00:00 +0000

J’avais vu sur un casse-tête intéressant : trouver un mot (anglais) de 8 lettres tel qu’en enlevant une lettre on obtienne un mot de 7 lettres correct, auquel en enlevant une lettre on tombe sur un mot anglais de 6 lettres également correct et ainsi de suite jusqu’à 1 lettre…

Je me suis mis à écrire le programme qui m’a permis de trouver de nombreuses solutions, parmi lesquelles :

replanted, replated, related, elated, elate, late, ate, at, a
restarted, restated, restate, estate, state, sate, ate, at, a
streambed, streamed, steamed, teamed, tamed, tame, tam, am, a

mais je n’ai bêtement pas eu l’idée d’en chercher une de 9 lettres, ce qui fait que ce n’est pas moi qui ai trouvé la :

STARTLING, STARTING, STARING, STRING, STRING, SING, SIN, IN, I

En français il n’y a 3 solutions si on admet les conjugaisons, les pluriels et les consonnes apostrophées (s,t,n) comme mots de une lettre valides, ce qui permet :

rabaisser, abaisser, baisser, baiser, baser, base, bas, as, s
chasseurs, chasseur, chasser, casser, caser, case, cas, as, s
moniteurs, monteurs, monteur, monter, monte, mont, ont, on, n

Pentominos

Sun, 04 Sep 2005 00:00:00 +0000

J’avais écrit un programme “PentoSolver” en Visual Basic qui trouve les solutions 6x10 mais résout toutes les variantes de Pentominos et de Polynominos encore plus vite, directement sur votre explorateur… TRES FORT !

Les 3 maisons

Sun, 21 Aug 2005 00:00:00 +0000

Comment amener l’eau, le gaz et l’électricité depuis les 3 usines correspondantes vers 3 maisons sans que les tuyaux et câbles correspondants ne se croisent sur un plan ?

C’est le genre de casse-tête qui m’énerve, surtout si on me dit qu’il existe une solution.

En fait, il n’y a pas de solution à ce problème. Mon collègue , et montre qu’un planète torique offrirait des avantages …

le Triangle Mystérieux

Fri, 14 Jan 2005 00:00:00 +0000

Si on regarde bien, le triangle vert à une pente différente du rouge : Le vert monte de 2 carrés pour 5 horizontalement, le rouge de 3 pour 8, et 2/5 est bien différent de 3/8.

Conc les deux figures ne sont pas des triangles parfaits : l’hypoténuse de celui sans trou est légèrement concave, celle de celui avec trou fait une bosse, et si on fait le calcul de la surface ainsi récupérée en grignotant l’hypoténuse, on risque bien de trouver la surface du trou.

En effet :

la surface du grand triangle a l’air (si il était parfait) d’être de 5x13/2 = 32.5 carrés
la surface des pièces est 5 (triangle vert) + 12 (triangle rouge) + 8 (vert clair) + 7 (orange) = 32

Il reste à montrer que la surface du triangle tout fin qu’il faut une fois ajouter et une fois enlever à l’hypoténuse vaut 0.5 carrés… A vos calculettes !

Il y a pas mal de variantes de ce casse-tête, au chalet j’ai une boite que l’on peut remplir “parfaitement” avec des petits plots de 2 manières différentes, mais dans un cas il reste un petit plot qu’on ne peut pas placer à moins de le réduire en fine sciure…

Temple de la Logique Pure

Mon, 21 Jun 2004 00:00:00 +0000

Le casse-tête suivant est un de mes favoris car il semble clair qu’il est insoluble, qu’il doit manquer quelque chose… et pourtant, il peut se résoudre avec un peu de logique…pure !

Dans un monastère retiré vivent les Adeptes de la Logique Pure. Leur vie est vouée à la réflexion et à l’étude de la Logique, et de la logique seule. Les Adeptes méprisent la communication, illogique, et donc ne se parlent ni ne s’écrivent, ni même n’échangent de l’information d’aucune manière. Leur vie sociale n’est rythmée que par le seul et unique repas qu’ils prennent quotidiennement en commun, dans un silence absolu.

Un jour cependant apparaît au beau milieu du repas la Logique elle-même, divinité éthérée et courroucée : “Certains d’entre vous ont failli à leur vœu et ont commis des actes aussi Illogiques qu’Impurs. J’ai marqué les coupables d’une marque indélébile sur le front. Ceux qui se sauront marqués feront pénitence en sautant un repas.” Sur ce, elle disparaît rejoindre Aristote, Bool, Gödel et les autres.

Evidemment, chaque Adepte est interloqué et dévisage les autres, comptant les marques de ses acolytes. Mais “comment savoir si l’on est soi-même marqué ?”, se demande chacun en se retirant dans sa sobre cellule, où tout miroir est évidemment proscrit. Ainsi s’achève ce qu’il est convenu d’appeler le jour zéro.

Le lendemain, tous les adeptes viennent manger, aucun n’ayant pu se convaincre qu’il est lui-même marqué. De même le second jour, puis le troisième, le quatrième, le cinquième et le sixième jour, tous les adeptes sont là.

Mais le septième jour soudain, tous les pécheurs manquent à l’appel. Combien y’en a-t-il ? Et comment ont-ils su qu’ils étaient marqués ?

Si vous séchez (et je suis sur que vous allez sécher…) un petit truc : supposez qu’il y un seul adepte marqué et demandez-vous ce qui se passera. Puis refaites le raisonnement avec 2 marqués etc.

publié dans le journal interne de Charmilles Technologies en 1999

Pesée des boules

Wed, 21 Jul 1999 00:00:00 +0000

On a 12 billes de billard dont l’une est soit plus lourde soit plus légère que les 11 autres. Il s’agit de la trouver à l’aide d’une balance à fléau (qui compare le poids des boules placées sur ses deux plateaux) en 3 pesées maximum.

Voici une méthode mathématiquement rigoureuse permettant de résoudre ce problème et d’autres du même type

Solution Générale

Chaque pesée peut donner 3 résultats : équilibré (noté 0), penche à gauche (noté 1) ou penche à droite (note 2)

Comme on a 3 pesées, le résultat des 3 pesées peut être noté en ternaire (base 3) par un nombre à 3 chiffres : par exemple “201” signifie : 1ère pesée penche à droite, seconde équilibrée, troisième à gauche.

Entre parenthèses, l’information contenue dans ce nombre est suffisante pour que l’on puisse distinguer à la fois quelle boule est truquée et dans quel sens : en effet il y a 3^3=27 combinaisons de pesées possible alors qu’il y a 12*2=24 possibilités de solutions.

Il suffit donc de “coder” les 12 balles par deux nombres en base 3, l’un donnant la séquence de pesée correspondant si la balle en question est trop lourde, l’autre la séquence correspondant à une bille trop légère. Evidemment, ces deux nombres en ternaire doivent êtres tels que les 1 du premier nombre sont des 2 dans le second et vice versa. De plus, il faut veiller à ce que le nombre de “1” dans chaque colonne des nombres ternaires corrresponde au nombre de “2”. Voici un codage possible :

bille 1 2 3 4 5 6 7 8 9 10 11 12
trop lourde 001 010 011 012 100 101 102 220 222 221 210 122
trop legere 002 020 022 021 200 202 201 110 111 112 120 211

En lisant la table, on détermine les 3 pesées à effectuer de la manière suivante : si le chiffre correspondant du code “trop lourde” est un 1, la bille est placée à gauche, si c’est un 2 elle est placée à droite, si c’est un 0 elle n’est pas présente dans la pesée :

pesée à gauche à droite
1 5+6+7+12 8+9+10+11
2 2+3+4+11 8+9+10+12
3 1+3+6+10 4+7+9+12

Exemple

Si vous ne croyez pas la démonstration ci-dessus, il ne reste plus qu’à vérifier de la manière suivante. par exemple :

Si la bille 10 est trop légère, alors en consultant la table des pesées on voit que la balance penchera à gauche à la première pesée, à gauche à la seconde et à droite à la troisième, ce qui donne “112”. En regardant la table des codes on voit que “112” correspond effectivement à “bille 10 trop légère”.

Si les trois pesées penchent successivement à droite, puis à gauche, puis est équilibrée (code 210), on voit dans la table des codes que ça correspond à “bille 11 trop lourde”. En consultant la table des pesées, on voit que la bille 11 est effectivement à droite à la première pesée, à gauche à la seconde et n’apparaît pas à la troisième.

Pour voir si vous avez compris, montrez qu’avec 5 pesées on peut trouver une bille truquée parmi 39…

publié lundi 21 juin 1999 dans le journal interne de Charmilles Technologies

x/heure	1	2	3	4	5	6	7	8	9
1	(a)	(a)	(a)	(a)	(a)	(a)	(a)	(a)	(a)
2	(b)	(b)	(b)	(b)	(b)	(b)	(b)	(b)	(b)
3	(g)	(e)	(d)	(c)	(m)	(h)	(m)	(m)	\(\sqrt{9}+9-9\)
4	(i)	(l)	(e)	(d)	(c)	\(\sqrt{66}\overline{.6}\)	(j)	\(8-\sqrt{8+8}\)	\(\sqrt{9}+9/9\)
5	\(\sqrt{1/\overline{.1}}! -1\)	(i)	\(3!-3/3\)	(e)	(d)	(c)		(j)	\(\sqrt{9}!-9/9\)
6	\((1+1+1)!\)	(g)	\(3!+3-3\)	\((4-4/4)!\)	(e)	(d)	(c)	\(8-\sqrt{\sqrt{8+8}}\)	(j)
7	(h)	\(3!+3/3\)	\((4!+4)/4\)		(e)	(d)	(c)	\(9-\sqrt{9}+\overline{.9}\)
8	(h)	\(222\)	\((3!/3)^3\)	\(4!-4*4\)	(i)	\((6+6)*\overline{.6}\)	(e)	(d)	(c)
9	(k)	(k)	(g)	(k)	(k)	(k)	(k)	(e)	(d)
10	\(11-1\)			\(4+4+\sqrt{4}\)	(l)	\(6+6*\overline{.6}\)	(i)	\(8+\sqrt{\sqrt{8+8}}\)	(e)
11	(f)	(f)	(f)	(f)	(f)	(f)	(f)	(f)	(f)
12	\(11+1\)	\((2+2)!/2\)	\(3*3+3\)	(g)	\(5!/(5+5)\)	(l)		\(8+\sqrt{8+8}\)	\(9+9/\sqrt{9}\)