Envoie des TD/TP 1 à 3

Annexe-gdb/README.md

+Le programme tirage_loto.c contient des erreurs.
+L'exercice (décrit dans le support de cours) consiste à les trouver 
+    avec gdb.
+
+Attention à ne pas modifier les fichiers présents dans ce répertoire
+sous peine de créer des conflits. Si vous voulez les modifier, faites
+des copies et modifiez les copies
+

Annexe-gdb/tirage_loto.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <stdbool.h>
+#define SIZE_MAX 20
+struct ensemble
+{
+    int size;
+    int elt[SIZE_MAX];
+};
+
+void
+init_ensemble (struct ensemble *E)
+{
+    E->size = 0;
+}
+
+void
+print_ensemble (struct ensemble *E)
+{
+    int i;
+    putchar ('{');
+    if (E->size > 0)
+      {
+          printf ("%d", E->elt[0]);
+          for (i = 1; i < E->size; i++)
+              printf (", %d", E->elt[i]);
+      }
+    puts ("}\n");
+}
+
+bool
+appartient (int b, struct ensemble *E)
+{
+    bool found;
+    int i;
+    found = false;
+    for (i = 0; i < E->size && !found; i++)
+        found = E->elt[i] == b;
+    return found;
+}
+
+void
+erreur (void)
+{
+    fprintf (stderr, "une erreur s'est produite\n");
+    exit (1);
+}
+
+void
+tirage_loto (void)
+{
+    struct ensemble boules, tirage;
+    int i, n, k;
+    init_ensemble (&boules);
+    init_ensemble (&tirage);
+/*  chaque itration, la structure "boules" est cohrente */
+    for (i = 0; i < SIZE_MAX; i++)
+      {
+          boules.elt[boules.size] = i + 1;
+          boules.size += 1;
+      }
+/* n = le nombre de boules  tirer */
+    srand48 ((long) time (NULL));
+    n = (int) (drand48 () * (SIZE_MAX + 1));
+    for (i = 0; i < n; i++)
+      {
+          k = (int) (drand48 () * (boules.size + 1));   /* <- bug ! */
+          if (appartient (boules.elt[k], &tirage))
+              erreur ();
+          tirage.elt[tirage.size] = boules.elt[k];
+          tirage.size += 1;
+/* ici, la structure "tirage" est cohrente */
+          boules.elt[k] = boules.elt[boules.size - 1];
+          boules.size -= 1;
+/* ici, la structure "boules" est cohrente */
+          if (boules.size < 0 || tirage.size > SIZE_MAX)
+              erreur ();
+      }
+    print_ensemble (&tirage);
+}
+
+int
+main ()
+{
+    tirage_loto ();
+    return 0;
+}

TD-conception-logicielle/README.md

+Ce sous-répertoire contient des sujets de TD de conception logicielle.
+Ce sont souvent des problèmes extraits des sujets d'examen des années 
+    précédentes

TP-1-allocation-dynamique/README.md

+Trois CM, deux TD et deux TP de 2h
+
+CM 1
+    Pour fabriquer un nouveau type en C (une structure) :
+    - on crée un fichier entête : déclarations de type, 
+        prototypes des actions/fonctions exportées, spécifications
+    - on crée un fichier source : l'implantation des actions/fonctions
+    Compilation séparée, constructeur et destructeur
+
+CM 2
+    Allocation dynamique (malloc, free), valgrind, gdb
+    Le mécanisme de gestion des variables locales (pile d'excécution)
+    Le mécanisme des constructeurs et destructeurs permet d'organiser
+        le code de façon rationnelle. C'est un guide très utile en cas
+        d'allocation dynamique.
+
+CM 3
+    Les listes chaînées
+
+TD 1
+    Gestion de la mémoire élémentaire
+
+TD 2
+    Listes chaînées
+
+    Note : les étudiants et apprentis sont incités à implanter leur 
+        propre module de listes chaînées (CM3 et TD2) mais celles du poly
+        sont disponibles au cas où
+
+TP 1
+    Implantations d'un module de chaînes de caractères
+    Version 1 : un malloc et un free dans un fichier .c
+    Version 2 : plusieurs realloc et un free dans un fichier .c
+
+TP 2
+    Version 3 : avec création d'un module séparé (chaine.h et chaine.c)
+    Version 4 : modification de l'implantation en adaptant le module
+        de listes chaînées (de doubles) en un module de listes de 
+        caractères
+    Version 5 (optionnelle) : remplacement des char par des wchar_t
+
+Technologies : 
+    l'utilitaire valgrind (très, très conseillé)
+    le debugger gdb (très conseillé)
+    gcc -c -g 
+    l'utilitaire make (conseillé mais rarement fait)
+

TP-1-allocation-dynamique/originaux/Makefile

+CC=gcc
+CFLAGS=-g -Wall -Wmissing-prototypes
+LDFLAGS=-g
+objects := $(patsubst %.c,%.o,$(wildcard *.c))
+all: main
+clean:
+	-rm $(objects)
+	-rm main
+main: $(objects)
+# Recopier ci-dessous la sortie de gcc -MM *.c

TP-1-allocation-dynamique/originaux/README.md

+Ne modifiez pas les originaux. 
+Faites des copies dans le répertoire TP-1-allocation-dynamique et modifiez 
+    les copies.
+
+Ce répertoire contient 
+
+un squelette de compte-rendu du TP 
+----------------------------------
+Deux formats (au choix) :
+
+1. le format OpenDocument (Libreoffice, Word, ...) : compte-rendu-de-tp.odt
+2. le format LaTeX : compte-rendu-de-tp.tex
+    Voir compte-rendu-de-tp.pdf pour les détails
+
+un Makefile incomplet
+---------------------
+Note : vous n'êtes pas obligés d'utiliser un Makefile
+
+Pour le compléter, dans le répertoire courant, entrer la commande 
+
+    gcc -MM *.c
+
+Recopier les lignes obtenues en fin de Makefile
+Ensuite :
+
+    make
+    make clean
+
+

TP-1-allocation-dynamique/originaux/compte-rendu-de-TP.tex

+% xelatex compte-rendu-de-TP
+% modifier le document à partir de la ligne 90
+
+\documentclass[11pt]{article}
+\DeclareTextCommandDefault{\nobreakspace}{\leavevmode\nobreak\ }
+\usepackage{xunicode}
+\usepackage{fontspec}
+\usepackage{xltxtra}
+\usepackage{url}
+% \usepackage[francais]{babel}
+\usepackage{fullpage}
+\usepackage{fancyvrb}
+\usepackage{tikz}
+\usepackage{xcolor}
+\usepackage{listings}
+
+\definecolor{mygreen}{rgb}{0,0.6,0}
+\definecolor{mygray}{rgb}{0.5,0.5,0.5}
+\definecolor{mymauve}{rgb}{0.58,0,0.82}
+\definecolor{terminalbgcolor}{HTML}{330033}
+\definecolor{terminalrulecolor}{HTML}{000099}
+\newcommand{\lstconsolestyle}{
+\lstset{
+	backgroundcolor=\color{terminalbgcolor},
+	basicstyle=\color{white}\fontfamily{lmtt}\footnotesize\selectfont,
+	breakatwhitespace=false,  
+	breaklines=true,
+	captionpos=b,
+	commentstyle=\color{mygreen},
+	deletekeywords={...},
+	escapeinside={\%*}{*)},
+	extendedchars=true,
+	frame=single,
+	keepspaces=true,
+	keywordstyle=\color{blue},
+	%language=none,
+	morekeywords={*,...},
+	numbers=none,
+	numbersep=5pt,
+    framerule=2pt,
+	numberstyle=\color{mygray}\tiny\selectfont,
+	rulecolor=\color{terminalrulecolor},
+	showspaces=false,
+	showstringspaces=false,
+	showtabs=false,
+	stepnumber=2,
+	stringstyle=\color{mymauve},
+	tabsize=2
+}
+}
+
+\lstconsolestyle
+
+%% Environnements
+
+%% Ensembles mathématiques
+
+\newcommand{\A}{\mathbb{A}}
+\newcommand{\Q}{\mathbb{Q}}
+\newcommand{\Z}{\mathbb{Z}}
+\newcommand{\C}{\mathbb{C}}
+\newcommand{\N}{\mathbb{N}}
+\newcommand{\R}{\mathbb{R}}
+\renewcommand{\emptyset}{\varnothing}
+
+\makeatletter %
+\renewcommand{\verbatim@font}{ %
+    \ttfamily\footnotesize\catcode`\<=\active\catcode`\>=\active %
+}
+\makeatother
+
+\begin{document}
+\begin{center}
+\textbf{\bf IS3 --- SD --- Compte-rendu du TP 1}
+ 
+\end{center}
+\medskip
+\hrule
+ 
+\bigskip
+
+Nom :
+
+\bigskip
+
+Prénom :
+
+\bigskip
+
+Attention à ne pas modifier les originaux. Faites une copie des documents
+dans le répertoire \texttt{TP-1-allocation-dynamique} de votre copie de 
+travail et modifiez les copies.
+
+Pour remplir ce compte-rendu en utilisant le système \LaTeX,
+modifiez \texttt{compte-rendu-de-TP.tex} (à partir de la ligne~$81$) avec un
+éditeur de texte (\texttt{nano}, \texttt{gedit}, \dots) puis
+lancez la commande suivante dans un terminal pour fabriquer le PDF~:
+\begin{lstlisting}
+fboulier@gayant10:~$ xelatex compte-rendu-de-TP.tex
+This is XeTeX, Version 3.14159265-2.6-0.999992 (TeX Live 2020/Debian) (preloaded format=xelatex)
+[...]
+Output written on compte-rendu-de-TP.pdf (2 pages).
+Transcript written on compte-rendu-de-TP.log.
+fboulier@gayant10:~$ ls *.pdf
+compte-rendu-de-TP.pdf
+fboulier@gayant10:~$ evince compte-rendu-de-TP.pdf &
+\end{lstlisting}
+
+\section{Séance 1}
+
+\subsection{Question 1}
+
+\textit{Un programme qui lit des caractères et les imprime à l'écran est fourni. Le réécrire en mettant en œuvre un mécanisme d'allocation dynamique.}
+
+\bigskip
+
+Comment exécuter votre programme (nom du fichier à compiler)~? 
+L'avez-vous testé sous valgrind~? 
+Avez-vous testé le cas limite de la chaîne vide~?
+Difficulté ressentie de~$1$ (aucune difficulté) à~$10$ 
+(je n'ai pas su le faire, même avec de l'aide)~:
+
+\bigskip
+
+Vous pouvez répondre ici. 
+Le petit exemple ci-dessous vous montre comment faire des copies
+de commandes dans le terminal pour répondre simplement.
+\begin{lstlisting}
+boulier@ciney:~/is3-sd-2023/TP-1-allocation-dynamique$ ls
+README.md  td1.pdf  tp1.pdf
+\end{lstlisting}
+
+\subsection{Question 2}
+
+\textit{Réécrire le programme précédent en réalisant un module \texttt{chaine} 
+et en mettant en œuvre un mécanisme de compilation séparée.}
+
+\bigskip
+
+Mêmes questions (il est conseillé de placer les fichiers dans un sous-répertoire \texttt{Q2} du répertoire \texttt{TP-1-allocation-dynamique}).
+Difficulté ressentie de~$1$ (aucune difficulté) à~$10$ 
+(je n'ai pas su le faire, même avec de l'aide)~:
+
+\bigskip
+
+Vous pouvez répondre ici. 
+\begin{lstlisting}
+\end{lstlisting}
+
+\subsection{Question 3}
+
+\textit{Améliorer le module \texttt{chaine} en supprimant la limitation à~$64$ caractères grâce à \texttt{realloc}.}
+
+\bigskip
+
+Si vous l'avez faite, mêmes questions (sous-répertoire~\texttt{Q3}).
+Difficulté ressentie de~$1$ (aucune difficulté) à~$10$ 
+(je n'ai pas su le faire, même avec de l'aide)~:
+
+\bigskip
+
+Vous pouvez répondre ici. 
+\begin{lstlisting}
+\end{lstlisting}
+
+\section{Séance 2}
+
+\subsection{Questions 4, 5 et 6}
+
+\textit{Modifier l'implantation du module \texttt{chaine} en implantant les chaînes de caractères sous la forme de listes chaînées.}
+
+\bigskip
+
+Mêmes questions (sous-répertoire~\texttt{Q4}).
+Difficulté ressentie de~$1$ (aucune difficulté) à~$10$ 
+(je n'ai pas su le faire, même avec de l'aide)~:
+
+\bigskip
+
+Vous pouvez répondre ici. 
+\begin{lstlisting}
+\end{lstlisting}
+
+
+\end{document}
+
+

TP-2-complexite/README.md

+Un CM, un TD et un TP
+
+CM :
+    Complexité
+
+TD :
+    Préparation du TP
+
+TP :
+    Algorithme de Karatsuba
+
+Technologie : Python

TP-2-complexite/originaux/Karatsuba.c

+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <math.h>
+#include <assert.h>
+
+/*
+ * Représentation élémentaire d'un polynôme. 
+ * On pourrait, au minimum, rajouter le degré !
+ */
+
+struct poly
+{
+  double *T;                    /* le tableau des coefficients */
+  bool dynamic;                 /* indique si T a été alloué dynamiquement */
+  int n;                        /* la taille du tableau */
+};
+
+/*
+ * Constructeur. Le tableau T est alloué dynamiquement 
+ */
+void
+init_poly (struct poly *A, int n)
+{
+  A->T = (double *) malloc (n * sizeof (double));
+  assert (A->T != (double *) 0);
+  A->n = n;
+  A->dynamic = true;
+}
+
+/*
+ * Autre constructeur. Le tableau T est passé en paramètre.
+ * Il n'est donc pas alloué dynamiquement 
+ */
+void
+init2_poly (struct poly *A, double *T, int n)
+{
+  A->T = T;
+  A->n = n;
+  A->dynamic = false;
+}
+
+/*
+ * Destructeur.
+ */
+void
+clear_poly (struct poly *A)
+{
+  if (A->dynamic)
+    free (A->T);
+}
+
+/*
+ * L'impression d'un polynôme est plus technique qu'on ne le croit :-)
+ * On suppose que les doubles sont en fait des entiers
+ */
+void
+print_poly (struct poly *A)
+{
+  long c;
+  int i;
+  bool b;
+
+  b = false;
+  for (i = A->n - 1; i >= 0; i--)
+    {
+      if (A->T[i] != 0.0)
+        {
+          if (A->T[i] > 0)
+            {
+              if (b)
+                printf (" + ");
+            }
+          else
+            {
+              if (b)
+                printf (" - ");
+              else
+                printf ("-");
+            }
+          b = true;
+          if (A->T[i] > 0)
+            c = (long) A->T[i];
+          else
+            c = (long) -A->T[i];
+          if (i == 0)
+            printf ("%ld", c);
+          else if (i == 1)
+            {
+              if (c != 1)
+                printf ("%ld*x", c);
+              else
+                printf ("x");
+            }
+          else
+            {
+              if (c != 1)
+                printf ("%ld*x^%d", c, i);
+              else
+                printf ("x^%d", i);
+            }
+        }
+    }
+  printf ("\n");
+}
+
+/*
+ * R = A + B
+ */
+void
+add_poly (struct poly *R, struct poly *A, struct poly *B)
+{
+  int i;
+  i = 0;
+  while (i < A->n && i < B->n)
+    {
+      R->T[i] = A->T[i] + B->T[i];
+      i += 1;
+    }
+  while (i < A->n)
+    {
+      R->T[i] = A->T[i];
+      i += 1;
+    }
+  while (i < B->n)
+    {
+      R->T[i] = B->T[i];
+      i += 1;
+    }
+  while (i < R->n)
+    {
+      R->T[i] = 0.0;
+      i += 1;
+    }
+}
+
+/*
+ * R = A - B
+ */
+void
+sub_poly (struct poly *R, struct poly *A, struct poly *B)
+{
+  int i;
+  i = 0;
+  while (i < A->n && i < B->n)
+    {
+      R->T[i] = A->T[i] - B->T[i];
+      i += 1;
+    }
+  while (i < A->n)
+    {
+      R->T[i] = A->T[i];
+      i += 1;
+    }
+  while (i < B->n)
+    {
+      R->T[i] = -B->T[i];
+      i += 1;
+    }
+  while (i < R->n)
+    {
+      R->T[i] = 0.0;
+      i += 1;
+    }
+}
+
+/*
+ * R = A * B par la méthode élémentaire
+ */
+void
+mul_poly (struct poly *R, struct poly *A, struct poly *B)
+{
+  int a, b;
+  for (a = 0; a < R->n; a++)
+    R->T[a] = 0.0;
+  for (a = 0; a < A->n; a++)
+    {
+      for (b = 0; b < B->n; b++)
+        {
+          R->T[a + b] = R->T[a + b] + A->T[a] * B->T[b];
+        }
+    }
+}
+
+/*
+ * R = A * B par la méthode de Karatsuba
+ */
+void
+Karatsuba (struct poly *R, struct poly *A, struct poly *B)
+{
+  struct poly R0, R1, R2, A0, A1, B0, B1, tmpA, tmpB;
+  int i, p, q;
+/*
+ * L'algorithme élémentaire est utilisé pour les cas de base
+ */
+  if (A->n == 1 || B->n == 1)
+    {
+      mul_poly (R, A, B);
+    }
+  else
+    {
+      if (A->n < B->n)
+        p = A->n / 2;
+      else
+        p = B->n / 2;
+/*
+ * Découper les polynômes A et B en deux se fait en temps constant 
+ */
+      init2_poly (&A0, A->T, p);
+      init2_poly (&A1, A->T + p, A->n - p);
+      init2_poly (&B0, B->T, p);
+      init2_poly (&B1, B->T + p, B->n - p);
+/*
+ * Les polynômes R0 et R2 sont des sous-tableaux de R.
+ * On évite ainsi deux recopies de tableaux.
+ */
+      init2_poly (&R0, R->T, 2 * p - 1);
+      init2_poly (&R2, R->T + 2 * p, A->n + B->n - 1 - 2 * p);
+      Karatsuba (&R0, &A0, &B0);
+      Karatsuba (&R2, &A1, &B1);
+/*
+ * À ce stade, R = R0 + x^(2*p)*R2. On calcule maintenant R1.
+ */
+      if (A0.n > A1.n)
+        q = A0.n;
+      else
+        q = A1.n;
+      init_poly (&tmpA, q);
+      add_poly (&tmpA, &A0, &A1);
+      if (B0.n > B1.n)
+        q = B0.n;
+      else
+        q = B1.n;
+      init_poly (&tmpB, q);
+      add_poly (&tmpB, &B0, &B1);
+      q = tmpA.n + tmpB.n - 1;
+      if (q < R0.n)
+        q = R0.n;
+      if (q < R2.n)
+        q = R2.n;
+      init_poly (&R1, q);
+      Karatsuba (&R1, &tmpA, &tmpB);
+      sub_poly (&R1, &R1, &R0);
+      sub_poly (&R1, &R1, &R2);
+/*
+ * R = R + x^p*R1
+ */
+      R->T[2 * p - 1] = 0;
+      for (i = 0; i < R1.n; i++)
+        {
+          R->T[p + i] = R->T[p + i] + R1.T[i];
+        }
+
+      clear_poly (&A0);
+      clear_poly (&A1);
+      clear_poly (&B0);
+      clear_poly (&B1);
+      clear_poly (&R0);
+      clear_poly (&R1);
+      clear_poly (&R2);
+      clear_poly (&tmpA);
+      clear_poly (&tmpB);
+    }
+}
+
+int
+main ()
+{
+  struct poly A, B, R;
+  int i, n, N;
+
+  srand48 ((long) 421);
+
+  /* augmenter N à 600 dès que les codes fonctionnent */
+  N = 20;
+  init_poly (&A, N);
+  init_poly (&B, N);
+  init_poly (&R, 2 * N - 1);
+  for (i = 0; i < N; i++)
+    {
+      A.T[i] = floor (10.0 * drand48 () - 5.0);
+      B.T[i] = floor (10.0 * drand48 () - 5.0);
+    }
+  /* les seules modifications nécessaires sont à faire ci-dessous */
+  for (n = 1; n < N; n++)
+    {
+      A.n = n;
+      B.n = n;
+      mul_poly (&R, &A, &B);
+      print_poly (&R);
+      Karatsuba (&R, &A, &B);
+      print_poly (&R);
+    }
+  printf
+    ("\n\nMultiplication de polynômes aléatoires de taille croissante\n");
+  printf ("par la méthode élémentaire, puis par celle de Karatsuba.\n");
+  printf ("Lors du TP, vous pouvez supprimer ces affichages.\n\n");
+  return 0;
+}

TP-2-complexite/originaux/compte-rendu-de-TP.tex

+% xelatex compte-rendu-de-TP
+% modifier le document à partir de la ligne 90
+
+\documentclass[11pt]{article}
+\DeclareTextCommandDefault{\nobreakspace}{\leavevmode\nobreak\ }
+\usepackage{xunicode}
+\usepackage{fontspec}
+\usepackage{xltxtra}
+\usepackage{url}
+% \usepackage[francais]{babel}
+\usepackage{fullpage}
+\usepackage{fancyvrb}
+\usepackage{tikz}
+\usepackage{xcolor}
+\usepackage{listings}
+
+\definecolor{mygreen}{rgb}{0,0.6,0}
+\definecolor{mygray}{rgb}{0.5,0.5,0.5}
+\definecolor{mymauve}{rgb}{0.58,0,0.82}
+\definecolor{terminalbgcolor}{HTML}{330033}
+\definecolor{terminalrulecolor}{HTML}{000099}
+\newcommand{\lstconsolestyle}{
+\lstset{
+	backgroundcolor=\color{terminalbgcolor},
+	basicstyle=\color{white}\fontfamily{lmtt}\footnotesize\selectfont,
+	breakatwhitespace=false,  
+	breaklines=true,
+	captionpos=b,
+	commentstyle=\color{mygreen},
+	deletekeywords={...},
+	escapeinside={\%*}{*)},
+	extendedchars=true,
+	frame=single,
+	keepspaces=true,
+	keywordstyle=\color{blue},
+	%language=none,
+	morekeywords={*,...},
+	numbers=none,
+	numbersep=5pt,
+    framerule=2pt,
+	numberstyle=\color{mygray}\tiny\selectfont,
+	rulecolor=\color{terminalrulecolor},
+	showspaces=false,
+	showstringspaces=false,
+	showtabs=false,
+	stepnumber=2,
+	stringstyle=\color{mymauve},
+	tabsize=2
+}
+}
+
+\lstconsolestyle
+
+%% Environnements
+
+%% Ensembles mathématiques
+
+\newcommand{\A}{\mathbb{A}}
+\newcommand{\Q}{\mathbb{Q}}
+\newcommand{\Z}{\mathbb{Z}}
+\newcommand{\C}{\mathbb{C}}
+\newcommand{\N}{\mathbb{N}}
+\newcommand{\R}{\mathbb{R}}
+\renewcommand{\emptyset}{\varnothing}
+
+\makeatletter %
+\renewcommand{\verbatim@font}{ %
+    \ttfamily\footnotesize\catcode`\<=\active\catcode`\>=\active %
+}
+\makeatother
+
+\begin{document}
+\begin{center}
+\textbf{\bf IS3 --- SD --- Compte-rendu du TP 2}
+ 
+\end{center}
+\medskip
+\hrule
+ 
+\bigskip
+
+Nom :
+
+\bigskip
+
+Prénom :
+
+\bigskip
+
+Attention à ne pas modifier les originaux. Faites une copie des documents
+dans le répertoire \texttt{TP-2-complexite} de votre copie de 
+travail et modifiez les copies.
+
+\subsection*{Question 4}
+
+\textit{Quel est le meilleur algorithme (multiplication élémentaire versus algorithme de Karatsuba)~? À partir de quelle valeur de n est-il meilleur~?}
+
+\bigskip
+
+\subsection*{Question 6}
+
+\textit{Où se situe la courbe théorique du cas simplifié 
+$\mathop{f_{\mbox{\rm simplifie}}}(n)$ par rapport à la courbe mesurée $f(n)$~? 
+La fonction~$f(n)$ est-elle un $\Omega(n^{\log_2(3)})$, 
+un $O(n^{\log_2(3)})$, un $\Theta(n^{\log_2(3)})$~?}
+
+\bigskip
+
+\subsection*{Question 7}
+
+\textit{Fonction~$F(n)$ asymptotiquement équivalente à~$f(n)$. 
+Empiriquement~? Fonction $F(n) = f(2\,n)$~?}
+
+\bigskip
+
+\subsection*{Question 8}
+
+\textit{Fonction $a\,n^{\log_2(3)}$ obtenue par moindres carrés
+(quelle valeur pour~$a$)~?}
+
+\bigskip
+
+\subsection*{Question 9}
+
+\textit{À partir de quel seuil l'algorithme de type diviser-pour-régner devrait-il appeler l'algorithme naïf~?}
+
+\bigskip
+
+\end{document}
+
+

TP-2-complexite/originaux/graphique.py

+# Suppose que les fichiers 'Karatsuba.stats' et 'Elementaire.stats'
+# sont disponibles
+
+# Commande : python3 graphique.py
+
+import numpy as np
+import matplotlib.pyplot as plt
+K = np.loadtxt ('Karatsuba.stats')
+E = np.loadtxt ('Elementaire.stats')
+plt.plot (K[:,0], K[:,1], label='Karatsuba')
+plt.plot (E[:,0], E[:,1], label='Élémentaire')
+plt.legend ()
+plt.show ()