mise à jour

representation_base/chapitre_1/TP/COULEURS.ipynb

@@ -0,0 +1,207 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Un peu de couleurs\n",
+    "\n",
+    "## Contexte\n",
+    "\n",
+    "Le codage informatique le plus simple de la couleur consiste à donner, pour chaque pixel, c'est-à-dire pour tout élément de l'image, trois valeurs chacune sur un octet, correspondant directement à la luminosité. \n",
+    "\n",
+    "Un pixel d'une image, d'un écran est constitué de 3 composantes de luminophore:\n",
+    "\n",
+    "<center>\n",
+    "<span style='background-color: rgb(255, 0, 0);'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span style='background-color: rgb(0, 255, 0);'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span style='background-color: rgb(0, 0, 255);'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>\n",
+    "</center>\n",
+    "\n",
+    "## Codage en RGB\n",
+    "\n",
+    "HTML et CSS acceptent la notation RGB `rgb(24,255,12)` où les nombres représentent la valeur en pourcentage pour le rouge, le vert et le bleu.\n",
+    "\n",
+    "Chaque nombre représente la valeur de la luminosité sur un octet (8 bits)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### À Faire\n",
+    "\n",
+    "1. Combien y a-t-il de valeurs possibles pour le rouge, vert et le bleu ? \n",
+    "2. Combien de couleurs totales peut-on coder avec 3 octets ?\n",
+    "3. Dans le code, modifier la valeur des composantes rgb pour changer la couleur du <span style='background-color: rgb(255, 255, 255);'>Fond du texte</span>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Codage condensé\n",
+    "\n",
+    "HTML et CSS acceptent également la notation condensée `#08A12C`, où le code après # agglutine trois valeurs hexadécimales qui sont directement celle des octets de commande des luminophores.\n",
+    "\n",
+    "Exemple : \n",
+    "\n",
+    "Le fond du texte suivant est en <span style='background-color: #808080;'>couleur grise</span>. \n",
+    "\n",
+    "En regardant le code source, on s'aperçoit que notation condensée de la couleur est : `#808080`. \n",
+    "\n",
+    "Il correspond à au codage RGB `rgb(128, 128, 128)` : <span style='background-color: rgb(128, 128, 128);'>couleur grise</span>\n",
+    "\n",
+    "### À Faire\n",
+    "\n",
+    "1. Convertir $80_{16}$ en base 10\n",
+    "2. Quel lien existe-t-il entre une composante RGB et le codage condensé d'une couleur ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Couleurs de l'arc-en-ciel\n",
+    "\n",
+    "Un arc-en-ciel est un phénomène optique se produisant dans le ciel, visible dans la direction opposée au Soleil quand il brille pendant la pluie. C'est un arc de cercle coloré d'un dégradé de couleurs continu du rouge, à l'extérieur, au jaune au vert et au bleu, jusqu'au violet à l'intérieur.\n",
+    "\n",
+    "L'objectif est de reconstituer les couleurs d'un arc en ciel !\n",
+    "\n",
+    "En analysant le code source, les couleurs de fond sont manquantes, vous devez modifiez les codes pour afficher les couleurs correspondantes.\n",
+    "\n",
+    "<table>\n",
+    "<tr>\n",
+    "    <td style=\"background-color : rgb(255, 255, 255); color: black;\">Violet</td>\n",
+    "    <td style=\"background-color : #ffffff; color: black;\">Indigo</td>\n",
+    "    <td style=\"background-color : rgb(255, 255, 255); color: black;\">Bleu</td>\n",
+    "    <td style=\"background-color : #ffffff; color: black;\">Vert</td>\n",
+    "    <td style=\"background-color : rgb(255, 255, 255); color: black;\">Jaune</td>\n",
+    "    <td style=\"background-color : #ffffff; color: black;\">Orangé</td>\n",
+    "    <td style=\"background-color : rgb(255, 255, 255); color: black;\">Rouge</td>\n",
+    "</tr>\n",
+    "</table>\n",
+    "\n",
+    "Pour cela, vous disposez de la liste des valeurs des couleurs...en binaire :\n",
+    "\n",
+    "| Couleur | Valeur binaire |\n",
+    "| :--: | :--: |\n",
+    "| Violet | `10000000 00000000 10000000` |\n",
+    "| Indigo | `00110011 01100110 11111111` |\n",
+    "| Bleu | `00000000 11001100 11111111` |\n",
+    "| Vert | `10011001 11001100 00000000` |\n",
+    "| Jaune | `11111111 11001100 00000000`|\n",
+    "| Orangé | `11111111 01100110 00000000`|\n",
+    "| Rouge | `11111111 00000000 00000000`|\n",
+    "\n",
+    "### À Faire\n",
+    "\n",
+    "1. Convertir les valeurs binaires en décimales\n",
+    "2. Programmer les blocs d'instructions permettant de :\n",
+    "    1. convertir une couleur RGB en condensé,\n",
+    "    2. convertir une couleur condensé en RGB.\n",
+    "3. Modifier les codes couleurs du tableau pour afficher les couleurs de l'arc-en-ciel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Conversion RGB $\\rightarrow$ condensé\n",
+    "\n",
+    "Ci-dessous, l'aide de la fonction `hex`, obtenue en exécutant `help(hex)`\n",
+    "\n",
+    "```python\n",
+    ">>>help(hex)\n",
+    "Help on built-in function hex in module builtins:\n",
+    "\n",
+    "hex(number, /)\n",
+    "    Return the hexadecimal representation of an integer.\n",
+    "    \n",
+    "    >>> hex(12648430)\n",
+    "    '0xc0ffee'\n",
+    "```\n",
+    "\n",
+    "Écrire les instructions qui permettent de convertir la valeur d'un RGB en condensé"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "la composante condensé de ( 0 , 0 , 0 ) est : None\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Conversion Codage RGB vers Codage condensé\n",
+    "\n",
+    "rouge = 0\n",
+    "vert = 0\n",
+    "bleu = 0 \n",
+    "\n",
+    "condense = None # valeur calculée du condensé de la couleur \n",
+    "\n",
+    "print(\"la composante condensé de (\", rouge, \",\", vert, \",\", bleu, \") est :\", condense)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Conversion condensé $\\rightarrow$ RGB\n",
+    "\n",
+    "Écrire les instructions qui permettent de convertir la valeur d'un condensé en RGB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "la composante RGB de None est : 0 0 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Conversion Codage condensé vers Codage RGB\n",
+    "\n",
+    "condense = None # valeur condensé de la couleur \n",
+    "\n",
+    "rouge = 0 # Extraire la valeur rouge de condense et la convertir en décimale\n",
+    "vert = 0 # Extraire la valeur verte de condense et la convertir en décimale\n",
+    "bleu = 0 # Extraire la valeur bleue de condense et la convertir en décimale\n",
+    "\n",
+    "print(\"la composante RGB de\", condense, \"est :\", rouge, vert, bleu)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

representation_base/chapitre_1/TP/README.md

@@ -0,0 +1,140 @@
+# Exercices : Représentation des nombres naturels
+
+
+
+## Manipulation
+
+__Question 1 :__ Écrire une fonction `est_valide(binaire)` qui retourne :
+
+* **True** si le nombre est valide 
+* **False** si le nombre est invalide. 
+Le paramètre de la fonction sera une chaîne de caractères représentant un nombre écrit en base 2.
+
+``` python
+>>> est_valide("100010101")
+True
+>>> est_valide("1010401034")
+False
+```
+
+
+
+__Question 2 :__ Écrire une fonction ``est_pair(binaire)`` qui retourne :
+
+* **True** si le nombre passé en paramètre est pair  
+* **False** si le nombre passé en paramètre est impair. 
+Le paramètre de la fonction sera une chaîne de caractères représentant un nombre écrit en base 2.
+
+```python
+>>> est_paire('1001')
+False
+>>> est_paire('1010')
+True
+```
+
+
+
+## Conversion Binaire - Décimal
+
+__Question 3 :__ Écrire une fonction ``deux_puissance(rang)`` qui retourne la puissance de 2 associée au rang passé en paramètre. Vous n'utiliserez pas les fonctions Python déjà existantes.
+
+``` python
+>>> deux_puissance(0)
+1
+>>> deux_puissance(1)
+2
+>>> deux_puissance(2)
+4
+```
+
+
+
+__Question 4 :__ A l'aide des fonctions précédentes, écrire une fonction ``binaire_en_decimal(binaire)`` qui retourne la valeur décimale du nombre passé en paramètre. Le paramètre sera une chaîne de caractères représentant un nombre binaire. On vérifiera que ce nombre binaire est valide.
+
+``` python
+>>> binaire_en_decimal("1")
+1
+>>> binaire_en_decimal("1010")
+10
+>>> binaire_en_decimal("1001")
+9
+```
+
+
+
+## Conversion Décimal - Binaire
+
+__Question 5 :__ Écrire une fonction ``division_euclidienne(nombre, diviseur)`` qui retourne le quotient et le reste obtenu lorsque l'on divise le paramètre *nombre* par le paramètre *diviseur*.
+
+``` python 
+>>> division_euclidienne(6,3)
+(2,0)
+>>> division_euclidienne(10,4)
+(2,2)
+>>> reste(6, 0)
+None
+```
+
+
+
+__Question 6 :__ A l'aide de l'algorithme de la division euclidienne et des fonctions précédentes, écrire une fonction ``decimal_en_binaire(*decimal*)`` qui retourne une chaîne de caractères correspondant à la représentation binaire du nombre passé en paramètre.
+
+
+``` python
+>>> decimal_en_binaire(16)
+"10000"
+>>> decimal_en_binaire(31)
+"11111"
+```
+
+
+
+## Conversion Décimal - Hexadécimal
+
+__Question 7 :__ Écrire une fonction ``symbole_hexa(decimal)`` qui retourne le symbole correspondant au paramètre dans la base 16.
+
+```python
+>>> symbole_hexa(1)
+"1"
+>>> symbole_hexa(10)
+"A"
+```
+
+
+
+__Question 8 :__ En s'inspirant des questions précédentes, écrire une fonction ``decimal_en_hexa(decimal)`` qui retourne une chaîne de caractères correspondant à la représentation en base 16 du nombre passé en paramètre.
+
+``` python
+>>> decimal_en_hexa(21)
+"15"
+>>> decimal_en_hexa(2019)
+"7E3"
+```
+
+
+
+## Conversion Hexadécimal - Décimal
+
+__Question 9 :__ écrire une fonction ``hexa_en_decimal(hexa)`` qui retourne le nombre correspondant à la représentation en base 10 du nombre passé en paramètre.
+
+```python
+>>> hexa_en_decimal("A")
+10
+>>> decimal_en_hexa("E10F")
+57615
+```
+
+
+
+## Conversion en base $$n$$
+
+__Question 10 :__ En s'inspirant des fonctions 8 et 10, écrire une fonction ``decimal_en_base_n(decimal, base)`` qui retourne une chaîne de caractères correspondant à la représentation en base *n* du nombre passé en paramètre.
+
+```python
+>>> decimal_en_base_n(10,2)
+"1010"
+>>> decimal_en_base_n(10,16)
+"A"
+>>> decimal_en_base_n(10,5)
+"20"
+```

representation_base/chapitre_1/TP/SHADOK.md

@@ -0,0 +1,101 @@
+---
+title : TD - Les Shadoks
+author : M. BODDAERT, M. MIESZCZAK
+license : CC-BY-NC-SA
+---
+# Les Shadoks
+
+## Contexte
+
+Les Shadoks réussissent à compter avec seulement 4 mots de leur bien maigre vocabulaire : __GA BU ZO__ et __MEU__.
+
+Dans cette [vidéo](https://youtu.be/lP9PaDs2xgQ), le professeur Shadoko explique simplement la méthode employée par les Shadoks.
+
+Ci dessous, l'explication du professeur Shadoko:
+
+_"Notez bien. Quand il n'y a pas de Shadok, on dit __GA__ et on écrit __O__.
+Quand il y a un Shadok en plus on dit __BU__ et on écrit __I__.
+Quand il y a un Shadok en plus on dit __ZO__ et on écrit __L__.
+Quand il y a un Shadok en plus on dit __MEU__ et on écrit __◺__._
+
+_Quand il y a un Shadok en plus on se rend compte qu'on ne peut plus compter._
+
+_On met tous les Shadoks dans une poubelle et on a __BU__ poubelle et __GA__ Shadok._
+
+_Et on continue: __BUGA__; __BUBU__; __BUZO__...Et on continue_
+
+_Les Shadoks applaudirent sauf un. Le devin plombier s'écria et disait qu'on n'avait pas idée des mettre des dessins sur des poubelles et des Shadoks et que la meilleure chose à faire, c'était de brûler Shadoko. Les Shadoks applaudirent aussi._
+
+## Question 1
+
+Complétez le tableau suivant en comptant jusqu'à 20 en _Shadoks_.
+
+| Nombre | Shadok |
+| ---- | ---- |
+| 0    | GA   |
+| 1    | BU   |
+| 2    | ZO   |
+| 3    | MEU  |
+| 4    |      |
+| 5    |      |
+| 6    |      |
+| 7    |      |
+| 8    |      |
+| 9    |      |
+| 10   |      |
+| 11   |     |
+| 12   |     |
+| 13   |     |
+| 14   |     |
+| 15   |     |
+| 16   |     |
+| 17   |     |
+| 18   |     |
+| 19   |     |
+| 20   |     |
+
+## Question 2
+
+1. Nous, humains, utilisons le système décimale. Quel est le système de numération utilisé par les Shadoks ?
+2. Quelle méthode permet de convertir un nombre décimal en shadok ? et inversement ?
+
+## Question 3
+
+Sachant que  **ZO MEU GA** _shadoks_ correspond à $`(44)_{10}`$, convertissez les nombres shadoks suivants en décimal :
+
+1. BUBUZO
+2. MEUGABU
+
+Saurez vous sauver le professeur du bûcher,même si brûler le professeur est intéressant aussi faut dire, en révélant le nombre écrit sur le panneau ?
+
+3. BUZOGAMEU
+
+## Question 4
+
+Plus difficile maintenant, le professeur a dénombré 21 shadoks hostiles à son système de numération et 94 shadoks favorables. Saurez vous écrire ces 2 entiers en écriture shadok ?
+
+1. 21 
+2. 94 
+
+## Question 5
+
+Les shadoks parlent mais écrivent également !!
+
+Convertissez les entiers écrits en shadoks, en décimale :
+
+1. II0◺
+2. ◺I◺O
+3. IOIOIO
+
+## Question 6
+
+Le Professeur Shadoko s'étant enfui, les shadoks ont besoin d'un traducteur officiel décimal / shadok. 
+
+Convertissez en _écriture_ shadok, les nombres suivants :
+
+1. 33
+2. 3210
+2. Votre jour / mois et année de naissance ! Les Shadoks vous souhaiteront un bon anniversaire prochainement.
+
+
+

representation_base/chapitre_1/cours/README.md

@@ -0,0 +1,228 @@
+# <span style="color:orange">Représentation des entiers naturels </span>
+
+> **_Contenu_** : Notions introduites pour l’écriture en base 2, en base 16 ainsi que la notion de boulisme. <br>
+> **_Compétences_** : Maitriser le codage d’une information et les différentes représentations de celle-ci
+
+## Le programme 
+
+<br>
+
+
+![bo_1.png](/premiere/representation_base/assets/BO_1.PNG)
+
+
+## <span style="color:blue"> Apport de connaissances </span>
+
+Pour que vous compreniez le fonctionnement du binaire, et des systèmes de comptage en général (plus communément appelés bases), je vais commencer par faire une petite réintroduction à la base 10 que vous connaissez tous et toutes. <p>
+
+<p>
+  En effet, tout le monde sait compter en base 10 (décimal). Mais comment ça marche ? Comment est construit notre système ? Pour répondre à cette question à l'apparence simple, oubliez tout et reprenons depuis le début : comment avez-vous appris à compter à l'école ?
+
+### <span style="color: green" > La numération décimale (base 10) </span>
+
+Dans la vie courante et dans beaucoup de domaines, nous utilisons la numération décimale. Elle repose à l’origine sur nos dix doigts : les dix symboles – chiffres – permettent de représenter tous les nombres.
+<br>
+La position des chiffres est primordiale dans cette représentation (numération de position) : il y a quelques années déjà, vous avez appris ce qu’étaient les unités (colonne de droite), les dizaines, les centaines, etc…
+
+Bref, il y a 10 chiffres : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Avec ces derniers, on peut compter jusqu'à 9. Et si l'on veut aller au-delà de 9, il faut changer de rang. Le nombre en est ainsi décomposé. <br>
+
+Ainsi, on peut écrire 4138 comme 4 * 1000 + 1 * 100 + 3 * 10 + 8 * 1
+→ On remarque les égalités suivantes : 1000 = 10<sup>3</sup> ; 100 = 10² ; 10 = 10<sup>1</sup> ; 1 = 10<sup>0</sup>
+
+Donc 4138 peut s’écrire : 4 * 10<sup>3</sup> + 1 * 10<sup>2</sup> + 3 * 10<sup>1</sup> + 8 * 10<sup>0</sup> <br>
+→où 10 est appelé BASE de cette numération (ici décimale)<br>
+→où chaque chiffre (compris entre 0 et 9) est soit celui des unités, dizaines, etc…
+
+![exercice_1.png](/premiere/representation_base/assets/exercice_1.PNG)
+
+✏ *Un nombre est égal à la somme des valeurs de ses rangs, et on peut décomposer n'importe quel nombre en
+puissance de sa base.* ✏
+
+### <span style="color: green" > Le codage binaire (base 10) </span>
+
+Je vous ai parlé ci-dessus de rangs. <br>En binaire, c'est pareil à la différence qu'on utilise le terme bit, qui est la
+contraction de **_binary digit_**, littéralement **_chiffre binaire_**. <br>Un bit a deux états stables.
+En électronique, il est facile d'obtenir un système présentant deux états stables distincts. Prenons l'exemple
+d'un interrupteur
+
+![interrupteur.png](/premiere/representation_base/assets/interrupteur.PNG)
+
+![exemples.png](/premiere/representation_base/assets/exemples.PNG)
+
+Ainsi, pour coder une information qui peut ne prendre que deux états stables, la numération binaire est la
+plus adaptée.
+<br>
+**Remarque** : étant donné que les symboles 0 et 1 sont communs à beaucoup de bases de numération (en
+l’occurrence 2 et 10), nous adoptons les notations suivantes.
+
+(1011)<sub>b</sub> ou 1011(en base 2) ou encore (1011)<sub>2</sub> pour la base binaire <br>
+(101)<sub>d</sub> ou 101(en base 10) ou encore (101)<sub>10</sub> pour la base dix
+
+#### <span style="color:blue">Comment trouver la représentation en base deux d'un entier naturel donné en base dix </span>
+
+→ Méthode des divisions successives <br>
+Exemple: (11)<sub>d</sub> = (?)<sub>b</sub>
+
+![10_vers_2.png](/premiere/representation_base/assets/10_vers_2.PNG)
+
+(11)<sub>d</sub> => (1011)<sub>b</sub>
+
+<br>
+
+ 
+✏ <span style ="color:purple"> Comment représenter des informations complexes ? </span> ✏
+
+<li>Avec 1 bit, nous pouvons coder 2 informations.
+<li>Avec 2 bits, nous pouvons coder 4 informations différentes (2²)
+
+Si nous généralisons un peu : avec **_k_** bits, nous pouvons coder **_2<sup>k</sup>_** informations différentes
+
+### À faire vous-même 
+
+Compléter le tableau suivant afin de coder les 8 premiers entiers naturels (entiers positifs ou nul)
+
+![tableau.png](/premiere/representation_base/assets/tableau.PNG)
+
+### À faire vous-même 
+
+1. Convertir 42(10) en base 2 : 101010 
+2. Convertir 104(10) en base 2 : 1101000
+
+<br>
+
+### <span style="color:violet"> Qu'est-ce qu'un octet ? </span>
+
+Un octet ((**byte** en anglais) est un regroupement de 8 bits.
+On parle aussi de mot. Il permet de coder 2<sup>8</sup> = 256 mots différents.
+Si nous codons des entiers naturels, nous coderons les nombres 0 à 255. Dans la littérature, un regroupement de 4 bits est appelé un quartet (cela nous servira plus tard).
+
+![octet.png](/premiere/representation_base/assets/octet.PNG)
+
+### <span style="color:violet">Unités de mesure</span>
+
+Il est très courant en informatique de mesurer la capacité mémoire d'un disque dur, de la RAM d'un ordinateur ou d'un débit de données Internet avec une unité de mesure exprimée comme un multiple d'octets. Ces multiples sont traditionnellement des puissances de 10 et on utilise les préfixes "kilo", " méga", etc. pour les nommer. Le tableau ci-dessous donne les principaux multiples utilisés dans la vie courante.
+
+| Nom              | Symbole            | Valeur |
+| :--------------- |:---------------:   | -----:|
+| Kilooctet  |   ko                     |  10<sup>3</sup> octets |
+| Mégaoctet  |   Mo                     |  10<sup>3</sup> ko |
+| Gigaoctet  |   Go                     |  10<sup>3</sup> Mo |
+| Teraoctet  |   To                     |  10<sup>3</sup> Go |
+
+> Remarque : Historiquement, les multiples utilisés en informatique étaient des puissances de 2. Pour ne pas confondre l'ancienne et la nouvelle notation, on utilise des symboles différents pour représenter ces multiples.
+
+| Nom              | valeur            | Nombre d'octeets |
+| :--------------- |:---------------:   | -----:|
+| Kio  |   2<sup>10</sup> octets                 |  1024 |
+| Mio  |   2<sup>10</sup>Kio                     |1048576|
+| Gio  |   2<sup>10</sup>Mio                     |1073741824|
+| Tio  |   2<sup>10</sup>Gio                     |1099511627776| 
+
+### À faire vous-même 
+
+> Faisons la conversion de la base 2 vers la base 10 --> Passer de (0 1 1 0 1 1 0 1)<sub>b</sub> = (….......)<sub>d</sub>
+
+Méthode : 
+<li>Ecrire le nombre binaire dans le tableau de correspondance <br>
+<li>Faire la somme des valeurs des rangs pour lesquels la valeur du bit vaut 1.
+
+![2_vers_10.png](/premiere/representation_base/assets/2_vers_10.PNG)
+
+Somme : ............
+
+----------------------------
+
+### <span style="color: green" > Le système hexadécimal (base 10) </span>
+
+<p>
+      La représentation en binaire n'est pas pratique à nous humain pour travailler (longueur de l'information importante, difficile à écrire et à lire sans faire d'erreur...).
+    <p>
+        Pour cela, nous travaillons avec la base hexadécimale. Le système hexadécimal permet de réduire la longueur des mots et facilite leur manipulation :
+L'écriture d'un nombre binaire en base hexadécimale est aisée.
+ 
+
+Ce système comporte seize symboles :
+- les dix chiffres du système décimal (0 à 9)
+- et les six premières lettres de l’alphabet (A à F) <br>
+<br>
+Ce sera donc un système en **base 16**.
+
+✏ Pour l'ordinateur, ça ne change rien, il travaille toujours en binaire. ✏
+
+### À faire vous-même
+
+> Compléter la colonne binaire
+
+![binaire.png](/premiere/representation_base/assets/binaire.PNG)
+
+> Passer de la base décimale à la base hexadécimale <br> Écrire le nombre 63650 (10) en base 16
+
+![exercice_2.png](/premiere/representation_base/assets/exercice_2.PNG)
+
+> Faisons la conversion de la base 16 vers la base 10, écrire le nombre 2A3 (16) en base décimale
+
+Méthode : 
+<li>Ecrire le nombre hexadécimal dans le tableau de correspondance en positionnant le chiffre correspondant à chacun des rangs.
+<li> Faire la somme des produits des chiffres avec la pondération correspondante.
+
+![tableau-hexa.png](/premiere/representation_base/assets/tableau_hexa.PNG)
+
+> Passer du code binaire au code hexadécimal
+
+**_Première méthode_** : opérer en deux étapes.
+<li> passer du binaire au décimal dans un premier temps
+<li> passer ensuite du décimal à l’hexadécimal <br>
+    
+Exemple : vérifier que 10110111101 (2) = 1469 (10) = 5BD
+
+
+**_Deuxième méthode_** : plus rapide, elle consiste à découper le nombre binaire en quartets (mots de 4 bits), à partir de la droite, puis à remplacer chaque quartet par le symbole hexadécimal correspondant.
+
+Exemple : 10110111101 (2) = 101 1011 1101 en binaire découpé en quartet 
+                          =  5   B    D   en hexadécimal
+
+------------------------------------
+
+### <span style = "color:green">Passer d'une base quelconque à une autre </span>
+
+Pour passer d'une base à une autre, on passera par la base 10 car c'est sur cette base qu'on maîtrise le mieux les opérations de base.
+
+Exemple : (944)<sub>10</sub> → ( 12234)<sub>5</sub>
+
+![base_quelconque.png](/premiere/representation_base/assets/Base_quelconque.PNG)
+
+-------------------------
+
+### <span style ="color:orange"> Le boutisme </span>
+
+La représentation des entiers naturels sur des mots de 2, 4 ou 8 octets se heurte au problème de l'ordre dans lequel ces octets sont organisés en mémoire. Ce problème est appelé le boutisme (ou endianness en anglais).
+
+Prenons l'exemple d'un mot de 2 octets (16 bits) comme 5BC9. Il y a deux organisations possibles d'un tel mot en mémoire :
+
+<li> Le gros boutisme (ou ou « mot de poids fort en tête » ou big endian en anglais), qui consiste à placer l'octet de poids fort en premier, c'est à dire à l'adresse mémoire la plus petite.
+
+![gros_boutisme.png](/premiere/representation_base/assets/gros_boutisme.PNG)
+
+> Quelques architectures respectant cette règle : _les processeurs Motorola 68000, les SPARC (Sun Microsystems) ou encore les System/370 (IBM)_. De plus, tous les protocoles TCP/IP communiquent en gros-boutiste. Il en va de même pour le protocole PCI Express.
+
+<li>Le petit boutisme (ou little endian en anglais), qui au contraire place l'octet de poids faible en premier.
+
+![petit_boutisme.png](/premiere/representation_base/assets/petit_boutisme.PNG)
+
+> Les processeurs x86 ont une architecture petit-boutiste. Celle-ci, au prix d'une moindre lisibilité du code machine par le programmeur, simplifiait la circuiterie de décodage d'adresses courtes et longues en 1975, quand un 8086 avait 29 000 transistors. Elle est d'influence pratiquement nulle aujourd’hui.
+
+Généralisons pour 4 octets. Ainsi, le mot 5BC96AF sera représenté de la manière suivante :
+en **gros boutisme**
+
+![gros_boutisme_2.png](/premiere/representation_base/assets/gros_boutisme_2.PNG)
+
+en **petit boutisme**
+
+![petit_boutisme_2.png](/premiere/representation_base/assets/petit_boutisme_2.PNG)
+
+La représentation petit ou gros boutisme est en principe transparente à l'utilisateur car cela est géré au niveau du système d'exploitation. Cette représentation prend de l'importance quand on accède aux octets soit en mémoire, soit lors d'échanges d'informations sur un réseau.
+
+
+```python
+
+```

representation_base/chapitre_1/exercices/README.md

@@ -0,0 +1,112 @@
+# Codage des entiers
+
+## Exercice 1
+
+Donner l'écriture décimale des entiers ci-dessous positifs codés en binaire sur un octet sans complément à 2.
+
+- $`00001000_2`$ = 
+- $`00001011_2`$ =
+- $`10000001_2`$=
+- $`11111110_2`$
+- $`01000010_2`$ =
+
+## Exercice 2
+
+Donner l'écriture binaire des entiers positifs ci-dessous sur un octet sans complément à 2.
+
+* 203 = 
+* 47 = 
+* 23 = 
+* 237 = 
+* 33 =
+* 24 =
+* 128 =
+* 255 =
+
+## Exercice 3
+
+
+Certaines oeuvres (film, livre, série...) contiennent un nombre dans leur titre. L'objectif est d'écrire les nombres en base 2, ce qui donne une toute autre lecture des titres...
+
+Exemple : Terminator $`2`$ $`\rightarrow`$ Terminator $`\overline{10}^2`$
+
+- Les **4** Fantastiques
+- Le **6**ème sens
+- Blanche neige et les **7** nains
+- Alien : Le **8**ème Passager
+- Fast and Furious **9**
+- **12** hommes en colère
+- Vendredi **13**
+- **21** Jump street
+- Les **101** dalmatiens
+- OSS **117** : Le Caire, nid d'espions
+- **2001** : L'Odysée de l'espace
+- **127** Heures
+- **300**
+- **28** jours plus tard
+- Les **Quatre Cents** Coups
+
+## Exercice 4
+
+Poser les additions de ces nombres binaires, tous positifs et codés sans complément à 2. Donner la valeur en base 10 du résultat.
+
+* $`10_2+10_2`$
+* $`101_2+11_2`$
+* $`10001_2+11010_2`$
+* $`1101_2+10101_2`$
+
+## Exercice 5
+
+Convertir en hexadécimal :
+
+* 203 =
+* 47 = 
+* 23 = 
+* 237 = 
+* 33 =
+* 24 =
+
+De même avec les entiers positifs ci-dessous codés sans compléments à 2.
+
+* $`10110010_2 = `$
+* $`10011001_2 = `$
+
+## Exercice 6
+
+Convertir en base 10.
+
+* $`1F_{16} = `$
+* $`13_{16} = `$
+* $`45_{16} = `$
+* $`FF_{16} = `$
+* $`FAB_{16} = `$
+* $`ABCD_{16} = `$
+
+## Exercice 7
+
+Convertir en base 10.
+
+- Un homme a $`14_{16}`$ doigts, si on compte les orteils !
+- En zone résidentielle, la vitesse est souvent limitée à $`1E_{16}`$ km/h.
+- La vitesse sur les autoroutes françaises est limitée à $`82_{16}`$ km/h.
+- Dans des conditions normales, l'eau bout à $`64_{16}`$ ºC.
+- Le revenu annuel médian en France s'élève à $`6EA_{16}`$ euros.
+- La population mondiale dépasse les $`1A0 000 000_{16}`$ habitants
+
+## Exercice 8
+
+Une recette de cuisine demande de la précision. 
+
+La recette suivante permet de fabriquer de délicieux __chocolats fourrés au beurre de cacahuètes__...Seulement, toutes les quantités sont exprimées en une base différente de la base décimale. 
+
+_Reconstituer la recette en convertissant toutes les quantités en décimal_.
+
+Pour $`\overline{100}^2`$ personnes, soit $`\overline{30}^8`$ biscuits.
+
+1. Mixer $`\overline{41}^{16}`$g de biscuits sablés pour les réduire en poudre
+2. Dans un saladier, mélanger cette poudre avec $`\overline{175}^8`$g de sucre glace et $`\overline{1\text{E}}^{16}`$g de beurre de cacahuètes. Bien mélanger pour obtenir une pâte.
+3. Faire fondre $`\overline{\text{F}0}^{16}`$g de chocolat pâtissier. 
+4. Dans des caissettes en aluminium, étaler un peu de chocolat fondu (environ $`\overline{100}^2`$g) puis placer un morceau de pâte, et recouvrir de chocolat fondu.
+5. Répéter l'opération avec les ingrédients restants.
+6. Mettre au réfrigérateur pendant environ $`\overline{1010}^2`$ minutes puis servir.
+