Source Latex
du cours de mathématiques
\documentclass[12pt]{article}
%\usepackage{french}
\usepackage{amsfonts}\usepackage{amssymb}
\usepackage[french]{babel}
\usepackage{amsmath}
\usepackage[utf8]{inputenc}
\usepackage{calc}
\usepackage{enumerate}
\usepackage{pst-all}
\usepackage{hyperref}
\hypersetup{
pdfauthor={Yoann Morel},
pdfsubject={Cours mathématiques: algorithmique},
pdftitle={Algorithmique},
pdfkeywords={algorithmique, programmation,
algorithme, programme, calculatrices, TI, Casio, python}
}
\hypersetup{
colorlinks = true,
linkcolor = red,
anchorcolor = red,
citecolor = blue,
filecolor = red,
pagecolor = red,
urlcolor = red
}
\voffset=-1.cm
% Raccourcis diverses:
\newcommand{\nwc}{\newcommand}
\nwc{\dsp}{\displaystyle}
\nwc{\ct}{\centerline}
\nwc{\bge}{\begin{equation}}\nwc{\ene}{\end{equation}}
\nwc{\bgar}{\begin{array}}\nwc{\enar}{\end{array}}
\nwc{\bgit}{\begin{itemize}}\nwc{\enit}{\end{itemize}}
\nwc{\bgen}{\begin{enumerate}}\nwc{\enen}{\end{enumerate}}
\nwc{\la}{\left\{}\nwc{\ra}{\right\}}
\nwc{\lp}{\left(}\nwc{\rp}{\right)}
\nwc{\lb}{\left[}\nwc{\rb}{\right]}
\nwc{\bgsk}{\bigskip}
\nwc{\vsp}{\vspace{0.1cm}}
\nwc{\vspd}{\vspace{0.2cm}}
\nwc{\vspt}{\vspace{0.3cm}}
\nwc{\vspq}{\vspace{0.4cm}}
\def\N{{\rm I\kern-.1567em N}}
\def\R{{\rm I\kern-.1567em R}}
\nwc{\tm}{\times}
\nwc{\V}[1]{\overrightarrow{#1}}
\nwc{\zb}{\mbox{$0\hspace{-0.67em}\mid$}}
\nwc{\db}{\mbox{$\hspace{0.1em}|\hspace{-0.67em}\mid$}}
\nwc{\ul}[1]{\underline{#1}}
\newcounter{nex}%[section]
\setcounter{nex}{0}
\newenvironment{EX}{%
\stepcounter{nex}
\bgsk{\noindent {\bf Exercice }\arabic{nex}}\hspace{0.2cm}
}{}
\nwc{\bgex}{\begin{EX}}\nwc{\enex}{\end{EX}}
\nwc{\bgmp}{\begin{minipage}}\nwc{\enmp}{\end{minipage}}
\headheight=0cm
\textheight=26.2cm
\topmargin=-1.9cm
\footskip=1cm
\textwidth=18cm
\oddsidemargin=-1cm
\parindent=0.2cm
\newcounter{nprop}
\setcounter{nprop}{1}
\newlength{\lprop}
\nwc{\bgprop}[1]{
\settowidth{\lprop}{Propriété \arabic{nprop}}
\noindent
\paragraph{Propriété}% \arabic{ntheo}}
\hspace{-0.5em}%\hspace{-0.4cm}
\bgmp[t]{\textwidth-\lprop-0.5em}{\it #1}\enmp
\stepcounter{nprop}
}
\newcounter{ndef}
\setcounter{ndef}{1}
\newlength{\ldef}
\nwc{\bgdef}[1]{
\settowidth{\ldef}{Définition \arabic{ndef}}
\noindent
\paragraph{Définition}% \arabic{ndef}}
\hspace{-0.5em}%\hspace{-0.4cm}
\bgmp[t]{\textwidth-\ldef-0.5em}{\it #1}\enmp
}
% "Cadre" type Objectifs....
\nwc{\ObjTitle}{Définition\!\!:\ \ }
\newlength{\lgObjTitle}
\newlength{\hgObj}
\newlength{\hgObjTitle}\settoheight{\hgObjTitle}{\ObjTitle}
\newcommand{\Obj}[1]{%
\begin{flushright}%
\settowidth{\lgObjTitle}{\ObjTitle}
\settototalheight{\hgObj}{\phantom{\bgmp{17.5cm}{\bf\emph{\ObjTitle}}#1\enmp}}
\bgmp{17.5cm}
\psline(-1ex,-\hgObj)(-1ex,-1.5\hgObjTitle)(\lgObjTitle,-1.5\hgObjTitle)\par
\bgmp{17.5cm}{\bf\emph{\ObjTitle}}#1\enmp
\enmp
\end{flushright}
}
\renewcommand\thesection{\Roman{section}\ \ -}
\renewcommand\thesubsection{\arabic{subsection})}
% Concernant la mise en page des algo:
\definecolor{grayp}{gray}{0.8}
\definecolor{graypc}{gray}{0.65}
\newlength{\ProgIndent}
\setlength{\ProgIndent}{0.6cm}
\nwc{\PI}{\hspace*{\ProgIndent}}
\nwc{\DPI}{\hspace*{2\ProgIndent}}
\nwc{\TPI}{\hspace*{3\ProgIndent}}
\nwc{\QPI}{\hspace*{4\ProgIndent}}
\newlength{\lgcoin}\setlength{\lgcoin}{3ex}
\newlength{\lgshadow}\setlength{\lgshadow}{0.5ex}
\newlength{\phgn}\newlength{\phgnp}
\newlength{\phgng}
\newlength{\plgn}\newlength{\plgng}
\newlength{\phgtq}\newlength{\phgtqg}
\newlength{\plgtq}\newlength{\plgtqg}
\newlength{\plgcoin}\setlength{\plgcoin}{3ex}
\newlength{\plgshadow}\setlength{\plgshadow}{0.5ex}
\nwc{\Prog}[3]{%
%\par\vspd%
\bgmp[t]{#2+0.5cm}%\linewidth}
\hspace*{-0.3pt}\hspace*{-\parindent}\hspace*{-1ex}%
\psframebox[fillstyle=solid,fillcolor=graypc]{
\emph{\textcolor{white}{\!\!#1}}} \\
\vspace*{-0.5ex}\\
\bgmp{#2}
%\setlength{\fboxrule}{0.1pt}
\settototalheight{\phgn}{\phantom{\bgmp{#2}#3\enmp}}
\setlength{\phgn}{\phgn-2ex}
\setlength{\plgn}{\linewidth}
\setlength{\phgtq}{-\phgn}%\addtolength{\hgtq}{-3ex}
\setlength{\phgtqg}{\phgtq}\addtolength{\phgtqg}{-\lgshadow}
\setlength{\plgng}{\plgn}\addtolength{\plgng}{\lgshadow}
\setlength{\plgtq}{\plgn}\addtolength{\plgtq}{-\lgcoin}
\setlength{\plgtqg}{\plgtq}\addtolength{\plgtqg}{\lgshadow}
\setlength{\phgnp}{\phgn}\addtolength{\phgnp}{\lgcoin}
\setlength{\phgng}{\phgnp}\addtolength{\phgng}{\lgshadow}
\pspolygon[linecolor=white,fillstyle=solid,fillcolor=grayp]%
(-1ex,-\phgnp)(-1ex,1ex)(\plgn,1ex)(\plgng,0)%
(\plgng,\phgtqg)(\plgtqg,-\phgng)(-0.5ex,-\phgng)
\pspolygon[linewidth=0.6pt,linecolor=graypc,fillstyle=solid,fillcolor=graypc]%
(\plgn,\phgtq)(\plgtq,\phgtq)(\plgtq,-\phgnp)
\pspolygon[fillstyle=solid,fillcolor=white]%
(-1ex,-\phgnp)(-1ex,1ex)(\plgn,1ex)%
(\plgn,\phgtq)(\plgtq,\phgtq)(\plgtq,-\phgnp)
\par
\bgmp{\linewidth}#3\enmp
\enmp
\enmp
\medskip
}
% et pour les progs casio:
\nwc{\return}{
\psset{unit=1cm,arrowsize=4pt}
\psline{<-}(0,0.1)(0.3,0.1)(0.3,0.25)}
\nwc{\disp}{\pspolygon[fillstyle=solid,fillcolor=black](0,0)(0.2,0)(0.2,0.15)}
% Bandeau en bas de page
\newcommand{\TITLE}{Algorithmique}
\author{Y. Morel}
\date{}
\usepackage{fancyhdr}
\pagestyle{fancyplain}
\setlength{\headheight}{0cm}
\renewcommand{\headrulewidth}{0pt}
\renewcommand{\footrulewidth}{0.1pt}
\lhead{}\chead{}\rhead{}
\lfoot{Y. Morel - \url{https://xymaths.fr/}}
\rfoot{\TITLE\ - \thepage/\pageref{LastPage}}
\cfoot{}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{document}
\ct{\LARGE \bf \TITLE}
\vspace{-0.6cm}
\section{Généralités}
\Obj{
Un \emph{algorithme} est une suite finie d'instructions
permettant la résolution systématique d'un problème donné.
}
Un algorithme peut-être utilisé pour\vsp
\bgit
\item[$\bullet$] \ul{décrire} par une suite d'instructions ou de procédures la
marche complète à suivre pour résoudre un problème;
\item[$\bullet$] \ul{automatiser} une tâche complexe;
on sait déjà dans ce cas résoudre le problème posé et on cherche
à tirer parti de moyens informatiques pour effectuer automatiquement
toutes les étapes et tous les calculs intermédiaires
%plus ou moins fastidieux
qui permettent d'aboutir au résultat;
\item[$\bullet$] \ul{chercher} la solution d'un problème;
on ne sait pas a priori résoudre le problème posé
mais on peut tirer parti d'un système informatisé pour explorer
l'ensemble des possibilités, et ainsi tenter de trouver la
solution, ou du moins une bonne approximation de celle-ci.
\enit
\bigskip
\bgmp{5.8cm}
\paragraph{Un exemple courant: notice d'utilisation ou mode d'emploi}
%Application d'une huile teck
\ \\[.4em]
La notice d'utilisation d'une huile teck, imprimée au dos du
flacon d'huile, est donnée ci-contre.
\enmp\hfill%\hspace{1.4em}
\bgmp{11.2cm}
\Prog{Mode d'application}{11.2cm}{
1. Vérifier que la surface est bien du teck ou un bois exotique \\
2. Bien agiter avant emploi \\
3. Imprégner le bois généreusement \\
4. 20 minutes après, essuyer l'excédent à l'aide d'un chiffon \\
5. Laisser sécher 6 heures \\
6. Recommencer à partir de l'étape 2 \\
7 Laisser couler quelques gouttes d'eau sur la surface traitée\\
\PI Si les gouttes perlent à la surface, \\
\PI Alors le bois est correctement huilé et imperméabilisé \\
\PI Sinon, recommencer à l'étape 2.
}
\enmp
\medskip\noindent
En termes algorithmiques,
on appelle \textbf{initialisation} l'étape 1,
et \textbf{traitement} les étapes 2 à 7. \\
Cette notice comporte une \textbf{boucle} sur les étapes 2 à 7. \\
Enfin, en terme d'algorithme, si celle-ci n'est pas tra\^itée par un humain
\textit{pensant}, elle comporte une (grave ?) erreur (bug ?) !
\Obj{
Un \emph{langage de programmation} est un ensemble d'instructions et
de règles syntaxiques compréhensibles par un système automatisé
(calculatrice, ordinateur, puce électronique,\dots).
\\[.4em]
Un \emph{programme} est la traduction d'un algorithme dans un langage
de programmation particulier. \
}
Il existe de très nombreux langages de programmation,
par exemple
Basic, Fortran, Python, C, C++, Matlab, assembleur\dots,
ainsi que ceux implantés dans les calculatrices
(alors dites "programmables"\dots).
\vspace*{-.5em}
\section{Variables}
\vspace*{-1.8em}
\bgdef{
On appelle \emph{variable} tout emplacement de la mémoire dans lequel
une information peut-être stockée.
Une variable est constituée de :
\begin{itemize}
\item un nom qui permet à l'ordinateur de la localiser dans sa
mémoire (une lettre:
\texttt{a}, \texttt{b}, \dots, \texttt{x}, \dots,
ou plusieurs: \texttt{ma\_variable}, \dots)
\item une valeur: l'information (un nombre, un texte, \dots) qu'elle
contient.
\end{itemize}
}
\bigskip
\noindent
La valeur d'une variable peut bien s\^ur changer au cours de l'exécution de
l'algorithme.
Une \textbf{affectation} consiste à attribuer une \texttt{valeur}
à une \texttt{variable}, ou à
en modifier la valeur.
\medskip
\noindent\fbox{\bgmp{3.5cm}\ \\[0em]{\it valeur}$\to$\texttt{variable}\\[-.2em]
\enmp}
\quad ou \quad
\fbox{\bgmp{3.5cm}\ \\[0em]\texttt{variable}={\it valeur}\\[-.2em]
\enmp}
\section{Structures dans les algorithmes}
\subsection{Boucles itératives}
\vspace{-0.8cm}
\begin{minipage}[c]{\textwidth-7.cm}
Une boucle permet de répéter un ensemble d'instructions un nombre fixé
de fois.
\end{minipage}\hspace{\fill}
\begin{tabular}[c]{|p{6cm}|}\hline\\[-.8em]
\texttt{Pour {\it variable} de {\it début} à {\it Fin}}\\
\hspace*{0.4cm}{\it instructions 1}\\
\hspace*{0.4cm}{\it instructions 2}\\
\hspace*{0.4cm}{\it \dots}\\
\texttt{Fin Pour} \\\hline
\end{tabular}
\vspace{-.8em}
\bgex
\bgen[a)]
\item Ecrire un algorithme qui calcule et affiche la suite des carrés
des nombres entiers de 1 à 10.
\item Modifier cet algorithme pour qu'il calcule et affiche la somme
des carrés des entiers de 1~à~10.
\enen
\enex
\subsection{Tests et instructions conditionnelles}
\vspace{-.6em}
\begin{minipage}[b]{\textwidth-5.cm}
Un test est une comparaison entre la valeur d'une variable et une
valeur donnée, ou entre les valeurs de deux variables.
\vspd
Un test a deux résultats possibles:
$0$ (faux), ou $1$ (vrai).
%\vspd
Dans une structure conditionnelle,
les instructions ne sont effectuées que \emph{si} le test indiqué est vrai.
\end{minipage}\hspace{\fill}
\begin{tabular}[b]{|p{4cm}|}\hline\\[-.8em]
\texttt{Si} {\it test}\\
\hspace*{0.4cm}{\it instructions 1}\\
\hspace*{0.4cm}{\it instructions 2}\\
\hspace*{0.4cm}{\it \dots}\\
\texttt{Fin Si} \\\hline
\end{tabular}
\bgex
Ecrire un algorithme qui demande un nombre à l'utilisateur et affiche
en résultat si le nombre est positif ou négatif.
\enex
\subsection{Boucles conditionnelles}
\vspace{-2.8em}
\begin{minipage}[b]{\textwidth-5cm}
Une boucle conditionnelle permet de répéter une série d'instructions
sans connaître a priori le nombre d'itérations.
La boucle est répété \emph{tant que} le test indiqué est vrai.
\end{minipage}\hspace{\fill}
\begin{tabular}[b]{|p{4cm}|}\hline
\texttt{Tant que} {\it test} \\
\hspace*{0.4cm}{\it instructions 1}\\
\hspace*{0.4cm}{\it instructions 2}\\
\hspace*{0.4cm}{\it \dots}\\
\texttt{Fin Tant que} \\\hline
\end{tabular}
\bgex
Ecrire un algorithme qui demande un nombre entier à l'utilisateur
et compte à rebours.
\enex
\bgex
Ecrire un algorithme qui demande successivement des nombres
et qui s'arr\^ete lorsque l'utilisateur entre le chiffre 5.
\enex
\vspace{-.5em}
\section{Corrigés: Algorithmes et programmes des exercices}
\setcounter{nex}{0}
\vspace{-1.5em}
\bgex
\bgen[a)]
\item Affichage des 10 premiers entiers:\vspd\par
\Prog{Algorithme}{3.6cm}{
\texttt{Pour I de 1 à 10}\\
\PI\texttt{Afficher I*I}\\
\texttt{Fin Pour}
}\hfill
\Prog{Programme TI}{3.2cm}{
\texttt{For (I,1,10)}\\
\texttt{Disp I*I}\\
\texttt{End}
}\hfill
\Prog{Programme Casio}{3.55cm}{
\texttt{For 1$\to$I To 10\!\return}\\
\texttt{I*I\disp}\\
\texttt{Next}
}\hfill
\hspace{\fill}
\Prog{Programme Python}{4.8cm}{
\texttt{for i in range(1,11):}\\
\hspace*{\ProgIndent}\texttt{print(i*i)}
}
\vspace{-.8em}
\item Calcul de la somme des carrés des 10 premiers entiers:\vspd\par
\Prog{Algorithme}{3.6cm}{
\texttt{0$\to$S}\\
\texttt{Pour I de 1 à 10}\\
\PI\texttt{S+I*I$\to$S}\\
\texttt{Fin Pour}\\
\texttt{Afficher S}
}\hfill
\Prog{Programme TI}{3.2cm}{
\texttt{0$\to$S}\\
\texttt{For (I,1,10)}\\
\texttt{S+I*I$\to$S}\\
\texttt{End}\\
\texttt{Disp S}
}\hfill
\Prog{Programme Casio}{3.55cm}{
\texttt{0$\to$S}\\
\texttt{For 1$\to$I To 10\!\return}\\
\texttt{S+I*I$\to$S\return}\\
\texttt{Next}\\
\texttt{S\disp}
}\hfill
\hspace{\fill}
\Prog{Programme Python}{4.8cm}{
\texttt{S=0}\\
\texttt{for i in range(1,11):}\\
\hspace*{\ProgIndent}\texttt{S=S+i*i}\\
\texttt{print(S)}
}
\enen
\enex
\bgex Test: nombre positif ? \vspd\par
\Prog{Algorithme}{5cm}{
\texttt{Lire A}\\
\texttt{Si A>0}\\
\hspace*{\ProgIndent}\texttt{Afficher "A positif"}\\
\texttt{Sinon}\\
\hspace*{\ProgIndent}\texttt{Afficher "A négatif"}\\
\texttt{Fin Si}
}
%\hspace{\fill}
\Prog{Programme TI}{3.5cm}{
\texttt{Prompt A}\\
\texttt{If A$\geq$0}\\
\texttt{Then}\\
\texttt{Disp "A positif"}\\
\texttt{Else}\\
\texttt{Disp "A négatif"}\\
\texttt{End}
}\hfill
\Prog{Programme Casio}{4.cm}{
\texttt{"A="?$\to$A\return}\\
\texttt{If A$>$0\return}\\
\texttt{Then "A positif"\!\return}\\
\texttt{Else "A négatif"\!\return}\\
\texttt{IfEnd}
}%\hfill
\Prog{Programme Python}{4.4cm}{
\texttt{A=input("A ?")}\\
\texttt{if A$\geq$0:}\\
\hspace*{\ProgIndent}\texttt{print("A positif")}\\
\texttt{else:}\\
\hspace*{\ProgIndent}\texttt{print("A negatif")}\\
}
\enex
\vspace{-1.4em}
\bgex Compte à rebours: \vspd\\
\Prog{Algorithme}{3.5cm}{
\texttt{Lire N}\\
\texttt{Tant que N>0}\\
\hspace*{\ProgIndent}\texttt{N-1$\to$N}\\
\hspace*{\ProgIndent}\texttt{Afficher "N"}\\
\texttt{Fin Tant que}
}\hfill
\Prog{Programme TI}{3.5cm}{
\texttt{Prompt N}\\
\texttt{While N>0}\\
\texttt{N-1$\to$N}\\
\texttt{Disp N}\\
\texttt{End}
}\hfill
\Prog{Programme Casio}{3.5cm}{
\texttt{"N="?$\to$N}\\
\texttt{While N>1\return}\\
\texttt{N-1$\to$N\disp}\\
\texttt{WhileEnd}\\
}\hfill
\Prog{Programme Python}{3.5cm}{
\texttt{N=input("N ?")}\\
\texttt{While N>0:}\\
\hspace*{\ProgIndent}\texttt{N=N-1}\\
\hspace*{\ProgIndent}\texttt{print(N)}
}
\enex
\vspace{-1.4em}
\bgex Boucle arr\^etée par l'utilisateur \\[.4em]
\Prog{Algorithme}{3.5cm}{
\texttt{Lire N}\\
\texttt{Tant que N$\not=$5}\\
\hspace*{\ProgIndent}\texttt{Lire N}\\
\texttt{Fin Tant que}
}\hfill
\Prog{Programme TI}{3.5cm}{
\texttt{Prompt N}\\
\texttt{While N$\not=$5}\\
\texttt{Prompt N}\\
\texttt{End}
}\hfill
\Prog{Programme Casio}{3.5cm}{
\texttt{"N="?$\to$N}\\
\texttt{While N$\not=$5\return}\\
\texttt{"N="?$\to$N}\\
\texttt{WhileEnd}
}\hfill
\Prog{Programme Python}{3.5cm}{
\texttt{N=input("N ?")}\\
\texttt{While not(N==5):}\\
\hspace*{\ProgIndent}\texttt{N=input("N ?")}\\
}
\enex
%\clearpage
\vspace{-.8em}
\section{Jeu du nombre mystérieux}
\vspace{-.8em}
Ce jeu se joue à deux personnes de la manière suivante.
Un des deux joueurs choisit un nombre entier au hasard compris entre 1
et 100.
Le but du deuxième joueur est de trouver ce nombre.
Pour cela il propose un nombre au premier joueur qui lui
fournit une des trois réponses:
\bgit
\item \emph{Gagné}, si le nombre proposé est le bon;
\item \emph{Trop grand}, si le nombre proposé est plus grand que le
nombre mystérieux;
\item \emph{Trop petit}, si le nombre proposé est plus petit que le
nombre mystérieux;
\enit
Si le nombre proposé n'est pas le bon, le deuxième joueur propose un
autre nombre, et le jeu se poursuit jusqu'à ce qu'il trouve le nombre
exact.
Le but du jeu est de trouver le nombre mystérieux avec le moins de
tentatives possible.
\noindent
\paragraph{1) L'ordinateur fait deviner. }
Le programme dans lequel l'ordinateur est le joueur choisissant
un nombre au hasard compris entre 1 et 100, et l'utilisateur est le
joueur qui doit trouver ce nombre.
Le programme doit aussi afficher le nombre de tentatives utilisées.
\vspd
Lire attentivement l'algorithme suivant (ou un des programmes),
bien suivre et comprendre la succession d'instruction,
et indiquer le rôle de chacune des variables
\texttt{M},
\texttt{C},
\texttt{N}.
\vspd\par
\Prog{Algorithme}{9.6cm}{
\texttt{M prend une valeur aléatoire entre $0$ et $100$}\\
\texttt{C prend la valeur 1}\\
\texttt{Afficher "Entrer un nombre"}\\
\texttt{Lire N}\\
\texttt{Tant que N$\not=$M}\\
\PI\texttt{Si N<M alors}\\
\DPI\texttt{Afficher "Trop petit"}\\
\PI\texttt{Sinon}\\
\DPI\texttt{Afficher "Trop grand"}\\
\PI\texttt{Fin Si}\\
\PI\texttt{C prend la valeur C+1}\\
\PI\texttt{Afficher "Entrer un nombre"}\\
\PI\texttt{Lire N}\\
\texttt{Fin Tant que}\\
\texttt{Afficher "Gagne en",C," coups"}
}
\Prog{Programme TI}{6.2cm}{
\texttt{randInt(0,100)$\to$M}\\
\texttt{1$\to$C}\\
\texttt{Prompt N}\\
\texttt{while N$\not=$M}\\
\texttt{if N<M}\\
\texttt{Then}\\
\texttt{Disp "Trop petit"}\\
\texttt{Else}\\
\texttt{Disp "Trop grand"}\\
\texttt{End}\\
\texttt{C+1$\to$C}\\
\texttt{Prompt N}\\
\texttt{End}\\
\texttt{Disp "Gagne en",C," coups"}
}
\Prog{Programme Casio}{4.5cm}{
\texttt{Int(100$\tm$Ran\#+1)$\to$M}\!\return\\
\texttt{1$\to$C}\return\\
\texttt{"N="?$\to$N}\return\\
\texttt{While N$\not=$M}\return\\
\texttt{If N<M}\return\\
\texttt{Then "Trop petit"}\return\\
\texttt{Else "Trop grand"}\return\\
\texttt{IfEnd}\return\\
\texttt{C+1$\to$C\return}\\
\texttt{"N="?$\to$N}\return\\
\texttt{WhileEnd}\return\\
\texttt{"Gagne"}\return\\
\texttt{"Nombre de coups="}\return\\
\texttt{C\disp}
}
\Prog{Programme Python}{7.3cm}{
\texttt{import random}\\
\newline
\texttt{M=random.randint(0,100)}\\
\texttt{N=input('Entrer un nombre: ')}\\
\newline
\texttt{C=1}\\
\texttt{while N!=M:}\\
\PI\texttt{N=input('Entrer un nombre: ')}\\
\PI\texttt{if N<M:}\\
\DPI\texttt{print("Trop petit")}\\
\PI\texttt{else}\\
\DPI\texttt{print("Trop grand")}\\
\PI\texttt{C=C+1}\\
\texttt{print("Gagne en ",C," coups")}
}
\vspace{-.8em}
\paragraph{2) L'ordinateur doit deviner. }
Ecrire un programme pour ce jeu avec les rôles inversés:
vous pensez à un nombre entier compris entre 1 et 100,
et l'ordinateur doit le trouver.
Essayer de trouver une stratégie pour que l'ordinateur trouve ce
nombre avec le moins de coups possible.
\vspace{-.8em}
\section{Exercices}
\vspace{-1.4em}
\bgex
Ecrire un algorithme qui demande à l'utilisateur un nombre entier $n$
et calcule et affiche la somme
$1+2+3+\dots+n$.
\enex
\bgex {\it Balayage de valeurs}
\noindent Ecrire un algorithme qui donne une valeur approchée à $10^{-2}$
près de la solution positive de l'équation $x^2=2$.
L'algorithme procédera par balayage à partir de $0$,
c'est-à-dire en testant $0$, $0,01$, $0,02$,\dots
\medskip
Modifier cet algorithme pour obtenir une solution approchée
à $10^{-3}$, puis $10^{-4}$ près.
\enex
\vspace{-.3em}
\bgex {\it Distributeur de billets}
Ecrire un algorithme qui demande un montant $N$ en euros
et qui calcule et affiche
le nombre minimal de billets de 20 euros, de 10 euros et de 5 euros
à fournir pour faire le montant $N$.
\enex
\vspace{-.3em}
\bgex
La population d'une ville augmente de 4\,\% par an.
Ecrire un algorithme qui détermine le nombre d'années au
bout duquel la population aura doublé.
\enex
\label{LastPage}
\end{document}
Télécharger le fichier source