{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5890192e",
   "metadata": {},
   "source": [
    "# ICS - Série 4\n",
    "\n",
    "01.10.25\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb279251",
   "metadata": {},
   "source": [
    "## Exercice 1 : qu'affiche ce code\n",
    "\n",
    "Qu'affichent les codes ci-dessous? N'hésitez pas à changer les valeurs et tester différents paramètres ! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d43343f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [3, 1, 6, -5]\n",
    "print(\"le max de L est\", max(L), \"et le min est\", min(L))\n",
    "L.sort()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d576674",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [\"voiture\", \"train\", \"vélo\", \"avion\", \"bateau\"]\n",
    "print(\"le max de L est\", max(L), \"et le min est\", min(L))\n",
    "L.sort()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a8ca6bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1, 3, 4, 2]\n",
    "L.reverse()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d63048e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [10, 20, 30, 20, 10]\n",
    "print(\"La liste\", L, \"contient\", L.count(10), \"fois l'élément 10\")\n",
    "print(\"La liste\", L, \"contient\", L.count(40), \"fois l'élément 40\")\n",
    "print(\"La première occurrence de l'élément 20 dans\", L, \"est à l'index\", L.index(20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1ec9a8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [\"a\", \"b\", \"d\"]\n",
    "print(\"a\" in L)\n",
    "print(\"c\" in L)\n",
    "\n",
    "s = \"hello\"\n",
    "\n",
    "if \"e\" in s:\n",
    "    print(s, \"contient la lettre e\")\n",
    "else:\n",
    "    print(s, \"ne contient pas la lettre e\")\n",
    "\n",
    "if \"a\" in s:\n",
    "    print(s, \"contient la lettre a\")\n",
    "else:\n",
    "    print(s, \"ne contient pas la lettre a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97f33758",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [1, 3, 5, 7]\n",
    "for x in L:\n",
    "    print(x)\n",
    "    \n",
    "print()\n",
    "\n",
    "for x in range(8):\n",
    "    if x not in L:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe6c24aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Salut tout le monde!\"\n",
    "\n",
    "for char in s:\n",
    "    if char == \" \":\n",
    "        print()\n",
    "    else:\n",
    "        print(char, end = \"\")\n",
    "        \n",
    "print(\"\\n***************\")\n",
    "\n",
    "for char in s:\n",
    "    if char == \" \":\n",
    "        break\n",
    "    else:\n",
    "        print(char, end = \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cb214d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "\n",
    "print(\"La matrice:\")\n",
    "for i in range(3):\n",
    "    print(L[i])\n",
    "    \n",
    "print(\"*************\")\n",
    "print(\"La matrice:\")\n",
    "for ligne in L:\n",
    "    print(ligne)\n",
    "    \n",
    "print(\"*************\")\n",
    "print(\"Une ligne:\")\n",
    "\n",
    "for i in range(3):\n",
    "    print(L[1][i], end = \" \")\n",
    "\n",
    "    \n",
    "print(\"\\n*************\")\n",
    "print(\"Une colonne:\")\n",
    "\n",
    "for i in range(3):\n",
    "    print(L[i][1])\n",
    "    \n",
    "    \n",
    "print(\"\\n*************\")\n",
    "print(\"Une diagonale:\")\n",
    "\n",
    "for i in range(3):\n",
    "    print(\"  \"*i, L[i][i])\n",
    "    \n",
    "print(\"\\n*************\")\n",
    "print(\"L'autre diagonale:\")\n",
    "\n",
    "## A VOUS DE L'ECRIRE >:)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3deadffb",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(2, 10, 3)) + list(\"haha\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "193ea3cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = tuple(\"abc\")\n",
    "s = str(t)\n",
    "print(s, len(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93af5ad4",
   "metadata": {},
   "source": [
    "# Exercice 2\n",
    "\n",
    "Effectuez cette suite d'opérations sur la liste `L = [1, 2, 3, 4]`:\n",
    "\n",
    "- ajoutez l'élément `5` à la fin\n",
    "- enlevez l'élément de valeur `2`\n",
    "- insérez l'élément `-1` à l'indice `3`\n",
    "- affectez la valeur `2` à l'élément d'indice `1`\n",
    "- enlevez le dernier élément de la liste\n",
    "- insérez l'élément `3` à l'indice `2`\n",
    "- enlevez l'élément d'indice `4`\n",
    "\n",
    "Affichez la liste après chaque opération."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac523dc6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f0ecec88",
   "metadata": {},
   "source": [
    "# Exercice 3\n",
    "\n",
    "\n",
    "Ecrivez une fonction qui prend en entrée un entier `n` positif et qui retourne la liste contenant les nombres `1, 2, ... n`:\n",
    "\n",
    "**(a)** En utilisant `list()`\n",
    "\n",
    "**(b)** En utilisant une boucle \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d37d613",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc1358bc",
   "metadata": {},
   "source": [
    "# Exercice 4 : simuler les opérations sur les listes\n",
    "\n",
    "\n",
    "**(a)** Sans utiliser la fonction `max()`, écrire une fonction qui prend une liste de nombres en entrée et retourne la plus grande valeur de la liste. Si la liste est vide, elle doit retourner `None`. \n",
    "\n",
    "**(b)** Sans utiliser la fonction `count()`, écrire une fonction qui prend une liste `L` de nombres et une valeur `x` en entrée et retourne le nombre d'occurrences de `x` dans `L`.\n",
    "\n",
    "**(c)** Sans utiliser la fonction `index()`, écrire une fonction qui prend une liste `L` de nombres et une valeur `x` en entrée et retourne l'index de la première occurrence de `x` dans `L` si `L` contient la valeur `x`, et `None` sinon.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1e5be93",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7f2f9e51",
   "metadata": {},
   "source": [
    "# Exercice 5\n",
    "\n",
    "**(a)** Ecrivez une fonction qui prend en entrée une liste `L` de nombres et retourne la somme des éléments de `L` (sans utiliser `sum()`). Votre fonction doit retourner `0` si `L` est vide.\n",
    "\n",
    "**(b)** Ecrivez une fonction qui prend en entrée une liste `L` de nombres et retourne une liste `L1` contenant uniquement les éléments pairs de `L`.\n",
    "\n",
    "**(c)** Ecrivez une fonction `list_intersection` qui prend en entrée deux listes `L1` et `L2` et retourne une liste `L` contenant l'intersection de `L1` et `L2`, c'est-à-dire les éléments présents dans les deux listes. Par exemple, l'appel `list_intersection([1, 3, 5], [2, 3])` doit retourner la liste `[3]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5a5241a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cd63bc7e",
   "metadata": {},
   "source": [
    "# Exercice 6 : addition de matrices\n",
    "\n",
    "On rappelle la formule d'addition de matrices de dimensions $2 \\times 2$:\n",
    "\n",
    "$\\begin{pmatrix}\n",
    "a_1 & b_1\\\\\n",
    "c_1 & d_1\n",
    "\\end{pmatrix} + \n",
    "\\begin{pmatrix}\n",
    "a_2 & b_2\\\\\n",
    "c_2 & d_2\n",
    "\\end{pmatrix} =\n",
    "\\begin{pmatrix}\n",
    "a_1+a_2 & b_1+b_2\\\\\n",
    "c_1+c_2 & d_1+d_2\n",
    "\\end{pmatrix}$\n",
    "\n",
    "En général, la somme de deux matrices $A$ et $B$ de dimensions  $m \\times n$ sera une matrice de dimensions $m \\times n$ où l'élément de coordonnées $(i, j)$ (c'est-à-dire l'élément à la ligne $i$ et colonne $j$) est la somme des éléments de coordonnées $(i, j)$ dans chacune des deux matrices $A$ et $B$. Par exemple\n",
    "\n",
    "$\\begin{pmatrix}\n",
    "1 & 2 & 3\\\\\n",
    "4 & 5 & 6\\\\\n",
    "\\end{pmatrix} + \n",
    "\\begin{pmatrix}\n",
    "10 & 20 & 30\\\\\n",
    "40 & 50 & 60\\\\\n",
    "\\end{pmatrix} =\n",
    "\\begin{pmatrix}\n",
    "11 & 22 & 33\\\\\n",
    "44 & 55 & 66\\\\\n",
    "\\end{pmatrix}.$\n",
    "\n",
    "**(a)** Ecrivez une fonction `somme_mat_2x2` qui prend en entrée deux listes de listes représentant des matrices $2 \\times 2$, comme vu au cours, et qui retourne une liste de listes représentant la somme des deux matrices données.\n",
    "\n",
    "Par exemple, l'appel `somme_mat_2x2([[1, 2],[3, 4]], [[5, 6],[7, 8]])` doit retourner la liste `[[6, 8],[10, 12]]`.\n",
    "\n",
    "**(b)** Ecrivez une fonction `somme_mat` qui prend en entrées deux listes de listes représentant deux matrices de même taille, et qui retourne une liste de listes représentant la somme des deux matrices données.\n",
    "Remarquez qu'à la différence de la partie (a) (où vous avez pu construire la matrice somme \"à la main\"), il vous faudra maintenant itérer sur les listes données. Commencez par trouver les dimensions des matrices..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53f9fb40",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c21dc799",
   "metadata": {},
   "source": [
    "# Exercice 7 : encore des opérations sur les listes\n",
    "\n",
    "Dans cet exercice, vous allez simuler encore des opérations sur les listes. Les seules opérations \"de base\" sur les listes que vous avez le droit d'invoquer sont les suivantes:\n",
    "\n",
    "- Vous pouvez appeler la fonction `len`\n",
    "- Pour tout index `i` valide, vous pouvez accéder à un élément de la liste en lecture ou en écriture\n",
    "- Vous pouvez ajouter un élément à la fin de la liste avec `L.append(x)`\n",
    "- Vous pouvez enlever un élément de la fin de la liste et le retourner avec `L.pop()`.\n",
    "\n",
    "**(a)** Ecrivez une fonction `my_pop` qui simule `L.pop(i)` : \n",
    "- elle prend une liste `L` et un index `i` (entre `0` et `len(L)-1`) en entrée \n",
    "- elle enlève l'élément qui se trouve à l'index `i` de `L` \n",
    "- elle retourne cet élément.\n",
    "\n",
    "Votre fonction doit modifier la liste `L` elle-même et pas créer une nouvelle liste.\n",
    "Les instructions\n",
    "\n",
    "`L = [1, 2, 3, 4, 5]`\n",
    "\n",
    "`x = my_pop(L, 2)`\n",
    "\n",
    "`print(x, L, len(L))`\n",
    "\n",
    "doivent afficher:\n",
    "\n",
    "`3  [1, 2, 4, 5]  4`\n",
    "\n",
    "et un `print(id(L))` avant et après l'appel de `my_pop` doit retourner la même valeur.\n",
    "\n",
    "\n",
    "**(b)** Ecrivez une fonction `my_remove` qui simule (à peu près) `L.remove(x)` : \n",
    "- elle prend une liste `L` et une valeur `x` en entrée \n",
    "- si `L` contient un élément de valeur `x`, `my_remove` enlève la première occurrence de `x` dans `L`\n",
    "- sinon elle ne fait rien.\n",
    "\n",
    "Votre fonction doit modifier la liste `L` elle-même, pas créer une nouvelle liste. Elle ne doit rien retourner.\n",
    "\n",
    "**(c)** Ecrivez une fonction `my_insert` qui simule (à peu près) `L.insert(i, x)` : \n",
    "- elle prend une liste `L`, un index `i` (entre `0` et `len(L)-1`) et une valeur `x` en entrée \n",
    "- elle insère un élément de valeur `x` à l'index `i` de `L` et décale tous les éléments après `i` vers la droite.\n",
    "\n",
    "Votre fonction doit modifier la liste `L` elle-même, pas créer une nouvelle liste. Elle ne doit rien retourner.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1025205",
   "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
}