modif 25/09

EXERCICES_S2/TP1_nombre.ipynb

@@ -0,0 +1,381 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TD1 Représentation de nombres"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Exercice sur papier:\n",
+    "\n",
+    "1. Convertir en binaire le nombre 115 (division successive par 2).\n",
+    "2. Donner la représentation de -115 en complément à 2 sur 8 bits.\n",
+    "3. Donner la représentation de 12,625 comme un flottant. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On représente un entier en binaire par une liste de 0 et de 1. Donner une fonction `conversionBase2(nombre)`\n",
+    "qui transforme un entier en sa représentation binaire. Attention, les bits sont calculés dans l'ordre inverse\n",
+    "(little endian), il faudra sans doute renverser la liste avec la méthode `.reverse()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['1', '1', '1', '0', '0', '1', '1']"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def conversionBase2(nombre):\n",
+    "    if(nombre==0):\n",
+    "        return [0]\n",
+    "    res = []\n",
+    "    while nombre!=0:\n",
+    "        if nombre%2==1:\n",
+    "            res.append(\"1\")\n",
+    "        elif nombre%2==0:\n",
+    "            res.append(\"0\")\n",
+    "        nombre=nombre//2\n",
+    "    res.reverse()\n",
+    "    return res\n",
+    "    \n",
+    "conversionBase2(115)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Faire une fonction d'affichage d'une liste représentant un nombre en binaire. Pour afficher avec `print` sans passer à la ligne il faut utiliser l'argument optionnel end=\"\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1110011"
+     ]
+    }
+   ],
+   "source": [
+    "def afficheBase(liste):\n",
+    "    for i in liste:\n",
+    "        print(i,end=\"\")\n",
+    "\n",
+    "afficheBase(conversionBase2(115))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Convertir un nombre dans n'importe quelle base b (représentée comme une liste des chiffres dans cette base).\n",
+    "Que faut-il changer dans `conversionBase2` pour gérer n'importe quelle base ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['1', '1', '1', '0', '0', '1', '1']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "['1', '1', '0', '2', '1']"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def conversionBase(nombre,b):\n",
+    "    if(nombre==0):\n",
+    "        return [0]\n",
+    "    res = []\n",
+    "    while nombre!=0:\n",
+    "        if nombre%b==0:\n",
+    "            res.append(\"0\")\n",
+    "        elif nombre%b!=0:\n",
+    "            res.append(str(nombre%b))\n",
+    "        nombre=nombre//b\n",
+    "    res.reverse()\n",
+    "    return res\n",
+    "\n",
+    "print(conversionBase(115,2))\n",
+    "conversionBase(115,3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Quels sont les nombres entiers qu'on peut écrire avec n chiffres en base b ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Écrire une fonction d'affichage pour un nombre en Hexadécimal (en base 16).\n",
+    "On rappelle que 10 doit être représenté par A, 11 par B ..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "22B8\n"
+     ]
+    }
+   ],
+   "source": [
+    "def afficheBaseHexa(liste):\n",
+    "    lettres=[\"A\",\"B\",\"C\",\"D\",\"E\",\"F\"]\n",
+    "    for v in liste:\n",
+    "        if int(v)<10:\n",
+    "            print(v,end=\"\")\n",
+    "        else:\n",
+    "            print(lettres[int(v)%10],end=\"\")\n",
+    "    print()\n",
+    "        \n",
+    "\n",
+    "            \n",
+    "\n",
+    "afficheBaseHexa(conversionBase(8888,16))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Donner la valeur de $(1001101)_2$ (dans la représentation traditionnelle en base 10).\n",
+    "Écrire une fonction qui transforme la représentation en base b d'un entier en cet entier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115\n",
+      "77\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "def conversionEntier(liste,b):\n",
+    "    res = 0\n",
+    "    for i in range (len(liste)):\n",
+    "        res+=int(liste[-i-1])*b**i\n",
+    "\n",
+    "    return res\n",
+    "\n",
+    "\n",
+    "\n",
+    "test = conversionBase(115,2)\n",
+    "print(conversionEntier(test,2))\n",
+    "\n",
+    "print(conversionEntier([\"1\",\"0\",\"0\",\"1\",\"1\",\"0\",\"1\"],2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Additioner $(10001101)_2$ et $(10111001)_2$ à la main. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On a `l` un nombre en base b et on veut l'écrire sur n chiffres (en ajoutant des 0 devant). Donner une fonction pour réaliser cette transformation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0, 0, 0, '1', '1', '1', '0', '0', '1', '1']"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def etendreEcriture(l,n):\n",
+    "    if n<len(l):\n",
+    "        return -1\n",
+    "    for i in range (n-(len(l))):\n",
+    "        l.insert(0,0)\n",
+    "    return l\n",
+    "\n",
+    "etendreEcriture(test,10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Réaliser ensuite un programme qui additionne la représentation en base b de deux entiers.\n",
+    "On pourra utiliser la méthode `.insert(pos,val)` qui ajoute val à la position pos."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "#Algorithme d'addition du primaire\n",
+    "\n",
+    "def addition(l1,l2,b):\n",
+    "    if(len(l1) > len(l2)):\n",
+    "        l2 = etendreEcriture(l2,len(l1))\n",
+    "    else:\n",
+    "        l1 = etendreEcriture(l1,len(l2))\n",
+    "    res = []\n",
+    "    ret=0\n",
+    "    for i in range(len(l2)-1,-1,-1):\n",
+    "        somme=l2[i]+l1[i]+ret\n",
+    "\n",
+    "        res.insert(0,somme%b)\n",
+    "    \n",
+    "    \n",
+    "\n",
+    "    return res\n",
+    "\n",
+    "test1 = conversionBase(7,2)\n",
+    "test2 = conversionBase(18,2)\n",
+    "\n",
+    "addition(test1,test2,2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "La multiplication Égyptienne est basée sur la propriété suivante:\n",
+    "* si x est pair, x*y = (x/2)*(y*2)\n",
+    "* si x est impair, x*y = (x/2)*(y*2) + y\n",
+    "\n",
+    "Implémenter la multiplication et la division par 2 d'un nombre en binaire. \n",
+    "S'en servir pour implémenter la multiplication Égyptienne en base 2. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def division2(l):\n",
+    "    l.pop()\n",
+    "    return l\n",
+    "\n",
+    "def multiplication2(l):\n",
+    "    l.append(0)\n",
+    "    return l\n",
+    "    \n",
+    "    \n",
+    "def est_pair(l):\n",
+    "    return l[-1] == 0\n",
+    "    \n",
+    "\n",
+    "def est_zero(l):\n",
+    "    for e in l:\n",
+    "        if e:\n",
+    "            return False\n",
+    "    return True\n",
+    "    \n",
+    "\n",
+    "def multiplication_egyptienne(l1,l2):\n",
+    "    if l1%2==0:\n",
+    "        return(l1/2)*(l2*2)\n",
+    "    elif l1%2!=0:\n",
+    "        return(l1/2)*(l2*2)+l2\n",
+    "    \n",
+    "\n",
+    "\n",
+    "test1 = conversionBase(15,2)\n",
+    "test2 = conversionBase(6,2)\n",
+    "multiplication_egyptienne(test1,test2)        "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "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.11.4"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "e5f921d2cbc40cc05b5a24db6ba0e6b62c33b50cc3ec097b0c624e897b5a9797"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}