LaTeX icone Téléchargement du fichier source: Cours-Introduction-algorithmes-programmation-BTSIn progress 



Fichier
Type: Cours
File type: Latex, tex (source)
Télécharger le document pdf compilé pdficon
Description
Cours de mathématiques en BTS: algorithmique et programmation
Niveau
BTS
Table des matières
  • Généralités
    • Algorithme, langage de programmation et programme
  • Variables
  • Structures dans les algorithmes
    • Boucles itératives
    • Tests et instructions conditionnelles
    • Boucles conditionnelles
  • Jeu du nombre mystérieux
  • Exercices
Mots clé
algorithme, algorithmique, programmation, variable, boucle, test, boucle conditionnelle, calculatrice TI, calculatrice Casio, python
Voir aussi:

Documentation sur LaTeX
pdficon
Source LaTex icone
Télécharger le fichier source pdficon

\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{xymaths.free.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}

Haut de la page Haut de la page