[{"data":1,"prerenderedAt":1548},["ShallowReactive",2],{"nav:fr:nsi":3,"page:fr:/nsi/algorithmique/jeu-vie":224},[4,10,58,104,135,197],{"title":5,"path":6,"stem":7,"icon":8,"description":9},"Markdown","/nsi/markdown","0.nsi/0.markdown","i-vscode-icons-file-type-markdown","Nous avons appris au cours de cette première séquence à utiliser le **langage Markdown** pour rédiger des documents.",{"title":11,"icon":12,"description":13,"path":14,"stem":15,"children":16,"page":57},"Algorithmique","i-lucide-arrow-down-0-1",null,"/nsi/algorithmique","0.nsi/1.algorithmique",[17,22,27,32,37,42,47,52],{"title":18,"path":19,"stem":20,"icon":13,"description":21},"Préparer son programme","/nsi/algorithmique/preparation","0.nsi/1.algorithmique/0.preparation","",{"title":23,"path":24,"stem":25,"icon":13,"description":26},"Complexité linéaire et quadratique","/nsi/algorithmique/complexite","0.nsi/1.algorithmique/1.complexite","Lorsqu'on cherche à résoudre un problème par un algorithme, il est essentiel de mesurer l'efficacité de celui-ci. La complexité permet d'estimer les ressources nécessaires (temps, mémoire) en fonction de la taille des données à traiter.",{"title":28,"path":29,"stem":30,"icon":13,"description":31},"Protéger les variables constantes","/nsi/algorithmique/protection-constantes","0.nsi/1.algorithmique/2.protection-constantes","Lorsqu'on récupère des données, par exemple depuis un fichier CSV, il est essentiel de protéger les variables qui doivent rester inchangées. Nous allons voir quelques bonnes pratiques simples pour éviter les erreurs involontaires.",{"title":33,"path":34,"stem":35,"icon":13,"description":36},"Le jeu de la vie","/nsi/algorithmique/jeu-vie","0.nsi/1.algorithmique/3.jeu-vie","Un automate cellulaire consiste en une grille régulière de « cellules » contenant chacune un « état » choisi parmi un ensemble fini et qui peut évoluer au cours du temps. L'état d'une cellule au temps t+1 est fonction de l'état au temps t d'un nombre fini de cellules appelé son « voisinage ». À chaque nouvelle unité de temps, les mêmes règles sont appliquées simultanément à toutes les cellules de la grille, produisant une nouvelle « génération » de cellules dépendant entièrement de la génération précédente.",{"title":38,"path":39,"stem":40,"icon":13,"description":41},"Invariant de boucle","/nsi/algorithmique/invariant-boucle","0.nsi/1.algorithmique/4.invariant-boucle","Quand on programme une boucle, il est souvent utile de pouvoir raisonner sur ce qui ne change pas pendant son exécution. C’est ce qu’on appelle un invariant de boucle.",{"title":43,"path":44,"stem":45,"icon":13,"description":46},"Tri par sélection","/nsi/algorithmique/tri-selection","0.nsi/1.algorithmique/4.tri-selection","Le tri par sélection est un algorithme de tri simple qui fonctionne en sélectionnant l'élément le plus petit (ou le plus grand) d'une liste et en le plaçant à la bonne position. Il est souvent utilisé pour illustrer les concepts de base des algorithmes de tri.",{"title":48,"path":49,"stem":50,"icon":13,"description":51},"Tri par insertion","/nsi/algorithmique/tri-insertion","0.nsi/1.algorithmique/5.tri-insertion","Le tri par insertion est un algorithme de tri simple qui fonctionne en insérant chaque élément à sa place correcte dans la partie déjà triée du tableau. Il est souvent utilisé pour illustrer les concepts de base des algorithmes de tri.",{"title":53,"path":54,"stem":55,"icon":13,"description":56},"Recherche dichotomique","/nsi/algorithmique/dichotomie","0.nsi/1.algorithmique/6.dichotomie","La recherche dichotomique est un algorithme de recherche efficace qui fonctionne en divisant récursivement une liste triée en deux moitiés jusqu'à ce que l'élément recherché soit trouvé ou qu'il ne soit plus possible de diviser la liste.",false,{"title":59,"icon":60,"description":13,"path":61,"stem":62,"children":63,"page":57},"Architecture","i-lucide-cpu","/nsi/architecture","0.nsi/2.architecture",[64,69,74,79,84,89,94,99],{"title":65,"path":66,"stem":67,"icon":13,"description":68},"Binaire/décimal","/nsi/architecture/binaire","0.nsi/2.architecture/2.binaire","Nous comptons au quotidien en décimal. Les ordinateurs fonctionnent avec des 0 et des 1, en base 2, c'est le binaire. Quatre bits forment une valeur que l'on peut coder en hexadécimal (base 16).",{"title":70,"path":71,"stem":72,"icon":13,"description":73},"Les opérations bit à bit","/nsi/architecture/bit-a-bit","0.nsi/2.architecture/2.bit-a-bit","Les opérations bit à bit permettent de manipuler les bits d'un entier directement. Elles sont très utiles pour optimiser la mémoire et la vitesse d'exécution dans les programmes.",{"title":75,"path":76,"stem":77,"icon":13,"description":78},"Portes Logiques","/nsi/architecture/portes-logiques","0.nsi/2.architecture/2.portes-logiques","Ci-dessous, présentation des portes logiques utilisées en logique combinatoire, accompagnées de leurs tables de vérité.",{"title":80,"path":81,"stem":82,"icon":13,"description":83},"Le complément à deux","/nsi/architecture/complement-deux","0.nsi/2.architecture/3.complement-deux","Le complément à deux est une méthode permettant de représenter les entiers signés (positifs et négatifs) en binaire. C'est le système utilisé par la plupart des ordinateurs pour effectuer des opérations avec des nombres négatifs.",{"title":85,"path":86,"stem":87,"icon":13,"description":88},"TP bases","/nsi/architecture/binaire-tp","0.nsi/2.architecture/4.binaire-tp","Compte-rendu du TP portant sur les conversions entre les différentes bases.",{"title":90,"path":91,"stem":92,"icon":13,"description":93},"Architecture de von Neumann","/nsi/architecture/von-neumann","0.nsi/2.architecture/5.von-neumann","Découvrez comment l'idée révolutionnaire de John von Neumann de stocker les programmes en mémoire a transformé l'ordinateur en machine universelle et reste la base de tous les ordinateurs modernes.",{"title":95,"path":96,"stem":97,"icon":98,"description":21},"Projet tkinter","/nsi/architecture/projet-tkinter","0.nsi/2.architecture/6.projet-tkinter","i-heroicons-light-bulb",{"title":100,"path":101,"stem":102,"icon":13,"description":103},"Protocoles de communication","/nsi/architecture/communication","0.nsi/2.architecture/7.communication","Expérimentation des protocoles de communication à l'aide des cartes micro:bit : comprendre pourquoi et comment structurer les échanges d'informations pour rendre les messages compréhensibles et exploitables.",{"title":105,"icon":106,"description":13,"path":107,"stem":108,"children":109,"page":57},"Linux","i-devicon-linux","/nsi/linux","0.nsi/3.linux",[110,115,120,125,130],{"title":111,"path":112,"stem":113,"icon":13,"description":114},"Linux: présentation","/nsi/linux/presentation","0.nsi/3.linux/1.presentation","Présentation succincte du système Linux.",{"title":116,"path":117,"stem":118,"icon":13,"description":119},"Système de fichiers","/nsi/linux/fichiers","0.nsi/3.linux/2.fichiers","Présentation de la structure de base du système de fichiers Linux, et présentation des notions de chemins relatif et absolu.",{"title":121,"path":122,"stem":123,"icon":13,"description":124},"Commandes","/nsi/linux/commandes","0.nsi/3.linux/3.commandes","Présentation de la notion de commande, appliqué au système Linux.",{"title":126,"path":127,"stem":128,"icon":13,"description":129},"Permissions","/nsi/linux/permissions","0.nsi/3.linux/4. permissions","Dans les systèmes basés sur Linux, les permissions permettent de contrôler qui peut accéder à quoi. Chaque fichier ou répertoire dispose de permissions associées au propriétaire, au groupe assigné, ainsi qu'à l'ensemble des autres utilisateurs.",{"title":131,"path":132,"stem":133,"icon":13,"description":134},"Utilisateurs et groupes","/nsi/linux/utilisateurs","0.nsi/3.linux/5.utilisateurs","Linux est basé sur un système d'utilisateurs et de groupes qui ont une utilité pour les personnes qui l'utilisent, ainsi que pour le système lui-même.",{"title":136,"icon":137,"description":13,"path":138,"stem":139,"children":140,"page":57},"Python","i-vscode-icons-file-type-python","/nsi/python","0.nsi/4.python",[141,145,149,154,159,164,168,173,178,183,187,192],{"title":142,"path":143,"stem":144,"icon":13,"description":21},"Bonnes pratiques","/nsi/python/bonnes-pratiques","0.nsi/4.python/1.bonnes-pratiques",{"title":146,"path":147,"stem":148,"icon":13,"description":21},"Expressions et instructions","/nsi/python/expressions-instructions","0.nsi/4.python/1.expressions-instructions",{"title":150,"path":151,"stem":152,"icon":13,"description":153},"Types de valeurs","/nsi/python/types-valeurs","0.nsi/4.python/1.types-valeurs","En Python, on manipule des données, sous la forme de contenu statique, ou sous la forme de variables. Nous allons ici passer en revue les quatre types de valeurs dits **primitifs**.",{"title":155,"path":156,"stem":157,"icon":13,"description":158},"Chaînes de caractères","/nsi/python/chaines-caracteres","0.nsi/4.python/2.chaines-caracteres","Les chaînes de caractères sont très utilisées en programmation. En Python, plusieurs fonctions permettent de faciliter la manipulation de ces objets.",{"title":160,"path":161,"stem":162,"icon":13,"description":163},"TD : CSV > Markdown (1)","/nsi/python/csv-markdown","0.nsi/4.python/3.csv-markdown","Pour rappel nous avons vu en TD comment aborder la manipulation d'une chaîne de caractères multi-lignes contenant des données au format CSV. L'exemple fourni correspond au code ci-dessous :",{"title":165,"path":166,"stem":167,"icon":13,"description":21},"Conditions","/nsi/python/conditions","0.nsi/4.python/4.conditions",{"title":169,"path":170,"stem":171,"icon":13,"description":172},"Boucles","/nsi/python/boucles","0.nsi/4.python/5.boucles","La notion de boucle est fondamentale en informatique. Une boucle permet d'exécuter plusieurs fois des instructions, soit tant qu'une condition est réalisée (utilisation de la boucle `while`), soit en déterminant le nombre d'__itérations__ qui devront être réalisées (utilisation de la boucle `for`).",{"title":174,"path":175,"stem":176,"icon":13,"description":177},"Dictionnaires","/nsi/python/dictionnaires","0.nsi/4.python/5.dictionnaires","Un nouvel exemple de type construit est le dictionnaire.",{"title":179,"path":180,"stem":181,"icon":13,"description":182},"Listes","/nsi/python/listes","0.nsi/4.python/5.listes","Il est possible de \"stocker\" plusieurs valeurs dans une même structure. Ce type de structure est appelé une __séquence__.",{"title":184,"path":185,"stem":186,"icon":13,"description":182},"Tuples","/nsi/python/tuples","0.nsi/4.python/5.tuples",{"title":188,"path":189,"stem":190,"icon":98,"description":191},"Exercices pratiques","/nsi/python/exercices-1","0.nsi/4.python/6.exercices-1","Pour s'entraîner sur les conditions, boucles, et manipulation de chaînes de caractères, voici quelques exercices pratiques à réaliser :",{"title":193,"path":194,"stem":195,"icon":13,"description":196},"Fonctions","/nsi/python/fonctions","0.nsi/4.python/7.fonctions","Ce cours vise à rassembler les éléments importants à considérer lorsque l'on crée une fonction.",{"title":198,"icon":13,"description":13,"path":199,"stem":200,"children":201,"page":57},"IHM","/nsi/ihm","0.nsi/5.ihm",[202,206,211,216,220],{"title":203,"path":204,"stem":205,"icon":13,"description":21},"Formulaires HTML","/nsi/ihm/formulaires","0.nsi/5.ihm/1.formulaires",{"title":207,"path":208,"stem":209,"icon":13,"description":210},"Les requêtes HTTP","/nsi/ihm/http","0.nsi/5.ihm/2.http","Lorsqu'on soumet un formulaire, les données sont envoyées au serveur grâce à une requête HTTP. Mais c'est quoi exactement une requête HTTP ?",{"title":212,"path":213,"stem":214,"icon":13,"description":215},"Gestion des évènements","/nsi/ihm/evenements","0.nsi/5.ihm/3.evenements","Les évènements permettent d'exécuter des actions en réponse aux interactions des utilisateurs avec une page web, comme l'appui sur une touche ou le déplacement de la souris. JavaScript utilise des écouteurs d’évènements pour détecter ces interactions et déclencher des fonctions en conséquence.",{"title":217,"path":218,"stem":219,"icon":13,"description":21},"Manipulation du DOM","/nsi/ihm/dom","0.nsi/5.ihm/4.dom",{"title":221,"path":222,"stem":223,"icon":98,"description":21},"Jeu du clic","/nsi/ihm/tp","0.nsi/5.ihm/5.tp",{"id":225,"title":33,"body":226,"description":36,"extension":1544,"icon":13,"landing":57,"links":13,"meta":1545,"navigation":422,"path":34,"seo":1546,"stem":35,"__hash__":1547},"content_fr/0.nsi/1.algorithmique/3.jeu-vie.md",{"type":227,"value":228,"toc":1531},"minimark",[229,233,236,239,246,251,255,272,275,279,282,292,297,299,303,307,311,314,318,325,360,365,368,505,509,515,652,656,700,733,736,764,802,806,809,820,906,910,916,1267,1271,1274,1504,1508,1519,1527],[230,231,33],"h1",{"id":232},"le-jeu-de-la-vie",[234,235,36],"p",{},[234,237,238],{},"Les automates cellulaires sont étudiés en mathématiques et en informatique théorique. Le modèle des automates cellulaires est remarquable par l'écart entre la simplicité de sa définition et la complexité que peuvent atteindre certains comportements macroscopiques.",[240,241,243],"alert",{"type":242},"success",[234,244,245],{},"Nous allons aujourd'hui créer nos premiers automates cellulaires !",[247,248,250],"h2",{"id":249},"système-unidimensionnel","Système unidimensionnel",[247,252,254],{"id":253},"présentation","Présentation",[234,256,257,258,262,263,267,268,271],{},"Nous allons considérer une grille ",[259,260,261],"strong",{},"unidimensionnelle"," de cellules ne pouvant prendre que deux états : ",[264,265,266],"code",{},"0"," ou ",[264,269,270],{},"1",", et nous allons définir des règles basées sur une cellule et ses deux voisines immédiates.",[234,273,274],{},"Exemple :",[276,277],"jeu-vie",{"code":278,"play":270,"reset":270},"000010000",[234,280,281],{},"Partant de cette grille unidimensionnelle, considérons que la couleur de chaque cellule dépend de ses voisines. Voici par exemple une règle simple :",[283,284,285,289],"ul",{},[286,287,288],"li",{},"si une cellule est noire, elle reste noire",[286,290,291],{},"si une cellule est blanche, elle devient noire si elle possède au moins une voisine noire.",[240,293,294],{"type":242},[234,295,296],{},"À chaque nouvelle génération, on applique cette règle à toutes les cellules",[276,298],{"code":278,"gen":270},[276,300],{"code":301,"gen":302},"000111000","2",[276,304],{"code":305,"gen":306},"001111100","3",[276,308],{"code":309,"gen":310},"011111110","4",[234,312,313],{},"Sur plusieurs générations successives, nous pouvons superposer les lignes obtenues et ainsi obtenir une image qui sera une représentation graphique de la règle que nous avons considérée.",[247,315,317],{"id":316},"mise-en-code","Mise en code",[234,319,320,321,324],{},"Nous allons utiliser Python pour automatiser le comportement de ces automates cellulaires unidimensionnels. Chaque case sera pour l'instant représentée par un élément d'un tableau, qui sera égal à 0 ou 1. Notre objectif d'ici la fin de la séance sera de générer une image pixel par pixel grâce à la librairie PIL (cf TP précédent).",[322,323],"br",{},"\nL'exemple ci-dessus donnera donc, dans un premier temps, dans une sortie console :",[326,327,331],"pre",{"className":328,"code":329,"language":330,"meta":21,"style":21},"language-bash shiki shiki-themes github-light github-light github-dark monokai","000010000\n000111000\n001111100\n011111110\n","bash",[264,332,333,342,348,354],{"__ignoreMap":21},[334,335,338],"span",{"class":336,"line":337},"line",1,[334,339,341],{"class":340},"s0Mi1","000010000\n",[334,343,345],{"class":336,"line":344},2,[334,346,347],{"class":340},"000111000\n",[334,349,351],{"class":336,"line":350},3,[334,352,353],{"class":340},"001111100\n",[334,355,357],{"class":336,"line":356},4,[334,358,359],{"class":340},"011111110\n",[361,362,364],"h3",{"id":363},"préparation-de-la-matrice","Préparation de la matrice",[234,366,367],{},"À la façon d'une image numérique, nous allons ranger nos générations successives dans une matrice, c'est-à-dire pour notre exemple une liste de chaînes de caractères.",[326,369,373],{"className":370,"code":371,"language":372,"meta":21,"style":21},"language-py shiki shiki-themes github-light github-light github-dark monokai","matrice = [\"000010000\"]\n# Ici, matrice est une liste de listes. Pour l'instant, elle n'en contient qu'une seule : [\"000010000\"]\n# Pour ajouter une génération, on fera :\nmatrice.append(\"000111000\")\n\n# On peut visualiser le résultat obtenu :\nprint(\"print(matrice) : \\n\", matrice)\n\n# Ou, si on veut afficher les lignes les unes au-dessus des autres :\nprint(\"Avec une boucle for :\")\n\nfor generation in matrice:\n    print(generation)\n\n","py",[264,374,375,395,401,406,417,424,430,453,458,464,476,481,496],{"__ignoreMap":21},[334,376,377,381,385,388,392],{"class":336,"line":337},[334,378,380],{"class":379},"s6P_L","matrice ",[334,382,384],{"class":383},"sM8ZF","=",[334,386,387],{"class":379}," [",[334,389,391],{"class":390},"s-2G5","\"000010000\"",[334,393,394],{"class":379},"]\n",[334,396,397],{"class":336,"line":344},[334,398,400],{"class":399},"sq-8i","# Ici, matrice est une liste de listes. Pour l'instant, elle n'en contient qu'une seule : [\"000010000\"]\n",[334,402,403],{"class":336,"line":350},[334,404,405],{"class":399},"# Pour ajouter une génération, on fera :\n",[334,407,408,411,414],{"class":336,"line":356},[334,409,410],{"class":379},"matrice.append(",[334,412,413],{"class":390},"\"000111000\"",[334,415,416],{"class":379},")\n",[334,418,420],{"class":336,"line":419},5,[334,421,423],{"emptyLinePlaceholder":422},true,"\n",[334,425,427],{"class":336,"line":426},6,[334,428,429],{"class":399},"# On peut visualiser le résultat obtenu :\n",[334,431,433,437,440,443,447,450],{"class":336,"line":432},7,[334,434,436],{"class":435},"s89Ua","print",[334,438,439],{"class":379},"(",[334,441,442],{"class":390},"\"print(matrice) : ",[334,444,446],{"class":445},"sROoR","\\n",[334,448,449],{"class":390},"\"",[334,451,452],{"class":379},", matrice)\n",[334,454,456],{"class":336,"line":455},8,[334,457,423],{"emptyLinePlaceholder":422},[334,459,461],{"class":336,"line":460},9,[334,462,463],{"class":399},"# Ou, si on veut afficher les lignes les unes au-dessus des autres :\n",[334,465,467,469,471,474],{"class":336,"line":466},10,[334,468,436],{"class":435},[334,470,439],{"class":379},[334,472,473],{"class":390},"\"Avec une boucle for :\"",[334,475,416],{"class":379},[334,477,479],{"class":336,"line":478},11,[334,480,423],{"emptyLinePlaceholder":422},[334,482,484,487,490,493],{"class":336,"line":483},12,[334,485,486],{"class":383},"for",[334,488,489],{"class":379}," generation ",[334,491,492],{"class":383},"in",[334,494,495],{"class":379}," matrice:\n",[334,497,499,502],{"class":336,"line":498},13,[334,500,501],{"class":435},"    print",[334,503,504],{"class":379},"(generation)\n",[361,506,508],{"id":507},"appliquer-les-règles","Appliquer les règles",[234,510,511,512,514],{},"Pour pouvoir appliquer appliquer la règle à une cellule, nous devons regarder les cellules voisines. Nous allons donc utiliser une boucle for avec un index d'itération.",[322,513],{},"\nPar exemple, dans le code ci-dessous, pour afficher la cellule courante et ses voisines :",[326,516,518],{"className":370,"code":517,"language":372,"meta":21,"style":21},"generation = \"000010000\"\n\nfor i in range(len(generation)):\n    print(\"cellule courante : \", generation[i])\n    if i > 0:\n        print(\"cellule précédente : \", generation[i-1])\n    if i+1 \u003C len(generation):\n        print(\"cellule suivante : \", generation[i+1])\n    print(\"---------\")\n",[264,519,520,530,534,554,566,582,603,624,641],{"__ignoreMap":21},[334,521,522,525,527],{"class":336,"line":337},[334,523,524],{"class":379},"generation ",[334,526,384],{"class":383},[334,528,529],{"class":390}," \"000010000\"\n",[334,531,532],{"class":336,"line":344},[334,533,423],{"emptyLinePlaceholder":422},[334,535,536,538,541,543,546,548,551],{"class":336,"line":350},[334,537,486],{"class":383},[334,539,540],{"class":379}," i ",[334,542,492],{"class":383},[334,544,545],{"class":435}," range",[334,547,439],{"class":379},[334,549,550],{"class":435},"len",[334,552,553],{"class":379},"(generation)):\n",[334,555,556,558,560,563],{"class":336,"line":356},[334,557,501],{"class":435},[334,559,439],{"class":379},[334,561,562],{"class":390},"\"cellule courante : \"",[334,564,565],{"class":379},", generation[i])\n",[334,567,568,571,573,576,579],{"class":336,"line":419},[334,569,570],{"class":383},"    if",[334,572,540],{"class":379},[334,574,575],{"class":383},">",[334,577,578],{"class":445}," 0",[334,580,581],{"class":379},":\n",[334,583,584,587,589,592,595,598,600],{"class":336,"line":426},[334,585,586],{"class":435},"        print",[334,588,439],{"class":379},[334,590,591],{"class":390},"\"cellule précédente : \"",[334,593,594],{"class":379},", generation[i",[334,596,597],{"class":383},"-",[334,599,270],{"class":445},[334,601,602],{"class":379},"])\n",[334,604,605,607,610,613,615,618,621],{"class":336,"line":432},[334,606,570],{"class":383},[334,608,609],{"class":379}," i",[334,611,612],{"class":383},"+",[334,614,270],{"class":445},[334,616,617],{"class":383}," \u003C",[334,619,620],{"class":435}," len",[334,622,623],{"class":379},"(generation):\n",[334,625,626,628,630,633,635,637,639],{"class":336,"line":455},[334,627,586],{"class":435},[334,629,439],{"class":379},[334,631,632],{"class":390},"\"cellule suivante : \"",[334,634,594],{"class":379},[334,636,612],{"class":383},[334,638,270],{"class":445},[334,640,602],{"class":379},[334,642,643,645,647,650],{"class":336,"line":460},[334,644,501],{"class":435},[334,646,439],{"class":379},[334,648,649],{"class":390},"\"---------\"",[334,651,416],{"class":379},[653,654,655],"badge",{},"JDV1",[240,657,659],{"type":658},"info",[234,660,661,662,665,666,669,670,673,674,676,677,680,681,684,685,687,688,691,693,694,267,697,673],{},"Écrire une fonction ",[264,663,664],{},"regle_A"," qui applique la règle fournie plus haut à la cellule d'indice ",[264,667,668],{},"indice"," de la génération ",[264,671,672],{},"gen_actuelle",".",[322,675],{},"\nLa fonction prend deux arguments : ",[259,678,679],{},"une chaîne de caractères"," représentant la génération actuelle, ainsi qu'un ",[259,682,683],{},"entier"," représentant l'indice de la cellule à étudier.",[322,686],{},"\nOn appellera la fonction ainsi : ",[264,689,690],{},"regle_A(gen_actuelle, indice)",[322,692],{},"\nLa fonction aura pour valeur de retour ",[264,695,696],{},"'0'",[264,698,699],{},"'1'",[701,702,703,712],"p-card-grid",{"cols":344},[704,705,706,709],"p-card",{},[234,707,708],{},"Exemple, avec la génération suivante :",[276,710],{"code":711,"gen":270},"100100",[704,713,714],{},[234,715,716,719,721,722,724,725,727,728,730],{},[264,717,718],{},"regle_A(\"100100\",2)",[322,720],{},"\nLa cellule de rang 2 est le ",[264,723,266],{}," juste avant le ",[264,726,270],{},". Elle a une voisine noire, donc elle devient noire.",[322,729],{},[264,731,732],{},"return \"0\"",[653,734,735],{},"JDV2",[240,737,738],{"type":658},[234,739,661,740,743,744,747,748,751,752,754,755,673,758,760,761,763],{},[264,741,742],{},"nouvelle_gen"," qui prend en argument une ",[259,745,746],{},"chaîne de caractères"," contenant les cellules de la génération ",[264,749,750],{},"n"," et qui renvoie une ",[259,753,746],{}," contenant la génération ",[264,756,757],{},"n+1",[322,759],{},"\nOn appliquera à chaque cellule de la génération n la fonction ",[264,762,664],{}," pour savoir quel sera son état lors de la prochaine génération (n+1).",[701,765,766,777],{"cols":344},[704,767,768,770,774],{},[234,769,708],{},[276,771],{"code":772,"gen":750,"jc":773},"0010100","end",[276,775],{"code":776,"gen":757,"jc":773},"0111110",[704,778,779],{},[234,780,781,784,786,787,790,791,793,794,796,797,799],{},[264,782,783],{},"nouvelle_gen(\"0010100\" gen=\"n\")",[322,785],{},"\nLa fonction fait une itération sur la chaîne ",[264,788,789],{},"\"0010100\""," et fait appel à ",[264,792,664],{}," pour appliquer la règle à chaque cellule.",[322,795],{},"\nElle stocke les valeurs au fur et à mesure, puis renvoie le résultat.",[322,798],{},[264,800,801],{},"return \"0111110\"",[361,803,805],{"id":804},"programme-complet","Programme complet",[653,807,808],{},"JDV3",[240,810,811],{"type":658},[234,812,813,814,816,817,819],{},"Grâce à vos fonctions ",[264,815,742],{}," et ",[264,818,664],{},", faire tourner le programme complet.",[326,821,823],{"className":370,"code":822,"language":372,"meta":21,"style":21},"# définition des fonctions\n# ...\n# python\n# python\n# python\n# ...\n\n# déroulé du programme :\nmatrice = [\"000010000\"]\nnb_generations = 4\n\nfor g in range(nb_generations):\n    matrice.append(nouvelle_gen(matrice[g]))\n",[264,824,825,830,835,840,844,848,852,856,861,873,883,887,901],{"__ignoreMap":21},[334,826,827],{"class":336,"line":337},[334,828,829],{"class":399},"# définition des fonctions\n",[334,831,832],{"class":336,"line":344},[334,833,834],{"class":399},"# ...\n",[334,836,837],{"class":336,"line":350},[334,838,839],{"class":399},"# python\n",[334,841,842],{"class":336,"line":356},[334,843,839],{"class":399},[334,845,846],{"class":336,"line":419},[334,847,839],{"class":399},[334,849,850],{"class":336,"line":426},[334,851,834],{"class":399},[334,853,854],{"class":336,"line":432},[334,855,423],{"emptyLinePlaceholder":422},[334,857,858],{"class":336,"line":455},[334,859,860],{"class":399},"# déroulé du programme :\n",[334,862,863,865,867,869,871],{"class":336,"line":460},[334,864,380],{"class":379},[334,866,384],{"class":383},[334,868,387],{"class":379},[334,870,391],{"class":390},[334,872,394],{"class":379},[334,874,875,878,880],{"class":336,"line":466},[334,876,877],{"class":379},"nb_generations ",[334,879,384],{"class":383},[334,881,882],{"class":445}," 4\n",[334,884,885],{"class":336,"line":478},[334,886,423],{"emptyLinePlaceholder":422},[334,888,889,891,894,896,898],{"class":336,"line":483},[334,890,486],{"class":383},[334,892,893],{"class":379}," g ",[334,895,492],{"class":383},[334,897,545],{"class":435},[334,899,900],{"class":379},"(nb_generations):\n",[334,902,903],{"class":336,"line":498},[334,904,905],{"class":379},"    matrice.append(nouvelle_gen(matrice[g]))\n",[247,907,909],{"id":908},"création-dimages","Création d'images",[234,911,912,913,915],{},"Nous pouvons désormais utiliser notre code pour générer une image qui contiendra les générations successives de notre automate cellulaire.",[322,914],{},"\nVoici le code Python qui fera le nécessaire :",[326,917,919],{"className":370,"code":918,"language":372,"meta":21,"style":21},"from PIL import Image\n\ngen_1 = \"00000000000000000000100000000000000000000\"\n\nmatrice_pic = Image.new(\"1\", (len(gen_1), len(gen_1)), color=1)\n\ndef regle_A(gen, indice):\n    # définition de la fonction\n    \n\ndef nouvelle_gen(generation):\n    n_gen = \"\"\n    for i in range(len(generation)):\n        n_gen += regle_C(generation, i)\n    \n    return n_gen\n    \n    \ndef print_line(image, line):\n    image.putdata(line)\n\n# déroulé du programme :\nmatrice = [gen_1]\n\npxl_data = []\n\nfor g in range(len(gen_1)):\n    matrice.append(nouvelle_gen(matrice[g]))\n    \n    for px in matrice[g]:\n        pxl_data.append(1-int(px))\n        \n    print(matrice[g])\n\n\nmatrice_pic.putdata(pxl_data)\nmatrice_pic.show()\n\n",[264,920,921,935,939,949,953,989,993,1016,1021,1026,1030,1044,1054,1071,1083,1088,1097,1102,1107,1126,1132,1137,1142,1152,1157,1168,1173,1191,1196,1201,1214,1231,1237,1245,1250,1255,1261],{"__ignoreMap":21},[334,922,923,926,929,932],{"class":336,"line":337},[334,924,925],{"class":383},"from",[334,927,928],{"class":445}," PIL",[334,930,931],{"class":383}," import",[334,933,934],{"class":379}," Image\n",[334,936,937],{"class":336,"line":344},[334,938,423],{"emptyLinePlaceholder":422},[334,940,941,944,946],{"class":336,"line":350},[334,942,943],{"class":379},"gen_1 ",[334,945,384],{"class":383},[334,947,948],{"class":390}," \"00000000000000000000100000000000000000000\"\n",[334,950,951],{"class":336,"line":356},[334,952,423],{"emptyLinePlaceholder":422},[334,954,955,958,960,963,966,969,971,974,976,979,983,985,987],{"class":336,"line":419},[334,956,957],{"class":379},"matrice_pic ",[334,959,384],{"class":383},[334,961,962],{"class":379}," Image.new(",[334,964,965],{"class":390},"\"1\"",[334,967,968],{"class":379},", (",[334,970,550],{"class":435},[334,972,973],{"class":379},"(gen_1), ",[334,975,550],{"class":435},[334,977,978],{"class":379},"(gen_1)), ",[334,980,982],{"class":981},"sEcNA","color",[334,984,384],{"class":383},[334,986,270],{"class":445},[334,988,416],{"class":379},[334,990,991],{"class":336,"line":426},[334,992,423],{"emptyLinePlaceholder":422},[334,994,995,999,1002,1004,1008,1011,1013],{"class":336,"line":432},[334,996,998],{"class":997},"sKQZD","def",[334,1000,1001],{"class":340}," regle_A",[334,1003,439],{"class":379},[334,1005,1007],{"class":1006},"sWcf1","gen",[334,1009,1010],{"class":379},", ",[334,1012,668],{"class":1006},[334,1014,1015],{"class":379},"):\n",[334,1017,1018],{"class":336,"line":455},[334,1019,1020],{"class":399},"    # définition de la fonction\n",[334,1022,1023],{"class":336,"line":460},[334,1024,1025],{"class":379},"    \n",[334,1027,1028],{"class":336,"line":466},[334,1029,423],{"emptyLinePlaceholder":422},[334,1031,1032,1034,1037,1039,1042],{"class":336,"line":478},[334,1033,998],{"class":997},[334,1035,1036],{"class":340}," nouvelle_gen",[334,1038,439],{"class":379},[334,1040,1041],{"class":1006},"generation",[334,1043,1015],{"class":379},[334,1045,1046,1049,1051],{"class":336,"line":483},[334,1047,1048],{"class":379},"    n_gen ",[334,1050,384],{"class":383},[334,1052,1053],{"class":390}," \"\"\n",[334,1055,1056,1059,1061,1063,1065,1067,1069],{"class":336,"line":498},[334,1057,1058],{"class":383},"    for",[334,1060,540],{"class":379},[334,1062,492],{"class":383},[334,1064,545],{"class":435},[334,1066,439],{"class":379},[334,1068,550],{"class":435},[334,1070,553],{"class":379},[334,1072,1074,1077,1080],{"class":336,"line":1073},14,[334,1075,1076],{"class":379},"        n_gen ",[334,1078,1079],{"class":383},"+=",[334,1081,1082],{"class":379}," regle_C(generation, i)\n",[334,1084,1086],{"class":336,"line":1085},15,[334,1087,1025],{"class":379},[334,1089,1091,1094],{"class":336,"line":1090},16,[334,1092,1093],{"class":383},"    return",[334,1095,1096],{"class":379}," n_gen\n",[334,1098,1100],{"class":336,"line":1099},17,[334,1101,1025],{"class":379},[334,1103,1105],{"class":336,"line":1104},18,[334,1106,1025],{"class":379},[334,1108,1110,1112,1115,1117,1120,1122,1124],{"class":336,"line":1109},19,[334,1111,998],{"class":997},[334,1113,1114],{"class":340}," print_line",[334,1116,439],{"class":379},[334,1118,1119],{"class":1006},"image",[334,1121,1010],{"class":379},[334,1123,336],{"class":1006},[334,1125,1015],{"class":379},[334,1127,1129],{"class":336,"line":1128},20,[334,1130,1131],{"class":379},"    image.putdata(line)\n",[334,1133,1135],{"class":336,"line":1134},21,[334,1136,423],{"emptyLinePlaceholder":422},[334,1138,1140],{"class":336,"line":1139},22,[334,1141,860],{"class":399},[334,1143,1145,1147,1149],{"class":336,"line":1144},23,[334,1146,380],{"class":379},[334,1148,384],{"class":383},[334,1150,1151],{"class":379}," [gen_1]\n",[334,1153,1155],{"class":336,"line":1154},24,[334,1156,423],{"emptyLinePlaceholder":422},[334,1158,1160,1163,1165],{"class":336,"line":1159},25,[334,1161,1162],{"class":379},"pxl_data ",[334,1164,384],{"class":383},[334,1166,1167],{"class":379}," []\n",[334,1169,1171],{"class":336,"line":1170},26,[334,1172,423],{"emptyLinePlaceholder":422},[334,1174,1176,1178,1180,1182,1184,1186,1188],{"class":336,"line":1175},27,[334,1177,486],{"class":383},[334,1179,893],{"class":379},[334,1181,492],{"class":383},[334,1183,545],{"class":435},[334,1185,439],{"class":379},[334,1187,550],{"class":435},[334,1189,1190],{"class":379},"(gen_1)):\n",[334,1192,1194],{"class":336,"line":1193},28,[334,1195,905],{"class":379},[334,1197,1199],{"class":336,"line":1198},29,[334,1200,1025],{"class":379},[334,1202,1204,1206,1209,1211],{"class":336,"line":1203},30,[334,1205,1058],{"class":383},[334,1207,1208],{"class":379}," px ",[334,1210,492],{"class":383},[334,1212,1213],{"class":379}," matrice[g]:\n",[334,1215,1217,1220,1222,1224,1228],{"class":336,"line":1216},31,[334,1218,1219],{"class":379},"        pxl_data.append(",[334,1221,270],{"class":445},[334,1223,597],{"class":383},[334,1225,1227],{"class":1226},"sp0el","int",[334,1229,1230],{"class":379},"(px))\n",[334,1232,1234],{"class":336,"line":1233},32,[334,1235,1236],{"class":379},"        \n",[334,1238,1240,1242],{"class":336,"line":1239},33,[334,1241,501],{"class":435},[334,1243,1244],{"class":379},"(matrice[g])\n",[334,1246,1248],{"class":336,"line":1247},34,[334,1249,423],{"emptyLinePlaceholder":422},[334,1251,1253],{"class":336,"line":1252},35,[334,1254,423],{"emptyLinePlaceholder":422},[334,1256,1258],{"class":336,"line":1257},36,[334,1259,1260],{"class":379},"matrice_pic.putdata(pxl_data)\n",[334,1262,1264],{"class":336,"line":1263},37,[334,1265,1266],{"class":379},"matrice_pic.show()\n",[361,1268,1270],{"id":1269},"dautres-règles","D'autres règles",[234,1272,1273],{},"Essayez le code précédent avec les règles B et C ci-dessous :",[326,1275,1277],{"className":370,"code":1276,"language":372,"meta":21,"style":21},"def regle_B(gen, indice):\n    cur = int(gen[indice])\n    if indice > 0:\n        prev = int(gen[indice - 1])\n    else:\n        prev = 0\n    if indice + 1 \u003C len(gen):\n        next = int(gen[indice + 1])\n    else:\n        next = 0\n\n    if prev + next == 2 or prev + next == 0:\n        return '0'\n    else:\n        return '1'\n\ndef regle_C(gen, indice):\n    return str(1 - int(regle_B(gen, indice)))\n",[264,1278,1279,1296,1309,1322,1341,1348,1357,1374,1392,1398,1406,1410,1443,1451,1457,1464,1468,1485],{"__ignoreMap":21},[334,1280,1281,1283,1286,1288,1290,1292,1294],{"class":336,"line":337},[334,1282,998],{"class":997},[334,1284,1285],{"class":340}," regle_B",[334,1287,439],{"class":379},[334,1289,1007],{"class":1006},[334,1291,1010],{"class":379},[334,1293,668],{"class":1006},[334,1295,1015],{"class":379},[334,1297,1298,1301,1303,1306],{"class":336,"line":344},[334,1299,1300],{"class":379},"    cur ",[334,1302,384],{"class":383},[334,1304,1305],{"class":1226}," int",[334,1307,1308],{"class":379},"(gen[indice])\n",[334,1310,1311,1313,1316,1318,1320],{"class":336,"line":350},[334,1312,570],{"class":383},[334,1314,1315],{"class":379}," indice ",[334,1317,575],{"class":383},[334,1319,578],{"class":445},[334,1321,581],{"class":379},[334,1323,1324,1327,1329,1331,1334,1336,1339],{"class":336,"line":356},[334,1325,1326],{"class":379},"        prev ",[334,1328,384],{"class":383},[334,1330,1305],{"class":1226},[334,1332,1333],{"class":379},"(gen[indice ",[334,1335,597],{"class":383},[334,1337,1338],{"class":445}," 1",[334,1340,602],{"class":379},[334,1342,1343,1346],{"class":336,"line":419},[334,1344,1345],{"class":383},"    else",[334,1347,581],{"class":379},[334,1349,1350,1352,1354],{"class":336,"line":426},[334,1351,1326],{"class":379},[334,1353,384],{"class":383},[334,1355,1356],{"class":445}," 0\n",[334,1358,1359,1361,1363,1365,1367,1369,1371],{"class":336,"line":432},[334,1360,570],{"class":383},[334,1362,1315],{"class":379},[334,1364,612],{"class":383},[334,1366,1338],{"class":445},[334,1368,617],{"class":383},[334,1370,620],{"class":435},[334,1372,1373],{"class":379},"(gen):\n",[334,1375,1376,1379,1382,1384,1386,1388,1390],{"class":336,"line":455},[334,1377,1378],{"class":435},"        next",[334,1380,1381],{"class":383}," =",[334,1383,1305],{"class":1226},[334,1385,1333],{"class":379},[334,1387,612],{"class":383},[334,1389,1338],{"class":445},[334,1391,602],{"class":379},[334,1393,1394,1396],{"class":336,"line":460},[334,1395,1345],{"class":383},[334,1397,581],{"class":379},[334,1399,1400,1402,1404],{"class":336,"line":466},[334,1401,1378],{"class":435},[334,1403,1381],{"class":383},[334,1405,1356],{"class":445},[334,1407,1408],{"class":336,"line":478},[334,1409,423],{"emptyLinePlaceholder":422},[334,1411,1412,1414,1417,1419,1422,1425,1428,1431,1433,1435,1437,1439,1441],{"class":336,"line":483},[334,1413,570],{"class":383},[334,1415,1416],{"class":379}," prev ",[334,1418,612],{"class":383},[334,1420,1421],{"class":435}," next",[334,1423,1424],{"class":383}," ==",[334,1426,1427],{"class":445}," 2",[334,1429,1430],{"class":383}," or",[334,1432,1416],{"class":379},[334,1434,612],{"class":383},[334,1436,1421],{"class":435},[334,1438,1424],{"class":383},[334,1440,578],{"class":445},[334,1442,581],{"class":379},[334,1444,1445,1448],{"class":336,"line":498},[334,1446,1447],{"class":383},"        return",[334,1449,1450],{"class":390}," '0'\n",[334,1452,1453,1455],{"class":336,"line":1073},[334,1454,1345],{"class":383},[334,1456,581],{"class":379},[334,1458,1459,1461],{"class":336,"line":1085},[334,1460,1447],{"class":383},[334,1462,1463],{"class":390}," '1'\n",[334,1465,1466],{"class":336,"line":1090},[334,1467,423],{"emptyLinePlaceholder":422},[334,1469,1470,1472,1475,1477,1479,1481,1483],{"class":336,"line":1099},[334,1471,998],{"class":997},[334,1473,1474],{"class":340}," regle_C",[334,1476,439],{"class":379},[334,1478,1007],{"class":1006},[334,1480,1010],{"class":379},[334,1482,668],{"class":1006},[334,1484,1015],{"class":379},[334,1486,1487,1489,1492,1494,1496,1499,1501],{"class":336,"line":1104},[334,1488,1093],{"class":383},[334,1490,1491],{"class":1226}," str",[334,1493,439],{"class":379},[334,1495,270],{"class":445},[334,1497,1498],{"class":383}," -",[334,1500,1305],{"class":1226},[334,1502,1503],{"class":379},"(regle_B(gen, indice)))\n",[247,1505,1507],{"id":1506},"pour-aller-plus-loin","Pour aller plus loin...",[234,1509,1510,1511,1518],{},"Vous pouvez lire ",[1512,1513,1517],"a",{"href":1514,"rel":1515},"https://scienceetonnante.com/2013/10/28/les-automates-cellulaires-elementaires/",[1516],"nofollow","cet article de Science étonnante"," dont ce TP est inspiré, et/ou regarder la vidéo associée, sur la chaîne YouTube de... Science étonnante !",[1520,1521],"iframe",{"src":1522,"title":1523,"frameBorder":266,"allow":1524,"referrerPolicy":1525,"allowFullScreen":422,"style":1526},"https://www.youtube-nocookie.com/embed/S-W0NX97DB0?si=IQxJx4swvCWcl_ba","YouTube video player","accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share","strict-origin-when-cross-origin","aspect-ratio: 16/9; width: 100%;",[1528,1529,1530],"style",{},"html pre.shiki code .s0Mi1, html code.shiki .s0Mi1{--shiki-light:#6F42C1;--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html pre.shiki code .s6P_L, html code.shiki .s6P_L{--shiki-light:#24292E;--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .sM8ZF, html code.shiki .sM8ZF{--shiki-light:#D73A49;--shiki-default:#D73A49;--shiki-dark:#F97583;--shiki-sepia:#F92672}html pre.shiki code .s-2G5, html code.shiki .s-2G5{--shiki-light:#032F62;--shiki-default:#032F62;--shiki-dark:#9ECBFF;--shiki-sepia:#E6DB74}html pre.shiki code .sq-8i, html code.shiki .sq-8i{--shiki-light:#6A737D;--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}html pre.shiki code .s89Ua, html code.shiki .s89Ua{--shiki-light:#005CC5;--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#66D9EF}html pre.shiki code .sROoR, html code.shiki .sROoR{--shiki-light:#005CC5;--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html pre.shiki code .sEcNA, html code.shiki .sEcNA{--shiki-light:#E36209;--shiki-light-font-style:inherit;--shiki-default:#E36209;--shiki-default-font-style:inherit;--shiki-dark:#FFAB70;--shiki-dark-font-style:inherit;--shiki-sepia:#FD971F;--shiki-sepia-font-style:italic}html pre.shiki code .sKQZD, html code.shiki .sKQZD{--shiki-light:#D73A49;--shiki-light-font-style:inherit;--shiki-default:#D73A49;--shiki-default-font-style:inherit;--shiki-dark:#F97583;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .sWcf1, html code.shiki .sWcf1{--shiki-light:#24292E;--shiki-light-font-style:inherit;--shiki-default:#24292E;--shiki-default-font-style:inherit;--shiki-dark:#E1E4E8;--shiki-dark-font-style:inherit;--shiki-sepia:#FD971F;--shiki-sepia-font-style:italic}html pre.shiki code .sp0el, html code.shiki .sp0el{--shiki-light:#005CC5;--shiki-light-font-style:inherit;--shiki-default:#005CC5;--shiki-default-font-style:inherit;--shiki-dark:#79B8FF;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}",{"title":21,"searchDepth":344,"depth":344,"links":1532},[1533,1534,1535,1540,1543],{"id":249,"depth":344,"text":250},{"id":253,"depth":344,"text":254},{"id":316,"depth":344,"text":317,"children":1536},[1537,1538,1539],{"id":363,"depth":350,"text":364},{"id":507,"depth":350,"text":508},{"id":804,"depth":350,"text":805},{"id":908,"depth":344,"text":909,"children":1541},[1542],{"id":1269,"depth":350,"text":1270},{"id":1506,"depth":344,"text":1507},"md",{},{"title":33,"description":36},"2nIzx4JwDnmwUEhecKFRCROk0dk0ClNYSr8uwckIcI0",1774301504865]