My Python Scripts

Écrire une fonction “adn” qui admet en paramètre une chaine de caractères et renvoie “Brin ADN” si les caractères sont uniquement des A, T, C et G ou “Pas ADN” si d’autres lettres sont présentes.

Enoncé de l’exercice Visitez ma chaine YouTube

Alice découvre la Numworks et tombe au pays des…

La fonction aff affiche du texte (txt) à la position (x,y), de taille t, de couleur fg (ex : (255,0,0) pour du rouge). Les 3 derniers paramètres sont optionnels et permettent d’ajouter une couleur de fond bg, d’avoir des traits verticaux (a=1,b=0), horizontaux (a=0,b=1), unis (a=0,b=0) ou carrés (a=1,b=1) Attention ! Le programme a besoin d’utiliser les pixels entre (0,0) et (8,17), il ne faut donc rien afficher dans cette zone ou alors la déplacer (lignes 6 et 12) Vous pouvez donner d’autres valeurs à a et b, voici un exemple avec le résultat obtenu : aff('Score',20, -5, 6, BL,GR,a=3,b=-2) aff('0123456789',20,85,3,RE,a=2,b=2) for i in range(26): aff(chr(97+i),25+10*i,132,1,BL,GR,-2,0) aff(chr(65+i),25+10*i,172+30*(i%2)-15,2,[BL,RE][i%2],a=-1,b=-2)

Calendrier 2022 Utilisez les flèches haut et bas pour naviguer dans le calendrier. Ma playlist Youtube consacrée à la NUMWORKS Explications du programme from kandinsky import draw_string, fill_rect from ion import keydown,KEY_UP,KEY_DOWN from time import sleep nbjMois = "303232332323" # 28 + nb de jours dans le mois (28+3 pour janv, 28 + 0 pour février etc.) jSem = "LMmJVSD" mois = "Janv,Fev, Mars,Avril,Mai,Juin,Juill,Aout,Sept,Oct,Nov,Dec".split(',') def aff(d): nb = 0 v = 5 # le 1/1/2022 etait un vendredi for i in range(d): v += int(nbjMois[i]) # on cherche le 1er du mois n°d v %= 7 while nb < 2: # Affichage de 2 mois m = d + nb for i,js in enumerate(jSem): # Ligne des jours de la semaine draw_string(js,10 + 30 * i, 5 + 110 * nb) l = 1 for j in range(28 + int(nbjMois[m])): # on parcourt tous les jours du mois pos = jSem.index(jSem[v]) # dans quelle colonne est ce jour de la semaine ? draw_string(str(j + 1),10 + 30 * pos, 5 + 110 * nb + 15 * l) v = (v + 1) % 7 if pos == 6: l += 1 # Si dimanche on passe à la ligne suivante draw_string(mois[m], 250, 110 * nb + 30) nb += 1 def eff(): fill_rect(0,0,320,222,(255,255,255)) sleep(.2) def key(): # attente touche while True: for (i, k) in enumerate([KEY_UP,KEY_DOWN]): if keydown(k): return 2 * i - 1 # renvoyer -1 ou +1 d = 0 while True: aff(d) t = key() d = (d + 2 * t) % 12 # on avance ou recule dans le calendrier eff()

Ma playlist consacrée à la NUMWORKS

Attention, à cause de la boucle infinie, ce script ne fonctionnera que sur votre calculatrice et pas dans l’émulateur. Appuyez sur la touche “Retour” pour arrêter le programme.

Source : http://www.peda.com/grafeq/gallery.html Chrome : https://my.numworks.com/python/schraf/chrome Sphère : https://my.numworks.com/python/schraf/sphere Margarita : https://my.numworks.com/python/schraf/margarita Threesome : https://my.numworks.com/python/schraf/threesome The Big Swim : https://my.numworks.com/python/schraf/bigswim

But de nos automates: Reconnaitre un langage Alphabet Σ : par exemple constitué de 2 lettres {a, b} Mots créés à partir de l’alphabet Σ : par exemples aaa, ababab, bbaaa, etc. Un automate va être un ensemble d’états (cercles) et de transitions (flèches) Un état initial (pour nous il n’y en aura qu’un seul et ce sera toujours le cercle de numéro “0”) et un ou plusieurs états finaux (cercles doubles) Un mot est accepté lorsque l’on arrive dans un état final sinon il est rejeté. Automate n°1 Cet automate accepte-t-il le mot “ba” ? Réponse : NON, car en partant de l’état 0, la lettre “b” nous amène au cercle 1 puis le “a” nous ramène à l’état 0. Or cet état n’est pas un état final (pas de cercle double comme pour le 1). Donc le mot est refusé. Cet automate accepte-t-il le mot “abbb” ? Réponse : OUI, le “a” nous amène au cercle 1 puis on y reste avec les 3 “b”. Intuitivement, quels mots reconnait cet automate ? Réponse : Que l’on soit en 0 ou en 1, la lettre “a” nous ramène en 0. Pour arriver en 1 il faudra donc que la dernière lettre soit obligatoirement un “b”. Inversement, il suffit que le mot se termine par un “b” pour arriver à l’état final 1. Cet automate reconnait tous les mots (écrits avec l’alphabet Σ = {a, b} qui se terminent par “b”) Automate n°2 Il ressemble beaucoup au précédent mais il ne reconnait pas du tout le même langage ! Cet automate accepte-t-il le mot “ba” ? Réponse : OUI Cet automate accepte-t-il le mot “aa” ? Réponse : NON Cet automate accepte-t-il le mot “abbaabb” ? Réponse : OUI Intuitivement, quels mots reconnait cet automate ? Réponse : Les mots qui contiennent un nombre impair de “a” On re

Il faut avoir fait l’activité automate_n1.py avant de regarder celle-ci. Automate n°2 de l'activité n°1 Imaginons que l’alphabet de cet automate soit beaucoup plus grand (par exemple Σ correspond à toutes les lettres de l’alphabet). Dans ce cas il devient quasi impossible de dessiner toutes les flèches. Ce que nous voulons est donc ( Σ - a signifie “Toutes les lettres sauf le “a”) Pour cela nous allons tout simplement renseigner uniquement les transitions qui sont utiles et oublier toutes les autres (celles qui font rester sur place). Finalement, l’automate ci-dessus se réduit à a2 = [{"a":1},{"a":0}] Comment s’écrit la version simplifiée de l’automate n°1 de l’activité 1 ? Réécrire les 2 fonctions accepte et details de l’activité n°1 pour qu’elles acceptent ces automates simplifiés en paramètres.

Inspiré par un commentaire de Numworks France Ce script utilise une technique que j’ai décrite ici Un autre exemple ici

Playlist NUMWORKS de ma chaine Youtube Version TikTok Version en JavaScript de Maxime Richard Vous pouvez effacer la dernière ligne “sleep(0.01)” pour que l’animation aille beaucoup plus vite sur votre calculatrice.

Nombre de façons d’écrire 5 paires de parenthèses bien formées.

Traduction en Python du script BASIC ci-dessous (“Creative Graphics on the BBC Microcomputer” John Cownie): Variation from turtle import * from math import * from kandinsky import fill_rect speed(0) hideturtle() fill_rect(0,0,320,222,(0,)*3) def s(a): return 120 * sin(a / 10) for a in range(1258): x, y = s(a), cos(a / 10) * s(a * .95) c = int((x * x + y * y) / 2200) pensize(7 - c) color(255 - 30 * c, 0, 0) goto(x,y)

Source : http://www.peda.com/grafeq/gallery.html Chrome : https://my.numworks.com/python/schraf/chrome Sphère : https://my.numworks.com/python/schraf/sphere Margarita : https://my.numworks.com/python/schraf/margarita Threesome : https://my.numworks.com/python/schraf/threesome Arachnid : https://my.numworks.com/python/schraf/arachnid

Autres exemples de tracés binaires ici

Représentation binaire des puissances 1, 2 et 3 des entiers entre 0 et 160. On bas de l’écran on lit 1, 10, 11, 100… (1 = rectangle noir, 0 = rectangle blanc) qui correspondent aux entiers 1, 2, 3, 4… Au milieu de l’écran on lit 1, 100, 1001, 10000… qui donnent 1, 4, 9, 16… Et en haut les puissances 3 des entiers.

Représentation binaire des 320 premiers termes de la suite de Fibonacci. Remarques : 1 & n permet de récupérer le bit unité, ce sera “1” si le nombre est impair et “0” sinon. n » 1 est une autre façon de diviser un entier par 2 sans tenir compte des décimales. Version avec la bibliothèque PIL : from PIL import Image, ImageDraw source = Image.new("RGB", (700, 700), color = "white") draw = ImageDraw.Draw(source) x, m = 0, 700 f = [0, 1] for i in range(m): if i < 2: n = i else: f = f[1:] + [sum(f)] n = f[1] j = 0 while n > 0: if 1 & n: draw.point((x, m - j), fill = 'black') j += 1 n >>= 1 x += 1 source.show()

Petits jeux inspirés des épreuves de Blanche dans Fort Boyard. COMBINAISON Vous devez reconstituer une combinaison de 5 balles bleues ou blanches. Vous disposez de 4 essais en niveau 1 et de 3 en niveau 2. Après chaque essai, le nombre de carrés bleus correctement positionnés est indiqué. STOP CHUTE Appuyez sur EXE pour lancer le jeu. Après un temps aléatoire, un carré bleu va apparaitre dans une des 5 cases. Vous devez appuyer sur la touche correspondante de votre calculatrice (1,2,3,+ ou -) dans les 4 dixièmes de seconde (en niveau 1) ou 3 dixièmes de seconde (au niveau 2). Vous avez 3 essais. SOUFFLE Un temps en secondes va s’afficher. Appuyez sur EXE puis comptez ce nombre de secondes dans votre tête et pressez sur la touche +. Le carré bleu se déplace alors vers le carré rouge et vous indique si vous êtes trop loin du temps ou si vous avez gagné. Vous avez 3 essais. Le niveau 1 vous donne un droit à l’erreur de 0,2s et le niveau 2 de 0,1s. from kandinsky import * from random import choice, randint from ion import * from time import sleep,monotonic BL, WH, RO = (80,176,216), (248,252,248), (232,120,88) # Etiquettes (Labels) pour le visuel LAB = "123+-" # Les touches autorisées TOUCHES = [KEY_ONE,KEY_TWO,KEY_THREE,KEY_PLUS,KEY_MINUS] NBJEUX = 3 # Phrases de Blanche PH = ["VOUS AVEZ PERDU !","BRAVO !","RATE !"] # Liste des clés cles = [] pal = [[255,255,255],[169,233,249],...,[100,123,137]] im = "A56B3...A2CB" # --- # Affichage des clés en bleu avec fond orange si perdu def aff_cles(): for i in range(len(cles)): draw_string(chr(254), 10+12*i,200,BL if cles[i] else RO) # --- # Voir vidéo sur l'utilisation de Gimp pour créer la chaine "im" def visage(): r,i = 0,0 while r < len(im): s = im[r] n = "" r += 1 while r < len(im) and "9" >= im[r] >= "0"

Le script d’origine avec les explications est ici : https://my.numworks.com/python/schraf/blanche Ajout d’un 4e jeu nommé “CARRE” et basé sur le jeu CERCLE de Blanche CARRE Un carré de taille variable s’affiche ainsi qu’une jauge à gauche. Appuyez sur + ou - pour définir le niveau de la force que vous voulez appliquer au lancer de votre balle. Appuyez ensuite sur EXE pour la lancer. Celle-ci doit s’arrêter dans la zone orange, si ce n’est pas le cas vous avez 3 essais pour réussir à trouver la bonne force. Remarque : Il est possible que la balle fasse plusieurs tours, ce n’est pas grave, il faut juste qu’elle s’arrête au bon endroit ! Description du code du jeu n°4 # Le carré est numéroté de 0 (en haut à gauche) # et les n° font le tour dans le sens inverse # des aiguilles d'une montre # pos_carre cherche les coord (x,y) suivant le n° i def pos_carre(i, cote): i %= 4 * cote if i <= cote: return 0,i if i <= 2 * cote: return i - cote, cote if i <= 3 * cote: return cote, 3 * cote - i return 4 * cote - i, 0 # Dessin d'une balle pour le jeu 4 def boule4(c,cote,i): x, y = pos_carre(i, cote) boule(0, c, 115 - 11 * cote + 22 * x, 119 - 11 * cote + 22 * y) def jeu4(niv): essai = 0 # Facile = taille 4 ou 5 et Difficile = taille 3 à 5 cote = randint(niv - 1,4) # La force que le joueur doit trouver force = randint(3,16) titre(0, "CARRE") while essai < 3: # Dessin du carré for i in range(4 * cote): boule4(RO if i > 3 * cote else WH, cote, i) # La balle bleue à la position 0 boule4(BL, cote, 0) # Dessin de la jauge à gauche fill_rect(15,80,20,102,BL) fill_rect(16,81,18,100,WH) draw_string("+",20,60,BL) draw_string("-",20,185,BL) # Le joueur choisit la force t,h = 0,0 while t != 2:

Modèle d’origine

Toutes les explications en vidéo ici À la maternelle, l’instituteur a donné des bonbons aux enfants. Le nombre de bonbons que chaque enfant reçoit n’est pas toujours le même. Voici par exemple une distribution possible : [10,2,8,22,16,4,10,6,14,20] L’instituteur a demandé aux enfants de faire un cercle et de jouer à un jeu : chaque enfant donne la moitié de ses bonbons à l’enfant sur sa droite (en même temps). Si le nombre de bonbons est un nombre impair, l’enseignant lui donne un bonbon supplémentaire pour que le partage tombe juste. On répète cette procédure jusqu’à ce que les enfants aient le même nombre de bonbons. Vous devez créer une fonction distrib qui, à partir de la distribution initiale de l’instituteur, affiche les différentes étapes jusqu’à ce que tous les enfants aient le même nombre de bonbons. >> distrib([ 1,2,3,4,5 ]) [ 4,2,3,4,5 ] # Le 1er enfant qui n'a qu'un bonbon reçoit de l'instit un autre bonbon qu'il donne au 2e # Le dernier qui en a 5 reçoit de l'instit un autre bonbon et donne donc 6/2 = 3 au premier enfant # L'enfant n°1 a donc bien 1+3 = 4 bonbons à la première étape [ 5,3,3,4,5 ] [ 6,5,4,4,5 ] [ 6,6,5,4,5 ] [ 6,6,6,5,5 ] [ 6,6,6,6,6 ] Dans cet exemple ont voit que tous les enfants auront 6 bonbons à la fin du jeu.

Animation TikTok

Voilà pourquoi il faut toujours prendre sa Numworks quand on part en vacances ! Imaginez 4 amis : Pierre (noté pi), Audrey (a), Patricia (pa) et Eric (e) - Pour aller au cinéma, Eric a avancé 10 euros à Audrey - Pierre a payé 20 euros l’entrée dans un parc pour les 4 personnes - Patricia a avancé 2 euros à Eric pour une glace - Eric a avancé 24 euros pour l’entrée à la piscine des 4 amis Qui doit combien à qui ?? C’est très simple en utilisant le programme amis : >> amis() Liste amis ? pi,a,pa,e T=tous, 0=fin # On nous dit d'utiliser T pour tous et 0 pour terminer a avance x EUR pr b # l'ordre de saisi est a puis x puis b a,x,b : e,10,a # Eric avance 10 EUR à Audrey a,x,b : pi,20,T # Pierre avance 20 EUR à Tous a,x,b : pa,2,e a,x,b : e,24,T a,x,b : 0 # On a fini Bilan : pi prend 9.0 # Pierre récupère 9 EUR a depose 21.0 # Audrey dépose 21 EUR pa depose 9.0 # Patricia dépose 9 EUR e prend 21.0 # Eric récupère 21 EUR Bien entendu vous pouvez utiliser des nombres à virgule, par exemple : pa,2.50,e.

Art génératif : Partie 2 - Le hasard Art génératif : Partie 1 - Transformations affines

Découvrez ma chaine YouTube (Jeux pour la NUMWORKS, Python…)

D’autres jeux pour la NUMWORKS sur ma chaine Youtube : Rubika, solitaire, Mission missile, démineur, carré magique, TRON, défis de blanche… Une vidéo pour en savoir plus sur ce programme

Vidéo d’explication Programme pour apprendre les lettres de l’alphabet Braille (sans les accents) Dans le menu qui s’affiche, choisir 1 si vous voulez lire des mots écrits en braille (tapez le mot pour vérifier ou simplement touche EXE), choisir 2 pour écrire en braille (touches 1-2-4-5-7-8 du clavier) des lettres de l’alphabet tirées au hasard et 3 pour que la machine écrive en braille le mot que vous taperez.

En savoir plus sur la (more about) fractale “burning ship” : Français | English

Explications en vidéo Autre exemple Des idées de caractères : Symbolïzm / Rune / Gumi

Explications en vidéo Version pour TI-83 Plus , TI-84 Plus, TI-84 Pocket. Mettre le programme sur la calculatrice puis le lancer en faisant 2nde CATALOG Asm( PRGM MERLIN. Vous avez à l’écran Asm(prgmMERLIN puis ENTER Version pour HP Prime Il s’agit de la réécriture de “carré magique” qui existait sur un jeu électronique de 1978 nommé MERLIN. La règle est simple : 9 points sont allumés (noir) ou éteints (gris) Dans la version normale, vous devez allumer tous les points sauf le central (touche 5 du clavier) Les touches 1,3,7 ou 9 du clavier inversent les 4 points d'un côté (un point allumé s'éteint et inversement). Par exemple la touche 1 inverse les points 1,2,4 et 5 Les touches 2,4,6 et 8 inversent les 3 points d'une rangée. Par exemple la touche 2 va inverser la rangée 1-2-3 La touche 5 inverse les points suivant une croix (2,4,5,6 et 8) Une fois que vous serez à l’aise avec la version de base, tentez >> go(2)

Habituellement, lorsque vous achetez un produit, on vous donne un reçu où l’on voit apparaitre les 4 derniers chiffres de votre carte de crédit. Plus généralement, on voudrait une fonction masque qui admet en paramètre une chaine (numéro de la carte de crédit, numéro de téléphone ou autre) et qui en sortie affiche des “*” sauf pour les 4 derniers chiffres. >> masque("123456") '**3456' >> masque("888") '888' >> masque("0620212223") '******2223'

Depuis 2019 le logo est plus simple (pas de bandes à l’intersection), voici un exemple de code : from kandinsky import * RO, OR, ROR, WH = (252,9,17), (254,167,0), (254,105,0), (255,255,255) R = 80 ** 2 for l in range(222): for c in range(320): rouge = (c - 100) ** 2 + (l - 111) ** 2 < R orange = (c - 216) ** 2 + (l - 111) ** 2 < R if rouge and orange: coul = ROR elif rouge: coul = RO elif orange: coul = OR if orange or rouge: set_pixel(c,l,coul)

Basé sur un Tweet de @fesh0r

Suivre une partie de jeu d'échecs Voir les explications en vidéo ici Première partie - Création du plateau et des pièces On reprend l’idée de la vidéo sur les nageurs pour la création des pièces. Inspiration pour la forme des pièces : https://youtu.be/36P26xWokjY

La variable part contient la partie à jouer. Amélioration possible : Appuie d’une touche pour passer au coup suivant Playlist Youtube sur la NUMWORKS (jeux, programmation Python…)

Déplacements possibles pour une pièce blanche sur un échiquier vide. Par exemple : >> jeu(T,"e4") >> jeu(D,"g8") >> jeu(C,"a6")

Petite fonction pour afficher un nombre n à la position (x,y) avec une taille t et une couleur co

Enoncé de l’énigme Numworks L’algorithme teste les différents choix possibles (remplir A, vider B, verser A dans B etc.). Tant qu’il obtient de nouvelles combinaisons, par exemples [0,0],[2,5],[3,0]… il continue. Quand il trouve une combinaison déjà existante, il remonte d’un niveau (indiqué par “Annuler”) et teste un autre choix.

4 dessins d’arbres de Noël (sur le simulateur il n’y a qu’un arbre qui s’affiche mais vous en aurez 4 différents en mettant le programme sur votre machine) Découvrez ma chaine YouTube (Python, JavaScript, calculatrices…)

Source : http://www.peda.com/grafeq/gallery.html Sphère : https://my.numworks.com/python/schraf/sphere Margarita : https://my.numworks.com/python/schraf/margarita Threesome : https://my.numworks.com/python/schraf/threesome The Big Swim : https://my.numworks.com/python/schraf/bigswim Arachnid : https://my.numworks.com/python/schraf/arachnid

Le modèle original est ici

“pion” dessine un pion de couleur “coul” aux coordonnées (c, l). Possibilité d’ajouter une ombre en utilisant le décalage “d” et une autre couleur, par exemple noire. La boucle “for i in range(3): pion()” permet d’avoir un tracé plus net, essayez avec 2 ou sans la boucle pour voir la différence.

Alphabet Circular Glyphs | Youtube channel

Création d'une ville from kandinsky import fill_rect, set_pixel from math import * from random import randint # Fond gris foncé fill_rect(0,0,320,222,(40,40,40)) # remplissage parallélogramme (begin_fill n'existe pas sur la NUMWORKS) def remplir(coul, *u): # On récupère les coordonnées des 4 points (ax,ay),(bx,by),(cx,cy),(dx,dy)=u[0] # On parcourt les pixels du rectangle contenant le parallélogramme for col in range(min(ax,bx,cx,dx), max(ax,bx,cx,dx)+1): for lig in range(min(ay,by,cy,dy), max(ay,by,cy,dy)+1): # Si c'est un pixel de l'écran if 0 <= col <= 320 and 0 <= lig <= 222: # On teste si le point est dans le parallélogramme xa,xb,xc,xd = ax-col,bx-col,cx-col,dx-col ya,yb,yc,yd = ay-lig,by-lig,cy-lig,dy-lig # xa*yb-ya*xb permet de déterminer de quel côté on est de la droite AB d1,d2,d3,d4 = xa*yb-ya*xb,xb*yc-yb*xc,xc*yd-yc*xd,xd*ya-yd*xa u,v,w,t = d1>0,d2>0,d3>0,d4>0 # Si tous identiques on est dans le parallélogramme if u == v == w == t: # On met la bordure en noir co = (0,0,0) if d1*d2*d3*d4 == 0 else coul set_pixel(col,222 - lig,co) # Plus z (profondeur) est grand, plus la couleur sera sombre def light(z,g): return ((max(0,min(255,g-1.1*z)),)*3) def cube(x, y, z): tx,ty,tz = 50-x,y,80-z x2,y2,z2 = x,y,z-1 # Description immeubles et rues # Testez avec d'autres fonctions if ty <= int(5+5*sin(tz)*cos(tx/2)) and (x % 10 > 2) and (z % 10 > 3): # dessus - devant - cote face(x,y,z,((1,0,0),(0,0,-1),(-1,0,0)),light(z,280)) face(x,y,z,((0,-1,0),(0,0,-1),(0,1,0)),light(z,60)) face(x2,y2,z2,((1,0,0),(0,-1,0),(-1,0,0)),light(z,140)) # Une face def face(x,y,z,dd,coul): coord = (pos2D(x,y,z),) for d in dd: x,y,z = x+d[0],y+d[1],z+d[2] coord += (pos2D(x, y, z),) remplir(coul, coord) # Coord 3D vers 2D def pos2D(x, y, z): t = x+z+2*y w = 450/(110+x+z) return (int(140+(x-z)*3*w), int(-70+t*w)) # Les etoiles for c in range(320): for _ in range(5): set_pixel(c

Oscillateur Horloge dans le jeu de la vie

En cours de réalisation : création de code-barres “Code 39” https://fr.wikipedia.org/wiki/Code_39

Saurez-vous atteindre le 💕 de votre élu.e avant le 14 février ?? Découvrez mon programme hautement scientifique (et complètement inutile 😂) qui vous donnera le nombre de jours 📅 nécessaires pour y arriver. ᴹᵃ ᶜʰᵃⁱⁿᵉ ʸᵒᵘᵗᵘᵇᵉ‧ᶜᵒᵐ/ˢᶜʰʳᵃᶠ

Spécial Saint-Valentin

Représentation binaire des coefficients binomiaux de 0 à 33. D’étranges créatures à imaginer (singe, guerrier, extra-terrestre, oiseau…) Visitez ma chaine YouTube Version avec la bibliothèque PIL : from PIL import Image, ImageDraw from math import comb source = Image.new("RGB", (1300, 50), color = "white") draw = ImageDraw.Draw(source) x = 0 for n in range(50): for i in range(n + 1): r = comb(n, i) j = 0 while r > 0: if 1 & r: y = 50 - j draw.point((x, y), fill = 'black') j += 1 r >>= 1 x += 1 source.show()

Création d’une plaque de cuisson, de la crêpe et de sa cuisson. Bon appétit !

Chaque jour vous devez ramasser les crottes (c) de votre chien (:) dans votre jardin ! Pour cela vous avez le plan du jardin (une liste de chaines de caractères composées de “c” (crotte), “_” (rien) ou “:” (chien)), ainsi qu’un nombre de sacs identiques et la capacité d’un sac. Par exemple jardin(["__c__","___c_","_:___"],1,3) signifie : Que votre jardin fait 3x5, qu’il y a une crotte sur la première et la deuxième rangée et que le chien est dans le jardin (3e rangée) : __c__ ___c_ _:___ De plus vous n’avez qu’un seul sac qui peut contenir 3 crottes. Vous devez écrire une fonction jardin qui à partir de ces 3 paramètres affiche “CHIEN !!” si le chien est encore dans le jardin ou “Nickel” s’il est possible de le nettoyer ou “Crottes !” s’il n’y a pas assez de sacs.

Possibilité de réponse à une activité proposée par NumWorks message = "LOI SMPJOSMPQUWOI IGZP WZ OZIOSTLO HO AGZZMQIIMZAOI MTIPBMQPOI BOIWLPMZP HO BMQIGZZOSOZPI LGCQUWOI MNNLQUWOI M HOI GTXOPI HQDOBI OLI UWO LOI OZIOSTLOI SMPJOSMPQUWOI, LOI ZGSTBOI, LOI VGBSOI… SOBAQ KQEQNOHQM !" # Codes ASCII de 'A' à 'Z' alphabet = range(65, 91) def decode(txt): # Stats sur les lettres stats = [] for a in alphabet: stats.append(txt.count(chr(a))) # On garde les 2 meilleurs scores # qui devraient correspondre aux lettres 'E' et 'S' best = sorted(enumerate(stats), key=lambda x:x[1], reverse = True)[:2] # Substitutions probables pour 'E' et 'S' # 0 pour 'A', 1 pour 'B'... x,y = best[0][0], best[1][0] # On cherche les transformations affines a*x+b # qui envoient x vers 4 (lettre 'E') et y vers 18 (lettre 'S') for a in range(27): for b in range(27): if (a * x + b) % 26 == 4 and (a * y + b) % 26 == 18: # Si on trouve une transformation # on traduit le texte en effectuant # la même transformation pour les autres lettres s = '' for c in txt: l = chr(65 + (a * (ord(c)-65) + b) % 26) if ord(c) in alphabet else c s += l # Affichage du résultat print('y={}x+{} mod 26\n{}'.format(a,b,s))

Quelques explications sur le programme Au démarrage la calculatrice mélange le cube puis voici les touches à utiliser : 4 flèches du haut : faire tourner le cube entier 1 et 4 : Face de Gauche (L = Left) 4 pour aller dans le sens 1 vers 4 et 1 pour sens inverse 8 et 9 : Face du Haut (U = Up) 9 pour aller dans le sens 8 vers 9 (horaire) 6 et 5 : Face Avant (F) x et + : Face de Droite (R = Right) . et x10^x : Face du Bas (B) et / : Face arrière

On considère une suite xn+1=f(xn ) avec une valeur initiale x0. Lorsqu’il existe i≠j tels que xi=xj la suite est périodique. Par exemple dans la suite : 2, 0, 6, 3, 1, 6, 3, 1, 6, 3, 1, ... le cycle est 6, 3, 1 et se répétera forcément puisque f(1)=6, f(6)=3 et f(3)=1. Ecrire une fonction cycle qui admet en paramètre la liste des premiers éléments de la suite et donne en sortie la valeur du premier terme qui se répète ainsi que la longueur du cycle ou alors “Pas de cycle” si aucun cycle n’est apparent. >> cycle([2,3,4,2,3,4]) [2,3] # En effet 2,3,4 est le cycle qui se répète donc le 1er terme est 2 et la longueur du cycle = 3 >> cycle([1,2,3,4]) 'Pas de cycle' >> cycle([1,2,3,4,7,3,4,7,3]) [3,3] # 3,4,7 est le cycle de 1er terme 3 et de longueur 3

Utilisation de classes pour animer 9 carrés Visuel final sur TikTok Ma chaine YouTube

Enoncé de l’exercice Visitez ma chaine YouTube from kandinsky import * from random import * from turtle import * BL, WH = (0, 0, 0), (255,) * 3 # Noir et Blanc def dot(x, y, c, fg, t, a, b): # Transfo d'un caractère en rectangles draw_string(c, 0, 0, BL, WH) # On affiche le caractere for v in range(18): # On parcourt les pixels de ce caractère for u in range(9): if get_pixel(u, v)[0] < 248: # Si ce n'est pas du blanc # rectangle avec effets de décalage 'a' et/ou 'b' fill_rect(x + u * t, y + v * t, t - a, t - b, fg) def aff(txt, x, y, t, a=1, b=1): for i, c in enumerate(txt): # On parcourt les lettres du mot dot(x + i * t * 9, y, c, BL, t, a, b) # ombre du caractere en noir dot(x + i * t * 9 - 3, y, c, WH, t, a, b) # texte en blanc def remplir(h): # fond degradé radial for l in range(h): for c in range(320): set_pixel(c, l, (150,) * 3 if 140000 * random() < l ** 2 + c ** 2 else (90,) * 3) remplir(222) aff("WANTED", 28, 15, 5) aff("NUMWORKS", 52, 100, 3, b=-5) # effet texte vertical aff("DEAD OR ALIVE", 45, 160, 2, a=4) # effet horizontal remplir(18) hideturtle() pensize(7) for _ in range(20): # les trous color(WH) x, y = randint(-160, 160), randint(-110, 110) penup(); goto(x, y);pendown() # point en blanc goto(x, y) color(BL) # et en noir avec léger décalage penup(); goto(x - 2, y - 2); pendown() goto(x - 2, y - 2)

En réponse à un Tweet de Vincent

Explications en vidéo ici 31 décembre : Décompte des secondes jusqu’à minuit. S’il est par exemple 17h29 à votre montre, tapez go(17.30) sur la Numworks et attendez qu’il soit exactement 17h30 sur votre montre pour appuyer sur EXE. Vous aurez alors le décompte des secondes jusqu’à minuit. Idées de variations : - Affichage plus sophistiqué : Montre Tokyoflash TEN ou STENCIL - Ajout de neige : Exemple ici. Il est possible que la mémoire de votre Numworks ne supporte pas les 200 flocons, dans ce cas diminuez le nombre.

Visuel basé sur un tweet de Julien Gachadoat lui-même inspiré d’un code écrit en BASIC tiré du livre de J.-P. Delahaye “Dessins géométriques et artistiques avec votre micro-ordinateur”

Explications en vidéo Ce jeu ne fonctionnera que sur votre calculatrice, pas sur l’émulateur. Pour le lancer, tapez >>go() ou >>go(30) si vous voulez que la machine cache 30 mines au lieu de 20

Division synthétique d’un polynôme P par x-a Exemple : Diviser P(x) = x^2-5x+6 par x-2 Les coefficients de P sont 1,-5,6 et a=2 On lance le programme et on tape 1,-5,6 EXE puis 2 EXE Le quotient Q(x) s’affiche sous la forme 1,-3 qui signifie x - 3 ainsi que le reste R(x) = 0

Voir la construction des 5 solides de Platon

Molécule de dopamine. Il s’agit d’une image convertie en script Python par img2calc. Visuel final pour Twitter

Écrire une fonction “double” qui admet 2 phrases en paramètres et affiche en sortie les lettres communes SANS répétition (y compris espace, ponctuation etc.). Les deux phrases devront automatiquement être converties en majuscules.

Jeu des drapeaux Tapez sur la touche Ans pour répondre puis tapez le numéro du pays et Ans. Pour avoir un autre drapeau, tapez sur la touche +

On vous donne une rangée de lampes éteintes représentée par une série de “x” (Par exemple “xxxxxx” pour 6 lampes éteintes) ainsi que la trajectoire d’un drone “T” (Par exemple “===T” pour un drone se déplaçant vers la droite de 4 unités). Lorsque le drone passe au-dessus d’une lampe il l’allume (symbole “o”). >> drone("xxxxxx", "===T") "ooooxx" Ce qui signifie que le drone a allumé les 4 premières lampes. Voici 2 autres exemples : >> drone("xxx", "=========T") "ooo" # le drone a allumé toutes les lampes >> drone("xxxx", "T") "oxxx" Écrire la fonction drone qui admet en paramètres la rangée de lampes éteintes ainsi que la trajectoire du drone et qui en sortie affiche l’état des lampes.

Vous devez écrire une fonction duplik admettant en paramètre une chaine de caractères. En sortie on doit obtenir une chaine où chaque caractère est soit “(“ (si le caractère n’apparait qu’une seule fois dans la chaine initiale), soit “)” (si le caractère apparait plusieurs fois). >> duplik("bacasable") '))()())((' Explications en vidéo

Vidéo sur comment dessiner un ovale avec la tortue Python

Spécial 8 ans de NUMWORKS

Pour envoyer visuellement un emoji, choisir le numéro voulu. Pour en envoyer un autre, tapez sur la touche “Retour” puis par exemple » emo(4) def nw(): lett="ABCDEFGHIJKLMNOP" img=gimp.image_list()[0] drw = pdb.gimp_image_active_drawable(img) if not(pdb.gimp_drawable_is_indexed(drw)): pdb.gimp_convert_indexed(img, 0, 0, 16, 0, 1, 0) im="" pal=[] c=0 for i in range(112*16): v=list(pdb.gimp_image_pick_color(img,drw,i%112,i//112,1,0,0))[:-1] if v not in pal: pal.append(v) cour = pal.index(v) if i==0 : prec = cour if prec != cour and i>0: im+=lett[prec] if c>1: im+=str(c) c=1 prec = cour else: c+=1 print "pal="+str(pal) print "im=\""+im+"\""

Traduction pour la NUMWORKS d’un programme BASIC trouvé p.41 dans le livre “Mathématiques et graphismes” (1985 - Edition PSI) à consulter ici. D’autres visuels ici.

Réponse à l’énigme proposée par NUMWORKS

Écrire une fonction “etoile” qui admet en paramètre un mot . En retour, ce mot sera mis en majuscules puis une étoile “*” traversera toutes les lettres. Plus précisément, si un utilisateur tape par exemple le mot “soleil” alors l’affichage sera constitué des 7 lignes suivantes : *SOLEIL S*OLEIL SO*LEIL SOL*EIL SOLE*IL SOLEI*L SOLEIL*

On fait varier a entre 2 et 4 par exemple avec un pas de 0.01 La première boucle permet d’arriver à un comportement limite (100 itérations) de u(n+1)=au(n)(1-u(n)) On trace ensuite les 20 points suivants (u(101) à u(120)) https://fr.wikipedia.org/wiki/Nombres_de_Feigenbaum

On vous donne une liste nommée ferme avec des éléments (m : mouton, v : vache, l : lapin, p : poule, c : canard). Créez les fonctions suivantes : animaux : compte le nombre d’animaux suivant le paramètre donné. Par exemple animaux(ferme,'m') va compter le nombre de moutons dans la ferme, etc. deux : compte le nombre d’animaux à 2 pattes (p ou c). Écrire 2 versions. quatre : compte le nombre d’animaux à 4 pattes (m, v, l). Écrire au moins 2 versions.

L’idée est de générer un dégradé entre 2 couleurs (Tweet de Vincent Robert) de façon plus organique. Ma première version est ce pinceau et la seconde cette sorte de feuille vue en transparence. Les scripts sont longs à s’exécuter !

D’autres jeux pour la NUMWORKS sur ma chaine Youtube : Rubika, solitaire, Mission missile, démineur, carré magique, TRON, défis de blanche… Explications en vidéo

Vous devez écrire une fonction score qui calcule le score à un jeu de fléchettes sachant que l’on obtient : 0 point si la fléchette est à plus de 10cm du centre 5 points si la fléchette est entre 5 et 10cm (inclus) du centre 10 points si la fléchette est à moins de 5cm du centre De plus, si tous les lancers sont à moins de 5cm on gagne un bonus de 100 points. Les différents lancers sont enregistrés dans une liste que l’on passera en paramètre à la fonction. >> score([1, 5, 11]) 15 >> score([15, 20, 30]) 0 >> score([1, 2, 3, 4]) 140 Explications en vidéo

Dans un forum des utilisateurs peuvent poser des questions et d’autres y répondre. Lorsqu’une réponse à notre question est proposée, on peut cliquer sur ❤ pour dire que la réponse nous plait. Dans tous les cas, proposer une réponse (même mauvaise) rapporte 1 point et une réponse appréciée rapporte 10 points supplémentaires. Par exemple dans la liste ci-dessous : forum=[["Amaury",8,1],["Amelie",28,17],["Anne",35,17],["Anthonin",31,7],["Camille",5,3],["Carole",14,2]] Amaury a posté 8 réponses et 1 a été validée en ❤, elle a donc accumulé 8×1+1×10=18 pts On vous demande d’écrire une fonction best3 qui admet en paramètre les données du forum et donne en sortie les noms des 3 internautes qui ont les meilleurs scores (par ordre décroissant). Explications en vidéo >> best3(forum) Anne (205), Amelie (198), Anthonin (101)

Fougère de Barnsley https://en.wikipedia.org/wiki/Barnsley_fern

Découvrez ma chaine YouTube (Python, JavaScript, calculatrices…)

Découvrez ma chaine YouTube (Python, JavaScript, calculatrices…)

Explications en vidéo Petit programme permettant de convertir un nombre décimal en fraction. >> fr(1/3+2.5) 17 / 6 >> fr(1.71428571) 12 / 7 Attention cependant, si dans votre calcul il y avait des nombres irrationnels (racine carrée, pi, etc), le programme donnera en réponse une fraction qui ne sera qu’une approximation du vrai résultat. >> fr(3.14159265) 355 / 113 En effet 355/113 vaut environ 3.1415929203… Version optimisée pour la Numworks def fr(x): p,d,q,z=0,0,1,x while abs(p/q-x)>1e-6: z=1/(z%1) d,q=q,q*int(z)+d p=round(x*q,0) return "{} / {}".format(int(p),q) Version pour la Ti-83 Premium CE Le fichier à transférer sur votre machine ou alors tapez le programme ci-dessous : Version simpliste Si vous savez que le dénominateur n’est pas très grand (< 106), une solution très simple est de tester les dénominateurs les uns après les autres (1, puis 2, puis 3 etc.), le programme est alors extrêmement court : def fr(x, q = 1): while abs(round(x*q)/q-x)>1e-6: q = q+1 return "{} / {}".format(round(x*q),q)

Suite à la publication de Numworks d’une carte de France dessinée par un élève, je me suis lancé le challenge de créer une carte avec le moins d’octets possible avec une résolution d’au moins 40*40 pixels

Explications ici

>> frise(f1) pour afficher la première frise, >> frise(f2,4) pour affiche la frise n°2 en petit, >> frise(f3,16) pour affiche la frise n°3 en grand, etc.

Adaptation d’un programme de Paul Malin pour la calculatrice Numworks. Ma chaine Youtube Maths-info

Playlist YouTube sur la NUMWORKS Vous êtes de corvée pour découper la galette des rois ? Certaines personnes veulent despetites parts et d’autres des parts normales ? Pas de panique, votre NUMWORKS va vous aider ! Outils nécessaires Une galette des rois, une NUMWORKS et une règle graduée Exemple n°1 La galette fait 24cm de diamètre, 3 personnes veulent une part normale et 2 personnes des parts petites (c’est-à-dire la moitié d’une part normale) Exécutez le programme puis var et galette : >>> from galette import * >>> galette(24,3,2)) Mesurez 16.97 cm (disons 17 cm) trois fois, cela correspond aux 3 parts normales puis 9.18 cm (disons 9 cm) ce qui permet d’avoir les parts deux fois plus petites. Exemple n°2 La galette fait 20cm de diamètre, 5 personnes veulent une part normale et 1 personne veut une part petite Exécutez le programme puis var et galette : >>> from galette import * >>> galette(20,5,1)) Mesurez 10.81 cm (disons 11 cm) cinq fois, cela correspond aux 5 parts normales, la part restant sera la petite. Exemple n°3 La galette fait 18cm de diamètre, 3 personnes veulent une part normale Exécutez le programme puis var et galette : >>> from galette import * >>> galette(18,3,0))

Ghee Beom Kim

Explications en vidéo

Affiche une photo sur la calculatrice But : Afficher une image quelconque (80*60 pixels avec 16 couleurs) sur la calculatrice Attention : Depuis la dernière mise à jour proposée par Numwroks cette version peut poser des problèmes de mémoire, utilisez plutôt la version 2 Explications en vidéo Lancez l’éditeur d’image gratuit Gimp et ouvrir une image quelconque Utilisez l’outil de sélection rectangulaire et dans les options de cet outil choisir “Fixé proportions 320:240” pour sélectionner avec une forme semblable à celle de la calculatrice (vous pouvez aussi choisir le format 4:3). Comme me l’a fait remarquer un internaute, le format de l’écran est bien 4:3 mais le bandeau orange fait que dans la réalité on ne peut dessiner que sur une zone de 320x222 pixels. Si bien que dans vous pouvez choisir 320:220 ou 320:224 comme proportions dans Gimp et dans le programme principal vous remplacez le 60 par 55 (4x55=220) ou 56 (4x56=224). Sélectionnez la zone à conserver puis Image - Rogner selon la sélection Ouvrir la console Python de Gimp par Filtres - Python-Fu - Console Copiez le code ci-dessous et le coller dans la console def nw(): lett="0123456789ABCDEF" img=gimp.image_list()[0] pdb.gimp_image_scale(img, 80, 60) drw = pdb.gimp_image_active_drawable(img) if not(pdb.gimp_drawable_is_indexed(drw)): pdb.gimp_convert_indexed(img, 0, 0, 16, 0, 1, 0) im="" pal=[] for i in range(4800): v=list(pdb.gimp_image_pick_color(img,drw,i%80,i//80,1,0,0))[:-1] if v not in pal: pal.append(v) im+=lett[pal.index(v)] print "pal="+str(pal) print "im=\""+im+"\"" Faire Entrée - Entrée pour obtenir >> à l’affichage et pas ... Tapez

Script de Tell Urik @t3llurik

Représentation isométrique de surfaces Exemple 1 f(x,y) = cos(x*x+y*y)*exp(-x*x-y*y) xmin,xmax,ymin,ymax=-2,2,-2,2 zmin,zmax=-0.5,0.8

Vidéo d’explications Résumé de la vidéo On parcourt tous les pixels (i,j) de l'écran de la machine de la gauche vers la droite et de bas en haut On transforme les coordonnées du pixel (i,j) de l'écran en coordonnées (x,y)dans le plan qui est en vue isométrique Si le point (x,y) est dans le rectangle défini par les bornes Xmax et Ymax, on cherche le z = f(x,y) On regarde alors si le point doit être tracé ou s'il est caché, cela dépend des points qui ont été tracés précédemment pour la même abscisse i. Si le z est plus grand que le maximum déjà à l'écran ou s'il est plus petit que le minimum déjà à l'écran, on peut afficher le point (ce qui actualise le minimum et maximum), sinon on ne fait rien. Modifications possibles Une modification très sympathique du programme concerne la ligne : if abs(x) <= xmax and abs(y) <= ymax: qui permet de savoir si le point est dans le rectangle défini par Xmax et Ymax. On peut en effet ne garder que les points qui sont dans l'ellipse définie par Xmax et Ymax. Vous remplacez la ligne par : if (x / xmax)**2 + (y / ymax)**2 <= 1: Une autre modification simple et impressionnante est de mettre la partie inférieure de la surface en une couleur plus foncée (comme si l'éclairage provenait du dessus). Il suffit pour cela de mettre une couleur sombre (17000 par exemple) lorsque z <= n et une couleur claire (52831 par exemple) sinon. Le programme ci-dessous propose la version améliorée. Quelques idées Le plus amusant est bien entendu d'inventer les équations et de regarder ce que cela donne ! Attention, si vous faites des division

C’est une belle soirée et le ciel est rempli d’étoiles. Plus précisément, il y a en moyenne 1% d’étoiles et parmi ces étoiles 1% sont rouges (les autres sont bleues). Ce qui donne par exemple : Visuel n°1 Comme vous pouvez le constater, il est difficile de repérer les étoiles rouges (vos préférées !). Vous décidez de programmer en Python votre télescope pour qu’il les repère à votre place : Visuel n°2 Plus précisément : Créez une fonction nuit sans paramètre qui permet de créer le ciel noir avec 1% d’étoiles dont 1% seront rouges. Ainsi, en lançant nuit() on obtiendra un visuel ressemblant au n°1 Créez ensuite une fonction scan sans paramètre qui appellera nuit puis, autour de chaque étoile rouge, ajoutera 4 pixels blancs comme sur le visuel ci-dessous : Visuel n°3 Remarque : On ne tiendra pas compte du fait qu’a priori mettre 4 pixels blancs peut cacher une autre étoile.

Le but de cet exercice est de simuler des écrans à la MATRIX. L’idée du programme (Explications en vidéo) : Écrire une fonction mat qui affiche graphiquement 24 rangées de 32 chiffres aléatoires entre 0 et 9. On fera en sorte que les chiffres soient placés horizontalement tous les 10 pixels et verticalement tous les 12 pixels. Pour avoir l’effet MATRIX, il faudrait qu’il y ait de moins en moins de caractères au fur et à mesure que l’on arrive en bas de l’écran. Utiliser une variable maxi initialement égale à 1. Pour chaque caractère tirez au hasard un nombre entre 0 et 1 puis si ce nombre est inférieur à maxi alors afficher le chiffre sinon ne rien mettre. Lorsque vous passez à la ligne suivante, diminuez légèrement la valeur de maxi (par exemple de 0.05) de sorte que les nombres au hasard auront de moins en moins de chance d’être inférieurs à cette valeur. Et donc nous aurons de moins en moins de nombres à l’écran. Passons à la couleur : vous allez parcourir l’ensemble des 320*240 pixels, si la couleur du pixel est blanche vous mettrez le pixel en noir. Sinon, vous choisirez au hasard une couleur entre noire (0), vert foncé (color(16,88,38)) et vert clair (color(104,253,151)). Ainsi chaque chiffre sera un mélange de noir et de nuances de vert. Pour les forts en maths : Dans la version actuelle la valeur de maxi diminue de 0.05 soit environ 1/24 à chaque ligne. On peut donc représenter les variations de maxi en fonction du numéro de la li

Programme qui permet de générer une “infinité” de tableaux aléatoires à la Piet Mondrian. Plusieurs améliorations sont envisageables comme : - Faire varier légèrement les couleurs des pixels pour donner un effet de texture - Lorsque 2 blocs contigus ont la même couleur, ne pas afficher de trait noir entre les 2 - Éviter qu’un même bloc puisse être choisi plusieurs fois ce qui est le cas dans le programme proposé Quelques exemples :

Symboles utilisés pour chiffrer | Youtube channel La fonction phrase décompose la phrase en mots. La fonction mot décompose le mot en caractères. La fonction car trace le symbole de la lettre à la position (x,y) et de taille t. Codage de lettres : "-" correspond à 0, "|" à 1 et "+" à 2 Exemples : La lettre “A” a pour symbole “ | - - “ c’est-à-dire “100” et “B” a pour symbole “- | +” soit “012”. En parcourant les “chiffres” de gauche à droite (on peut bien sûr faire l’inverse), la chaine “100” correspond au nombre 1 + 0 * 3 + 0 * 9 = 1 en base 3. De même “012” correspond au nombre 0 + 1 * 3 + 2 * 9 = 21. Si l’alphabet “ABC…Z” commence à la position 0, les nombres 1 et 21 sont les lettres “B” et “V”. C’est la ligne alpha dans le code ci-dessous.

Explications pour transformer un gif animé en animation pour ta NUMWORKS

Version sonore ;-)

Explications en vidéo But : Essayez d’arriver à 15 parties gagnantes avant la machine ! Dans la vidéo je dis que s’il y a un blocage, c’est qu’il reste le même nombre de pions blancs et de pions noirs, ce n’est pas exact : X.X X.O O.. est une situation bloquée et pourtant les nombres de pions sont différents ;-) J’ai donc changé le test et mis tout simplement : if len(jouables(position)) == 0: return 1 En d’autres termes, s’il n’y a pas de déplacement possible, c’est que la situation est bloquée.

Les anneaux hongrois Explications en vidéos

My YouTube channel : Python, NUMWORKS, JavaScript, Excel Macro (VBA, Office Script)

Exercice posté sur "Le coin boulot des profs de mathématiques" Rejoindre ce groupe Ma chaine Youtube consacrée aux maths et à l’informatique Explications du programme On fait 10000 simulations, soit 10000 files d’attente A chaque simulation on crée une file de personnes nommée pers, une personne ayant le virus (noté 1) avec une probabilité de 40% et saine sinon (noté 0) On duplique cette liste dans fin qui sera la file finale Pour chacune des personnes v de la file initiale, on regarde si elle a le virus : v == 1 Si c’est le cas, dans 20% des cas elle contamine la personne derrière elle : fin[i - 1] = 1 Et dans 20% des cas celle de devant On vérifie avec i > 0 et i < 99 que l’on ne sort pas de la file (la prochaine personne qui va être testée ne peut pas contaminée celle qui est devant elle puisque c’est la première…) En sortant de la boucle, on compte le nombre de personnes contaminées et on l’additionne aux valeurs trouvées dans les autres simulations On affiche la moyenne (ou mieux, un intervalle de confiance)

Comme le prouve le script, les 2 rectangles vont à la même vitesse, c’est uniquement la couleur du fond qui change ! 🖥 Visiter ma chaine Youtube Maths-info ☕ M’offrir un café

Illusion du mur du café : Il n’y a que des lignes horizontales et des carrés noirs ! 🖥 Visiter ma chaine Youtube Maths-info

Comme vous pouvez le constater dans le script, tous les cercles ont la même couleur or ils paraissent de couleurs différentes une fois le dessin terminé ! 🖥 Visiter ma chaine Youtube Maths-info

Posez votre calculatrice sur la table. Mettez-vous debout, regardez le point noir central puis approchez votre visage de la calculatrice, vous verrez les losanges tourner ! 🖥 Visiter ma chaine Youtube Maths-info ☕ M’offrir un café

Illusion de Orbison : Le carré rouge parait déformé et ressemble à un losange, or il a bien 4 angles droits ! 🖥 Visiter ma chaine Youtube Maths-info ☕ M’offrir un café

Constatez que le trait noir est bien dans le prolongement du trait rouge. Une fois que le rectangle gris est apparu, n’avez-vous pas l’impression que le trait noir est plutôt en face du bleu ?? 🖥 Visiter ma chaine Youtube Maths-info ☕ M’offrir un café

📺 Découvrez ma chaine Youtube

Écrire une fonction initiales qui admet en paramètre une phrase et affiche la première lettre de chacun de ses mots en majuscule. Les mots peuvent être séparés par un ou plusieurs espaces. Par exemple : “Rentre avec tes pieds” donnera RATP. Conseils On aura une première lettre si le caractère n’est pas un espace et si le précédent est un espace. Par exemple dans “ tes”, le “t” est bien une initiale, par contre le “e” non puisqu’il est précédé d’un “t”. On pourra mémoriser le caractère précédent dans une variable nommée preced On ne peut pas comparer le 1er caractère de la phrase avec le précédent puisqu’il n’y en a pas. L’idée est d’initialiser preced avec un espace, ce qui revient à dire que toutes nos phrases commencent par espace.

Explications en vidéo

Écrire une fonction “inverse” qui admet une phrase en paramètre (par exemple “Python For ever !”) et qui en sortie affiche cette même phrase où les minuscules sont devenues des majuscules et vice-versa. Les autres lettres (apostrophes, ponctuations, guillemets etc) ne changent pas. Pour notre exemple, le programme affichera donc “pYTHON fOR EVER !”

Le célèbre jeu 2048 sur votre calculatrice Numworks ! Ce programme nécessite l’utilisation du Firmware 13 officiel Explication en vidéo du programme ci-dessous.

Explications en vidéo Utilisez les flèches de direction pour jouer.

Découvrez ma chaine YouTube (Python, JavaScript, calculatrices…)

Petit jeu inspiré d’un Tweet de NUMWORKS

Le jeu Kibur (Rubik à l’envers) est apparu page 42 de la revue “L’ordinateur de poche” n°3 en 1981. La règle est la suivante : (Explications et corrigé en vidéo ici) - La machine vous affiche les chiffres de 0 à 9 de façon mélangée, par exemple 7328459061 - Vous devez remettre les chiffres dans l’ordre 0123456789 sachant que lorsque vous choisissez un chiffre entre 0 et 9, celui-ci est inversé avec le chiffre qui est en première position et les 2 chiffres à côté sont permutés également. Voici quelques exemples pour clarifier : 0748695312#8 # Le 8 à droite du "#" signifie que l'on veut inverser ce chiffre avec celui complètement à gauche, on obtient dans un premier temps : 8760495312 # C'est-à-dire que le 0 et le 8 ont été inversés # Dans un second temps on inverse également les 2 chiffres qui étaient à la position du 8 au départ (ici le 4 à gauche et le 6 à droite). On obtient alors : 8740695312 Voici 2 autres exemples : 0748695312#7 donne 4078695312 # en effet, on inverse le 7 et le chiffre de gauche (ici 0) 7048695312 # et les 2 chiffres qui étaient à côté de de la position du 7 au départ 4078695312 7328459061#1 donne 6328459017 # en effet on inverse le 1 et le 7 1328459067 # et également les 2 chiffres qui sont à la position initiale du 1 (le 6 à gauche et le 7 (on reprend le chiffre de l'autre extrémité) Écrire une fonction jouer qui admet en paramètres la liste des chiffres et le chiffre à permuter et qui en sortie donne la nouvelle liste.

Le jeu de Nim (Marienbad) Une vidéo est en cours de réalisation. La machine connait la solution optimale pour gagner et donc il y a peu de chances de la battre à moins que vous ne connaissiez vous-même la stratégie. Dans cette version le vainqueur est celui qui tire la dernière allumette, il existe la variante inverse comme dans le film ci-dessous “L’année dernière à Marienbad”. Comme le dit l’acteur, “je peux perdre, mais je gagne toujours” http://people.math.harvard.edu/~knill/mathmovies/swf/marienbad.html

Un article sur cet automate : https://www.miximum.fr/blog/jouons-avec-les-automates-cellulaires-en-javascript/ Descriptions des règles suivant le numéro : http://atlas.wolfram.com/01/01/rulelist.html Exemples de résultats : >> life(30) (on part d’un seul point central et on applique la règle n°30) >> life(90) >> life(184,1) (on met “1” en second paramètre si on veut un tirage aléatoire pour la première ligne)

Explications en vidéo du jeu de la Vie et du programme. Touche 1 pour lancer un “planeur” Touche 2 pour un vaisseau “LWSS” Touche 3 pour l’oscillateur “pentadécathlon” Touche 0 pour effacer l’écran Touche “.” pour remplir aléatoirement l’écran J’ai mis (FO)ncé et (CL)air dans cet ordre pour que l’on voit les changements à l’écran, si vous voulez un affichage plus discret, il suffit d’inverser les valeurs de ces 2 variables à la ligne n°8 de sorte que CL = (8,)*3 et FO = (248,)*3 Vous pouvez aussi enlever la ligne alea() si vous ne voulez pas que le jeu débute par une grille remplie aléatoirement. Clignotant : ["0100","1001","1001","0010"]

Ma playlist consacrée à la NUMWORKS

Comment trouver mentalement un jour de la semaine pour une date au 20e ou 21e siècle ? C’est en fait assez simple, il suffit de quelques additions et l’apprentissage de 12 chiffres. L’explication en vidéo est donnée ici, et je vous propose la transcription de la méthode sur la calculatrice Numworks. >> jour(6,10,2018) 'Sa' Le 6 octobre 2018 était donc un samedi. >> jour(6,6,1945) 'Me' Évidemment, l’idéal serait que le module time soit incorporé dans la calculatrice mais ce n’est hélas pas le cas pour le moment. Application de la fonction jour: Deux années sont identiques lorsque les 1er janvier et les 1er mars tombent les mêmes jours de la semaine. Ecrire une fonction idem qui admet en paramètre une année et donne en retour toutes les années strictement identiques entre 1901 et 2050 (1900 n’était pas une année bissextile, on l’a exclue pour simplifier le programme). Par exemple : >> idem(1968) 1912, 1940, 1968, 1996, 2024, Faire les calculs de tête Avec la version 2 du programme, vous avez exactement le cheminement à suivre pour faire les calculs de tête. La seule différence est que l’on fera les %7 (reste de la division par 7) au fur et à mesure et pas à la fin. Il faut bien entendu apprendre par cœur les 12 chiffres 144 025 036 146 def jour(j, m, a): return (j+int("144025036146"[m-1])+(a%100)//4+a%100-1-(a>=2000)-(a%4==0)*(m<3))%7 Exemple : 20 juillet 1969 (1er pas sur la lune) j=20, m=7, a=1969 Le reste de la division de 20 par 7 est 6 (il suffit de se dire que l’on soustrait 2*7 = 14 de 20) le 7e code de “144025036146” est 0, j’ai donc 6+0=6 a%100 vaut 69 (2 derniers chiffres), pour calculer (a%100)//4 on divise par 2 et encore par 2 sans tenir compte des virgules, ce qui donne 69 –> 34 –> 17. J’en

Agent 008, vous avez une nouvelle mission ! Parmi les citoyens de la ville sont cachés 2 jumeaux très dangereux. Votre mission, si vous l’acceptez, est de les identifier et de les éliminer ! A partir d’une liste d’entiers, vous devez trouver les deux mêmes nombres et renvoyer l’un d’entre eux, par exemple dans le tableau [2, 3, 6, 34, 7, 8, 2] la réponse est 2. S’il n’y a pas de jumeaux dans la ville, renvoyez “RAS” (Rien à signaler). >> jumeaux([2, 3, 6, 34, 7, 8, 2]) 2 >> jumeaux([5, 12, 9, 7, 11]) 'RAS' On admettra qu’il y a au plus une paire de jumeaux dans la liste qui est donnée en paramètre. Explications en vidéo

👉👉 Ma chaine YouTube

D’après un Tweet de NUMWORKS

D’après ce tweet

Vidéo d’explication ici Partie GIMP Création des 50 caractères def alpha(): img = gimp.image_list()[0] cal_txt = img.layers[0] alpha = "".join([chr(32+i) for i in range(59)]) pdb.gimp_text_layer_set_text(cal_txt, alpha) pdb.gimp_text_layer_resize(cal_txt, 295, 12) Conversion de votre police en code def nw(): img = gimp.image_list()[0] drw = pdb.gimp_image_active_drawable(img) code = "" for c in range(295): nb = 0 for l in range(8): v = list(pdb.gimp_image_pick_color(img,drw,c,l,1,0,0))[:-1] if sum(v) == 0: nb = nb + 2**l code += ("0"+(hex(nb)[2:]))[-2:] return code Exemples de codes Futurist Fixed '000000000000005e0000000404000000787c3400006cbc74000c2c386460205c7c600000000c00000000fc00000000fc0000000c0c000000007800000000c000000000200000004000000000601c0000007c443c0000007c00000044641c000044547c0000387c2000004c4c7000007854700000641c0400007c547c00000c741c00000000000000d00000000020505000003030300000505020000014740c003c7c6c7c1c60182c3040007c547c003844444400007c444438007c544000007c1414003844445434000010107c00007c000000407c0000007c284400007c4040007c3860107c7c0810207c3c4444443c007c140c00384444647c007c344c00004c54740000047c04003c4040403c0438601c0c70381c6038046c186400000c700c0000645c4400' Monaco 8 amélioré '000000000000005e00000006000600287e287e28004eff72004230084600764a5670000000060000007c8282000082827c0000281c280000207020000000c000000010101000000040000040300806003c42427e0000427e400000724a4600004a4a7600102c227e00004e4a72003c524a7a0000621a060000764a76000c52527e0000004800000000c8000000103844441010101010444438100000520a06003e5a5e621c4038263840007e52522c1866424200007e427e00007e524200007e1202001866427200007e107e0000427e42000040423e00007e1c6200007e4040007e1c300c7e7e04187e003c42427e00007e120e003c42627e80007e126e00004e4a700002027e0202007e407e000638601e001e7018701e0066186600020478060060524a46

Voici une version simplifiée du langage Leet Speak On remplace les « A » par des « 4 », les « E » par des 3, les « I » par des 1 et les « O » par des « 0 ». La fonction leetspeak que vous devez créer admet une chaine de caractères en paramètre et en sortie le texte doit être en majuscules avec les changements voulus sur les 4 voyelles. >> leetspeak("Je parle en Leet Speak") "J3 P4RL3 3N L33T SP34K" Explications en vidéo

Sur une idée de Fabien Beyaert Tapez go() puis entrez les valeurs de AB, OA et f’ (par exemple 5, 25, 15 ou 7, 40, 10) La machine affiche OA’ et A’B’. Appuyez sur EXE pour voir le diagramme.

Écrire une fonction maxi qui admet en paramètre des lettres (pas d’espace ni de ponctuation) et qui en retour affiche en majuscule la lettre la plus loin dans l’alphabet. Par exemple : >> maxi("BonjourATous") 'U' car la lettre ‘U’ est bien celle la plus proche de la fin de l’alphabet.

Forever Louise Brooks Visitez ma chaine YouTube (bureautique, programmation, calculatrices…)

Application de l’effet dégradé vu dans la vidéo Art génératif : Partie 2 - Le hasard

Visiter ma chaine Youtube Maths-info

Sur une machine à sous d’un casino, on gagne 50€ dès que l’on a 3 valeurs identiques (3 Rois, 3 Dames ou 3 Valets) et chaque partie coute 2€. Voici les résultats que d’un joueur : var casino= ['DVR','VVR','RDV','VVV','RRV','DVD','VRV','RVD','DVD','VRV','VRV','DDD','DDV','VRR','DVV','DDR','RRR','DRR','DRR','DVR','DDD','VVD','DRR','RRD','RRV','RDD','VDV','VDV','VDR','DRV','RVV','VRV','RRD','DRR','DDD','DDV','RVV','VDD','DVR','DRD','VRD','VVV','VRR','DRV','RRV','VVR','DRR','DRV','DDR','VDD','VRD','VVV','RRR','RVR','VVD','RVD','DVD','RVD','VVD','DDR','VVD','RDR','VRD','RDD','VDV','DVR','RVV','RVV','RDV','RRV','RVD','DVD','DDD','RVV','DDR','VDV','VVD','VVD','RVR','VDD','DDD','RDV','RVD','DDR','VDD','RVV','VRV','DRR','RRD','RVV','RVD','VRR','VRV','DRR','DVV','DRV','VRD','VDV','VDV','DRV'] Écrire une fonction gain qui admet en paramètre la liste des résultats obtenus et donne en retour le montant gagné (ou perdu !). Explications en vidéo

Vidéo d’explication Votre calculatrice peut-elle avoir plus de chance que vous à un jeu de hasard ? A priori non et pourtant vous allez découvrir que votre Numworks gagnera beaucoup plus souvent que vous ! Il vous faut un jeu de cartes (au minimum 32 cartes) Vous le mélangez et posez le tas sur la table Posez votre calculatrice dessus et appuyez sur EXE La Numworks se concentre et devine quelle combinaison il faut choisir ! Elle vous demande 3 couleurs, par exemple vous choisissez NOIR-NOIR-ROUGE Pour cela tapez 001 ( 0 pour Noir, 1 pour Rouge) La machine vous dit ensuite quelle combinaison elle choisit, par exemple ROUGE-NOIR-NOIR Ensuite, retournez une par une les cartes et entrez 0 lorsque la carte est noire et 1 lorsqu’elle est rouge Quand les 3 dernières cartes ont les mêmes couleurs que celles que la machine ou vous avez choisies, un point est donné et vous retirez ces 3 cartes Si vous vous trompez en entrant une couleur, tapez sur 2, la machine affiche alors toutes les couleurs du jeu et enlève la dernière carte Touche 9 pour quitter le jeu à n’importe quel moment Explication ? Je ne vous livre pas le secret mais en analysant le script Python, vous pourrez voir quel algorithme la machine utilise pour choisir les 3 couleurs. Sachez que la machine peut parfois perdre, dans ce cas c’est que vraiment vous avez de la chance !

Explications en vidéo Ce programme très court permet de faire un tour de cartes plutôt sympathique qui réussit assez souvent. Faire mélanger un jeu de 52 cartes à un spectateur (on peut aussi n’utiliser que les cartes 1 à 5 par exemple) Le spectateur pose 3 rangées de 10 cartes (4 rangées c’est encore mieux) En parallèle vous tapez sur la calculatrice les codes des cartes (V=D=Roi=5, 10=0 et les autres gardent leurs valeurs) Vous demandez au spectateur de choisir dans sa tête une carte de la première ligne La calculatrice vous donne la ou les cartes les plus probables. Si elle indique 100%, vous pouvez dire une phrase comme “Ton esprit est vraiment simple à lire !” et dans le cas où il y a 2 choix (par exemple 80% - 20%), semez le doute chez le spectateur en lui disant que c’est de sa faute, il devait trop hésiter entre 2 cartes, etc. Il peut arriver plus rarement que la machine propose 3 ou 4 possibilités !! Dans ce cas, vous risquez hélas de louper le tour… Ensuite le spectateur dit quelle carte il avait choisie puis avance sur le jeu en regardant à chaque fois la valeur de la carte Statistiquement, il arrivera sur la ou une des cartes que la machine avait choisies Il s’agit du comptage de Kruskal

Explications en vidéo Si vous utilisez plutôt un jeu de 52 cartes, remplacez le 32 par 52 directement dans le programme, cela évitera de le taper en paramètre.

Vidéo d’explication But : Créer des dessins dans le style de Manfred Mohr, pionner dans l’art et l’informatique dans les années 70. Visuels et explications : dans le catalogue de l’exposition de 1971 Le script pour la Numworks utilise le module Turtle de la version 10 donc pensez à mettre votre calculatrice à jour : https://workshop.numworks.com/devices/upgrade Art génératif Manfred Mohr Quelques visuels tirés du site de l’auteur (avec son aimable autorisation). P-10, “random walk” P-021/A + B, “band-structure” Projet P 142 P 142 Negative Field Syntax Inspiration n°1 from turtle import * from random import * TRANSI = {'m':'db','d':'mph','p':'mph','b':'mp','h':'d'} TRAITS = {'m':[1,30,10], 'd':[1,-30,10], 'p':[3,0,9], 'b':[1,-90,5], 'h':[1,90,5]} speed(1000) reset() def trait(t): pensize(t[0]) setheading(t[1]) forward(t[2]) for i in range(14): actuel = choice('mp') setheading(180) penup() goto(-160,100 - 15*i) pendown() while position()[0]<160: trait(TRAITS[actuel]) actuel = choice(TRANSI[actuel]) Inspiration n°2 En changeant la forme de la montée et en choisissant de mettre des traits épais pour le

Vous avez 10 minutes à attendre avant un rendez-vous. Votre téléphone possède une application qui génère des chemins (par exemple “NOEESON” pour “Avancer 1 minute vers le Nord, puis 1 minute vers l’Ouest, 2 minutes vers l’Est, etc.) Créez une fonction valide qui admet une proposition de chemin en paramètre et qui en retour indique si celui-ci est compatible avec votre situation, à savoir qu’il doit durer 10 minutes et bien sûr vous ramener au point de départ (vu que vous avez rendez-vous) >> valide("NNSS") "Impossible" En effet le chemin NNSS vous ramène bien à votre point de départ mais il ne dure pas 10 minutes. >> valide("NSEONSEONS") "Parfait"

Source : http://www.peda.com/grafeq/gallery.html Chrome : https://my.numworks.com/python/schraf/chrome Sphère : https://my.numworks.com/python/schraf/sphere Threesome : https://my.numworks.com/python/schraf/threesome

Vidéo d’explication Le célèbre jeu du Mastermind est assez facile à programmer en Python comme nous allons le voir. Jouer Lancez le jeu en tapant mm(), par défaut il y aura 6 couleurs différentes (chiffres de 1 à 6) et la combinaison sera de taille 4 avec possibilité de répétitions (par exemple “2446”). Il s’affiche Coup 1 :, tapez alors votre proposition, par exemple 1234. La machine vous dit alors combien de chiffres sont bien placés et combien sont mal placés. Si vous voulez un niveau plus difficile avec une taille 4, tapez par exemple mm(4,8) pour qu’il y ait 8 couleurs, ou alors tapez mm(5) pour que la taille soit 5 (avec par défaut 6 couleurs) ou encore mm(6,9) pour une taille 6 avec 9 couleurs (bon courage !) Le programme Ligne 5 : on choisit les couleurs aléatoires jusqu'à obtenir la taille voulue. Remarquez l'utilisation de str pour avoir un code secret du type ["1","4","4","5"], la raison est que lorsque le joueur tapera sa proposition ce sera une chaine de caractères ainsi ce sera plus simple pour les comparaisons, de plus nous remplacerons plus bas certains éléments par des "#" ou des "*" donc autant travailler avec des caractères. Ligne 6 : on a aucune idée de la durée du jeu Lignes 7 et 8 : on mémorise le code secret et la proposition du joueur dans des listes Ligne 9 : si le joueur n'a rien proposé le jeu s'arrête Ligne 10 et 11 : Le nombre de coups joués augmente de 1 et on va compter les positions bien ou mal placées Ligne 12 : on commence par les bien placées en comparant une à une les valeurs Ligne 15 et 16 : pour ne pas recompter tout à l'heure les éléments, on les remplace par des caractères quelconques (ici # et *) Ligne 17 : si on a 4 bien placés la partie est finie Ligne 18 : on passe maintenant aux positions

En réponse à Numworks

Tenir la calculatrice en mode paysage

Un mélange parfait (mélange Faro) est un mélange parfaitement réussi dans le sens où l’on partage le paquet initial en deux paquets égaux et que le mélange est parfaitement alterné, une carte d’un paquet succédant à une carte de l’autre dans le paquet final. Par exemple, le mélange Faro de [0,1,2,3,4,5] sera : [0,3,1,4,2,5] En effet, on coupe le paquet en 2, soit [0,1,2] et [3,4,5] puis on prend alternativement un élément dans le premier paquet puis dans le second, etc. >> faro(range(6)) [0, 3, 1, 4, 2, 5] Écrire une fonction faro qui admet en paramètre une liste paire d’éléments (pour pouvoir couper le paquet en 2) et donne en retour le mélange. Écrire une fonction cycle qui admet en paramètre une pair d’éléments et donne le nombre de fois où il faut appliquer le mélange de Faro pour retomber sur l’ordre initial.

Exemple tiré de Wikipédia

Les dessins viennent de ce site / Explications pour créer vos propres dessins Derrière les 20 touches inférieures du clavier de la NUMWORKS ( de “0” à “)” ) se cachent des motifs (5 différents avec 2 couleurs possibles). A vous de trouver les paires ! Le programme ne fonctionne que sur votre machine, pas avec le simulateur. Quelques explications # toutes les touches du bas du clavier # codes 30 à 52 sauf les valeurs 35,41 et 47 clav=[v for v in range(30,53) if v not in [35,41,47]] # association aléatoire avec les figures # Au lieu de mélanger les figures+couleurs, on mélange les touches jeu=sorted(list(clav),key=lambda x:random()) trouve=[] score=0 tt.reset() # efface écran sleep(.5) while len(trouve) < 10: # choix figure gauche à partir touche clavier t1=jeu.index(key(clav)) tt.reset() # On recherche la valeur et couleur de cette touche v1,c1 = t1 // 4, t1 % 2 lettre(40,20,az[v1],2,c1) # Affichage figure t2=jeu.index(key(clav)) # Idem avec figure de droite score+=1 v2,c2 = t2 // 4, t2 % 2 lettre(170,20,az[v2],2,c2) # Si 2 touches différentes mais même motif+couleur et pas déjà trouvé if t1 != t2 and (v1,c1) == (v2,c2) and (v1,c1) not in trouve: trouve.append((v1,c1)) # Ajout de la paire trouvée for i,(v,c) in enumerate(trouve): # Affichage des cartes trouvées lettre(10+30*i,180,az[v],.5,c) tt.reset() # Affichage du score s=max(1,20-score) for i in range(10): lettre(20 + 55 * (i % 5), 60 + 60 * (i // 5), az[2],1,i<s)

Vidéo d’explication Prévisions météo Nous allons générer des journées ensoleillées, nuageuses ou pluvieuses sur 50 ans (365*50 jours) avec la règle suivante que nous tiendrons secrète (et que notre calculatrice devra découvrir toute seule) : Lorsqu’il y a du soleil (S) un jour, le lendemain il y a également du soleil dans 70% des cas. Dans 20% des autres cas le ciel sera nuageux (N) et dans 10% il sera pluvieux (P) Lorsqu’il y a des nuages un jour, le lendemain il y a également des nuages dans 30% des cas. Dans 30% des autres cas le ciel sera ensoleillé et dans 40% il sera pluvieux (P) Lorsqu’il y a de la pluie un jour, le lendemain il y a également de la pluie dans 50% des cas. Dans 20% des autres cas le ciel sera nuageux et dans 30% il sera ensoleillé Simuler des lois discrètes Pile ou face équilibré Il y a plusieurs façons de simuler un lancer de pièce équilibré, par exemple : >> from random import * >> choice([0,1]) 1 donnera 0 ou 1 dans environ 50% des cas. >> random()<0.5 True donnera True ou False également dans environ 50% des cas. Pièce truquée Comment simuler une pièce qui donne par exemple 60% de Pile et 40% de Face ? Une version très simple est : >> random()<0.6 False donnera True dans 60% des cas et False dans 40%. Pouvait-on utiliser choice ? Oui, par exemple en tapant : >> >> choice([1]*60+[0]*40) 0 C’est-à-dire en créant une liste de 100 termes (60 fois “1” et 40 fois “0”, la probabilité d’obtenir un “1” est donc bien de 60%). Avouons que ce n’est pas une technique très efficace ! On peut aussi voir que 60% = 3 / 5 et que 40% = 2 / 5, donc au lieu de 100 termes 5 suffisent : >> >> choice([1,1,1,0,0]) 1 Dé truqué Comment simuler le lancer d’un dé (4 faces pour simplifier) en ayant non pas 25% de chance par face mais par exemple 30% d’avoir le “

Jeu “météorites” inspiré du jeu Game & Watch “Helmet”. But du jeu : Traverser le terrain en évitant la pluie de météorites ! Mais attention, la porte du côté droit n’est pas toujours ouverte, il faut attendre que le voyant soit vert ;-) Le programme a la même base que jeu “fire” pour la NUMWORKS, vous ne devriez donc pas avoir de difficultés à le comprendre.

Explications en vidéo

Vous souvenez-vous des anciens claviers des mobiles ? Vous souvenez-vous également de l’inconvénient pour écrire ? Ici, vous devez calculer le nombre de touches que vous devez taper pour écrire un mot spécifique. Voici la disposition : Exemples >> taper("123") 3 >> taper("abc") 9 (2+3+4) # Taper 2 fois pour obtenir "a", 3 fois pour obtenir "b", 4 fois pour "c" >> taper("baccalaureat") 35 On ne tiendra pas compte ici des touches spéciales * et #. Écrire une fonction taper qui admet en paramètre la le mot à afficher et qui en sortie donne le nombre de touches qu’il faudra taper.

Moiré : https://fr.wikipedia.org/wiki/Moir%C3%A9_(physique)

Version améliorée : Les blocs ne sont plus remplis plusieurs fois

Le problème de Monty Hall ou les probabilités changent de porte | Voyages au pays des maths | ARTE Visitez ma chaine YouTube

Explications en vidéo Ce script permet de coder et de décoder des messages écrits en morse. Pratique pour envoyer un message à une personne à travers une pièce quand on n’a pas de téléphone sous la main ! L’idéal est que les 2 personnes aient une calculatrice Numworks pour pouvoir se répondre. Envoyer un message Il suffit de taper code("Votre texte ici") et d’orienter la calculatrice vers la personne. Le message tournera en boucle, attentez que la personne vous dise qu’elle l’a compris. Décoder un message Tapez dec(). Il y a plusieurs indications sur ce que vous voyez sur l’écran de l’autre personne : 2 barres bleues consécutives à droite, c'est le début d'un message pour vous, tenez vous prêt ! 1 barre rouge au milieu durant 1 seconde = trait long en morse. Tapez "0" au clavier. 1 barre jaune au milieu et brève = 1 point en morse. Tapez "." au clavier 1 barre violette à droite = fin d'une lettre. Tapez sur EXE. Si la machine comprend, elle déchiffre la lettre. Recommencez avec les autres lettres jusqu'à revoir les 2 barres bleues. Appuyez sur la touche Maison (en jaune) pour sortir du programme

Vidéo d’explication Attention ! Depuis la dernière mise à jour de Numworks concernant la gestion des couleurs sous forme uniquement de tuples (par exemple (0,0,0) pour le noir et non plus un nombre), plusieurs programmes ne fonctionnent plus. Le programme ci-dessous fonctionnera sur votre calculatrice mais semble planter en ligne. Recherche d’une séquence d’ADN en utilisant l’algorithme naïf (case après case) Le motif du haut de taille 5 est trouvé sur le brin d’ADN à la 1511e case : La séquence de taille 7 est absente du brin: La séquence de taille 7 est présente à la 1870e place : Algorithmes plus sophistiqués : Utilisation d’une fonction de hachage : voir par ici pour la numworks Lien Wikipédia : voir par ici

Utilisation d’une fonction de hachage simple : somme des couleurs

Il existe 31 mots de 5 lettres et plus dont les lettres sont en ordre croissant. Vous pourrez vérifier que la liste ci-dessous contient 32 mots, il y a donc un mot en trop ! Le retrouver en créant une fonction intrus, pour cela on pourra pour chacun des mots mettre réellement les lettres par ordre croissant et comparer si on a bien le mot d’origine. Par exemple avec le mot « sac » : « sac » trié donne « acs » qui est différent de « sac » mots = "abces,abdos,abers,adent,agios,ainou,alors,bijou,ceins,ceint,chiot,chips,chops,choux,defis,defit,delot,demos,dents,dentu,dhikr,filmo,films,filos,filou,flops,horst,bijoux,chintz,dehors,dhikrs,filmos"

Le challenge est décrit ici

Lien vers l’énoncé de l’exercice

Enoncé de l’exercice

Enoncé du problème

Découvrez ma chaine YouTube

Enoncé de l’exercice

Multiplication russe. Comment multiplier 2 nombres sans utiliser l’opérateur * ? https://fr.wikipedia.org/wiki/Technique_de_multiplication_dite_russe

Faites vos jeux et devinez qui finira premier de cette course de natation ! Vous pouvez vous servir de ce programme pour déterminer dans quel ordre des personnes devront participer à une activité. Explications en vidéo Si vous voulez mettre le rang du joueur à droite plutôt que l’ordre d’arrivée, il suffit de remplacer la ligne : draw_string(str(i+1),300,19+35*rg) par celle-ci : draw_string(str(rg+1),300,19+35*i)

On part d’un nombre, par exemple 235, que l’on écrit en français chiffre par chiffre, ce qui donne “deuxtroiscinq”. Ce mot fait 13 lettres qui, transformé en français, fait “untrois”. Ce mot lui-même fait 7 lettres (“sept”) d’où 4 lettres (“quatre”) puis 6 lettres (“six”) puis “trois”, “cinq” et à nouveau “quatre”. On s’arrête lorsque l’on retombe sur un nombre que l’on a déjà obtenu. Donnons un autre exemple : >> nb(171) unseptun huit quatre six trois cinq 'quatre'

Appuyez plusieurs fois sur la touche “Retour” à côté de “OK” pour arrêter le script.

Lancez le programme et attendez 15 à 20 minutes pour voir le résultat final (Pour les personnes pressées) Version sonore accélérée 80 fois sur ma chaine Youtube

Apprendre Python sur une Numworks

Apprendre Python sur une Numworks

Apprendre Python sur une Numworks

Un ami veut trouver un nouveau nom pour son groupe de musique. Il aime les groupes qui utilisent la formule : ‘The’ + un nom avec la première lettre en majuscule. 'dauphin' doit donner 'The Dauphin' Cependant, lorsqu’un nom commence et se termine avec la même lettre, il aime répéter le nom deux fois en les reliant et sans le « The » devant. 'Alaska' doit donner 'Alaskalaska' 'europe' doit donner 'Europeurope' Pouvez-vous écrire une fonction groupe qui prend en paramètre un mot et renvoie le nom du groupe ? >> groupe('KniFE') 'The Knife' >> groupe('tart') 'Tartart' >> groupe('bed') 'The Bed'

Explications en vidéo Version avec kandinsky Ce programme permet de retrouver (approximativement) le Nord et le Sud à l’aide de la calculatrice. Il suffit pour de préciser l’heure actuelle, si nous sommes en heure d’été ou d’hiver puis d’orienter la machine horizontalement vers le soleil… Version avec turtle En rouge la direction du nord et en vert le sud from turtle import * def trait(a, c): pensize(8) color(c) penup() goto(0,0) pendown() setheading(a) forward(100) def nord(): hm = input("hh.mm ? ") he = input("Heure hiver (o/n) ? ") [h,m] = [int(v) for v in hm.split(".")] v = h + m / 60 - 1 if he.upper() == "N" or he == "8": v -= 1 angle = 15 * v - 90 trait(90, "black") trait(angle, "green") trait(angle + 180, "red") hideturtle()

Version papier-peint des années 70 : from math import * from kandinsky import * for i in range(321*222): set_pixel(i%321,i//321,[(194,156,94),(255,255,0),(255,128,0),(77,40,4)][int(3*sin((i%321-160)/16)*cos((i//321-111)/16))])

Numworks City Des personnes ont signalé des voitures suspectes à Numworks City mais les plaques n’ont pas correctement été identifiées. Par exemples, “c’était une Renault et sa plaque se terminait par 15” ou “la plaque commençait par 28-AC mais je ne connais pas la marque”. Les différentes marques seront ici représentées par une lettre : B : BMW C : Citroën M : Mercedes P : Peugeot R : Renault V : Volvo Les plaques sont de la forme “2 chiffres - 2 lettres - 2 chiffres”, par exemple “20-AB-13” La police de la Numworks City a le fichier complet avec toutes les plaques et marques des véhicules. C’est une liste nommée NWC où chaque élément est une liste avec la plaque et la marque, par exemple : [‘20-AB-13’,’P’] qui correspond à une Peugeot immatriculée 20-AB-13 Questions Voici les questions auxquelles vous devez répondre en utilisant la console uniquement : 1) Combien y a-t-il de véhicules dans le fichier ? 2) Combien y a-t-il de Volvo ? 3) Donnez le nombre de véhicules dont la plaque se termine par 18 4) Combien de Mercedes ont une plaque se terminant par 18 ? 5) Affichez uniquement les marques des véhicule dont la plaque commence par “28-AC” ? 6) “J’ai vu un 18 sur la plaque mais je ne sais plus si c’était au début ou à la fin”. Combien de voitures vérifient ce critère ? 7) “J’ai vu la lettre “D” sur la plaque”. Quelle voiture était-ce ? 8) “J’ai vu une Volvo, je me souviens que les nombres du début et de la fin étaient identiques”. Pouvez-vous retrouver le véhicule ? Programme de recherche Ecrire une fonction recherche qui, à partir d’informations partielles, va rechercher les véhicules correspondants. Les éléments non renseignés seront remplacés par des *. Par exemple : >> recherche("28-*-11","R") devra renvoyer [ "28-AC-11", "R" ] Réponses 1) Combien y a-t-il de véhicules dans le fichier ? >>

Version plus générale : import turtle from random import * t = turtle.Turtle() t.speed(0) t.hideturtle() p = 3 w, h = 400, 300 wn = turtle.Screen() wn.setup(2 * w, 2 * h) wn.colormode(255) wn.tracer(0) c = -w c1, c2 = (60,200,230), (30,) *3 rvb = [0,0,0] t.speed(0) def T(u,a1,a2,b1,b2): return int((b2-b1)/(a2-a1)*(u-a1)+b1) while c < w: l = -h t.pensize(1) for i in range(3): rvb[i] = T(c,-w,w,c1[i],c2[i]) t.pencolor((rvb[0],rvb[1],rvb[2])) while l < 1.1 * h: t.penup() t.goto(c,l) t.pendown() t.setheading(choice((randint(-60,-30),randint(-150,-120)))) t.fd(p*1.414) l += 3 p += 1 c += 5 wn.update()

Écrire une fonction ola qui admet un mot en paramètre et le transforme en ola (Wikipédia : Une ola, ou vague, est un mouvement de foule, semblable à la houle, qui se manifeste principalement dans les stades lors de rencontres sportives, mais aussi dans des rassemblements importants.) Plus précisément, supposons que le mot soit foule, on devra obtenir les lignes : >> ola("foule") Foule fOuLe foUle fouLe foulE donnant l’impression que les lettres se lèvent les unes après les autres de la gauche vers la droite.

Explications en vidéo

On vous donne une chaine de mots (séparés par des virgules) palindromes qui sont valides au Scrabble. Combien y en a-t-il ? Un intrus s’est caché parmi eux, le retrouver en créant une fonction intrus et en utilisant cette chaine en paramètre. Quelle est la vraie écriture de ce mot ? Faire la correction et vérifiez qu’il n’y a plus d’erreur. Bien entendu, il est conseillé de créer à part une fonction palindrome qui permettra de vérifier si un mot est un palindrome ou non.

Traduction en Python de la formule Excel =FLOOR(DATE(year,3,MOD(18.37*MOD(year,19)-6,29)),7)+29 permettant de trouver la date du dimanche de Pâques pour une année quelconque entre 1900 et 2099. >>> easter(2025) (20, 4, 2025) # 20 avril 2025

Un parc d’attraction est accessible aux enfants de 13 ans et plus. Il est également accessible aux enfants de moins de 13 ans s’ils sont accompagnés par un adulte. Écrire une fonction parc qui admet 2 paramètres, l’âge du visiteur et s’il est accompagné ou non d’un adulte (False ou True). En sortie on obtient : >> parc(15,False) "Bienvenue" >> parc(17,True) "Bienvenue" >> parc(7,True) "Bienvenue" >> parc(9,False) "Interdit"

Exercice proposé sur le groupe Facebook "Casse-tête, énigmes et paradoxes" 3 particules apparaissent de manière aléatoire sur un disque. Quelle est la probabilité que les 3 soient sur un même demi-disque ? (Le demi disque en question peut être tracé après coup) Ma chaine Youtube consacrée aux maths et à l’informatique L’idée est assez simple : Choisir au hasard 3 angles entre 0 et 360 (par ex : 320, 10, 290) Trier par ordre croissant : 10, 290, 320 Tester si l’intervalle a une largeur <= 180, si c’est le cas, les 3 points peuvent être mis dans un demi-disque. Ici 320 - 10 = 310 > 180 On ajoute 360 au plus petit, soit maintenant 370, 290, 320. En fait le 10° est proche du 320° car 10+360 = 370° est proche de 320. Trier par ordre croissant : 290, 320, 370 Cette fois-ci 370 - 290 = 80 <= 180 donc ils peuvent être mis dans un demi-disque

Explications en vidéo Voici le célèbre jeu du pendu. Pour cela vous aurez besoin d’une autre personne qui tapera le mot ou la phrase secrète puis ce sera à vous de jouer. Modifications possibles : Ajouter une liste de mots prédéfinis pour ne pas avoir besoin d’un autre joueur : from random import * mot=["CHIEN","CHAT","CRAYON","FEUILLE"] secret = choice(mot) Modifier le visuel du pendu pour avoir plus de coups, par exemple en 10 coups : | o /-+-/ | | / \

Version en couleurs ici

Vidéo d’explication D’autres exemples

Goûteur de plats chez Cléopâtre Le jeu d'origine provient de la revue "L'ordinateur de poche n°22 (1984) page 42" que vous pourrez télécharger ici Programmation du jeu Explications en vidéo L'organigramme du jeu est le suivant (PL = Points de Liberté) : Le programme final est disponible ci-dessous. Probabilités de gagner (par simulation) Quelles sont les probabilités de gagner à ce jeu lorsqu'au départ nous avons un seul point de liberté ? 2 points ? 3 points ? Pour le savoir, nous allons demander à la machine de jouer toute seule et nous calculerons les fréquences de succès dans les différents cas. from random import * def go(PL = 1): # un seul PL par defaut gagne = 0 # nb de parties gagnees nbsimul = 10000 # nb de simulations for k in range(nbsimul): if jeu(PL): gagne += 1 # +1 si on gagne return gagne / nbsimul # frequence observee def jeu(PL): while True: # boucle principale plats = ["1","2","3","4"] # Liste des plats poison = choice(plats) # Ordi choisit plat avec poison choix = choice(plats) # Joueur choisit un plat pr ennemi plats.remove(choix) # On enleve le plat if choix == poison: PL += 1 # Ennemi meurt donc +1 pour nous if PL == 4: return True # On gagne la partie else: choix = choice(plats) # Joueur choisir un plat pr lui if choix == poison: # oups, plat avec poison if PL > 1: PL -= 1 # -1 si on a encore des PL else: return False # Sinon on perd la partie En lançant le programme avec différents paramètres on obtient : go() 0.2491 # 25% de chance de gagner avec un seul PL au départ > go(2) 0.5044 # 50% de chance de gagner avec un 2 PL au départ > go(3) 0.7527 # 75% de chance de gagner avec un 3 PL au départ Probabilités de gagner

2 exercices, un facile et un plus délicat : Exercice 1 Lorsque l’on photocopie un document il perd toujours un peu en qualité. Voici ce que cela peut donner avec une cassette VHS . Imaginons le cas où une lettre peut “muter” en une autre à chaque fois qu’on la photocopie. Par exemple un “A” devient un “a” puis un “#” puis un “+” etc. jusqu’à éventuellement disparaitre (“espace”) Plus précisément, voilà ce qui pourra se passer dans notre cas : C’est-à-dire qu’une lettre peut ne pas être modifiée (un “A” reste un “A” après photocopie) ou être dégradée (Une majuscule devient une minuscule, un “#” devient un “+” etc.) Écrire une fonction scan(txt, n, erreur) qui à partir d’un texte écrit normalement avec des lettres dans A-Z, a-z et/ou les caractères #,+,:,. et espace ainsi que du nombre n de photocopies que l’on fait et du taux d’erreur (par exemple 0.01 pour 1% d’erreur) renvoie le texte final. Ainsi, dans le pire des cas, en 6 photocopies le texte aura entièrement disparu. >> scan("BONJOUR A TOUS",10,0.5) BONJOUR A TOUS bOnJour A toUS bo#jour a ##Us #o+jo#r a ++us +o+jo+r a +:u# +o:jo+# a ::#+ :o.#o:+ a ..#+ .o #o.+ # . #+ o ## + + #: # #+ : + +. + #+ : + + Exercice 2 On vous donne un texte original et un texte qui provient d’une série de photocopies. On vous demande d’écrire un programme qui permet d’affirmer que la photocopie peut provenir de l’original ou non. Par exemple, si on vous donne Bonjour A Tous comme texte original et #o:+++r a t:u# comme photocopie, il est tout à fait possible de passer de l’initial au final, par exemple en faisant : Bonjour A Tous bo####r A T#us bo++##r A t+us #o:+++r a t:u# Par contre, si on vous donne le même texte initial mais #O:+++r a t:u# comme photoc

Vous pouvez tester le script dans l’émulateur en tapant >> dess() Version améliorée du script gimpnumworks.py dans le sens où l’on compresse les données de l’image. Par exemple im="A7B3CD3" signifie 7 fois le caractère “A”, 3 fois le “B”, 1 fois le “C” et 3 fois le “D” ce qui est plus court en mémoire que im="AAAAAAABBBCDDD" def nw(): lett="ABCDEFGHIJKLMNOP" img=gimp.image_list()[0] pdb.gimp_image_scale(img, 80, 55) drw = pdb.gimp_image_active_drawable(img) if not(pdb.gimp_drawable_is_indexed(drw)): pdb.gimp_convert_indexed(img, 0, 0, 16, 0, 1, 0) im="" pal=[] c=0 for i in range(4400): v=list(pdb.gimp_image_pick_color(img,drw,i%80,i//80,1,0,0))[:-1] if v not in pal: pal.append(v) cour = pal.index(v) if i==0 : prec = cour if prec != cour and i>0: im+=lett[prec] if c>1: im+=str(c) c=1 prec = cour else: c+=1 print "pal="+str(pal) print "im=\""+im+"\""

Calculer 1860 décimales exactes en moins de 35 secondes sur une NUMWORKS (N110), c’est possible Pour la NUMWORKS ancienne génération (N100), remplacez 6525 par 2227 et 6524 par 2226, ce qui vous donnera 635 décimales exactes. Mes vidéos autour des décimales de pi : En route vers les décimales de Pi : partie 1 - découvrons les formules de MACHIN En route vers les décimales de Pi : partie 2 - programme Python

Voici les 88 touches d’un piano : La touche n°1 complètement à gauche est blanche, la 2e noire, la 3e et 4e blanches, la 5e noire etc. La touche n°88 complètement à droite est blanche et la 89e sera pour nous à nouveau comme la touche n°1. Vous jouez en tapant successivement sur les touches 1 puis 2 puis 3 etc. Compte tenu du numéro sur lequel vous vous êtes arrêté, serez-vous sur une touche noire ou sur une touche blanche ? Par exemple, si vous vous êtes arrêté à 92, vous êtes allé au bout des touches 1 à 88, puis vous avez continuez sur la n°1, de sorte que vous serez sur la quatrième touche qui est blanche. Écrire une fonction couleur qui admet en paramètre un nombre entier quelconque et qui devra renvoyer la chaîne “noire” ou “blanche”. >> couleur(1) 'blanche' >> couleur(12) 'noire' >> couleur(100) 'noire' >> couleur(1000) 'blanche'

Explications en vidéo Le programme ne fonctionne pas dans l’émulateur mais devrait fonctionner sur votre machine.

Petit script en 314 octets pour célébrer le 14 mars, journée de π

D’autres jeux pour la NUMWORKS sur ma chaine Youtube : Rubika, solitaire, Mission missile, démineur, carré magique, TRON, défis de blanche… Explications en vidéo Le célèbre jeu Pipe Mania (Pipe Dream) pour votre Numworks. Pour jouer Evitez la fuite en plaçant des tuyaux et formez un parcours Flèches de directions Touche EXE pour placer un tuyau Pour passer au niveau suivant, dist doit être égal à zéro OK pour passer au tour suivant

Explications en vidéo ici Dans la vidéo j’utilise monotonic pour temporiser le jeu, dans la version ci-dessous j’ai simplifié en ne mettant que sleep. Pixel Art Restez appuyé sur une des touches 7, 8 ou 9 en vous déplaçant pour obtenir une frise colorée Appuyez sur 2 flèches de direction pour vous déplacer en diagonal Changez la valeur de d = 8 par une autre valeur pour obtenir un quadrillage plus gros ou plus petit. Essayez par exemple avec d = 2 ! N’oubliez pas de prendre en photo vos oeuvres avant de sortir du programme ;-)

Une pizzéria applique la règle suivante : Si un client a commandé un certain nombre de pizzas ayant un certain prix minimum, on lui offre une pizza gratuite. Voici quelques exemples pour fixer les idées : La pizzéria décide qu’il faut au moins 5 pizzas à 20€ pour en avoir une gratuite Commandes du client n°1 : [22, 30, 11, 17, 15, 52, 27, 12]. Il n’a que 3 pizzas à plus de 20€ et donc il n’aura pas de pizza gratuite Commandes du client n°2 : [5, 17, 30, 33, 40, 22, 26, 10, 11, 45]. Il a commandé 6 pizzas à plus de 20€ et donc il aura une pizza gratuite Écrire une fonction pizza qui admet en paramètres la liste des commandes ainsi que le nombre et prix minimal pour en avoir une gratuite. >> pizza([22, 30, 11, 17, 15, 52, 27, 12], 5, 20) 0 >> pizza([5, 17, 30, 33, 40, 22, 26, 10, 11, 45], 5, 20) '1 GRATUITE' >> pizza([22, 30, 11, 17, 15, 52, 27, 12], 2, 30) '1 GRATUITE'

Ma chaine Youtube consacrée aux maths, à la programmation en Python, aux calculatrices, Excel, etc. Découpage d'une pizza xc,yc sont les coordonnées de la pointe de la part de pizza, réparties sur un cercle de rayon 20 et centré en (0,0). Il ne faut pas oublier d’orienter la tortue avant de tracer les arcs de cercles (en partant à 90° pour le premier) Testez par exemple pizza(3) ou pizza(17)

(L) contente 1er service [0.2132 ; 0.2195] (A) content 1er service [0.4265 ; 0.4328] (A) content si (L) contente [0.4629 ; 0.4692] (A) pleure si (L) pleure [0.5781 ; 0.5844]

Ma chaine Youtube consacrée aux maths, à la programmation en Python, aux calculatrices, Excel, etc. Version simple avec des cercles import turtle t = turtle for [x,y] in [[-160,-97],[160,-97],[0,-207],[0,13]]: t.penup() t.goto(x,y) t.pendown() t.circle(97) t.hideturtle() Version avec de vrais demi-cercles Voir programme ci-dessous

Vidéo et explications en cours de réalisation

Réponse à l’énigme proposée par NumWorks. La tortue trace un carré (polygone régulier à 4 côtés) avec toutes les arêtes, ce qui fait un total de 6. Appuyez sur la Flèche du haut pour passer au dessin suivant qui sera un polygone régulier à 6 côtés avec toutes les arêtes, ce qui fait un total de 15. Appuyez sur la Flèche du haut pour continuer le processus… Bon courage 😅

Playlist NUMWORKS de ma chaine Youtube Put your your score in comment / Mets ton score en commentaire !

Le but est d’amener votre avion à la position (200,200,0) La difficulté est que nous sommes dans un espace à 3 dimensions et qu’un missile vous poursuit… Touche 7 et 1 pour augmenter ou diminuer la vitesse sur l’axe des “X” Touche 8 et 2 pour augmenter ou diminuer la vitesse sur l’axe des “Y” Touche 9 et 3 pour augmenter ou diminuer la vitesse sur l’axe des “Z” Au début du jeu votre avion est en X=0, Y=0, Z=255 (point blanc en haut à gauche de l’écran) Le missile est noir et à la position X=200, Y=200 et Z=0 (là où vous devez aller) Attention à ne pas sortir de l’écran ou de vous faire rattraper par le missile sinon votre avion explose ! Vous pouvez régler la difficulté en modifiant la valeur de diff. Mettre par exemple 0.4 Notre avion a explosé ! Remarquez que la couleur de l’avion passe du blanc (loin, par exemple Z = 255) au magenta (proche, par exemple Z = 0)

Visitez ma chaine YouTube (NUMWORKS, fx92…) Persistence of vision / Persistance de la vision Vous avez l’impression de voir une ligne ?? Restez appuyé sur la touche EXE (ou Entrée si vous êtes sur ordinateur) pour stopper l’animation et… la ligne disparait ! Do you feel like you’re seeing a line? Keep pressing the EXE or ENTER key to stop the animation, and… the line disappears!

Vidéo d’explication D’autres exemples

D’après une idée de Sébastien REB

Explications en vidéo BTS = [42,43,44,36,37,38,30] correspond aux codes des touches de 1 à 7 sur la machine.

Jeu Pyramide proposé pour le Grand Concours 2024-2025 - Programmation Python !

Enoncé / Explications Les différentes parties du programme Définir les mots et leurs séries de chiffres correspondants : Nous avons une liste de mots associés à une série de chiffres. Série à décoder : La série de chiffres pour laquelle nous devons trouver le mot. Fonction possibles : Recherche des lettres possibles par chiffre : Pour chaque chiffre unique, nous trouvons les lettres possibles en intersectant les lettres des mots contenant ce chiffre. Nettoyage des correspondances : Nous réduisons les correspondances en éliminant les lettres déjà assignées. Décodage de la série : Nous utilisons les correspondances résolues pour décoder la série de chiffres.

Voici la liste de tous les mots autorisés au Scrabble qui contiennent un Q mais pas de U. Hélas des erreurs se sont glissées, à vous de les retrouver en créant une fonction intrus. Proposez 2 versions. mots = coq#faq#qat#qin#cinq#coqs#faqs#fiqh#qats#qing#qins#fiqhs#maqam#niqab#qibla#qings#maqams#uasdaq#niqabs#paqson#qasida#qatari#qiblas#qwerty#qwertz#tariqa#iraqien#nasdaqs#paqsons#qaddich#qaraite#qasidas#qatarie#qataris#qawwali#tariqas#iraqiens#qaddichs#qaraites#katarien#qataries#qawwalis#tamacheq#iraqienne#qatariens#qatariote#tamacheqs#iraqiennes#qatarienne#qatariotes#qatariennes"

Explications en vidéo

Sur une idée de Vincent Pantaloni But : Trouver des valeurs approchées de √2 sous forme de fractions. Vous devriez trouver successivement 4 / 3, 7 / 5, 10 / 7, 17 / 12… √2 étant irrationnel, aucun des coins des carreaux supérieurs ne tombera exactement sur un des coins des carreaux inférieurs.

Suite au Tweet de nsi.xyz, voici un petit programme qui recherche les nombres n se terminant par l’année voulue et tels que rac(n + rac(n + rac( n + …))) donne un entier. Par exemple n = 1722 correspond au 1er juillet 2022 (1.7.22) et rac(1722 + rac(1722 + rac(1722 + …))) = 42 qui est un entier. Lancez le programme et tapez 22 pour l’année 2022. Remarquez que certaines solutions ne sont pas de vraies dates En quelle année aurons-nous à nouveau des dates donnant des entiers en appliquant la succession infinie de racines carrées ?

Explications en vidéo ici

Calculer plusieurs milliers de décimales exactes des racines carrées avec cet algorithme. Explications en vidéo ici

Version TikTok avec son

Visitez ma chaine YouTube (jeux pour la NUMWORKS, CASIO fx-92…) Image d’origine

Un joueur de flûte a proposé à la ville de Hamelin de la débarrasser de ses rats. Malheureusement certains de ces rats sont sourds et vont dans la mauvaise direction ! Voici les notations : P : joueur de flûte O- ou o- : rat allant vers la gauche (O pour un gros rat et o pour un petit) -O ou -o : rat allant vers la droite Exemples : -O-O -o -O P : Aucun rat sourd (ils vont bien tous vers le joueur de flûte) P o- O- -O O- : 1 rat sourd (il va dans la mauvaise direction) -O-O -o -o P -O -O o- 2 rats sourds (remarquez aussi qu’il peut y avoir plusieurs espaces entre les rats) Écrire une fonction sourds qui admet en paramètre la chaine contenant les rats et le joueur de flûte et renvoie le nombre de rats sourds.

Il s’agit ici d’adapter pour la NUMWORKS le programme écrit initialement en BASIC dans la revue MICR’ORIC de 1983 pour l’ordinateur Oric. Observez le temps d’exécution sur votre calculatrice par rapport à celui annoncé dans la revue… Exemple de graphique (avec une version légèrement améliorée) pour f(z) = 70*cos(z*z/100)*exp(-z*z/1000) : f(z) = 20*sqrt(exp(-sin(z/3))) : f(z) = 110*cos(z/30)*sqrt(exp(-sin(z/3))) : Le chapeau : Ce que vous pouvez modifier dans le script : - la valeur de m initialement mise à 30 comme dans la revue peut être augmentée. - au lieu de r=y1 vous pouvez aussi mettre r=60 (et -60 plus loin) pour que la base du graphique ne soit plus un disque mais un carré (mais le visuel est alors moins fun !) - Le .7 de la ligne 31 permet d’avoir une vue plus ou moins plongeante (testez avec 0.1 et 1 par exemple) - L’astuce pour ne pas voir les parties cachées de la surface est, pour un x donné, de n’afficher le pixel que si la valeur du y est supérieur au max des valeurs précédentes (par exemple si les valeurs de y sont 3, 5, 9, 6, 15, 11, 13, 18 et 2, les valeurs réellement affichées seront 3,5,9,15 (car le 6 est <9), 18 (car 11 et 13<15) et 18.

Anaglyphes Vidéo d’explication. Remarques : Certaines personnes ne voient pas les images en relief donc pas d’inquiétude… Regardez la calculatrice en vous éloignant d’au moins 50 cm et bien la tenir à la verticale (pas sur la table) Il faut une paire de lunettes rouge-cyan pour voir les images ci-dessous en 3D. Collection personnelle Fabriquer des lunettes (avec des marqueurs rouge+bleu et un boitier de CD). En acheter sur Amazon >> go1() >> go2() (remplacer r//10 par r*r//1600 pour obtenir une paraboloïde) >> go3() >> go4() >> go5() (courbes de Lissajou, regardez-là se construire en 3D sur l’écran de votre machine. Testez go5(2) puis go5(3) puis go5(5) etc et observez les différences) >> go6() (Pyramide vue du dessus et 4 points) >> go7() (Plantes grimpantes)

Visitez ma chaine YouTube

Tapez par exemple convertir(2022) Découvrez ma chaine YouTube (Python, JavaScript, calculatrices…)

rot13 est un système de codage utilisé sur Internet par exemple pour révéler la fin d’un film ou … insulter une personne ! YR UREBF ZRHEG N YN SVA ! Le système consiste à décaler les lettres de 13 rangs, le A devient un N, le B un O…, le M un Z, le N un A jusqu’au Z qui devient un M. Si la lettre est entre A et M, ajoutez 13 pour obtenir lettre entre N et Z Si la lettre est entre N et Z à Soustraire 13 pour obtenir lettre entre A et M Appliquer rot13 permet de coder et de décoder un message puisqu’il y a 26 lettres dans l’alphabet. Écrire une fonction code qui admet en paramètre une phrase écrite en majuscules et décale toutes les lettres de 13 rangs. Les ponctuations ne devront pas bouger.

Script original ici

Vidéo d’explication J’ai également fait une version visuelle dans le cas du cube 2x2x2 Le programme calcule l’ordre d’un mouvement, c’est-à-dire combien de fois il faut le répéter pour revenir au point de départ. Il est suffisamment général pour pouvoir s’appliquer au Rubik’s cube classique, au pocket ou à d’autres jeux comme les anneaux Hongrois. >> ordre("FR") donnera 15 (Le mouvement est face avant + droite) Utilisez des minuscules pour tourner une face en sens inverse. Pour passer d’un objet à un autre, faire un copier-coller des constantes ci-dessous. Rubik 2x2x2 U=[(8,9,11,10),(2,12,17,7),(3,14,16,5)] R=[(12,13,15,14),(23,19,11,3),(21,17,9,1)] L=[(4,5,7,6),(0,8,16,20),(2,10,18,22)] F=[(16,17,19,18),(6,10,14,21),(7,11,15,20)] D=[(20,21,23,22),(18,15,1,4),(19,13,0,6)] B=[(3,2,0,1),(13,9,5,22),(12,8,4,23)] CUBES=4 COUL="RBWVOJ" Rubik 3x3x3 F=[(0,6,8,2),(1,3,7,5),(9,45,44,35),(29,11,51,38),(10,48,41,32)] B=[(18,24,26,20),(19,21,25,23),(15,33,42,47),(27,36,53,17),(16,30,39,50)] U=[(9,15,17,11),(10,12,16,14),(6,27,20,45),(29,18,47,8),(28,19,46,7)] D=[(42,36,38,44),(43,39,37,41),(0,51,20,33),(35,2,53,24),(1,52,25,34)] R=[(45,47,53,51),(46,50,52,48),(2,11,20,42),(44,8,17,26),(5,14,23,43)] L=[(27,29,35,33),(28,32,34,30),(0,36,18,9),(38,24,15,6),(12,3,37,21)] CUBES=9 COUL="RBWVOJ" Anneaux Hongrois L=[(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 23)] R=[(19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 4)] COUL="RBNJ" cube="R"*10+"B"*9+"N"*10+"J"*9

Amélioration du programme Rubik avec visualisation éclatée du cube 2x2x2 Vous pouvez tester par exemple avec >> ordre("FR")

Explications en vidéo Pour lancer le jeu, faire go() tout seul ou go avec un paramètre pour augmenter ou diminuer la difficulté, par exemple go(2) pour avoir un jeu dont la solution est possible en 2 coups. Le jeu d’origine pour la HP 41

Explications en vidéo ici

Renne dessiné avec des morceaux de paraboles. La fonction coeff permet de trouver les coefficients a,b,c de la parabole passant par le sommet S(xs,ys) et le point A(x1,y1). La fonction parab trace la parabole passant par S et A pour les abscisses entre x1 et x1 + d (d pouvant être négatif) Il suffit donc de repérer (avec un logiciel comme Gimp) les coordonnées de S et A ainsi que la distance d, en faisant attention au fait que le centre de l’écran a pour coordonnées (0,0). Si l’image Gimp fait 320x220 pixels, il faudra effectuer les translations X - 160 et 110 - Y pour passer aux coordonnées de la tortue. Ci-dessous le visuel expliquant d’où vient par exemple le parabole(0,-100,-45,-12,90) dans le script : Ma chaine Youtube Schraf - Maths info

YouTube Channel - Post Facebook

Automate cellulaire à une dimension https://mathworld.wolfram.com/Rule182.html Page Wikipedia consacrée aux automates cellulaires Tapez par exemple >>> go() ou go(30), le nombre devant être entre 0 et 255

from math import * from kandinsky import set_pixel, fill_rect, get_pixel # Rayon (au carré) des 3 disques R = 180*180 # Précision du tracé (mettre 1 par exemple) pas = 4 def synthese(sous = 1): # Fond blanc si synthèse soustrative sinon noir fill_rect(0,0,320,222,(255 * sous,) * 3) # On dessine les 3 disques centrés en (0,50), etc. for i, m in enumerate([[0,50],[320,50],[160,290]]): # On parcourt tous les pixels de l'écran for c in range(0,320,pas): for l in range(0,222,pas): # Distance au carré entre le point (c,l) et le centre du disque d = (m[0] - c) ** 2 + (m[1] - l) ** 2 # On est dans le disque ? if d < R: # Couleur actuelle du pixel en (c,l) # On transforme en liste car un tuple n'est pas modifiable p = list(get_pixel(c,l)) # Synthèse soustractive if sous: p[i] = int(max(p[i] - 255 * sqrt(d / R), 0)) # Synthèse additive else: p[i] = int(min(p[i] + 255 * sqrt(d / R), 255)) # On dessine le rectangle avec la précision voulue fill_rect(c,l,pas,pas,tuple(p))

Vidéo TikTok de ce script | En savoir plus (En anglais) Le script plante parfois avec le simulateur mais devrait bien tourner sur votre NUMWORKS N110 ou N120 Ma chaine Youtube

Poids idéal et récupération de la fréquence cardiaque. Enoncé Poids Idéal T : Taille en cm TP : Tour du poignet en cm Age : Age en années Programmez les formules de Lorentz, Creff et Monnerot suivantes pour le calcul du poids idéal : Lorentz : T - 100 - (T - 150) / 4 pour les Hommes et T - 100 - (T - 150)/2.5 pour les Femmes Creff : (T - 100 + Age / 10) * 0.9 Monnerot : (T - 100 + 4 * TP) / 2 On pourra donner 3 valeurs à chaque fois, la valeur idéale puis le poids minimum (90% de la valeur idéale) et le poids maximum (110% de la valeur idéale) Enoncé fréquence cardiaque La machine doit demander le nombre de pulsation au repos pendant 15 secondes. Multipliez par 4 pour avoir le nombre de pulsations par minute -> FC1 Ensuite “faire 30 flexions pendant 45 secondes” puis à nouveau on demande le nombre de pulsations pendant 15 secondes. Multipliez par 4 -> FC2 Ensuite “Se reposer 1 minute” puis à nouveau le nombre de pulsations pendant 15 secondes. Multipliez par 4 -> FC3 Indice de Ruffier : (FC1 + FC2 + FC3 - 200) / 10 Plus l’indice est faible, meilleure est l’adaptation à l’effort Faire en sorte d’avoir à l’affichage ‘Très bon’, ‘Bon’, ‘Moyen’, ‘Insuffisant’ ou ‘Mauvais’ suivant la valeur de l’indice : indice = 0 : très bonne adaptation à l’effort ; indice compris entre 0 et 5 : bonne adaptation à l’effort ; indice compris entre 5 et 10 : adaptation à l’effort moyenne ; indice compris entre 10 et 15 : adaptation à l’effort insuffisante ; indice supérieur à 15 : mauvaise adaptation à l’effort

Quelques explications : la variable boules contient toutes les boules lumineuses du sapin chaque boule a sa propre vie, à savoir une position x,y, une taille t, une couleur c et un angle a Toutes les 0,01 seconde on met à jour l’ensemble des boules la position x,y suit une ellipse, l’angle augmentant de façon aléatoire (dit autrement, les boules ne tournent pas à la même vitesse) et lorsqu’un tour complet est effectué (2*pi), la couleur change (en suivant les valeurs qu’il y a dans la variable couleurs) A chaque fois on dessine un rectangle noir pour nettoyer un peu le dessin, on pourrait également mémoriser la position précédente de la boule pour l’effacer plus proprement.

Image originale

Voir l’oeuvre “Schotter” de Georg Nees L’oeuvre commence avec une rangée standard de carrés et augmente progressivement l’ampleur du caractère aléatoire de la rotation à mesure que l’on descend dans les rangées.

Sécurité routière Les « 0 » ci-dessous représentent des éléments de véhicules, par exemple « 000 » est un véhicule de longueur 3 (un camion) et « 0 » une petite voiture. route = "==000==0==00=000==00=0000===00=====000===00=000====0=0====00====" Les « = » représentent la route et on imagine que les véhicules se déplacent vers la droite. Donc sur la route ci-dessus on a à gauche un camion et devant lui une petite voiture etc. Créez une fonction vehic qui admet une route en paramètre et donne en retour le nombre total de véhicules (camions et voitures) Créez une fonction voit qui donne uniquement le nombre de voitures (C’est-dire un véhicule de longueur inférieure à 3) Un véhicule est en infraction lorsque sa distance avec celui qui le précède est de seulement 1 « = ». Créez une fonction radar qui compte combien il y a d’infractions sur la route. Créez une fonction simple qui simplifie l’écriture de la route sous la forme : “cvvcvcvcvcvvv” qui signifie camion – voiture – voiture… ? Explications en vidéo

Bon 7e anniversaire à la NUMWORKS

Petit jeu type “simon” : Touche 0 pour lancer un tour et touches de 1 à 9 pour répéter le motif. En cas d’erreur la partie est terminée et votre score s’affiche. Ma chaine Youtube consacrée aux maths, à la programmation en Python, aux calculatrices, Excel, etc. Description du programme from random import randint from ion import * from kandinsky import fill_rect,draw_string from time import sleep VE, RO, BL, NR = (0,255,0), (255,0,0), 3 * (255,), (0,0,0) # couleurs def eff_ecran(): # efface écran et dessin de la grille fill_rect(0,0,320,222,BL) for i in range(4): fill_rect(130 + 60 * i, 20, 1, 180, NR) fill_rect(130, 20 + 60 * i, 180, 1, NR) def wait(*dg): # Attente d'une touche numérique while True: for k in dg: # on parcourt les codes attendus if keydown(k): # si touche enfoncée while keydown(k): continue # on attend qu'elle soit relâchée return (1 + (k + 3) % 9) * (k < 48) # retour de la valeur correspondante def aff(txt, attend = 0): # affichage d'un texte fill_rect(0,0,129,222,BL) draw_string(txt, 60 - 5 * len(txt), 100) if attend: wait(48) # Attente appui touche "0" def rect(v,coul = NR): # rectangle dans la grille x, y = 135 + 60 * ((v - 1) % 3), 25 + 60 * (2 - (v - 1) // 3) fill_rect(x, y, 50, 50, coul) # en couleur sleep(.3) fill_rect(x, y, 50, 50, BL) # on l'efface sleep(.3) def go(): while True: simon = [] # contenu du simon tour = 1 eff_ecran() while tour > 0: aff('Tour '+str(tour), 1) simon.append(randint(1, 9)) # ajout d'une valeur à simon for v in simon: rect(v) # animation aff('A toi !') correct = True # Pour le moment le joueur a bon i = 0 while correct: t = wait(42,43,44,36,37,38,30,31,32) # on attend un chiffre entre 1 et 9 if t == simon[i]: # si correct rect(t, VE) # rectangle vert

Un fumeur a 2 boites de 40 allumettes dans ses poches. A chaque fois qu’il fume il prend une allumette au hasard dans une des 2 boites. Combien en moyenne restera t-il d’allumettes dans ses poches lorsqu’il aura vidé une des boites ? Répéter un certain nombre de fois l’expérience (𝑛 = 5000 par exemple) Chaque expérience donnera un résultat (Temps d’attente en minutes, nombre d’allumettes etc.) Faire la moyenne de ces résultats (Somme des résultats divisé par le nombre de simulations) On obtient une estimation ponctuelle de la moyenne (notée 𝑚𝑒) Explications du programme en vidéo : https://youtu.be/YOBwrrTIHe0?t=12m28s La valeur théorique est 7.

A une soirée, 50 personnes déposent leur chapeau à un vestiaire. En repartant la dame du vestiaire donne à chacun un chapeau au hasard. Quelle est la probabilité qu’au moins une des personnes reparte avec son bon chapeau ? Répéter un certain nombre de fois l’expérience (𝑛 = 5000 par exemple) Chaque expérience donnera un résultat (Temps d’attente en minutes, nombre d’allumettes etc.) Faire la moyenne de ces résultats (Somme des résultats divisé par le nombre de simulations) On obtient une estimation ponctuelle de la moyenne (notée 𝑚𝑒) Explications du programme en vidéo : https://youtu.be/YOBwrrTIHe0?t=26m55s La valeur théorique est 𝑝 = 1−𝑒−1 ≃ 0,6321

On lance 5 dés. A chaque lancer on met de côté ceux qui ont fait « As » et on relance les autres jusqu’à obtenir 5 « As ». Combien en moyenne faut-il lancer les dés ? Répéter un certain nombre de fois l’expérience (𝑛 = 5000 par exemple) Chaque expérience donnera un résultat (Temps d’attente en minutes, nombre d’allumettes etc.) Faire la moyenne de ces résultats (Somme des résultats divisé par le nombre de simulations) On obtient une estimation ponctuelle de la moyenne (notée 𝑚𝑒) Explications du programme en vidéo : https://youtu.be/YOBwrrTIHe0?t=19m22s La valeur théorique est :

Deux personnes se donnent rendez-vous entre 12h et 13h. Quel sera en moyenne le temps d’attente de la première personne arrivée ? Répéter un certain nombre de fois l’expérience (𝑛 = 5000 par exemple) Chaque expérience donnera un résultat (Temps d’attente en minutes, nombre d’allumettes etc.) Faire la moyenne de ces résultats (Somme des résultats divisé par le nombre de simulations) On obtient une estimation ponctuelle de la moyenne (notée 𝑚𝑒) Explications du programme en vidéo : https://youtu.be/YOBwrrTIHe0 La valeur théorique que l’on peut trouver après calculs est de 20 minutes. Modifiez le programme pour savoir quel sera le temps d’attente de la première personne lorsque le rendez-vous est prévu entre 16h et 16h30. Explications en vidéo des exercices de simulation Aller plus loin et trouver un intervalle de confiance : La moyenne est dans l’intervalle [mini ; maxi] avec 95% de chance 𝐼=[ 𝑚𝑒 − (1,96 𝜎𝑒) / √𝑛 ; 𝑚𝑒 + (1,96 𝜎𝑒) / √𝑛 ] où 𝜎𝑒 est l’écart-type observé

Adaptation en Python Turtle d’un script écrit à l’origine en Smalltalk (Revue Micro Systèmes de février 1984 - pages 116 et suivantes)

Explication en vidéo ici

En réponse à un Tweet de @NumWorksFR

Enigme proposée par NUMWORKS

Explications en vidéo Vous pouvez jouer avec l’émulateur en utilisant les flèches du clavier, la touche Entrée et la touche Retour (Backspace).

Source : http://www.peda.com/grafeq/gallery.html Chrome : https://my.numworks.com/python/schraf/chrome Margarita : https://my.numworks.com/python/schraf/margarita Threesome : https://my.numworks.com/python/schraf/threesome The Big Swim : https://my.numworks.com/python/schraf/bigswim Arachnid : https://my.numworks.com/python/schraf/arachnid

Facebook ZX Spectrum

Un point A parcourt un cercle de rayon R1 (repéré avec un angle t). Sur un second cercle de rayon R2 centré en A, on place le point M à l’angle t*v où v est fixé dès le départ. Le programme ci-dessous affiche la trajectoire du point M Il ne s’agit donc pas du cas d’un cercle roulant à l’intérieur (hypocycloïde) ou à l’extérieur (épicycloïde) d’un autre cercle comme on l’a sur les jeux pour enfants : >> go(5,1,10) pour un grand cercle R1=5, un petit cercle R2=1 et une vitesse = 10 (le point M tourne 10 fois plus vite autour du petit cercle que le point A autour du grand) >> go(1,3,10,1000) pour un petit cercle R1=1, un grand cercle R2=3, une vitesse = 10 et 1000 points >> go(4,2,2) Le point M sur le petit cercle va 2 fois plus vite que le A sur le grand cercle >> go(1,10,2) >> go(10,1,40,1000) La ligne while random()>.001: t=0 est juste là pour ralentir la machine qui va trop vite pour afficher le déroulement…

Construction d'une hypocycloïde Trajectoire d’un point fixé à un cercle qui roule sans glisser sur un autre cercle dit directeur et à l’intérieur de celui-ci. Autres courbes ici >> go(7,2) (un tour ne suffit pas à tout afficher) >> go(7,2,2) (on fait faire 2 tour au petit cercle. Mathématiquement, il faut chercher le plus petit multiple commun entre 7 et 2, à savoir 14, et diviser ce nombre par le premier paramètre (7) d’où 14/7 = 2 tours)

Tuto détaillé sur la création de ce jeu (utile si vous suivez la filière NSI au lycée) But Obtenir le plus grand territoire possible en lançant de la peinture. Comment jouer ? A la ligne n°79 il y a un 0 après le -100, cela signifie qu’il s’agit d’un joueur humain A la ligne n°80 il y a un 1 après le 100, cela signifie que c’est la calculatrice qui joue. Donc mettez des 0 ou des 1 pour avoir 2 joueurs humains ou pour que la calculatrice joue toute seule. Les touches sont les flèches gauche et droite et pour lancer la peinture, restez appuyé plus ou moins longtemps sur la flèche vers le bas (Flèche vers le haut pour le 2e joueur humain) pour définir la distance du jet.

Explications en vidéo ici Simulation de l’économiseur d’écran “Starfield” bien connu sous les anciennes versions de Windows. Autres versions Effet 1 Modifiez uniquement la ligne qui génère les positions initiales des points (on les met tous très loin entre 50 et 55) : def point(): return [randrange(-40,40),randrange(-40,40),randrange(50,55)] Testez avec >>go() Effet 2 Modifiez alors les lignes : px = min(320, max(-1,st[i][0] * (1 - z / 10)**2 + 160)) py = min(240, max(-1, 5 * st[i][1] / z + 120)) Effet 3 On peut aussi changer les lignes px = et py = du programme ci-dessous pour obtenir de nombreux autres effets, par exemples : px = min(320, max(-1,st[i][0] * sqrt(z/5) + 160)) py = min(240, max(-1,st[i][1] / z + 120)) Effet 4 px = min(320, max(-1,st[i][0] * (10 - z) / 10 + 160)) py = min(240, max(-1,st[i][1] * cos(z / 2) + 120)) Sans oublier de mettre from math import sqrt, cos au début du programme. Version "Neige" from random import * from kandinsky import * from time import sleep nb = 120 st = [0]*nb pr = [0]*nb NR = (0,0,0) def point(): return [randrange(320),0,randrange(1,10)] def init(): fill_rect(0,0,320,222,NR) for i in range(nb): st[i] = point() def go(): init() while True: sleep(.05) for i in range(nb): st[i][1] += randrange(1,int(50/st[i][2])) z = st[i][2] px = st[i][0] py = min(240,st[i][1]) if py >= 240: st[i] = point() if pr[i] != 0: set_pixel(pr[i][0],pr[i][1],NR) pr[i] = [int(px),int(py)] c = int((1 - z/10) * 255) set_pixel(pr[i][0],pr[i][1],color(c,c,c))

Réalisation de la montre suivante sur la NumWorks : https://www.tokyoflash.com/en/watches/kisai-stencil On peut aussi remplacer le changement des heures - minutes - secondes par : s+=1 m+=s//60 s%=60 h=(h+m//60)%24 m%=60 Autre présentation aff(20,20,h//10,3) aff(80,20,h%10,3) aff(20,110,m//10,3) aff(80,110,m%10,3) aff(180,80,s//10,2) aff(220,80,s%10,2)

Des jeux pour la NUMWORKS sur ma chaine Youtube : Rubika, solitaire, Mission missile, démineur, carré magique, TRON, défis de blanche…

Vidéo d’explication ici String Art (Tableaux de fils) Tapez >> art0(), >> art1() etc pour voir les différents tableaux. La vidéo explique comment trouver les coordonnées des points (sur le cercle, les rayons, les arcs et les cordes) pour générer une infinité de tableaux.

On vous donne un mot en minuscules et vous devez supprimer k caractères en respectant les règles suivantes : Supprimer les lettres “a” puis “b” puis “c”, etc. Supprimer les lettres en partant de la gauche Exemples : >> suppr("abracadabra", 1) 'bracadabra' # on supprime le 'a' le plus à gauche >> suppr('abracadabra', 2) 'brcadabra' # suppr des 2 'a' à gauche >> suppr('abracadabra', 6) 'rcdbr' # 5 'a' puis 1 'b' >> suppr('abracadabra', 8) 'rdr' >> suppr('abracadabra',50) '' Explications en vidéo

A court d’idée pour la Saint-Valentin ? Offrez-lui ce script pour sa Numworks ! 💝💗💖 Version TikTok 📺 Découvrez ma chaine Youtube

Découvrez ma chaine YouTube (Python, JavaScript, calculatrices…) Le principe est très simple, en une minute vous devez réaliser le score le plus élevé possible. Pour cela appuyez sur les touches 0, ., x10^x,Ans ou EXE en fonction des rectangles bleus qui apparaissent en bas de l’écran. OK = Nombre d’appuis réussis et KO = Nombre d’appuis ratés.

Suite au tweet de @nsi.xyz proposant à ces élèves le thème “Ecrire un script python qui produit une image”, avec différents sujets possibles et imposant l’usage de la tortue, voici ci-dessous ma proposition. Attention, il faut plusieurs minutes avant de voir le résultat final… Je suis resté dans l’esprit Synthwave

Sur une idée de Jean-Yves Labouche

Version récursive du script de : https://my.numworks.com/python/eloidrai1/sierpinski Mⷨᴀͣ ᴄͨʜͪᴀͣɪͥɴᴇͤ ʸᵒᵘᵗᵘᵇᵉ‧ᶜᵒᵐ/ˢᶜʰʳᵃᶠ

Animation TikTok En savoir plus (Learn more)

Une version simple du célèbre télécran. Utilisation Tapez >> tel(), un point apparaît alors au milieu de l’écran. Tapez sur les touches 2, 4, 6 ou 8 pour vous déplacer vers le bas, à gauche, en haut ou à droite. De même avec 1, 3, 7 et 9 pour partir en diagonal. Validez ensuite par EXE (tout cela sans voir ce que vous tapez…) Vous pouvez bien entendu taper des séries comme 2486 pour obtenir un carré ou 12369874 pour un pseudo cercle. Pour effacer appuyez sur la touche 0 suivi d’un chemin (par exemple 0999) et la touche . pour abaisser à nouveau le crayon. Exemple de 2 triangles côte à côte : 4493066.9344 2 traits vers la gauche (44), haut-droit (9), bas-droit (3), on lève le crayon (0), 2 pas vers la droite (66), on repose le crayon (.) et on dessine l’autre triangle (9344). Dès le lancement du programme vous pouvez déjà taper un chemin, par exemple >> tel("7931") Si vous êtes en manque d’inspiration, tapez >> tel(alea) Réalisations un peu plus complexes Améliorations possibles Les traits ont une longueur de 5 pixels ce qui peut être embêtant pour faire des dessins plus précis Dans cette version, si on passe 2 fois au même endroit la couleur reste noire, on peut imaginer faire des traits en gris (couleur = 31727 (moitié de 65535)) et lorsque l’on repasse sur du gris le pixel devient alors noir (couleur = 0)

Explications en vidéo Réalisation de la montre suivante sur la NumWorks : https://www.tokyoflash.com/en/kisai-tenmetsu >> go(17,29,30) pour lancer la montre avec l’heure 17h29m30s

Une vidéo est en cours de réalisation pour expliquer comment obtenir des résultats analogues en partant de Geogebra

Source : http://www.peda.com/grafeq/gallery.html Chrome : https://my.numworks.com/python/schraf/chrome Sphère : https://my.numworks.com/python/schraf/sphere Margarita : https://my.numworks.com/python/schraf/margarita The Big Swim : https://my.numworks.com/python/schraf/bigswim Arachnid : https://my.numworks.com/python/schraf/arachnid

Sur une idée d’Andrew Wulf

Quelques exemples : def f(t, i, x, y): return sin(y/8+t) def f(t, i, x, y): return random() def f(t, i, x, y): return sin(t) def f(t, i, x, y): return i / 256 def f(t, i, x, y): return x / 16 def f(t, i, x, y): return y - 7.5 def f(t, i, x, y): return y - t def f(t, i, x, y): return [1, 0, -1][i%3] def f(t, i, x, y): return sin(t-sqrt((x-7.5)**2+(y-6)**2)) def f(t, i, x, y): return (y > x) and (14-x < y) def f(t, i, x, y): return (int(t*10)) & (1<<x) and y==8 def f(t, i, x, y): return random() * 2 - 1 def f(t, i, x, y): return cos(t + i + x * y) def f(t, i, x, y): return sin(x/2) - sin(x-t) - y+6 def f(t, i, x, y): return -.4/(.01+hypot(x-t%10,y-t%8)-t%2*9) def f(t, i, x, y): return .02/sin(3**(x+1)-atan2(x+1,(x+1)*y)*3-t) def f(t, i, x, y): return sin(atan2(x-8,y+5)*8+sin(y)+t*4) def f(t, i, x, y): return x & 1 if cos((i|17)**2+t)>0 else y & 1 def f(t, i, x, y): return (16*(1+sin(t+x))<(x+y))*sin(x-t) def f(t, i, x, y): return sin((x & y)/(.01 + sin((t/3)%3)*38-y-x))

Ma playlist de jeux et de tutos pour la NUMWORKS Vidéo TikTok sur une vraie machine

Au pied d’un arbre, dans un petit coffre enterré, vous trouvez un parchemin avec le texte suivant : “Pirate, pour arriver au trésor, tu devras faire 100 pas dans chacune de ces directions : ONNESEE” Mais en faisant un schéma on se rend vite compte que pour arriver au trésor nous ne sommes pas obligés de faire tout le parcours indiqué mais seulement de faire 200 pas vers l’Est et 100 pas vers le Nord, soit EEN. On vous demande d’écrire une fonction nommée tresor qui admet en paramètre le chemin indiqué sur le parchemin et qui en sortie vous donne le chemin le plus court pour y accéder.

Ecrire une fonction tresse ayant en paramètres le nombre de colonnes et de lignes voulues (par exemple tresse(5,7) pour 5 colonnes et 7 lignes) et qui en sortie affiche un motif dont la partie en gauche est répétée symétriquement à droite et la partie haute est répétée symétriquement en bas. Exemples : >> tresse(5,4) -o-o- ooooo ooooo -o-o- >>tresse(8,5) o------o o-oooo-o ooo--ooo o-oooo-o o------o La version ci-dessous utilise les nombres binaires mais on peut imaginer plusieurs autres solutions.

Explications en vidéo

Dans le script ci-dessous je n’utilise que “lt” (left) pour orienter la tortue et “fd” pour la faire avancer. La lettre “m” permet d’indiquer qu’il faut mémoriser la position actuelle et “r” qu’il faut retourner à cette position.

Explications en vidéo Pour lancer le programme avec 2 joueurs, tapez >> go() et pour 3 joueurs tapez >> go(3)

Simulation d'une machine de Turing Explications du principe de la machine ici m1 : Ajouter un 1 à droite d’une séquence m2 : Compter en binaire m3 : Addition unaire 11(2) + 111(3) = 11111(5) m4 : Doubler les éléments 111 –> 111111 m5 : Remplacer les 0 par des 1 m6 : Parité du nombre de 1 dans une chaîne (0=pair, 1=impair) m7 : Conjecture de Syracuse (voir Programme) m8 : Castor affairé (voir Wikipédia) Dans cette machine simplifiée il n’y a que 6 états possibles (A à F), l’état F étant l’état final. On peut lire ou écrire sur le ruban les caractères b (blanc), 0 , 1 et s Vous pouvez tester le programme dans l’émulateur de cette page ou sur https://repl.it/languages/python3 en copiant/collant le code. >> turing(m5) EXE # Appuyez sur la touche EXE pour passer à l'étape suivante A bbb001101 0 d # Etat = A, tête de lecture = 0, action = déplacement à droite A bbb001101 1 d # La tête est maintenant en 1, action = déplacement à droite A bbb001101 2 d # La tête en 2 A bbb001101 3 B # Mettre l'état à B B bbb001101 3 1d # Ecrire un "1" et se déplacer à droite B bbb101101 4 1d # Ecrire un "1" et se déplacer à droite B bbb111101 5 d B bbb111101 6 d B bbb111101 7 1d B bbb111111 8 d B bbb111111b 9 F # Fin du programme Explications rapides du programme prgm = {c[:2]:c[2:] for c in code.split(',') } : On récupère les données du programme sous la forme “état+caractère” : “choses à faire”, par exemples "Ab" : "1F" try: c = rub[pos] : On tente de lire ce qu’il y a sur le ruban (problème si pos est négatif ou plus grand

Lancez ce script sur une vraie machine. La calculatrice attend un appui sur un chiffre impair (1,3,5,7 ou 9) puis sur 2 ou 8 et à nouveau un nombre impair, etc. La formule (1 + (k + 3) % 9) * (k < 48) permet de transformer les codes des touches en chiffres : 42 -> 1, 44 -> 3 etc

txt("Bonjour",10,20,color(255,0,0)) met le texte “Bonjour” en rouge à la position (10,20) L’idée est de récupérer les valeurs Rouge-Vert-Bleu des pixels du texte écrit en noir et gris et de les convertir dans la couleur voulue. Chaque lettre fait 10*18 pixels

Adaptation d’un programme de Paul Malin pour la calculatrice Numworks. Ma chaine Youtube Maths-info

Animation et script d’origine Ma chaine YouTube

Comment utiliser ces 2 scripts Python : Vidéo d’explication Comprendre en 10 minutes les mathématiques cachées derrière : Les courbes de Bézier - Elles sont partout ! Gimp def conv(s): try: return int(float(s)) except: return s def nw(): img = gimp.image_list()[0] svg = pdb.gimp_vectors_export_to_string(img, img.vectors[0]) svg = svg.split(" d=\"")[1].split("\"")[0].replace(" ",",").replace("\n",",").replace("M",",M") svg = [conv(v) for v in svg.split(",") if len(v)>0] return svg Ce script permet de récupérer dans une chaine de caractères nommée svg les coordonnées des points et des poignées. Un petit nettoyage est fait sur les espace et les retours à la ligne et on ne prend que des coordonnées entières afin de gagner en espace mémoire. Quelques visuels Lunettes en coeur et téléphone svg = ['M',166,119,'C',166,119,149,71,149,71,148,68,146,65,142,64,138,63,134,62,130,63,130,63,111,68,111,68,108,68,107,70,107,72,108,74,111,75,114,74,114,74,133,70,133,70,134,69,136,70,137,70,138,71,139,71,139,72,139,72,152,109,152,109,150,109,148,109,146,109,140,109,134,111,130,114,126,111,121,109,115,109,109,109,103,110,99,113,97,115,95,117,94,120,94,120,87,120,87,120,86,117,84,115,82,113,78,110,73,109,67,109,60,109,55,111,51,114,47,111,41,109,35,109,33,109,31,109,29,109,29,109,41,72,41,72,42,71,43,70,44,70,45,70,47,69,48,70,48,70,67,74,67,74,70,75,73,74,74,72,74,70,73,68,70,68,70,68,51,63,51,63,47,62,43,63,39,64,35,65,33,68,32,71,32,71,15,120,15,120,15,121,15,123,15,124,15,132,24,137,37,145,40,147,44,149,48,151,49,151,50,152,51,152,52,152,53,151,54,151,58,149,62,147,65,145,76,138,85,134,87,127,87,127,94,127,94,127,96,134,105,138,116,145,120,147,123,149,127,151,128,151,129,152,130,152,131,152,133,151,133,151,137,149,141,147,144,145,157,137,167,132,167,124,167,122,166,121,166,119,'Z','M',59,139,'C',56,141,54,142,51,144,48,142,46,141,43,1

Suite à une publication de Numworks concernant les vendredis 13, voici un petit programme qui permet de compter combien de fois, sur une période de 400 ans, il y a eu de lundi 13, mardi 13 etc. On constate qu’il y a effectivement eu plus de vendredis 13 ! J’ai utilisé la formule de Schwerdtfeger pour le calcul. Quelques unes de mes vidéos Youtube sur des sujets similaires : Théorie des calendriers perpétuels portatifs Astuce pour retrouver le jour de la semaine d’une date quelconque

Enoncé des 4 exercices et Corrigé Utilisation Lancez le script puis molnar(1) pour l’exercice 1, molnar(2) pour l’exercice 2 etc.

Des personnes forment une file d’attente devant un distributeur de billets. Certaines doivent retirer de l’argent, ceux sont des gens ordinaires; d’autres veulent voler de l’argent, ceux sont des voleurs et enfin les autres sont des policiers, ils cherchent les voleurs. Étant donnée une file d’attente au format chaîne, comme celle-ci : V1VT2VTVV Où T représente une personne ordinaire; V un voleur et un chiffre un policier. La valeur numérique représente la zone de surveillance. Par exemple, 1 signifie qu’il peut voir 1 personne devant lui et 1 personne à l’arrière. Tous les voleurs dans la ligne de vue de la police seront capturés ! Votre tâche consiste à créer une fonction pris admettant en paramètre la file d’attente et qui donne le nombre de voleurs pris par les policiers. >> pris("V1VT2VTVV") 3 # En effet le policier "1" prend les 2 voleurs à côté de lui # Le policier "2" prend celui à droite (l'autre a déjà été attrapé) >> pris("V5VT3VTTTVVVVTT1TV1V") 5 # Le policier "5" prend 3 voleurs et le dernier policier "1" en prend 2

Autre version ici

Autre version ici

L’idée m’est venue en regardant la vidéo de Nicolas Decoster - Art génératif avec adacraft - JAIME 2022

Enchevêtrements Actualisez la page pour obtenir un autre motif ! Explications du code from kandinsky import * from math import sqrt from random import randint # nb d'anneaux (couleurs alternées) et largeur anneau (nb, r) = (randint(3,40), randint(2,10)) p = nb * r COUL = (70, 75, 75) fill_rect(0, 0, 320, 222, (255, 210, 0)) def cercles(u,v,du,dv): # Bord opposé (en diagonale) au point de départ (u,v) (u2, v2) = (u + du * nb * r, v + dv * nb * r) # Pour chaque pixel du carré p * p for x in range(p): for y in range(p): # Recherche du n° de l'anneau d = int(sqrt(x ** 2 + y ** 2) / r) # Si c'est un nb impair et qu'il est inférieur au nb d'anneaux total if d & 1 and d < nb: # On le dessine (gris foncé) set_pixel(u + du * x, v + dv * y, COUL) # Distance point par rapport à l'autre extrémité # et calcul du n° de l'anneau d2 = int(sqrt((x - p) ** 2 + (y - p) ** 2) / r) # On dessine pixel si en dehors des anneaux précédents if d2 > nb - 2: set_pixel(u2 - du * x, v2 - dv * y, COUL) def motif(x,y): # (a,b) = position départ du motif et (c,d) = directions du remplissage en x et y # Faire varier (c,d) avec d'autres combinaisons de 1 et -1 for (a,b,c,d) in ((1,1,-1,-1),(2,0,-1,1),(0,2,1,-1),(1,1,1,1)): cercles(x + a * p, y + b * p, c, d) for c in range(1+ 160 // p): for l in range(1 + 110 // p): motif(2 * c * p,2 * l * p)

Script d’origine en BASIC pour Apple Adaptation pour la Numworks avec une compression type RLE (Run-Length Encoding)

Il existe plusieurs versions du jeu des allumettes : Celle où il n’y a qu’une ligne et chaque joueur peut enlever 1, 2 ou 3 allumettes. Le perdant est celui qui prend la dernière allumette Celle appelée Jeu de Nim qui utilise plusieurs rangées et dont la stratégie gagnante utilise le “ou exclusif, j’ai fait une vidéo à ce sujet La version proposée ici n’utilise que 2 rangées. Vous pouvez enlever autant d’allumettes que vous voulez sur UNE des 2 rangées, ou alors enlever le même nombre d’allumettes sur les DEUX rangées en même temps. Le gagnant est celui qui enlève la (ou les) dernière(s) allumette(s). Utilisation avec la NUMWORKS : Flèche du haut pour enlever des allumettes sur la rangée du haut, flèche du bas pour la rangée du bas, flèche de gauche pour les 2 rangées à la fois, OK pour valider et touche Backspace pour annuler votre coup. L’intervention du nombre d’Or dans la redoutable stratégie de la calculatrice parait tout à fait étonnante ! Si vous voulez en savoir plus, regardez par ici. Ma chaine Youtube

Ma playlist consacrée à la NUMWORKS