Voici une adaptation tactile du célèbre jeu de logique WaterSort Puzzle, spécialement conçue pour la calculatrice HP Prime en langage Python. Le principe est simple, mais diaboliquement addictif : vous devez verser les couleurs d’un tube à l’autre pour que chaque tube contienne qu’une seule couleur.

Au départ, les couleurs sont mélangées dans plusieurs tubes. À chaque tour, vous pouvez déplacer un empilement de couleur d’un tube vers un autre, à condition que la couleur soit identique ou que le tube soit vide. L’objectif est de reconstituer les couleurs uniformément dans chaque tube, sans déborder.

💡 Ce jeu fait appel à la logique, à l’anticipation… et un peu à votre patience !

Fonctionnalités :

• Interface graphique simple et intuitive adaptée à l’écran de la HP Prime
• Affichage coloré dynamique (jusqu’à 8 couleurs différentes)
• Bouton ® pour recommencer le niveau si vous êtes bloqué
• Détection automatique de victoire

Vous trouverez ci-dessous le code source complet ainsi que le fichier watercolor.hpprgm (fonctionne avec la version 2.1 du 13/04/2023 et les suivantes) :

#python jeu
from hpprime import *
from urandom import choice

couleurs_rgb = {
    "a": 0x845ec2,
    "b": 0xd65db1,
    "c": 0xff6f91,
    "d": 0xff9671,
    "e": 0xffc75f,
    "f": 0xf9f871,
    "g": 0x9bde7e,
    "h": 0x4bbc8e
}
liste_couleurs = list(couleurs_rgb.keys())

LARGEUR_TUBE = 20
HAUTEUR_TUBE = 60
ESPACEMENT_X = 80
ESPACEMENT_Y = 74
MARGE_X = 45
MARGE_Y = 20
COLONNES = 3
LIGNES = 3
TOTAL_COULEURS = 7
NOIR = 0x000000
BLANC = 0xFFFFFF
BG = 0x03132C

def position_tube(index):
    col = index % COLONNES
    lig = index // COLONNES
    x = MARGE_X + col * ESPACEMENT_X
    y = MARGE_Y + lig * ESPACEMENT_Y
    return x, y

def attendre_clic():
    while True:
        f1, _ = eval('mouse')
        if f1:
            while eval('mouse')[0]: pass
            return f1[:2]

def tube_clique(x, y):
    for i in range(9):
        tx, ty = position_tube(i)
        if tx - ESPACEMENT_X / 2 < x < tx + LARGEUR_TUBE + ESPACEMENT_X / 2 and ty <= y <= ty + HAUTEUR_TUBE:
            return i
    return None

def dessiner_tubes(tubes, selectionne=None):
    fillrect(0, 0, 0, 320, 240, BG, BG)
    for i, tube in enumerate(tubes):
        x, y = position_tube(i)
        bordure = 0x00FF00 if i == selectionne else BLANC
        rect(0, x-2, y-2, LARGEUR_TUBE+4, HAUTEUR_TUBE+4, bordure)
        rect(0, x-3, y-3, LARGEUR_TUBE+6, HAUTEUR_TUBE+6, bordure)
        fillrect(0, x, y-3, LARGEUR_TUBE, 3, BG, BG)
        h = HAUTEUR_TUBE // 4
        for j, couleur in enumerate(tube):
            c = couleurs_rgb.get(couleur)
            fillrect(0, x, y + HAUTEUR_TUBE - (j + 1)*h, LARGEUR_TUBE, h, c, c)
    # Bouton recommencer
    textout(0, 270, 110, chr(174), BLANC)

def sommet_identique(tube):
    if not tube: return None, 0
    sommet = tube[-1]
    compteur = 1
    for i in range(len(tube)-2, -1, -1):
        if tube[i] == sommet: compteur += 1
        else: break
    return sommet, compteur

def peut_verser(depuis, vers):
    if not depuis or len(vers) >= 4:
        return False
    couleur, nb = sommet_identique(depuis)
    if not vers: return True
    return vers[-1] == couleur

def verser(depuis, vers):
    if not peut_verser(depuis, vers): return
    couleur, nb = sommet_identique(depuis)
    espace = 4 - len(vers)
    a_verser = min(nb, espace)
    for _ in range(a_verser):
        vers.append(depuis.pop())

def generer_tubes():
    couleurs = []
    for couleur in liste_couleurs[:TOTAL_COULEURS]:
        couleurs += [couleur]*4
    melange = []
    while couleurs:
        c = choice(couleurs)
        couleurs.remove(c)
        melange.append(c)
    tubes = [melange[i*4:(i+1)*4] for i in range(TOTAL_COULEURS)]
    tubes += [[] for _ in range(9 - TOTAL_COULEURS)]
    return tubes

def a_gagne(tubes):
    for tube in tubes:
        if not tube: continue
        if len(tube) != 4: return False
        if any(c != tube[0] for c in tube): return False
    return True

def afficher_message_gagne():
    fillrect(0, 50, 90, 220, 60, BLANC, couleurs_rgb["d"])
    textout(0, 85, 105, "Bravo ! Vous avez gagné", NOIR)
    fillrect(0, 110, 130, 100, 25, BLANC, couleurs_rgb["g"])
    textout(0, 130, 135, "REJOUER", NOIR)

def attendre_redemarrage():
    while True:
        x, y = attendre_clic()
        if 110 <= x <= 210 and 130 <= y <= 155: return

def bouton_redemarrer(x, y):
    return 260 <= x <= 300 and 80 <= y <= 130

def main():
    while True:
        tubes = generer_tubes()
        tubes_depart = [tube[:] for tube in tubes]
        selection = None
        while True:
            dessiner_tubes(tubes, selection)
            if a_gagne(tubes):
                afficher_message_gagne()
                attendre_redemarrage()
                break
            x, y = attendre_clic()
            if bouton_redemarrer(x, y):
                tubes = [tube[:] for tube in tubes_depart]
                selection = None
                continue
            index = tube_clique(x, y)
            if index is None:
                selection = None
                continue
            if selection is None:
                if tubes[index]: selection = index
            elif selection == index:
                selection = None
            else:
                verser(tubes[selection], tubes[index])
                selection = None

main()
#end

EXPORT watercolor()
BEGIN
  wait(.3);
  python(jeu);
END;

En parcourant le livre « Mathematiques et graphismes » de 1985, j’ai trouvé page 41 un programme intéressant en BASIC (pour TO7/Apple/Commodore 64/Oric etc) permettant de tracer une enveloppe de droites (de la forme ax+by+c = 0). En faisant varier a,b et c en fonction d’un paramètre (noté t dans le programme), on obtient des visuels sympathiques :

Traduction en Python (avec 18 exemples)

Version pour la NUMWORKS ici.

import turtle
from math import *
from time import sleep

t = turtle.Turtle()
t.hideturtle()
t.pensize(2)

w, h = 800, 600

wn = turtle.Screen()

wn.colormode(255)
t.pencolor(255, 255, 0)


def ex0():
    def g(t):
        return 2 - t * t, -2 * t, t**3

    return g, -5, 5, -2, 1.5, -3, 3


def ex1():
    def g(t):
        return cos(3 * t), sin(3 * t), sin(t) ** 2

    return g, -1, 1, -1.1, 1.1, 0, 2 * pi


def ex2():
    def g(t):
        return cos(3 * t), sin(3 * t), cos(t)

    return g, -1.2, 0.8, -1.2, 1.2, -pi / 2, pi / 2


def ex3():
    def g(t):
        return cos(t), sin(t), exp(-exp(-t / 5))

    return g, -2, 2, -2, 3, -5, 10


def ex4():
    def g(t):
        return cos(t), sin(t), -sin(t) / t

    return g, -0.3, 1.2, -0.9, 0.9, -5, 5


def ex5():
    def g(t):
        return cos(t), sin(t), -1 - int(t / 2 / pi)

    return g, -6, 6, -6, 6, 0, 10 * pi


def ex6():
    def g(t):
        return cos(t), sin(t), 1 / t

    return g, -2, 2, -1, 0.5, -10, 10


def ex7():
    def g(t):
        return cos(t), sin(t), log10(t)

    return g, -4, 4, -4, 4, 0.2, 20


def ex8():
    def g(t):
        return cos(t), sin(t), t * t * sin(t)

    return g, -4, 4, -10, 3, -pi, pi


def ex9():
    def g(t):
        return cos(t), sin(t), t * t / (1 + t * t)

    return g, -1, 1, -1, 1, -2 * pi, 2 * pi


def ex10():
    def g(t):
        return cos(t), sin(t), (1 - t * t) / (1 + t * t)

    return g, -1.5, 1.5, -1.5, 1.5, -2 * pi, 2 * pi


def ex11():
    def g(t):
        return cos(t), sin(t), sqrt(abs(t))

    return g, -4, 4, -4, 4, -10, 10


def ex12():
    def g(t):
        return cos(t), sin(t), t / (1 + t)

    return g, -3, 3, -3, 3, -10, 10


def ex13():
    def g(t):
        return cos(t), sin(t), 2 + cos(t / 2)

    return g, -4, 4, -4, 4, -2 * pi, 2 * pi


def ex14():
    def g(t):
        return cos(t), sin(t), -0.5 + cos(t / 2)

    return g, -2, 2, -2, 2, -2 * pi, 2 * pi


def ex15():
    def g(t):
        return cos(t), sin(t), t * t * sin(t)

    return g, -4, 4, -10, 3, -pi, pi


def ex16():
    def g(t):
        return cos(t), sin(t), t * t / (1 - t * t)

    return g, -1.5, 2, -2, 2, -2 * pi, 2 * pi


def ex17():
    def g(t):
        return cos(t), sin(t), sin(t) + sin(t) ** 2 / 2 + sin(t) ** 3 / 3

    return g, -2, 2, -3, 0, -pi, pi


def tracer(x, y):
    global f, pts
    if x < xi or x > xs or y < yi or y > ys:
        return
    f += 1
    pts[f] = [
        -w / 2 + ceil(w * (x - xi) / (xs - xi)),
        -h / 2 + ceil(h * (y - yi) / (ys - yi)),
    ]
    if f == 1 and pts[0] == pts[1]:
        f = -1
    elif f == 1:
        t.penup()
        t.goto(pts[0])
        t.pendown()
        t.goto(pts[1])


t.hideturtle()
for k in range(18):
    turtle.Screen().bgcolor(0, 0, 0)
    t.clear()
    wn.tracer(0)
    g, xi, xs, yi, ys, ti, ts = eval("ex" + str(k) + "()")
    pts = [[0, 0], [0, 0]]
    n = 200
    th = (ts - ti) / (n - 1)
    for i in range(n):
        try: a, b, c = g(ti + i * th)
        except: continue
        f = -1
        if b != 0:
            tracer(xi, -(c + a * xi) / b)
            tracer(xs, -(c + a * xs) / b)
        if a != 0:
            tracer(-(c + b * yi) / a, yi)
            tracer(-(c + b * ys) / a, ys)
    wn.update()
    sleep(2)

Outils

Simulateur 8080 : https://www.sim8085.com

Création d’un fichier binaire : https://www.asm80.com/

Simulateur ALTAIR 8800 : https://s2js.com/altair/sim.html

Tous les codes (00.MEM = 3n+1, 01.MEM = n/2, 02.MEM = pair/impair + saut, 03.MEM = avec temps de vol, 04.MEM = avec maximum, 16bits.bin = version 16 bits) : https://uabox.univ-angers.fr/s/o96B5MEfeQAcXLA

Chargement d’une bande perforée : https://youtu.be/qv5b1Xowxdk?feature=shared&t=235

Calcul de 3n+1

Mettre une valeur N en 80h puis lancer le programme ci-dessous
Lire en 80h la valeur 3N+1 (modulo 256)

HEXA : 3A80004787803C32800076

Programme source :

LDA 80h
MOV B, A
ADD A
ADD B
INR A
STA 80h
HLT

Programme objet :

3A 80 00   LDA 80h
47         MOV B, A
87         ADD A
80         ADD B
3C         INR A
32 80 00   STA 80h
76         HLT

Division par 2

Mettre une valeur N en 80h puis lancer le programme ci-dessous
Lire en 80h la valeur ENT(N/2)

HEXA : 373F3E1B1F32800076

Programme source :

STC
CMC
MVI A, 27
RAR
STA 80h
HLT

Sauts avec tests pair ou impair

HEXA : 3A800047FE01CA2100E60178CA180087803C328000C30000373F1F328000C3000076

Programme source :

loop: 	LDA 80h
	MOV B, A
        CPI 1
	JZ fin
	ANI 1
	MOV A, B
	JZ pair
	ADD A
	ADD B
	INR A
	STA 80h
	JMP loop
pair:	STC
	CMC
	RAR
	STA 80h
	JMP loop
fin:	HLT 

Version 1 avec temps de vol uniquement

HEXA : 3E003281 003A8000 47FE01CA 2E003A81 003C3281 0078E601 78CA2500 87803C32 8000C305 00373F1F 328000C3 050076

Programme source :

MVI A, 0
STA 81h
loop: 	LDA 80h
	MOV B, A
CPI 1
	JZ fin
	LDA 81h
	INR A
	STA 81h
	MOV A, B
	ANI 1
	MOV A, B
	JZ pair
	ADD A
	ADD B
	INR A
	STA 80h
	JMP loop
pair:	STC
	CMC
	RAR
	STA 80h
	JMP loop
fin:	HLT 

Version 2 avec temps de vol et maximum

HEXA : 3E003281 003A8000 3282003A 800047FE 01CA4000 3A81003C 32810078 E60178CA 37008780 3C328000 473A8200 B8D20B00 78328200 C30B0037 3F1F3280 00C30B00 76

Programme source :

MVI A, 0
STA 81h
LDA 80h
STA 82h

loop: 	LDA 80h
	MOV B, A
        CPI 1
	JZ fin
	LDA 81h
	INR A
	STA 81h
	MOV A, B
	ANI 1
	MOV A, B
	JZ pair
	ADD A
	ADD B
	INR A
	STA 80h
	MOV B, A
    	LDA 82h
    	CMP B
    	JNC loop
    	MOV A, B
    	STA 82h
	JMP loop
pair:	STC
	CMC
	RAR
	STA 80h
	JMP loop
fin:	HLT 

Version 16 bits

Mettre la partie basse de N en 80h et la partie haute en 81h. Par exemple pour 27 : 00 011 011 en 80h et 00 000 000 en 81h

Lire le temps de vol en 84h et le maximum aux adresses 82h (partie basse) et 83h (partie haute)

2A 80 00	LHLD 80H 	; Initialisation des mémoires 82h à 84h
22 82 00	SHLD 82H 	; copie de 80-81h vers 82-83h
21 84 00	LXI H, 84H	;
36 00		MVI M, 0 	; Temps de vol = 0
21 81 00 collatz: LXI H, 81H	
7E		MOV A, M  	; Si la valeur haute
B7		ORA A     	; n'est pas nulle
C2 1A 00	JNZ parity 	; On va tester la parité 
2B		DCX H       	; sinon,
7E		MOV A, M	; Si la valeur basse
FE 01		CPI 1       	;  vaut 1
CA 5D 00	JZ fin	        ; on arrête le programme
21 84 00 parity:LXI H, 84H	
34		INR M     	; temps de vol augmente de +1
21 80 00	LXI H, 80H	
7E		MOV A, M	
5F		MOV E, A    	; que l'on stocke dans E
E6 01		ANI 1       	; Si Z = 0
CA 3A 00	JZ pair     	; C'est un nombre pair
23		INX H	
56		MOV D, M	
D5		PUSH D	
E1		POP H	        ; HL = DE
29		DAD H	        ; HL = 2HL
19		DAD D	        ; HL = 3HL
23		INX H	        ; HL = 3HL + 1
22 80 00	SHLD 80h    	; Nouvelle valeur en 80h
E5		PUSH H	
D1		POP D    	; On la stocke dans DE
CD 46 00	CALL maxi	; Sous-routine maxi
C3 0B 00	JMP collatz 	; Retour à collatz
23	  pair: INX H  	        ; Si le nombre est pair
AF		XRA A         	; Carry = 0
7E		MOV A, M      	; Division par 2
1F		RAR           	; de la partie haute
77		MOV M, A	
2B		DCX H	
7E		MOV A, M      	; division par 2 de la partie basse
1F		RAR           	; avec ajout éventuel de C à gauche
77		MOV M, A	;
C3 0B 00	JMP collatz   	; Retour à collatz
2A 82 00  maxi:	LHLD 82H	;
7A		MOV A, D      	; Récup partie haute du max
BC		CMP H         	; si égalité des parties hautes
CA 52 00	JZ unite      	; tester les unités
D2 58 00	JNC change    	; si retenue le max a été dépassé
C9		RET           	; sinon ne rien faire
7B	unite:	MOV A, E   	; test des unités
BD		CMP L           ; si une retenue
DA 58 00	JC change     	; le max est dépassé
C9		RET           	; retour
EB	change:	XCHG  	        ; HL = DE
22 82 00	SHLD 82H	; que l'on place en 82h
C9		RET	
76	fin:	HLT	

Résultats à obtenir aux adresses 82-83h et 84h

00 010 000 en 82h (partie basse) et 00 100 100 en 83h (haut) 

parseInt('0010010000010000',2)
9232

01 101 111 à l'adresse 84h : 

parseInt('01101111',2)
111

Résultats pour N = 639

>>> bin(639)
'0b1001111111'

Il faut donc mettre 01 111 111 à l'adresse 80h et 10 à l'adresse 81h

On lance le programme et on trouve :

Adresse 82h : 00 110 100
Adresse 83h : 10 100 010

Le maximum vaut donc :

>>> int('1010001000110100',2)
41524

Et le temps de vol est à l'adresse 84h : 10 000 011

>>> int('10000011',2)
131

Sur cette page de Wolfram, on peut voir différentes fractales :

Et en bas de cette même page les algorithmes utilisés pour transformer les cases :

Ci-dessous un programme Python qui permet d’appliquer le motif voulu, il suffit d’indiquer les coordonnées des cases blanches. Par exemple pour le (a), la seule case blanche est au milieu (coordonnées (1,1))

from PIL import Image, ImageDraw
import numpy as np

# Dimensions de l'image finale (à modifier comme vous le voulez)
source = Image.new("RGB", (600, 600), color="white")
draw = ImageDraw.Draw(source)

# Recherche s'il y a une case blanche
def has_common(str1, str2, pattern):
    min_len = min(len(str1), len(str2))
    for i in range(1, min_len + 1):
        for p in pattern:
            # Ne pas afficher si on trouve une case blanche
            if str1[-i] == p[0] and str2[-i] == p[1]:
                return False
    # Sinon case noire
    return True

# Construction de la fractale
def fractal(pattern):
    # On parcourt les colonnes
    for c in range(600):
        # Convertir 'c' en base 3 (ici à l'aide de numpy)
        t1 = np.base_repr(c, base=3)
        # On parcourt les lignes
        for l in range(600):
            t2 = np.base_repr(l, base=3)
            # Si pas de case blanche, afficher le point
            if has_common(t1, t2, pattern):
                draw.point((c, l), fill=(0, 0, 0))

# Exemple avec le tapis de Sierpiński
fractal(["11"])
source.show()

Quelques motifs

Et on peut en inventer de nouveaux :

Exercice 1

Écrire un programme qui cherche tous les mots de 5 lettres pouvant être formés à partir de mots de 9 lettres en prenant 1 lettre sur 2, en commençant par la première lettre. Exemples :

Vous pouvez utiliser ces 2 dictionnaires (mots de 9 et 5 lettres) : https://uabox.univ-angers.fr/s/b3GotFzpTYkL4MT

Corrigé en python

with open('dictionary_9.txt', 'r') as f:
    dictionary_9 = [line.strip() for line in f]

with open('dictionary_5.txt', 'r') as f:
    dictionary_5 = set(line.strip() for line in f)

compte = 0                      # Nb de mots trouvés

for word9 in dictionary_9:
  word5 = word9[::2]            # une lettre sur deux
  if word5 in dictionary_5:     # Si le mot existe
    print(word9, word5)         # on l'affiche
    compte += 1                 # et le compteur augmente de +1
print(f"Total = {compte}")  

Résultat :

ABLATIONS ALTOS
ABLUTIONS ALTOS
ABREGEAIS ARGAS
ABROGEAIS ARGAS
ABSTIENNE ASINE
ACCONIERS ACNES
...
VIELLEUSE VELUE
VIELLIONS VELOS
VIENDRAIS VEDAS
VOILETTES VIETS
Total = 913

corrigé en javascript

Cliquez sur ce lien puis bouton droit – Inspecter – Console. Copiez-collez le code suivant :

 dictionary_9.reduce((a, m) => {
     var mot5 = m.slice(0,2)+m[4]+m.slice(-2);
     return dictionary_5.includes(mot5) ? [...a, [m, mot5]] : a 
  }, [])

Exercice 2

Identifiez tous les mots de 10 lettres qui peuvent être composés de 2 mots de 5 lettres en respectant l’ordre des lettres. Exemple : RACHIDIENS s’écrit à partir de CHIEN et RADIS

Comme il y a beaucoup de solutions, on peut créer une fonction qui admet en paramètre un mot de 5 lettres et qui renvoie tous les mots de 10 lettres contenant ce mot ainsi que l’autre mot de 5 lettres pour compléter. Exemples :

>>> trouve("CHIEN")
BANCHAIENT CHIEN BANAT
CHARMAIENT CHIEN ARMAT
CHERRAIENT CHIEN ERRAT
CHIADERENT CHIEN ADRET
CHIENDENTS CHIEN DENTS
CHTHONIENS CHIEN THONS
CHTONIENNE CHIEN TONNE
CRASHAIENT CHIEN RASAT
DOUCHAIENT CHIEN DOUAT
LOUCHAIENT CHIEN LOUAT
MATCHAIENT CHIEN MATAT
RACHIDIENS CHIEN RADIS
TOUCHAIENT CHIEN TOUAT
TRICHAIENT CHIEN TRIAT

Corrigé en python

with open('dictionary_10.txt', 'r') as f:
    dictionary_10 = [line.strip() for line in f]

with open('dictionary_5.txt', 'r') as f:
    dictionary_5 = set(line.strip() for line in f)

def is_included(word1, word2):
    positions = []
    index = 0
    for letter in word2:
        index = word1.find(letter, index)
        if index == -1: return False
        positions.append(index)
        index += 1      
    return positions

def trouve(word5):
 for word10 in dictionary_10:
  positions = is_included(word10, word5)  
  if positions:
    reste = ''.join(word10[i] for i in range(10) if i not in positions)
    if reste in dictionary_5:
       print(word10, word5, reste)

exercice 3

Ci-dessous un jeu très simple trouvé dans le journal TV Télé Z. Dans notre cas nous allons travailler avec des mots de 9 et 5 lettres.

But : créer un programme qui, à partir d’une liste de mots de 5 lettres, va rechercher autant de mots de 9 lettres les contenant.

>>> jeu(["AIDER","CAPTER","GAINE","LOGER","FILES"])
PYRAMIDER AIDER PYR-M----
CAPTERAIT CAPTER ------AIT
GRAINIERS GAINE -R---I-RS
PLONGEOIR LOGER P--N--OI-
FILONIENS FILES ---ONI-N-

corrigé en python

from random import choice

with open('dictionary_9.txt', 'r') as f:
    dictionary_9 = [line.strip() for line in f]

with open('dictionary_5.txt', 'r') as f:
    dictionary_5 = set(line.strip() for line in f)

def is_included(word1, word2):
    positions = []
    index = 0
    for letter in word2:
        index = word1.find(letter, index)
        if index == -1: return False
        positions.append(index)
        index += 1      
    return positions

def trouve(word5):
 res = []         # On cherche toutes les solutions
 for word9 in dictionary_9:
  positions = is_included(word9, word5)  
  if positions: res.append((word9, positions))
 if len(res) > 0: return choice(res)      # on renvoie une solution au hasard
 return False

def jeu(arr):
 for mot in arr:
  r = trouve(mot)
  if r:     # Si un mot de 9 lettres a été trouvé
   cache = ''.join(r[0][i] if i not in r[1] else '-' for i in range(9))
   print(r[0], mot, cache)
  else: print(f"Rien trouvé pour {mot}")