Ch8_Notebook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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"
    },
    "colab": {
      "name": "Ch8-Notebook.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/othoni-hub/ECG1/blob/main/Ch8_Notebook.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pUUIRRJjAg-Y"
      },
      "source": [
        "# **CPGE-ECG1** \n",
        "<img src=\"https://drive.google.com/uc?id=12Wo3LubGGT4qOvYFAuLP4CyCuwjKNVuk\" width=\"230\" height=\"150\" align = \"right\"/>\n",
        "\n",
        "## Notebook du Chapitre 8 : COMBINATOIRE\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "**O.Thöni - Lycée Saint-Charles Sainte Croix - LE MANS**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X11pVUmNAg-f"
      },
      "source": [
        "### 1. Calcul des combinaisons, triangle de Pascal\n",
        "\n",
        "\n",
        "**_1.1. Factorielle_**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K4E1RpY1Ag-5"
      },
      "source": [
        "def factorielle(n):\n",
        "    ''' cette fonction reçoit un entier n et retourne factorielle de n'''\n",
        "    f = 1\n",
        "    for k in range(1,n+1):\n",
        "        f = f * k\n",
        "    return f"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V6AxmjR0Ag_D",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "33d63334-4cd9-4183-b2d7-f531bc8b5a47"
      },
      "source": [
        "factorielle(6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "720"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f3Ms8dhFhQ69",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37b0afaf-a733-4384-a1da-3a4dcceb6f23"
      },
      "source": [
        "factorielle(5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "120"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eqrIVTy7Ag_O"
      },
      "source": [
        "On peut aussi utiliser une fonction récursive, c'est-à-dire une fonction qui s'appelle elle-même. Cela permet de s'approcher au plus près de la notion de suite récurrente...\n",
        "\n",
        "**<span style=\"color: #26B260\">Python : fonction récursive</span>**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tR5zDcW1Ag_R"
      },
      "source": [
        "def factorielle_rec(n):\n",
        "    ''' cette fonction reçoit un entier n et retourne factorielle de n'''\n",
        "    f = 1\n",
        "    if n == 0:\n",
        "        return f\n",
        "    else :\n",
        "        return n * factorielle_rec(n-1)\n",
        "        "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KPNu-0o5Ag_d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a2f98d78-bc61-45f5-d3cb-739b90101068"
      },
      "source": [
        "factorielle_rec(5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "120"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5GZiqwa1Ag_m"
      },
      "source": [
        "**_Utilisation de Python Tutor_**\n",
        "\n",
        "**<span style=\"color: #26B260\">Complément Python : mode pas à pas</span>**\n",
        "\n",
        "Python tutor est une fonction du module \"metakernell\" qui permet d'exécuter un bout de script en mode pas à pas.\n",
        "\n",
        "Ici, cela peut être intéressant d'observer le déroulé de la fonction *factorielle* ainsi que de la fonction *factorielle_rec*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ELHLMkxwAg_q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73a3b938-3dd4-4635-a173-3d4f4cd94ad7"
      },
      "source": [
        "!pip install metakernel\n",
        "\n",
        "from metakernel import register_ipython_magics\n",
        "register_ipython_magics()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting metakernel\n",
            "  Downloading metakernel-0.27.5-py2.py3-none-any.whl (208 kB)\n",
            "\u001b[?25l\r\u001b[K     |█▋                              | 10 kB 20.3 MB/s eta 0:00:01\r\u001b[K     |███▏                            | 20 kB 25.2 MB/s eta 0:00:01\r\u001b[K     |████▊                           | 30 kB 12.3 MB/s eta 0:00:01\r\u001b[K     |██████▎                         | 40 kB 9.4 MB/s eta 0:00:01\r\u001b[K     |███████▉                        | 51 kB 4.9 MB/s eta 0:00:01\r\u001b[K     |█████████▍                      | 61 kB 5.3 MB/s eta 0:00:01\r\u001b[K     |███████████                     | 71 kB 5.8 MB/s eta 0:00:01\r\u001b[K     |████████████▌                   | 81 kB 6.1 MB/s eta 0:00:01\r\u001b[K     |██████████████▏                 | 92 kB 6.2 MB/s eta 0:00:01\r\u001b[K     |███████████████▊                | 102 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |█████████████████▎              | 112 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |██████████████████▉             | 122 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |████████████████████▍           | 133 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |██████████████████████          | 143 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |███████████████████████▌        | 153 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |█████████████████████████       | 163 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |██████████████████████████▊     | 174 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |████████████████████████████▎   | 184 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |█████████████████████████████▉  | 194 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |███████████████████████████████▍| 204 kB 5.1 MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 208 kB 5.1 MB/s \n",
            "\u001b[?25hRequirement already satisfied: pexpect>=4.2 in /usr/local/lib/python3.7/dist-packages (from metakernel) (4.8.0)\n",
            "Requirement already satisfied: ipykernel in /usr/local/lib/python3.7/dist-packages (from metakernel) (4.10.1)\n",
            "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.7/dist-packages (from pexpect>=4.2->metakernel) (0.7.0)\n",
            "Requirement already satisfied: jupyter-client in /usr/local/lib/python3.7/dist-packages (from ipykernel->metakernel) (5.3.5)\n",
            "Requirement already satisfied: tornado>=4.0 in /usr/local/lib/python3.7/dist-packages (from ipykernel->metakernel) (5.1.1)\n",
            "Requirement already satisfied: traitlets>=4.1.0 in /usr/local/lib/python3.7/dist-packages (from ipykernel->metakernel) (5.0.5)\n",
            "Requirement already satisfied: ipython>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from ipykernel->metakernel) (5.5.0)\n",
            "Requirement already satisfied: decorator in /usr/local/lib/python3.7/dist-packages (from ipython>=4.0.0->ipykernel->metakernel) (4.4.2)\n",
            "Requirement already satisfied: simplegeneric>0.8 in /usr/local/lib/python3.7/dist-packages (from ipython>=4.0.0->ipykernel->metakernel) (0.8.1)\n",
            "Requirement already satisfied: prompt-toolkit<2.0.0,>=1.0.4 in /usr/local/lib/python3.7/dist-packages (from ipython>=4.0.0->ipykernel->metakernel) (1.0.18)\n",
            "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.7/dist-packages (from ipython>=4.0.0->ipykernel->metakernel) (57.2.0)\n",
            "Requirement already satisfied: pickleshare in /usr/local/lib/python3.7/dist-packages (from ipython>=4.0.0->ipykernel->metakernel) (0.7.5)\n",
            "Requirement already satisfied: pygments in /usr/local/lib/python3.7/dist-packages (from ipython>=4.0.0->ipykernel->metakernel) (2.6.1)\n",
            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from prompt-toolkit<2.0.0,>=1.0.4->ipython>=4.0.0->ipykernel->metakernel) (0.2.5)\n",
            "Requirement already satisfied: six>=1.9.0 in /usr/local/lib/python3.7/dist-packages (from prompt-toolkit<2.0.0,>=1.0.4->ipython>=4.0.0->ipykernel->metakernel) (1.15.0)\n",
            "Requirement already satisfied: ipython-genutils in /usr/local/lib/python3.7/dist-packages (from traitlets>=4.1.0->ipykernel->metakernel) (0.2.0)\n",
            "Requirement already satisfied: pyzmq>=13 in /usr/local/lib/python3.7/dist-packages (from jupyter-client->ipykernel->metakernel) (22.1.0)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from jupyter-client->ipykernel->metakernel) (2.8.1)\n",
            "Requirement already satisfied: jupyter-core>=4.6.0 in /usr/local/lib/python3.7/dist-packages (from jupyter-client->ipykernel->metakernel) (4.7.1)\n",
            "Installing collected packages: metakernel\n",
            "Successfully installed metakernel-0.27.5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fGU81uXeAg_y",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 521
        },
        "outputId": "783c15aa-fb14-4230-a79b-dc2067b614ea"
      },
      "source": [
        "%%tutor\n",
        "\n",
        "def factorielle(n):\n",
        "    f = 1\n",
        "    for k in range(1,n+1):\n",
        "        f = f * k\n",
        "    return f\n",
        "\n",
        "factorielle(6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "        <iframe\n",
              "            width=\"100%\"\n",
              "            height=\"500\"\n",
              "            src=\"https://pythontutor.com/iframe-embed.html#code=%0Adef%20factorielle%28n%29%3A%0A%20%20%20%20f%20%3D%201%0A%20%20%20%20for%20k%20in%20range%281%2Cn%2B1%29%3A%0A%20%20%20%20%20%20%20%20f%20%3D%20f%20%2A%20k%0A%20%20%20%20return%20f%0A%0Afactorielle%286%29&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&py=3&rawInputLstJSON=%5B%5D&curInstr=0&codeDivWidth=350&codeDivHeight=400\"\n",
              "            frameborder=\"0\"\n",
              "            allowfullscreen\n",
              "        ></iframe>\n",
              "        "
            ],
            "text/plain": [
              "<IPython.lib.display.IFrame at 0x7f5164986490>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nl7q6sLMAg_8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 521
        },
        "outputId": "89f74deb-6215-4bbc-e314-564185c46ce1"
      },
      "source": [
        "%%tutor\n",
        "\n",
        "def factorielle_rec(n):\n",
        "    f = 1\n",
        "    if n == 1:\n",
        "        return f\n",
        "    else :\n",
        "        return n * factorielle_rec(n-1)\n",
        "\n",
        "factorielle_rec(6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "        <iframe\n",
              "            width=\"100%\"\n",
              "            height=\"500\"\n",
              "            src=\"https://pythontutor.com/iframe-embed.html#code=%0Adef%20factorielle_rec%28n%29%3A%0A%20%20%20%20f%20%3D%201%0A%20%20%20%20if%20n%20%3D%3D%201%3A%0A%20%20%20%20%20%20%20%20return%20f%0A%20%20%20%20else%20%3A%0A%20%20%20%20%20%20%20%20return%20n%20%2A%20factorielle_rec%28n-1%29%0A%0Afactorielle_rec%286%29&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&py=3&rawInputLstJSON=%5B%5D&curInstr=0&codeDivWidth=350&codeDivHeight=400\"\n",
              "            frameborder=\"0\"\n",
              "            allowfullscreen\n",
              "        ></iframe>\n",
              "        "
            ],
            "text/plain": [
              "<IPython.lib.display.IFrame at 0x7f5164986950>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_5ec97kAAhAL"
      },
      "source": [
        "**_1.2. Combinaisons_**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lG1KOL7wAhAN"
      },
      "source": [
        "def combinaison_def(k,n):\n",
        "    return int(factorielle(n)/(factorielle(k) * factorielle(n-k)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1Eu3Ak4UAhAU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa94fa39-e7b5-464b-b8b4-1d92272c9ef2"
      },
      "source": [
        "combinaison_def(3,6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "20"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u9OygnnKAhAd"
      },
      "source": [
        "Cette première méthode, directement issue de la définition, fait trop de calculs.\n",
        "\n",
        "Simplifions un peu tout ça..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WOBfIxZfAhAr"
      },
      "source": [
        "def combinaison(k,n):\n",
        "    c = 1\n",
        "    for m in range(n,n-k,-1):\n",
        "        c = c * m\n",
        "    c = int(c / factorielle(k))\n",
        "    return c"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5u-qkAr2AhAz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "04eb6915-94ce-405f-ebf6-86389b3c3daa"
      },
      "source": [
        "combinaison(3,6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "20"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jsyRRyMvAhA9"
      },
      "source": [
        "**_1.3. Triangle de Pascal_**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4R3vohM1AhBA"
      },
      "source": [
        "def triangle_Pascal1(num_ligne) :\n",
        "    tp = [] # ligne n°0\n",
        "\n",
        "    for n in range (num_ligne + 1):\n",
        "        ligne_n = [combinaison(k,n) for k in range (n+1)] \n",
        "        tp.append(ligne_n)\n",
        "        #print(ligne_n)\n",
        "    return(tp)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dfTDAB_-AhBH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "018cec90-171b-4322-bf65-ff626850b86d"
      },
      "source": [
        "triangle_Pascal1(6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1],\n",
              " [1, 1],\n",
              " [1, 2, 1],\n",
              " [1, 3, 3, 1],\n",
              " [1, 4, 6, 4, 1],\n",
              " [1, 5, 10, 10, 5, 1],\n",
              " [1, 6, 15, 20, 15, 6, 1]]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MGV7xtoPAhBP"
      },
      "source": [
        "Ce procédé est correct, mais calcule les combinaisons à chaque étape.\n",
        "\n",
        "La formule de Pascal donne un procédé plus rapide : \n",
        "\n",
        "![Formule de Pascal](https://wikimedia.org/api/rest_v1/media/math/render/svg/203b128a098e18cbb8cf36d004bd7282b28461bf)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AQGH2c2XAhBR"
      },
      "source": [
        "def triangle_Pascal(num_ligne) :\n",
        "    tp = [[1]]\n",
        "    for n in range(1,num_ligne + 1 ):\n",
        "        l = tp[n-1][:]+[0]\n",
        "        ligne_n = [1]\n",
        "        for k in range(1,n+1):\n",
        "            ligne_n = ligne_n +[l[k-1] + l[k]]\n",
        "        tp = tp + [ligne_n]\n",
        "    return(tp)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IKftWDepAhBX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f349d368-39dc-4588-93ca-80c6ac259491"
      },
      "source": [
        "triangle_Pascal(6)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1],\n",
              " [1, 1],\n",
              " [1, 2, 1],\n",
              " [1, 3, 3, 1],\n",
              " [1, 4, 6, 4, 1],\n",
              " [1, 5, 10, 10, 5, 1],\n",
              " [1, 6, 15, 20, 15, 6, 1]]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CnBbsy4GAhBe"
      },
      "source": [
        "### 2. Permutations d'une liste et parties d'un ensemble\n",
        "\n",
        "**<span style=\"color: #D17460\">TSpé </span>**\n",
        "\n",
        "**_2.1. Transposition dans une liste_**\n",
        "\n",
        "Une transposition consiste à échanger deux éléments"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t-c-d8GKAhBg"
      },
      "source": [
        "def transpose(liste,i,j) : # numérotation démarre à 0\n",
        "    liste[i], liste[j] = liste[j], liste[i]\n",
        "    return liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N55epjbzAhBu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3167119f-cdc8-45d7-d593-a306a6fb2384"
      },
      "source": [
        "l = [k+1 for k in range(6)]\n",
        "print(l)\n",
        "transpose(l,2,4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 6]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 5, 4, 3, 6]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "brOgDMYRAhB1"
      },
      "source": [
        "**<span style=\"color: #26B260\">Python : fonction *randint* du module *random*</span>**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7GrqMF8oAhB4"
      },
      "source": [
        "def permutation_aleatoire(liste):\n",
        "    from random import randint\n",
        "    N = len(liste)**2\n",
        "    k = 1\n",
        "    \n",
        "    while k < N:\n",
        "        n1 = randint(0,len(liste)-1)\n",
        "        n2 = randint(0,len(liste)-1)\n",
        "        if n1 != n2:\n",
        "            k = k+1\n",
        "            transpose(liste,n1,n2)\n",
        "            #print(liste)\n",
        "    return(liste)\n",
        "    \n",
        "        "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pr6jPC7EAhB-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2cd14597-cf05-4c4a-e699-38a7a983cfba"
      },
      "source": [
        "permutation_aleatoire(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[4, 3, 5, 1, 6, 2]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5f7o92fqAhCE"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O3KnPd77AhCK"
      },
      "source": [
        "### 3. Couples ou paires (parties à 2 éléments), triplets ou parties à 3 éléments d'un ensemble à N éléments \n",
        "\n",
        "**<span style=\"color: #26B260\">Python : *set* (ensemble)</span>**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j9JQ6ehUAhCN"
      },
      "source": [
        "def couples(E):\n",
        "    C2 = {(a,b) for a in E for b in E if a!=b} # (1,2) != (2,1)\n",
        "    return C2\n",
        "\n",
        "def paires(E):\n",
        "    P2 = {(a,b) for a in E for b in E if a<b} # (1,2) = (2,1)\n",
        "    return P2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6tG-QLASaxFL"
      },
      "source": [
        "**remarque :** En Python, un ensemble ne peut pas contenir ni d'autres ensembles, ni des listes, c'est bien dommage ici. Les couples et les paires sont donc représentés par des \"tuples\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0vdoKR1CAhCU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "53e590da-bab7-4b8d-ae89-1566c1f35f63"
      },
      "source": [
        "N = 4\n",
        "E = set(range(N))\n",
        "print('E = ',E)\n",
        "print('E permet de générer', int(factorielle(N)/factorielle(N-2)),'couples :')\n",
        "print(couples(E))\n",
        "print()\n",
        "\n",
        "print('E permet de générer', combinaison(2,N),'paires :')\n",
        "print(paires(E))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "E =  {0, 1, 2, 3}\n",
            "E permet de générer 12 couples :\n",
            "{(0, 1), (1, 2), (3, 2), (1, 3), (3, 0), (3, 1), (2, 1), (2, 0), (2, 3), (1, 0), (0, 2), (0, 3)}\n",
            "\n",
            "E permet de générer 6 paires :\n",
            "{(0, 1), (1, 2), (1, 3), (2, 3), (0, 3), (0, 2)}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mk1qivqKZaBM",
        "outputId": "bec0e938-f3d0-4108-b3f0-6550275a1dc3"
      },
      "source": [
        "{0,1} in paires(E)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1VP-0It1AhCa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d870ef85-1aa2-40c2-8649-ddaecc324def"
      },
      "source": [
        "print('E = ',E)\n",
        "print('E permet de générer', int(factorielle(N)/factorielle(N-3)),'triplets :')\n",
        "\n",
        "print({(a,b,c) for a in E for b in E for c in E if a!=b!=c!=a} )\n",
        "# tests de comparaisons enchaînés... fonctionnalité de Python bien pratique\n",
        "\n",
        "print()\n",
        "\n",
        "print('E permet de générer', combinaison(3,N),'parties à 3 éléments :')\n",
        "print({(a,b,c) for a in E for b in E for c in E if a<b<c}) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "E =  {0, 1, 2, 3}\n",
            "E permet de générer 24 triplets :\n",
            "{(3, 0, 2), (1, 0, 3), (1, 3, 2), (0, 1, 2), (0, 1, 3), (1, 3, 0), (2, 3, 0), (0, 2, 1), (2, 3, 1), (0, 2, 3), (2, 0, 1), (0, 3, 2), (1, 2, 0), (3, 1, 2), (3, 2, 0), (2, 0, 3), (3, 2, 1), (3, 1, 0), (0, 3, 1), (1, 2, 3), (2, 1, 3), (2, 1, 0), (3, 0, 1), (1, 0, 2)}\n",
            "\n",
            "E permet de générer 4 parties à 3 éléments :\n",
            "{(0, 1, 2), (0, 2, 3), (1, 2, 3), (0, 1, 3)}\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}