{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0b7324f3",
   "metadata": {},
   "source": [
    "# ICS - Série 3\n",
    "\n",
    "24.09.25\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c0602ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in \"Python\":\n",
    "    print(i, end = ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "166961da",
   "metadata": {},
   "outputs": [],
   "source": [
    "for a in range(7):\n",
    "    print(a, end = \" \")\n",
    "print()\n",
    "\n",
    "for a in range(3, 7):\n",
    "    print(a, end = \" \")\n",
    "print()\n",
    "      \n",
    "for a in range(7, 3):\n",
    "    print(a, end = \" \")\n",
    "print()\n",
    "    \n",
    "for a in range(10, 100, 10):\n",
    "    print(a, end = \" \")\n",
    "print()\n",
    "    \n",
    "for a in range(5, -20, -4):\n",
    "    print(a, end = \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "466dbe45",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 100:\n",
    "    if i % 10 == 0:\n",
    "        print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb1b867d",
   "metadata": {},
   "source": [
    "Quelle est la différence entre les affichages produits par les deux boucles while ci-dessous?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf564d34",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i, end = \" \")\n",
    "    i += 1\n",
    "    \n",
    "print()\n",
    "    \n",
    "i = 0\n",
    "while i < 10:\n",
    "    i += 1\n",
    "    print(i, end = \" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d3e4cd3",
   "metadata": {},
   "source": [
    "Note avant d'exécuter la cellule suivante : \n",
    "\n",
    "- Pour interrompre le calcul en cours, vous pouvez cliquer sur \"Kernel > Interrupt Kernel\" dans le menu de Noto.\n",
    "- Pour effacer les résultats (output) des cellules,  \"Kernel > Restart Kernel and Clear all Output\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0c5d912",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "s = 0\n",
    "while i >= 0:\n",
    "    s += i\n",
    "    i += 1\n",
    "    print(\"Que se passe-t-il ?!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00312a8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1 \n",
    "j = 1\n",
    "while j:\n",
    "    if i < 5:\n",
    "        print(i, \"< 5\")\n",
    "        i += 1\n",
    "    else:\n",
    "        j = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a65da1d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = -1\n",
    "while b < 4:\n",
    "    print(\"Try again\")\n",
    "    b += 1\n",
    "print(\"Okay\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4a74170",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (\"salut\",)\n",
    "print(x[0])\n",
    "print(type(x))\n",
    "\n",
    "print(\"\\n********************\\n\")\n",
    "\n",
    "x = (\"salut\")\n",
    "print(x[0])\n",
    "print(type(x))\n",
    "\n",
    "print(\"\\n********************\\n\")\n",
    "\n",
    "x = tuple(\"salut\")\n",
    "print(x[0])\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8b7f2a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "for c1 in \"Bnnrm\":\n",
    "    for c2 in \"a\":\n",
    "        print(c1 + c2, end = \"\")\n",
    "        \n",
    "print(\"\\n**************************\\n\")\n",
    "\n",
    "for c1 in \"Bnnrm\":\n",
    "    for c2 in \"aa\":\n",
    "        print(c1 + c2, end = \"\")\n",
    "\n",
    "print(\"\\n**************************\\n\")\n",
    "\n",
    "for c1 in \"aa\":\n",
    "    for c2 in \"Bnnrm\":\n",
    "        print(c2 + c1, end = \"\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7ebd875",
   "metadata": {},
   "outputs": [],
   "source": [
    "if 'p' in 'pizza':\n",
    "    print(\"je le savais bien\")\n",
    "\n",
    "if 'izz' in 'pizza':\n",
    "    print(\"ça c'est un peu plus surprenant peut-être\")\n",
    "    \n",
    "if 'pzz' in 'pizza':\n",
    "    print(\"n'exagérons pas quand même\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "902e6368",
   "metadata": {},
   "outputs": [],
   "source": [
    "for c in 'pizza':\n",
    "    print(c, \"est une lettre du mot 'pizza'\")\n",
    "    \n",
    "print(\"\\n***************************************\\n\")\n",
    "\n",
    "for c in range(-2, 3):\n",
    "    print(c, \"est un élément de range(-2, 3)\")\n",
    "    \n",
    "print(\"\\n***************************************\\n\")\n",
    "\n",
    "for c in (30, 20, 10):\n",
    "    print(c, \"est un élément du tuple (30, 20, 10)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40ba1c04",
   "metadata": {},
   "source": [
    "## Exercice 2 : somme des entiers pairs\n",
    "\n",
    "**(a)** Ecrivez une fonction `somme_pairs_while` qui prend en entrée un entier positif `n` et retourne la somme des entiers pairs entre `0` et `n` inclus, à l'aide d'une boucle `while`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71a113ec",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cf7f9334",
   "metadata": {},
   "source": [
    "**(b)** Même question mais avec une boucle `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bafce51",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0cdd1a76",
   "metadata": {},
   "source": [
    "**(c)** Modifiez vos fonctions des points (a) et (b) pour qu'elles prennent en entrée un entier relatif quelconque `m`, et retournent la somme des entiers pairs de `0` à `m` ou de `m` à `0` selon le signe de `m`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff568afb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "30d18633",
   "metadata": {},
   "source": [
    "## Exercice 3: premières boucles `for`\n",
    "\n",
    "Pour chacun des affichages ci-dessous, écrire une boucle `for`, ou deux boucles `for` imbriquées, qui le produisent.\n",
    "\n",
    "**(a)** \n",
    "\n",
    "`( 0 , 0 )\t( 0 , 1 )\t( 0 , 2 )\t( 0 , 3 )`\n",
    "\n",
    "`( 1 , 0 )\t( 1 , 1 )\t( 1 , 2 )\t( 1 , 3 )`\n",
    "\n",
    "`( 2 , 0 )\t( 2 , 1 )\t( 2 , 2 )\t( 2 , 3 )`\n",
    "\n",
    "`( 3 , 0 )\t( 3 , 1 )\t( 3 , 2 )\t( 3 , 3 )`\n",
    "\n",
    "\n",
    "**(b)** \n",
    "\n",
    "\n",
    "`( 0 , 0 )`\n",
    "\n",
    "`( 1 , 0 )\t( 1 , 1 ) `\n",
    "\n",
    "`( 2 , 0 )\t( 2 , 1 )\t( 2 , 2 )\t`\n",
    "\n",
    "`( 3 , 0 )\t( 3 , 1 )\t( 3 , 2 )\t( 3 , 3 )\t`\n",
    "\n",
    "`( 4 , 0 )\t( 4 , 1 )\t( 4 , 2 )\t( 4 , 3 )\t( 4 , 4 )\t`\n",
    "\n",
    "\n",
    "**(c)**\n",
    "\n",
    "\n",
    "`( 0 , 6 ) `\n",
    "\n",
    "`( 1 , 5 )`\n",
    "\n",
    "`( 2 , 4 ) `\n",
    "\n",
    "`( 3 , 3 ) `\n",
    "\n",
    "`( 4 , 2 ) `\n",
    "\n",
    "`( 5 , 1 ) `\n",
    "\n",
    "`( 6 , 0 ) `\n",
    "\n",
    "\n",
    "\n",
    "**(d)**\n",
    "\n",
    "\n",
    "`( 0 , 0 )\t( 0 , 1 )\t( 0 , 2 )\t( 0 , 3 )\t( 0 , 4 )\t( 0 , 5 ) `\n",
    "\n",
    "`( 1 , 1 )\t( 1 , 2 )\t( 1 , 3 )\t( 1 , 4 )\t( 1 , 5 )\t`\n",
    "\n",
    "`( 2 , 2 )\t( 2 , 3 )\t( 2 , 4 )\t( 2 , 5 )\t`\n",
    "\n",
    "`( 3 , 3 )\t( 3 , 4 )\t( 3 , 5 )\t`\n",
    "\n",
    "`( 4 , 4 )\t( 4 , 5 )\t`\n",
    "\n",
    "`( 5 , 5 )\t`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f31dacc6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7781a802",
   "metadata": {},
   "source": [
    "## Exercice 4 : affichage d'étoiles\n",
    "\n",
    "**(a)** Ecrivez une fonction `rectangle` qui prend en entrée deux entiers strictement positifs `lignes` et `colonnes` et affiche un rectangle d'étoiles des dimensions précisées. Par exemple, l'appel `rectangle(3, 4)` doit afficher\n",
    "\n",
    "    * * * *\n",
    "    * * * *\n",
    "    * * * *\n",
    " \n",
    "Votre fonction **ne peut pas** utiliser d'opérations de concaténation de strings pour afficher plusieurs étoiles à la fois."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37644c28",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "08034e69",
   "metadata": {},
   "source": [
    "**(b)** Ecrivez une fonction `rectangle_debout_couché` qui prend en entrée deux entiers strictement positifs `m` et `n` et un booléen `debout` et affiche un rectangle d'étoiles de dimensions `m` et `n`. Si `debout` vaut `True`, la fonction affiche un rectangle qui a plus de ligne que de colonnes, et sinon elle affiche un rectangle qui a plus de colonnes et de lignes. Le paramètre `debout` doit avoir une valeur par défaut de `False`.\n",
    "\n",
    "\n",
    "Par exemple, les appels `rectangle_debout_couché(3, 4, True)` et `rectangle_debout_couché(4, 3, True)` doivent tous deux afficher\n",
    "\n",
    "    * * * \n",
    "    * * * \n",
    "    * * * \n",
    "    * * *\n",
    "    \n",
    " et les appels `rectangle_debout_couché(3, 4)` et `rectangle_debout_couché(4, 3)` doivent afficher \n",
    " \n",
    "     * * * * \n",
    "     * * * *\n",
    "     * * * *\n",
    " \n",
    "\n",
    "Votre fonction ne peut toujours pas utiliser d'opérations de concaténation de strings pour afficher une ligne d'un coup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "901391e4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0c8c97c4",
   "metadata": {},
   "source": [
    "**(c)** Ecrivez une fonction `triangle_SW` qui prend en entrée un entier strictement positif `n` et affiche un triangle rectangle isocèle de côté `n` étoiles, où l'angle droit est au sud-ouest. Par exemple, `triangle_SW(3)` doit afficher\n",
    "\n",
    "    * \n",
    "    * *\n",
    "    * * *\n",
    "    \n",
    " et `triangle_SW(1)` doit afficher une seule étoile.\n",
    " \n",
    " Ensuite, écrivez une fonction `triangle_NW` qui prend en entrée un entier strictement positif `n` et affiche un triangle rectangle isocèle de côté `n` étoiles, où l'angle droit est au nord-ouest. Par exemple, `triangle_NW(3)` doit afficher\n",
    "\n",
    "    * * *\n",
    "    * *\n",
    "    *\n",
    "    \n",
    " \n",
    " \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "963f4aeb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "17560383",
   "metadata": {},
   "source": [
    "**(d)** Ecrivez les deux fonctions `triangle_NE` et `triangle_SE` qui affichent les deux rotations restantes du triangle, avec l'angle droit au nord-est et au sud-est respectivement:\n",
    "\n",
    "    \n",
    "    * * *\n",
    "      * *\n",
    "        *\n",
    "        \n",
    "        *\n",
    "      * *\n",
    "    * * *\n",
    "\n",
    "**Indication:** Pour chaque ligne commencez par afficher un certain nombre d'espaces (ou de doubles espaces selon comment vous avez espacé vos étoiles), et puis affichez un certain nombre d'étoiles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8a91fd3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f594d070",
   "metadata": {},
   "source": [
    "## Exercice 5 : recherche de nombres premiers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "106dbc13",
   "metadata": {},
   "source": [
    "Un nombre entier positif est dit **premier** s'il n'est divisible que par 1 et par lui-même. Par définition, 1 n'est pas un nombre premier, le plus petit nombre premier est donc 2.\n",
    "\n",
    "**(a)** Ecrivez une fonction `divise` qui prend comme paramètre deux entiers strictement positifs `d` et `N`, et retourne `True` si `d` divise `N`, et `False` sinon.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e16995d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2c2798b3",
   "metadata": {},
   "source": [
    "**(b)** Ecrivez une fonction `premier` qui prend comme paramètre un entier strictement positif `N` et retourne `True` s'il est premier, et `False` sinon. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4bede54",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7d7e8edf",
   "metadata": {},
   "source": [
    "**(c)** Ecrivez une fonction `affiche_premiers` qui prend comme paramètre un entier strictement positif `m` et affiche les `m` premiers nombres premiers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90dfee5a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "56e19cae",
   "metadata": {},
   "source": [
    "## Exercice 6 : lucky strike\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6be18ca9",
   "metadata": {},
   "source": [
    "**(a)** Ecrivez une fonction `lucky_strike` qui\n",
    "- prend en entrée un entier positif `cible`\n",
    "- génère des entiers aléatoires entre `0` et `2 * cible` jusqu'à tomber sur `cible`\n",
    "- retourne le nombre de coups que ça lui a pris pour tomber sur `cible`.\n",
    "\n",
    "De plus, si elle tombe sur `cible` du premier coup, elle doit afficher `That's a LUCKY STRIKE!`\n",
    "\n",
    "Par exemple, l'appel `lucky_strike(10)` pourrait afficher \n",
    "\n",
    "`J'ai trouvé 10 en 8 coup(s)!`\n",
    "\n",
    "ou peut-être\n",
    "\n",
    "`J'ai trouvé 10 en 25 coup(s)!` \n",
    "\n",
    "ou, si on a de la chance,\n",
    "\n",
    "`That's a LUCKY STRIKE!`\n",
    "\n",
    "`J'ai trouvé 10 en 1 coup(s)!`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d852d92",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2ac2d705",
   "metadata": {},
   "source": [
    "## Exercice 7 : fonction troll\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a88175e",
   "metadata": {},
   "source": [
    "Ecrivez une fonction `troll` qui prend en entrée un nombre variable d'arguments, et qui, quand on lui passe `n` arguments, affiche:\n",
    "\n",
    "`Erreur: troll() a reçu n arguments mais elle est définie avec n+1 paramètres !`\n",
    "\n",
    "et liste les arguments reçus.\n",
    "\n",
    "Par exemple, l'appel `troll(\"a\", \"b\", \"c\")` doit produire l'affichage:\n",
    "\n",
    "`Erreur: troll() a reçu 3 arguments mais elle est définie avec 4 paramètres ! Arguments reçus: `\n",
    "\n",
    "`a b c`\n",
    "\n",
    "et l'appel `troll(10, 20, 30, 40)` doit produire l'affichage:\n",
    "\n",
    "`Erreur: troll() a reçu 4 arguments mais elle est définie avec 5 paramètres ! Arguments reçus: `\n",
    "\n",
    "`10 20 30 40`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75dd4709",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e823f50b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}