Codes de la vidéo

from random import randint

def grilleVide():
 grille = []
 for i in range(6):
  ligne = []
  for j in range(6): ligne.append('⬛')
  grille.append(ligne)
 return grille

def rotate(m, n):
 for _ in range(n): m = list(zip(*m))[::-1]
 return m

def afficher(g):
 for l in range(6): print(''.join(g[l]))

def creerGrille():
    grille = grilleVide()
    m = [[6 * l + c for c in range(6)] for l in range(6)]
    for c in range(3):
     for l in range(3):
      m = rotate(m, randint(0, 3))
      pos = m[l][c]
      x, y = pos % 6, pos // 6      
      grille[y][x] = '⬜'
    return grille
    
def completeEtoiles(phrase):
 return phrase + "*" * (9 - len(phrase) % 9)

def listeTrous(g):
 trous = []
 for l in range(6):
  for c in range(6):
   if g[l][c] == '⬜': trous.append(6 * l + c)
 return trous  

def chiffrer(phrase, grille):
 phrase = completeEtoiles(phrase)
 chiffre = grilleVide()
 trous = listeTrous(grille)
 for i, v in enumerate(phrase):
  pos = i % 9 
  if pos == 0 and i > 0:
   grille = rotate(grille, 1)
   trous = listeTrous(grille)
  x, y = trous[pos] % 6, trous[pos] // 6
  if v == "*": v = chr(randint(65, 90))
  chiffre[y][x] = v
 return chiffre 

def dechiffrer(crypte, grille):
 clair = ''
 trous = listeTrous(grille)
 for i in range(36):
  pos = i % 9 
  if pos == 0 and i > 0:
   grille = rotate(grille, 1)
   trous = listeTrous(grille)
  x, y = trous[pos] % 6, trous[pos] // 6
  clair += crypte[y][x]
 return clair
 
grille = creerGrille()        
afficher(grille)
phrase='RENDEZVOUSAQUINZEHEURESPLACELECLERC'
crypte = chiffrer(phrase, grille)
afficher(crypte)
clair = dechiffrer(crypte, grille)
print(clair)
  

# Substitution simple

def subSimple(phrase:str, decalage:int):
    phrase = phrase.upper()
    chiffrement = ''
    for c in phrase:
        if 'A' <= c <= 'Z':
            position = (ord(c) - 65 + decalage) % 26
            chiffrement += chr(65 + position)
        else:
            chiffrement += c
    return chiffrement

# Substitution double (avec clé numérique)

def subDouble(phrase:str, decalage):
    phrase = phrase.upper()
    chiffrement = ''
    longueur = len(decalage)
    for i,c in enumerate(phrase):
        if 'A' <= c <= 'Z':
            position = (ord(c) - 65 + decalage[i % longueur]) % 26
            chiffrement += chr(65 + position)
        else:
            chiffrement += c
    return chiffrement            

# Substitution avec mot-clé

def fabriqueAlphabet(cle:str):
    lettres = list(cle.upper()) + [chr(v) for v in range(65, 91)]
    alphabet = ''
    for c in lettres:
        if c not in alphabet: alphabet += c
    tailleCle = len(set(cle))
    alphabetFinal = ''
    for col in range(tailleCle):
        suiv = col
        while suiv < 26:
         alphabetFinal += alphabet[suiv]
         suiv += tailleCle       
    return alphabetFinal

def subCleSimple(phrase:str,cle:str):
    alphabet = fabriqueAlphabet(cle)
    phrase = phrase.upper()
    chiffrement = ''
    for c in phrase:
        if 'A' <= c <= 'Z':
            chiffrement += alphabet[ord(c) - 65]
        else:
            chiffrement += c
    return chiffrement 

Python & Cryptographie niveau lycée : Déchiffrement des substitutions

def decryptSimple(phrase:str):
    freq = [0] * 26
    for c in phrase:
     if 'A' <= c <= 'Z':
         freq[ord(c) - 65] += 1
    decal = 4 - freq.index(max(freq))
    return subSimple(phrase, decal)

def decryptDouble(phrase:str, taille:int):
    clair = ''
    res = []
    for i in range(taille):
     res.append(decryptSimple(phrase[i::taille]))
    return ''.join(''.join(v) for v in zip(*res))

def inverseAlphabet(chiffre:str, clair:str):
    alphabetDecode = ''
    for i in range(65, 91):
      c = chr(i)
      if c in chiffre: code = clair[chiffre.index(c)]
      else: code = '?'
      alphabetDecode += code     
    return alphabetDecode 

def decryptEnPartie(phrase:str,alphabet:str):
    alphabet = alphabet.upper()
    phrase = phrase.upper()
    chiffrement = ''
    for c in phrase:
        if 'A' <= c <= 'Z':
            chiffrement += chr(65 + alphabet.index(c))
        else:
            chiffrement += c
    return chiffrement 

Exemples de textes :

clair = 'CHOISISSEZUNTRAVAILQUEVOUSAIMEZETVOUSNAUREZPASATRAVAILLERUNSEULJOURDEVOTREVIE'
# Clé numérique [3, 2, 1, 0]
crypte = 'FJPIVKTSHBVNWTBVDKMQXGWOXUBIPGAEWXPUVPBUUGAPDUBTUCWALNMEUWOSHWMJRWSDHXPTUGWIH'

# Extrait du livre "Le petit Prince"

princeClair = 'LESGRANDESPERSONNESMONTCONSEILLEDELAISSERDECOTELESDESSINSDESERPENTSBOASOUVERTSOUFERMESETDEMINTERESSERPLUTOTALAGEOGRAPHIEALHISTOIREAUCALCULETALAGRAMMAIRECESTAINSIQUEJAIABANDONNEALAGEDESIXANSUNEMAGNIFIQUECARRIEREDEPEINTREJAVAISETEDECOURAGEPARLINSUCCESDEMONDESSINNUMERO1ETDEMONDESSINNUMEROLESGRANDESPERSONNESNECOMPRENNENTJAMAISRIENTOUTESSEULESETCESTFATIGANTPOURLESENFANTSDETOUJOURSETTOUJOURSLEURDONNERDESEXPLICATIONSJAIDONCDUCHOISIRUNAUTREMETIERETJAIAPPRISAPILOTERDESAVIONSJAIVOLEUNPEUPARTOUTDANSLEMONDEETLAGEOGRAPHIECESTEXACTMABEAUCOUPSERVIJESAVAISRECONNAITREDUPREMIERCOUPDŒILLACHINEDELARIZONACESTTRESUTILESILONESTEGAREPENDANTLANUITJAIAINSIEUAUCOURSDEMAVIEDESTASDECONTACTSAVECDESTASDEGENSSERIEUXJAIBEAUCOUPVECUCHEZLESGRANDESPERSONNESJELESAIVUESDETRESPRESCANAPASTROPAMELIOREMONOPINIONQUANDJENRENCONTRAISUNEQUIMEPARAISSAITUNPEULUCIDEJEFAISAISLEXPERIENCESURELLEDEMONDESSINNUMERO1QUEJAITOUJOURSCONSERVEJEVOULAISSAVOIRSIELLEETAITVRAIMENTCOMPREHENSIVEMAISTOUJOURSELLEMEREPONDAITCESTUNCHAPEAUALORSJENELUIPARLAISNIDESERPENTSBOASNIDEFORETSVIERGESNIDETOILESJEMEMETTAISASAPORTEEJELUIPARLAISDEBRIDGEDEGOLFDEPOLITIQUEETDECRAVATESETLAGRANDEPERSONNEETAITBIENCONTENTEDECONNAITREUNHOMMEAUSSIRAISONNABLE'

princeChiffre = 'OGTGUCODHUQEUUPNQGTMRPUCRPTELNMEGGMALUTEUFFCRVFLHUEEVUJNVFFSHTQEQVTBRCTOXXFRWUPUIGSMHUFTGGNIQVFRHUTEURMUWQUAOCHERISASJJEDNIIVVPIUGBUFCMCXNFTDNBGUCNMDKSEFGTTDKOSLSVEMCJAECODRPOEDNBGHFFSLZBNVWOEPCHNLHJQXGDAUTJEUGEESGJNWTFJDXBIVGUEGGDOXTBGHRBROKOSXEDEVFFMRPEEVUJNQWNEUQ1EWFFMRPEEVUJNQWNEUQMEVISAQFFSSGSSRPOEVPFCROQRHPOEQVKAPCJSUKFNWQVTHUTEXNFSHVDEVVGAWKHAQVQOXTMEVGOFDPUSGGUOXLPUUUFTWQVJRWSSOGVRGQONHTEEVGYPOKDAWKPNVLBIGQOCGWDHRKTIUWOAXVSEPGUIHTFTMCJASRSIVCQIOQUEUFFSDXJOQUKALXPLHWOPHWQAUVPUWFBNVNFMRPEEHVMAJGPGUCQHLGDEVVFXDEUMDDFAXEPUSUFRYKKEVCWALUSEFQONDKURHFVPUGNIHTDOXREŒLNMAFJJNHFFLDTJZRPBCHUUTUGTUWKMEVKMOQGTTHIBRHRFNGCOTOCOULVKALCJNVKFUDWDOXTTDHOBVLGEEVVBSGGDOQVBCWUBVHEEEVVBSGGHEQUTEUKFUALBIEGBUFQVPYGDUFJFZOGTGUCODHUQEUUPNQGTJHNFSDKWUHUEEWTFSSTFSFCOASCTTUQQAPGMIRTFMRPPPLPJOQSVAQFKEQTFNFQOTUCJSXPFQXKNESCSALUTALVVNSGVLXEJDHLFFDKTALUMEARFRLGOCHUVRHNMEGGNOQFFSVKONXOFRR1RUHLBIWQVJRWSSFQOSHTWEMGWOXNBIVUBVRKSSLGMLHGUALVWRDKNEQVDOPRSEKGOSLXFMDKTTRWKOXTTEONFMHTFPRPEALVDEVVVNFJBPHCVAOQSSMGOEOWJPDTMALUOIGGTEURFNWUCODUOIGGGOUGUSYKFRJGTNLFFTRKMEVLFMHOFTWCJSDUBPRTUEHLFLXKQAUNBIVFFBUKEGHFFGRNGDHRPLLVJQXGFTGGDRDXBTHUFTOCHRDPEESGSSRPOEHVBIWDJEQEPNWGOTHFFCRPOALVSEXPIOPOFAXUTIUCJSRPOAENF'

Voici l’énoncé d’un problème que j’ai posté sur le groupe HP Calculator Fan Club

Des propositions de simulations pour quelques calculatrices HP :

Le calcul théorique est très simple :

La réponse à trouver était donc : 5 mouvements

Version en Python

from random import random

def simul(n:int):
    tot = 0    # Total de tous les mouvements
    for _ in range(n):    # n simulations
        r = 1       # Dernier mvt de 2 vers 1
        # Aller-retour de 2 vers 3 ou 4 avec probabilité 2/3
        while int(3 * random()) != 0: r += 2
        # On ajoute le nb de mvt au total
        tot += r
    # Moyenne
    return tot / n

>>> simul(1000)
4.752
>>> simul(10000)
5.0992
>>> simul(100000)
4.98308

David, un collègue enseignant, a posté un tweet sur l’utilisation du mode de représentation Truth sur les anciennes calculatrices HP 48G. Voici son premier résultat, le tapis de Sierpinski :

Avec cette équation très courte :

Quelques explications : R→B permet de convertir un nombre en binaire. Pour chaque abscisse X (entre 0 et 63) et chaque Y (entre 0 et 63), on regarde s’ils ont au moins un bit en commun dans leurs écritures binaires respectives. Par exemple si X = 12 = 1100b et Y = 6 = 110b ont un bit en commun à la 3e position, on affiche dans ce cas un pixel noir à l’écran.

A partir de là j’ai trouvé la page Binary Plot du site Wollfram avec quelques visuels que j’ai voulu reproduire en Python.

from kandinsky import *

for y in range(30):
 n = 2 ** y
 for x in range(160):
    for i in range(3): 
     if x ** (i + 1) & n > 0:
       fill_rect(2 * x, 214 - 63 * i - 4 * y, 2, 4, (0, 0, 0))

En Python il est très simple de faire des opérations bit à bit. Pour le « ET » on utilise &. Par exemple :

Pour le « OU » le symbole est |. Par exemple 12 | 6 = 14 car 1100b | 110b = 1110b

Et le « OU EXCLUSIF » par ^. Par exemple 12 ^ 6 = 10 car 1100b ^110b = 1010b

Passons à la représentation des coefficients binomiaux :

Les scripts (bibliothèque PIL et NUMWORKS) sont ici.

En bas à gauche les coefficients (écrits en binaires) qui apparaissent dans les développements de (a+b)^0, (a+b)^1, (a+b)^3 etc.

Quelques formes amusantes apparaissent !

On peut également représenter la suite de Fibonacci :

Les scripts sont ici.

Enfin, l’idée m’est venue de représenter la conjecture de Syracuse (on part d’un entier, s’il est pair on le divise par 2 sinon on le multiplie par 3 et on ajoute 1, la conjecture prétend que l’on arrivera à 1 au bout d’un certain temps). Avec N = 27 comme départ on arrive à 1 au bout de 111 itérations (appelé temps de vol) et le maximum atteint est 9232.

Représentons les termes de la suite sous forme binaire :

Il est alors assez facile de lire la valeur exacte de chacune des colonnes, par exemple du maximum. Il suffit de repérer les numéros de lignes (En bas = 0). Sur le visuel on lit les lignes 4, 10 et 13. Le nombre correspondant est donc 2^4 + 2^10 + 2^13 = 9232.

Autres exemples

Script NUMWORKS pour les « spirales »

from kandinsky import *

def tapis(x, y):
  while x > 0 and y > 0:
    if x % 3 == 1 and y % 3 == 1: return 0
    x //= 3
    y //= 3
  return 1  

for y in range(222):
  for x in range(320):
    if tapis(x, y): set_pixel(x, 221 - y, (0,) * 3)

@ Adaptation d'un script de David Cobac pour HP-48

« 3 PICK 3 MOD » 'MOD3 STO
« 3 / IP SWAP » 'IP3 STO
{ (0 0) (130 63) X 0 (0 0) TRUTH Y } 'PPAR STO

« X Y 
WHILE DUP2 *
 MOD3 MOD3 *
 1 ≠ *
REPEAT
 IP3 IP3
END
* NOT » 'EQ STO

« ERASE DRAW {} PVIEW » 'TAP STO

Lancez TAP


Version 2 :

« X Y 
WHILE DUP2 DUP2
 3 MOD SWAP 3 MOD
 * 1 ≠ * *
REPEAT
 3 / IP SWAP 3 / IP
END
* NOT »

Il y a une dizaine d’années certains internautes se sont amusés à créer des graphiques en secteurs originaux, voyons comment les reproduire en Python avec la TI-83

Le coin de ma chambre

import ti_plotlib as plt
from ti_draw import *
from math import *

data = {-14: (143, 133, 133), 90: (158, 143, 133), 214: (93, 42, 40)}

def dec(l,n,u): return [v[n] + u for v in l]

def secteurs(data):
  plt.cls()
  o = (0, 0)
  xy = [o]
  mini = min(data.keys())
  for i in range(mini, 361 + mini):
    xy.append((cos(radians(i)) * 100, -sin(radians(i)) * 100))
    if i in data.keys():
      if i != mini: fill_poly(dec(xy, 0, 160), dec(xy, 1, 105))
      set_color(*data[i])
      xy = [o] + xy[-1:]
  fill_poly(dec(xy, 0, 160), dec(xy, 1, 105))

secteurs(data)
show_draw()

Les données sont représentées sous la forme angle : couleur. Pour l’exemple ci-dessus, on part de l’angle -14° avec la couleur (143, 133, 133), on trace le secteur jusqu’à l’angle 90° puis on change de couleur, etc.

L’idée du programme est de tracer un polygone en partant du centre de l’écran (160, 105), la variable i parcourt les entiers allant de l’angle le plus petit (-14° dans l’exemple) jusqu’à faire un tour complet (360 – 14 = 346°). On mémorise dans la variable xy les coordonnées des points sur le bord du cercle de 1° en 1° et dès qu’il y a un changement de couleur on trace le polygone xy.

La pyramide

Même programme que précédemment mais en changeant data.

data = {-42: (65, 100, 145), 222: (210, 163, 83), 298: (88, 57, 36)}

data = {-42: (65, 100, 145), -1: (220,220,220), 0:(65, 100, 145), \
        179: (220,220,220), 180:(65, 100, 145), 202: (220,220,220), \
        204:(65, 100, 145), 222: (210, 163, 83), 298: (88, 57, 36)}

pacman

data = {-32: (255, 255, 255), 32: (216, 160, 24)}

Dégradé

data = {}

for i in range(20): data[18 * i] = (12 * i,) * 3

Lien vers Basthon P5 : https://console.basthon.fr/

Mode écran avec p5

from p5 import *
from random import *

def setup():
 createCanvas(600, 600)
 background(20,20,20)
 fill(10, 25, 10)
 blendMode(SCREEN)
 for x in range(30):
   for n in range(1 + x):
    rect(20 * x + randint(0,10), randint(-100,600), 80, 80) 

def draw():
 noLoop()

run()

Mode multiplier – NUMWORKS

from kandinsky import *
from random import randint

def rvb01(c): return tuple(v / 255 for v in c)
def rvb255(c): return tuple(255 * v for v in c)
def zip01(c1,c2): return zip(rvb01(c1), rvb01(c2))
def multiply(c1,c2): return rvb255(a * b for (a, b) in zip01(c1,c2))

def rect(x,y,w,h,c,mode):
 for i in range(w):
  for j in range(h):
   rvb = mode(c, get_pixel(x + i, y + j))
   set_pixel(x + i, y + j, rvb)

for x in range(0,320,8):
 for y in range(0,220,3):      
  rect(x + randint(0, 7), y + randint(0, 6), \
       randint(1, 320 - x), randint(1, 9), (250, 100, 250), multiply)

Mode différences – NUMWORKS et P5

# Version - NUMWORKS

from kandinsky import *
from random import *

def rvb01(c): return tuple(v / 255 for v in c)
def rvb255(c): return tuple(int(255 * v) for v in c)
def zip01(c1,c2): return zip(rvb01(c1),rvb01(c2))

def diff(c1,c2):
 return rvb255(abs(a - b) for (a, b) in zip01(c1,c2))

def rect(x,y,w,h,c,mode):
 for i in range(w):
  for j in range(h):
    rvb = mode(c, get_pixel(x + i, y + j))
    set_pixel(x + i, y + j, rvb)

fill_rect(0,0,320,222,(250, 100, 250))
for _ in range(500):  
  t = randint(20,40)   
  rect(randint(-10, 315), randint(-10, 220), t, t, (250, 100, 250), diff)

# Version P5 - Python

from p5 import *
from random import *

c = (250, 100, 250)

def setup():
 createCanvas(900, 600)

 background(c)
 blendMode(DIFFERENCE)
 fill(c)
 for _ in range(1000):
    t = randint(20,80)
    rect(randint(-20,900), randint(-20,600), t, t) 

def draw():
 noLoop()

run()

Mode addition – NUMWORKS

from kandinsky import *
from random import *
from math import cos

def rvb01(c): return tuple(v / 255 for v in c)
def rvb255(c): return tuple(int(255 * v) for v in c)
def zip01(c1,c2): return zip(rvb01(c1),rvb01(c2))

def add(c1,c2):
 return rvb255(min(1,a+b) for (a, b) in zip01(c1,c2))

def rect(x,y,w,h,c,mode):
 for i in range(w):
  for j in range(h):
    rvb = mode(c, get_pixel(x + i, y + j))
    set_pixel(x + i, y + j, rvb)

fill_rect(0,0,320,222,(40,40,40))
for i in range(50):
 rect(randint(-20,300), randint(-20,200), 60, 60,\
      (randint(0,255), randint(0,255), randint(0,255)), add)

TISSU écossais – p5

Cet exemple a été supprimé au montage de la vidéo:

from p5 import *

def setup():
 createCanvas(770, 770)
 noStroke()
 background((40,40,40))
 blendMode(SCREEN)
 fill(20, 40, 20)
 for i in range(10):
    for j in range(10):
      rect(60 * i, 60 * j, 50 + 20 * i, 50 + 20 * j) 

def draw():
    noLoop()

run()

MODE addition – p5 et NUMWORKS

from p5 import *
from random import *

def setup():
 createCanvas(800, 400)
 noStroke()
 background((50,50,50))
 blendMode(ADD)
 fill(20, 140, 20)
 
 x, y = 200, 0
 for i in range(100):
    textSize(1 + i)
    x -= 2
    y += randint(-5,11)
    fill(20, 140, 20)
    if random()<.2: fill(255, 0, 0)
    text('PROGRAMMATION', x, y)

def draw():
    noLoop()

run()

from kandinsky import *
from random import *

BL, WH = (0, 0, 0), (255,) * 3

def rvb01(c): return tuple(v / 255 for v in c)
def rvb255(c): return tuple(int(255 * v) for v in c)
def zip01(c1,c2): return zip(rvb01(c1),rvb01(c2))

def screen(c1,c2):
  return rvb255(1 - (1 - a) * (1 - b) for (a, b) in zip01(c1,c2))

def rect(x,y,w,h,c,mode):  
 for i in range(w):
  for j in range(h):
   rvb = mode(c, get_pixel(x + i, y + j))
   set_pixel(x + i, y + j, rvb)

def dot(x, y, c, fg, t):
  draw_string(c, 0, 0, fg, (0,0,0))
  for v in range(18):
    for u in range(9):
      rect(x + u * t, y + v * t, t, t, get_pixel(u, v), screen)  

def aff(txt, x, y, t):
  coul = (255, 0, 0)if random()<.3 else (20, 140, 20)    
  for i, c in enumerate(txt):
    dot(x + i * t * 9, y, c, coul, t)

fill_rect(0,0,320,222,(50,50,50))
x, y = 150, -30
for i in range(80):
 x -= 2
 y += randint(1,4)
 aff("PROGRAMMATION", x, y, i//20)
fill_rect(0,0,20,20,(50,50,50))

Dégradés – NUMWORKS

from kandinsky import *

def rvb01(c): return tuple(v / 255 for v in c)
def rvb255(c): return tuple(int(255 * v) for v in c)
def zip01(c1,c2): return zip(rvb01(c1),rvb01(c2))

def alpha(c1, t, c2):
 return rvb255(a * t + b * (1 - t) for (a, b) in zip01(c1,c2))

def rect(x,y,w,h,c,d):
 (dx,dy) = d   
 for i in range(w):
  for j in range(h):
   t = 1   
   if dx == 1: t = 1 - i / w
   elif dx == -1: t = i / w 
   if dy == 1: t = 1 - j / h
   elif dy == -1: t = j / h
   rvb = alpha(c, t, get_pixel(x + i, y + j))
   set_pixel(x + i, y + j, rvb)

rect(0, 0, 200, 200, (255, 0, 0), (1,0))
rect(0, 0, 200, 200, (0, 255, 0), (0,1))
rect(0, 0, 200, 200, (0, 0, 255), (-1,0))

Effet alpha – NUMWORKS

from kandinsky import *
from random import randint, choice

coul = (255,0,255), (255,255,0), (255,127,0), (255,0,127)

def rvb01(c): return tuple(v / 255 for v in c)
def rvb255(c): return tuple(int(255 * v) for v in c)
def zip01(c1,c2): return zip(rvb01(c1),rvb01(c2))

def alpha(c1, t, c2):
 return rvb255(a * t + b * (1 - t) for (a, b) in zip01(c1,c2))

def rect(x,y,w,h,c,t):  
 for i in range(w):
  for j in range(h):
   if i == 0 or j == 0 or i == w - 1 or j == h - 1: 
    rvb = (255,255,255)
   else: 
    rvb = alpha(c, t, get_pixel(x + i, y + j))
   set_pixel(x + i, y + j, rvb)

def effet(t):
 for _ in range(150):
  x, y = randint(-10,300), randint(-10,200)
  w, h = randint(10,80), randint(10,80)
  rect(x,y,w,h,choice(coul),t)

effet(0.15)

Suite à ma vidéo d’initiation à JavaScript concernant la recherche de mots (palindromes, anacycliques, mots croissants…), je vous propose ici les traductions en Python

Importer les dictionnaires

Enregistrez le fichier dicos.py dans un dossier et créez un fichier recherche.py dans ce même dossier avec pour contenu :

import dicos

print(len(dicos.dico5))

En exécutant le fichier vous devriez voir le nombre 7276 qui correspond au nombre de mots de 5 lettres.

Mots en sens inverse et palindromes

import dicos

def inverse(mot):
    return mot[::-1]

def palindrome(dico):
    return [mot for mot in dico if mot == inverse(mot)]

Testons :

>>> inverse('BONJOUR')
'RUOJNOB'

>>> palindrome(dicos.dico6)
['SASSAS', 'SELLES', 'SENNES', 'SERRES', ... ]

Anacycliques

def anacyclique(dico):
    return [mot for mot in dico if inverse(mot) in dico]

Testons :

>>> anacyclique(dicos.dico7)
['ALLIACE', 'ALLIAGE', 'ANNOTAT', 'ARETIER',...]

Mots croissants

def croissant(dico):
    return [mot for mot in dico if mot == ''.join(sorted(list(mot)))]

Testons :

>>> croissant(dicos.dico6)
['ACCENT', 'ACCORT', 'AFFINS', 'AFFLUX', 'AGGLOS', 'BELLOT', 'BIJOUX', 'BILLOT', 'CHINTZ', 'DEHORS', 'EFFORT']

Q sans U

def QsansU(dico):
    return [mot for mot in dico if 'Q' in mot and 'U' not in mot]

Testons :

>>> QsansU(dicos.dico5)
['QIBLA']

Toutes les voyelles

def nbVoyelles(mot):
    return len([v for v in 'AEIOU' if v in mot])

def ToutesLesVoyelles(dico):
    return [mot for mot in dico if nbVoyelles(mot) == 5]

Testons :

>>> nbVoyelles('BONJOUR')
2

>>> ToutesLesVoyelles(dicos.dico6)
['EBOUAI', 'ENOUAI', 'OISEAU']