sommes_partielles_recursif(sous_liste)

et nommer le résultat

liste_remontee

qui est une liste[y₀,y₁, . . . ,y_n//2−1]. Descente.

— Initialiser une liste

liste_descente

qui contient seulementx₀.

— Pour iallant de 1 àn−1 :

— Siiest pair, ajouter à

liste_descente

^{l’élément} y_i//2−1+x_i,

— sinon, ajouter à

liste_descente

^{l’élément} y_(i−1)//2.

• Renvoyer la liste

liste_descente

^.

3. Applications : sélection des éléments par un filtre.

Imaginons une liste quelconque, par exemple :

liste = [15, 18, 16, 11, 15, 19, 13, 12]

dont on souhaite ne conserver que certains éléments. Pour cela on définit un filtre :

filtre = [0, 0, 1, 0, 1, 0, 0, 1]

On ne retient que ceux qui sont en correspondance avec un 1 :

selec = [16, 15, 12]

C’est très facile à programmer de façon séquentielle (fais-le) et même en parallèle si on ne se préoccupe pas de l’ordre des éléments (on autorise la sortie

[15, 12, 16]

par exemple). Voici un algorithme pour le faire en parallèle en préservant l’ordre des éléments.

• On calcule la liste des sommes partielles du filtre. Sur notre exemple, cela donne :

sommes = [0, 0, 1, 1, 2, 2, 2, 3]

Le dernier élémentn(icin=3) donne la taille de la liste finale

selec

. On initialise donc une liste

selec

^{de taillen.}

• Les sommes partielles donnent le rang des éléments à conserver dans la liste finale (avec un décalage de 1). Comment ? Par exemple on sait qu’il faut conserver l’élément de rang 2 de la liste initiale, en effet pouri=2 on a

filtre[i]=1

(et pas 0), donc il faut garder l’élément

liste[i]

qui vaut 16. La somme partielle au rang 2,

sommes[i]

, vaut 1, alors 16 aura comme rang final 0 (il y a un décalage de 1). Pour 15, sa somme partielle associée est 2, il sera donc au rang 1 ; pour 12, sa somme partielle est 3 il sera donc au rang 2.

• Ainsi pouriindexant les éléments de la liste initiale, si on doit conserver l’élément de rangi, alors il sera au rang

sommes[i]-1

dans la liste finale. Autrement dit :

selec[sommes[i]-1] = liste[i]

• Les éléments à conserver sont maintenant dans la liste

selec

^.

Programme cet algorithme en une fonction

selection(liste,filtre)

. (Si tu utilises la fonction de la question précédente, les longueurs des listes doivent être des puissances de 2.)

P R O J E T S

122

Automates 13

Tu vas programmer des automates cellulaires qui, à partir de règles simples, produisent des visualisa-tions amusantes.

Activité 1(Une suite logique).

Objectifs : programmer une suite logique amusante (mais pas nécessaire pour l’activité suivante).

Voici une suite :

1 11 21 1211 111221 312211 13112221 1113213211

Pour passer d’une ligne à la suivante, il suffit de lire à haute voix en comptant les nombres ! Par exemple la ligne 1211 est lue « un un (pour 1), un deux (pour 2), deux un (pour 1 1) », la ligne d’après est donc 111221 ! Cette dernière ligne se lit « trois uns, deux deux, un un » donc la ligne suivante sera 312211.

Programme une fonction

lecture(mot)

qui calcule et renvoie la lecture de la chaîne

mot

. Par exemple

lecture("1211")

^renvoie

"111221"

^.

• Essaie de programmer cette fonction sans lire les indications suivantes !

• Indications.Tu peux utiliser trois variables : une variable qui lit chaque caractère du mot, une variable correspondant au caractère précédent, un compteur à incrémenter si ces deux caractères sont égaux.

• Algorithme.Si tu n’y arrives pas tout seul, voici les grandes lignes d’un algorithme possible.

Pour chaque caractère du mot :

— si le caractère est le même que le caractère précédent, incrémenter le compteur,

— sinon, rajouter au mot à créer la valeur du compteur suivie du caractère précédent.

À la fin, il faut aussi rajouter au mot à créer la valeur du compteur suivie du caractère précédent.

Question.Trouve le premier mot qui contient

33

^.

Cours 1(Automates linéaires).

On travaille sur des lignes superposées, formées de cases. Chaque case peut contenir une cellule (la case est alors noire/contient 1) ou être vide (la case est blanche/contient 0).

Cellule Case vide

Unautomate linéaireest une règle qui à partir du contenu de trois cases consécutives sur une ligne, détermine le contenu de la case sur la ligne du dessous.

La règleest donc donnée par la liste des 8 configurations possibles au départ, avec pour chacune la naissance ou pas d’une cellule en-dessous.

? ? ? ? ? ? ? ?

Exemple.

• Partons d’une seule cellule qui sera sur la ligne du haut.

ligne initiale

• Et choisissons la règle définie par les configurations :

• Pour décider de la naissance d’une cellule dans une case de la ligne en-dessous, on regarde les trois cases au-dessus et on applique la règle. Sur le dessin ci-dessous deux cellules sont vivantes après l’évolution (on a indiqué par des flèches seulement les règles pour lesquelles une cellule apparaît).

ligne initiale

première évolution

• On peut itérer le processus. Une seule cellule apparaît lors de cette seconde évolution.

ligne initiale

première évolution

seconde évolution Notations.

• On note 0 pour une case vide et 1 pour une case contenant une cellule vivante.

• Un ligne est représentée par une liste de 0 et de 1. Par exemple

[0,0,0,1,0,1,0,1,0,0]

^{est une} ligne de 10 cases, contenant 3 cellules.

• La règle est codée par une liste de 0 et 1 et de longueur 8, déterminée par l’image des 8 configurations possibles. Par exemple :[0, 0, 1, 0, 1, 1, 0, 1]correspond à la règle :

0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1

1 1 1 1

0 0 0 0

règle du codage

Activité 2(Automates linéaires).

Objectifs : calculer et afficher les automates linéaires.

1. Évolution d’une cellule.Programme une fonction

cellule_suivante(a,b,c,regle)

qui calcule et renvoie la couleur (0 ou 1) de la case située sous les trois cases contenant

a

^,

b

^,

c

selon la règle donnée.

a b c

?

•

a

^,

b

^,

c

sont les couleurs (0 ou 1) des cases situées au-dessus (aest la case la plus à gauche).

• La loi de transformation est donnée par la liste

regle

formée d’une suite de 8 entiers 0 ou 1.

• Exemple avec

regle = [0,0,1,0,1,1,0,1]

^alors

cellule_suivante(0,0,0, regle)

^renvoie

0

^,

cellule_suivante(0,0,1, regle)

^{renvoie aussi}

0

^,

cellule_suivante(0,1,0, regle)

^renvoie

1

^{, etc.}

• Si tu ne veux pas écrire les 8 cas possibles, calcule 4a+2b+c!

2. Affichage de la règle.Déduis-en une fonction

affiche_regle(regle)

qui affiche à l’écran la règle donnée sous la forme «a,b,c→d» oùd est la couleur de la nouvelle case, par exemple :

0 0 0 -> 0

0 0 1 -> 0 0 1 0 -> 1 ...

3. Évolution d’une ligne.Programme une fonction

ligne_suivante(ligne,regle)

qui à partir d’une liste

ligne

formée de 0 et 1, calcule les cellules de la ligne suivante (renvoyée sous la forme d’une liste de 0 et de 1).

Exemple.Avec la règle[0, 0, 1, 0, 1, 1, 0, 1]alors la ligne suivant[0, 0, 1, 0, 1]est la ligne[0, 0, 1, 1, 1].

Remarque.Lors du calcul des cases situées à l’une des deux extrémités de la ligne, on considère qu’au delà, il n’y a pas de cellule (c’est donc comme si à droite et à gauche de la ligne initiale il y avait un 0).

Cases vides

ligne

4. Itérations.Déduis-en une fonction

plusieurs_lignes(n,ligne,regle)

qui affiche sur le termi-nal lesnlignes qui suivent la ligne donnée.

Exemple.Toujours avec la règle[0, 0, 1, 0, 1, 1, 0, 1], pars d’une ligne définie par une seule cellule au milieu :

ligne = [0]*10 + [1] + [0]*10

Alors l’itération du processus correspond à l’évolution d’une cellule, qui voyage vers la droite en se dédoublant une fois sur deux.

5. Affichage.Programme une fonction

afficher_lignes(n,ligne,regle)

qui réalise un bel affi-chage graphique d’une ligne de cellules et de son évolution surnlignes. La présence d’une cellule (marquée par 1) est affichée par une case noire, l’absence de cellule (marquée par 0) est affichée par

une case blanche.

6. Numérotation des règles.Il y a en tout 2⁸=256 règles possibles, car une règle est une liste de 8 bits. On décide donc de numéroter la règle en fonction du nombre binaire représenté par la liste :

[0, 0, 1, 0, 1, 1, 0, 1]

| {z }

règle

←→ 0.0.1.0.1.1.0.1

| {z }

nombre binaire

←→ 45

|{z}

numéro

Écris une fonction

definir_regle(numero)

qui n’est autre que la conversion d’un entier en écriture binaire sur 8bits. Par exemple

definir_regle(45)

renvoie la règle[0, 0, 1, 0, 1, 1, 0, 1].

Algorithme.

• — Entrée : un entiernentre 0 et 255.

— Sortie : le nombrenen écriture binaire sous la forme d’une liste de 8bits.

• Démarrer avec une liste vide.

• Répéter 8 fois :

— Ajouter n% 2 au début de la liste.

— Fairen←n//2.

• Renvoyer la liste.

7. Types d’automates.

En partant d’une seule cellule, essaie de trouver différents types de comportements :

• des automates cellulaires qui convergent vers un état stable (voire vide),

• des automates cellulaires qui convergent vers un état périodique,

• des automates cellulaires ayant des structures symétriques (par exemple, qui réalisent des triangles de Sierpinski),

• des automates cellulaires avec des structures qui semblent aléatoires.

Cryptographie 14

Tu vas jouer le rôle d’un espion qui intercepte des messages secrets et tente de les décrypter.

Cours 1(Chiffre de César).

Lechiffre de Césarest une façon simple de coder un message afin de conserver le secret du contenu jusqu’à son destinataire. Il s’agit tout simplement de décaler chaque lettre du message. Voyons l’exemple d’un décalage de trois lettres :AdevientD;BdevientE; etc.

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z lettres du message en clair D E F G H I J K L M N O P Q R S T U V W X Y Z A B C lettres du message codé Par exemple le message :

CAPTUREZ IDEFIX se chiffre en :

FDSWXUHC LGHILA

Une autre façon de présenter le décalage est de placer les alphabets en clair (anneau extérieur en rouge) et codé (anneau intérieur en vert) sur deux roues concentriques. À gauche un décalage aveck=3 et à droite un décalage aveck=10.

A

Pour chiffrer des messages tu passes des lettres rouges à l’extérieur aux lettres vertes à l’intérieur. Pour déchiffrer des messages il suffit de faire l’opération inverse : passer des lettres vertes aux lettres rouges ! Déchiffre à la main les messages suivants :

• EORTXHC DVWHULAchiffré avec un décalagek=3.

• YE OCD ZKXYBKWSHchiffré avec un décalagek=10.

Cours 2(Passer d’un caractère à un nombre et inversement).

On préfère travailler avec des nombres qu’avec des lettres !

• Alphabet.Tu vas définir une constante globale

Alphabet

qui contient toutes les lettres de l’alphabet :

Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

• Numérotation.On numérote chaque lettre : 0 pourA, 1 pourB, 2 pourC, . . . , 25 pourZ.

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

• D’un numéro vers une lettre.Pour récupérer la lettre correspondant au rangi, il suffit d’écrire :

Alphabet[i]

Par exemple

Alphabet[2]

^vaut'

C

'^.

• D’une lettre vers son numéro.Pour récupérer le rang d’une lettre, notée

car

, il suffit d’écrire :

Alphabet.index(car)

Dans le document – Suites géométriques 1 (Page 126-136)