TP3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q0** Quelles sont les six structures fondamentales des algorithmes ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binaire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q1** Convertir 0x7FF en décimal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q2** Convertir 1000 en binaire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q3** Convertir 0x3CF0 en binaire "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fonctionMystere(n):\n",
    "    s=''\n",
    "    while n:\n",
    "        s=str(n%2)+s\n",
    "        n=n//2\n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q4** Que fait la fonction mystère ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q5** Décrire en français l'algorithme employé par cette fonction mystère."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q6** Ecrire une fonction logbin qui donne le plus petit entier $k$ tel que $2^k >n$ où $n$ est le paramètre de la fonction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les variables P,Q,R sont des Booléens.\n",
    "\n",
    "**Q7** Recopier et compléter le tableau avec True ou False.\n",
    "\n",
    "| P | Q | R |P or not Q|not P or not R|not Q or R|(P or not Q) and (not P or not R) and (not Q or R)|\n",
    "|:----:|:----:|:----:|:---------:|:--------:|:--------:|:---------------------------------------------:|\n",
    "|False|False|False| \n",
    "|False|False|True|   \n",
    "|False|True|False|   \n",
    "|False|True|True|   \n",
    "|True|False|False|  \n",
    "|True|False|True|  \n",
    "|True|True|False|  \n",
    "|True|True|True|  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q9** Existe-t-il des valeurs booléennes pour a, b, c et d telles que la formule (not a or b or not c or d) and (a or b or not c or d) and (a or c or not d) soit vraie ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boucles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def somme(liste):\n",
    "    if liste==[]:\n",
    "        return 0\n",
    "    else:\n",
    "        return liste[0]+somme(liste[1:])\n",
    "\n",
    "somme([3,5,7,9,11])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction somme est _récursive_ , elle s'appelle elle-même.\n",
    "\n",
    "**Q10** Que fait la fonction somme ?\n",
    "\n",
    "**Q11**  Ecrire une fonction somme2 qui fait la même chose que somme mais avec une boucle, sans récursivité."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0\n",
    "s=0\n",
    "while s<100:\n",
    "    n=n+1\n",
    "    s=s+n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q12** Que contient la variable n à la fin de la boucle ci-dessus ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q13** Ecrire une fonction qui prenne un seuil $A$ en paramètre (p.ex 100) et qui renvoie le plus petit entier $n$ tel que $1+2+3+\\ldots+n \\geqslant A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste=[]\n",
    "for k in range(10):\n",
    "    liste.append(k**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q14** Que contient la variable liste à la fin de la boucle ? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q15** Que fait la _méthode_ append ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Motifs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in range(10):\n",
    "    print('*',end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'option end=' ' permet que print ne passe pas à la ligne à chaque appel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q16** Ecrire un programme qui écrit une ligne de 80 *, puis une ligne de 80 /."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q17** Ecrire une fonction ligne(n) qui permet d'écrire une ligne de n caractères *."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q18** Ecrire un programme permettant d'afficher\n",
    "\n",
    "\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\n",
    "\n",
    "\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\n",
    "\n",
    "\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\n",
    "\n",
    "On peut utiliser la fonction ligne."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q19** Ecrire une fonction ligne2(n,carac) qui permet d'afficher n fois le caractère carac.\n",
    "\n",
    "Par exemple carac(10,'/') devra afficher //////////."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q20** Ecrire une fonction rectangle(m,n,carac) qui permet d'afficher un rectangle de m lignes et n colonnes du caractère carac. Par exemple l'affichage de la question 18 doit pouvoir être obtenu par rectangle(3,10,'\\*')."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les questions fondamentales des algorithmes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def DEFP(n):\n",
    "    liste=[]\n",
    "    p=2\n",
    "    while n:\n",
    "        if n%p==0:\n",
    "            liste.append(p)\n",
    "            n=n//p\n",
    "        else:\n",
    "            p=p+1\n",
    "    return liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q21** Que renvoie DEFP(1750) ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q22** Que fait la fonction DEFP ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q23** Comment peut-on être sûr que la fonction DEFP **termine** ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q24** Comment peut-on être sûr que la liste renvoyée ne contient que des nombres premiers, et que leur produit est le paramètre n ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}