\thumb

\begin{qcm}{Entiers de 1 à 9}{3}
On cherche à écrire un programme en Python qui affichera tous les nombres entiers de 1 à 9. Parmi ces propositions, écrites en Python, lesquelles vous paraissent correctes~?

\choix \verb+ if k>0 and k>0 : print(k) + 

\choix \verb+ k=1 ; while k>0 : print(k) +

\choix \verb+ for k in range(1,10): print(k) +

\choix \verb+ for k in range(1,9): print(k) +
\end{qcm}

\begin{corrige}
\begin{tabular}{@{}lm{63mm}m{30mm}@{}}
\choix & \multicolumn{2}{p{93mm}}{Cette instruction n'est pas une boucle. Dans le meilleur cas, seule une valeur de k s'affichera à l'écran.} \\
\raisebox{15mm}{\choix} & Il s'agit bien d'une boucle, mais la valeur de k n'est pas incrémentée. Elle gardera donc toujours la valeur 1, et cette valeur sera affichée à l'écran un nombre indéfini de fois, jusqu'à ce que l'utilisateur arrête le programme~! 
On peut corriger le programme en ajoutant \linebreak
\texttt{k = k + 1} dans la boucle pour incrémenter la variable k.
&
\begin{listing}{}{01-qcm01.py}\end{listing} \\
\choix & \multicolumn{2}{l}{C'est la solution élégante et efficace pour le problème posé.}\\
\choix\newline~\newline~ & \multicolumn{2}{l}{Attention, en Python la borne finale est
toujours exclue, les entiers}\\
& \multicolumn{2}{l}{de 1 à 8 seront affichés.}
\end{tabular}
\end{corrige}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{qcm}{De Python à un algorithme}{5}
Voici un programme en Python :

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-qcm02.py}}}
\vspace*{-10pt}

\begin{listing}{}{01-qcm02.py}\end{listing}

\Par

Parmi les algorithmes suivants, quel est celui qui représente ce programme ?\resetchoix

\begin{itemize}
\item[\choix] \begin{algorithme}{}
x $\leftarrow$ 5
Pour i allant de 1 à 10
\hspace*{1em} x $\leftarrow$ x*2/(x-4)
Fin Pour
Afficher x
\end{algorithme}

\item[\choix] \begin{algorithme}{}
x $\leftarrow$ 5
Pour i allant de 0 à 9
\hspace*{1em} x $\leftarrow$ x*2/(x-4)
\hspace*{1em} Afficher x
Fin Pour
\end{algorithme}

\item[\choix] \begin{algorithme}{}
x $\leftarrow$ 5
Pour i allant de 0 à 10
\hspace*{1em} x $\leftarrow$ x*2/(x-4)
\hspace*{1em} Afficher x
Fin Pour
\end{algorithme}
\end{itemize}
\end{qcm}

\begin{corrige}
Rappelons qu'en Python, la borne supérieure de l'intervalle est exclue, donc \texttt{i} prend les valeurs 0, 1, 2, ..., 9.

L'algorithme \choix[a] n'affiche qu'une valeur car \og Afficher x \fg{} est en dehors de la boucle \og Pour \fg.
Il ne peut donc pas convenir car dans le programme Python,
l'indentation montre que l'affichage de \texttt{x} est bien à l'intérieur de la boucle \texttt{for} ; il faut donc que les valeurs successives de \texttt{x} s'affichent 10 fois. Or, l'algorithme \choix[c] affiche 11 valeurs (car la boucle s'exécute pour \texttt{i} allant de 0 à 10 et il y a 11 valeurs : 0, 1, 2, 3, \ldots, 9, 10).

La bonne réponse est donc l'algorithme \choix[b] qui affiche bien 10 valeurs (car \texttt{i} prend les valeurs 0, 1, 2, \ldots, 8, 9) de \texttt{x}.
\end{corrige}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{exo}{Traduire un programme Python}{Lycée Hoche, Versailles}{1}{5}
Voici un programme Python :

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-traduire-prog.py}}}
\vspace*{-10pt}

\begin{listing}{}{01-traduire-prog.py}\end{listing}

\Par

En utilisant une boucle \og \texttt{Tant que} \fg, écrire 
en langage naturel un algorithme qui décrit exactement ce que fait ce programme.
\end{exo}

\begin{corrige}
\enlargethispage*{3em}
\begin{algorithme}{}
Variables : u, d, n (nombres)
Début
  u $\leftarrow$ 50
  d $\leftarrow$ 10
  n $\leftarrow$ 0
  Tant que d$\geqslant$0,01 faire:
    u $\leftarrow$ 0,7$\times$u+20
    d $\leftarrow$ 200/3-u
    n $\leftarrow$ n+1
  Fin Tant que
  Afficher n
Fin
\end{algorithme}
\end{corrige}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% EX4

%\begin{exo}{Fonctions}{Lycée Fénelon, Paris}{1}{20}
%$x$ étant un réel, on considère les fonctions :
%\[
%A(x)=5-\dfrac{3}{x^2},\ B(x)=3(x+2)^2+4,\ C(x)=\dfrac{4}{2x+1}\text{ et }D(x)=6-\dfrac{7}{x}. 
%\]
%Programmer ces fonctions en Python.
%\end{exo}
%
%\begin{corrige}
%L'avantage du langage Python est qu'il est à la fois
%structuré et proche du langage naturel~: 
%
%\begin{listing}{}{01-exo-04.py}\end{listing}
%\end{corrige}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{exo}{Un programme}{Lycée Turgot, Paris}{1}{20}
On considère le programme suivant:

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1.2,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-lycee-turgot.py}}}
\vspace*{-10pt}

\begin{listing}[numbers=left]{}{01-lycee-turgot.py}\end{listing}

\begin{questions}
\item Quel est le type des variables \texttt{x}? 
\texttt{y} ? \texttt{f}? 
\item Pour quelle(s) valeur(s) de \texttt{x} l'algorithme va-t-il échouer? 
\item Que fait la fonction \texttt{f}?
\end{questions}
\end{exo}


\begin{corrige}
\begin{questions}
\item \texttt{x} peut être entier (type \og INT \fg) ou réel~(type flottant, ou \og FLOAT \fg).

À cause de la division, la variable \texttt{y} est toujours interprétée comme un flottant par Python).

Enfin, \texttt{f} est une fonction. 

\item À la ligne 5, on effectue une division par $x+1$. 

La valeur
$x=-1$ va donc causer une erreur de calcul (division par zéro).

\item Au début de l'évaluation de \texttt{f(x)}, 
$y=(x+2)(x-1)=x^2+x-2$
puis $y=4(x^2+x-2)=4x^2+4x-8$.

Ensuite, $y=(4x^2+4x-8)+8=4x^2+4x$. 

La valeur finale est $y=\frac{(4x^2+4x)}{x+1}=\frac{4x(x+1)}{x+1}=4x$. 

\textit{Conclusion~:} la fonction $f$ 
ne fait que multiplier $x$
par 4. 
\end{questions}
\end{corrige}


%%%%%% 2024

\begin{exo}{Programmes de calculs}{Lycée Notre-Dame-de-Boulogne, Boulogne}{1}{10}
On considère les programmes de calculs page suivante:

\begin{questions}
\item \'Ecrire deux fonctions Python \texttt{A(x)} et \texttt{B(x)} qui retournent respectivement les résultats du programme de calcul A et B pour un nombre $x$ entré en argument.

\item \'Ecrire un programme Python qui affiche les résultats des programmes A et B pour tous les entiers compris entre $-5$ et 5.
\end{questions}

\begin{tabularx}{\linewidth}{|X|X|}
\hline\tabulartitle
Programme A & Programme B\\
\hline
\begin{itemize}
\item Choisir un nombre $x$
\item \'Elever ce nombre au carré 
\item Soustraire au résultat le double du nombre de départ
\item Ajouter 1 au résultat
\end{itemize}
& 
\begin{itemize}
\item Choisir un nombre $x$
\item Lui soustraire 1
\item Élever au carré le résultat
\end{itemize} \\
\hline
\end{tabularx}

\end{exo}

\begin{corrige}
\begin{questions}
\item Il y a plusieurs manières d'aborder un tel exercice. L'une d'elles consiste à exprimer en fonction de $x$ le résultat des deux programmes de calculs.

\Par

\begin{tabularx}{\linewidth}{|X|X|}
\hline\tabulartitle
Programme A & Expressions algébriques\\
\hline
\begin{itemize}
\item Choisir un nombre $x$
\item \'Elever ce nombre au carré 
\item Soustraire le double de $x$
\item Ajouter 1 au résultat
\end{itemize}
& 
\begin{itemize}
\item $x$
\item $x^2$
\item $x^2-2x$
\item $x^2-2x+1$
\end{itemize} \\
\hline
\end{tabularx}

et

\begin{tabularx}{\linewidth}{|X|X|}
\hline\tabulartitle
Programme B & Expressions algébriques\\
\hline
\begin{itemize}
\item Choisir un nombre $x$
\item Lui soustraire 1
\item Élever au carré le résultat
\end{itemize}
&
\begin{itemize}
\item $x$
\item $x-1$
% ERREUR %\item $(x-1)^3$
\item $(x-1)^2$
\end{itemize}\\
\hline
\end{tabularx}

\Par


Les fonctions \texttt{A(x)} et \texttt{B(x)} peuvent donc s'écrire comme indiqué page suivante.

\newpage

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-prog-calculs.py}}}
\vspace*{-10pt}

\begin{listing}{}{01-prog-calculs.py}\end{listing}

\item Une possibilité de programme est la suivante:

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-prog-calculs-boucle-while.py}}}
\vspace*{-10pt}

\begin{listing}{}{01-prog-calculs-boucle-while.py}\end{listing}

\Par

Si nous préférons utiliser une boucle POUR, nous pouvons opter pour la solution suivante:

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-prog-calculs-boucle-for.py}}}
\vspace*{-10pt}

\begin{listing}{}{01-prog-calculs-boucle-for.py}\end{listing}
\end{questions}
\end{corrige}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{exo}{Pécule}{Lycée Rabelais, Meudon}{2}{10}
Les parents de Johanna décident de lui constituer un petit pécule. Le jour de sa naissance, ils déposent 250 \euro sur un compte rapportant $2,75$\;\% par an. 

À chaque anniversaire, ils ajoutent également 250 \euro. 

\begin{questions}
\item {\'E}crire un algorithme avec une boucle POUR... qui permet de calculer le pécule de Johanna le jour de ses 18 ans. 
\item Programmer cet algorithme en Python ou sur votre 
calculatrice.
\end{questions} 
\end{exo}


\begin{corrige}
\begin{questions}
\item Chaque année, le pécule de Johanna est donc multiplié par  $1,0275$ puis on lui ajoute $250$.

\begin{algorithme}{Algorithme}
Variables: anniversaire, pecule (nombres)
Début
  pecule $\leftarrow$ 250
  Pour anniversaire allant de 1 à 18
    pecule $\leftarrow$ 250+1,0275$\times$pecule
  Fin Pour
  Afficher pecule
Fin
\end{algorithme}

\item La traduction en Python est quasi-immédiate~:\enlargethispage*{5em}

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-pecule.py}}}
\vspace*{-10pt}

\begin{listing}{}{01-pecule.py}\end{listing}

\Par

Ce programme affiche la valeur 6130.75365, 
Johanna disposera donc de \numprint{6130,75}~\euro à son 18\up{ème} anniversaire.
\end{questions} 
\end{corrige}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%% NEW2017

\begin{exo}{Lecture d'un algorithme}{Lycée Camille Jullian, Bordeaux}{2}{10}
On considère l'algorithme suivant:

\begin{algorithme}{}
Variables : n, r, i, c (nombres entiers)
Début :
  c $\leftarrow$ 0
  Lire la valeur de n
  i $\leftarrow$ 2
  Tant que i**2 <= n faire:
    Si (n/i) est un entier alors
      c $\leftarrow$ c+1
    i $\leftarrow$ i+1
    Fin Si
  Fin Pour
  Si c=0 alors
    Afficher n " est un nombre premier"
  Sinon
    Afficher n " n'est pas un nombre premier"
  Fin Si
Fin
\end{algorithme}

\begin{questions}
\item Exécuter à la main cet algorithme en prenant $n=20$ puis $n=23$ (présenter les résultats dans un tableau).
\item Expliquer le rôle de cet algorithme et la propriété qu'il semble utiliser.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item 
\begin{itemize}
\item La variable \texttt{i} est initialisée à la valeur $2$, puis est incrémentée tant qu'elle reste inférieure ou égale
à $\sqrt{n}$. 
Pour $n=20$, $i$ varie de $2$ à $4$. 

\Par

\begin{center}
\begin{tabular}{|C|*4{Zc|}}
\hline
Valeurs de \texttt{i} & - & 2 & 3 & 4\\\hline
Valeurs de \texttt{c} & 0 & 1 & 1 & 2\\\hline
\end{tabular}
\end{center}

\Par

\emph{Explications} : quand $i=2$, on fait la division $20\div2$ et on trouve un nombre entier (10). Donc \texttt{c} va augmenter de 1.

Ensuite, pour $i=3$, comme $20\div3$ n'est pas un entier, \texttt{c} n'augmente pas.

Enfin, pour $i=4$, $20\div4=5$ est un entier donc on ajoute 1 à \texttt{c}.

L'algorithme affiche ici : \og 20 n'est pas un nombre premier \fg{} car \mbox{$\texttt{c}\neq0$}.

\item Pour $n=23$, \texttt{i} varie également de 2 à 4.  

\Par

\begin{center}
\begin{tabular}{|C|*4{Zc|}}
\hline
Valeurs de \texttt{i} & - & 2 & 3 & 4\\\hline
Valeurs de \texttt{c} & 0 & 0 & 0 & 0\\\hline
\end{tabular}
\end{center}

\Par

En effet, parmi les nombres 2, 3 et 4, aucun n'est diviseur de 23 donc \texttt{c} n'augmente pas.

L'algorithme affiche donc ici : \og 23 est un nombre premier \fg{} car \mbox{$\texttt{c}=0$}.
\end{itemize}

\item A priori, cet algorithme compte
les diviseurs de $n$ compris entre $2$ et $\sqrt{n}$. 
Le résultat est stocké dans le compteur \texttt{c}. 
Si \texttt{c} est égal à $0$, l'algorithme 
en déduit que $n$ est un nombre premier.

Cet algorithme semble s'appuyer sur une propriété qui pourrait s'écrire ainsi :


Si $a$ est un entier de $]\sqrt{n},n[$
qui divise $n$, alors $b=\frac{n}{a}$
est un entier de $]1,\sqrt{n}]$ qui divise $n$. Par conséquent,
\og 
Si un entier $n$ n'admet aucun diviseur dans $[2,\sqrt{n}]$,
alors il est premier.\fg  

\end{questions}
\end{corrige}



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%% NEW2017

\begin{exo}{Laboratoire pharmaceutique}{Lycée Gustave Eiffel, Bordeaux}{2}{10}
Un laboratoire produisant un sirop contre la fièvre à destination de nouveaux-nés fournit le protocole médical suivant : pour une température corporelle dépassant 38,5°C, donner 2 cuillères de sirop. Pour une température corporelle comprise entre 37,5°C et 38,5°C, donner 1 cuillère de sirop.

On considère le programme Python suivant :

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-labopharma-trous.py}}}
\vspace*{-10pt}

\begin{listing}{}{01-labopharma-trous.py}
\end{listing}

\begin{questions}
\item À quoi sert cette fonction ? Préciser à quoi correspondent
les variables T et N. 
\item Compléter la fonction.
\item Le cas où le nouveau-né n'a pas de fièvre (température corporelle 
inférieure à 37,5°C) est-il prévu dans l'algorithme ? On pourra justifier la 
réponse en testant l'algorithme avec le nombre 37 en entrée.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Cet algorithme permet d'afficher le nombre de cuillères de sirop N à donner en fonction de la température T saisie. 
\item La fonction complète est :
\Par
\NathanLiveProg[]{}{}\vspace*{-3em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-labopharma-correction.py}}}
\vspace*{-10pt}
\begin{listing}{En Python}{01-labopharma-correction.py}
\end{listing}

\item Comme l'énoncé nous le suggère, on peut tester le cas où l'on appelle la fonction avec 37 en argument. 

Les deux conditions $T>38.5$ et $T>=37.5$ 
ne sont pas satisfaites et les instructions 
\verb+ N=2+ et \verb+ N=1+ ne sont pas exécutées. 
La valeur de \texttt{N} reste donc à 0, valeur
retournée par la fonction. 

Ceci 
est correct car si le nouveau-né n'a pas de fièvre, aucune cuillère de sirop ne doit être donnée. 

Ainsi, le cas où le nouveau-né n'a pas de fièvre est prévu par l'algorithme.
\end{questions}
\end{corrige}


%%%%%%%%%%%%%%% NEW2017

\begin{exo}{Le site marchand}{Lycée Fénelon, Paris}{2}{10}
Durant tout le week-end, un site marchand propose une promotion pour toute commande d'un montant minimum de 20 \euro.

Si le montant de la commande est :
\begin{itemize}
\item strictement inférieur à 100 \euro, une remise de 10 \euro{} est offerte.
\item entre 100 \euro{} compris et 200 \euro{} non compris, une remise de 25 \euro{} est offerte.
\item supérieur ou égal à 200 \euro, une remise de 20\% est offerte.
\end{itemize}

\begin{questions}
\item Calculer le prix à payer pour une commande d'un montant de 130 \euro, de 80 \euro{} et de 300~\euro.
\item On a commencé l'écriture d'une fonction Python qui automatise le calcul du prix à payer pour une commande de montant $M\geqslant20$ :

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-site-marchand-trous.py}}}
\vspace*{-10pt}

\begin{listing}{}{01-site-marchand-trous.py}\end{listing}

\Par

Compléter le code pour qu'il fonctionne correctement.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item 
\begin{itemize}
\item Pour 130 \euro, le prix à payer est :
\[
130-25=105~\text{\euro}\qquad\text{car }100\leqslant130<200.
\]
\item Pour 80 \euro, le prix à payer est :
\[
80-10=70~\text{\euro}\qquad\text{car }80<100.
\]
\item Pour 300 \euro, le prix à payer est :
\[
\left(1-\dfrac{20}{100}\right)\times300=0,8\times300=240~\text{\euro}\qquad\text{car }300\geqslant200.
\]
\end{itemize}

\Par\Par

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-1.2){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-site-marchand-correction.py}}}
\vspace*{-10pt}

\item ~\par%Le programme Python est le suivant:
\vspace*{-3em}\begin{listing}{}{01-site-marchand-correction.py}\end{listing}

\Par

Pour $M\in[20,200[$, on retire $25$ à $M$. 
Si $M\geq 200$, on fait une remise de $20\%$, on
doit donc payer $0{,}80\times M$. Si aucune
des deux conditions n'est vérifiée, on atteint la 
dernière ligne, et $M$ est renvoyé (pas de remise). 

\end{questions}
\end{corrige}


%%%%%%%%%%%%%% NEW2017

\begin{exo}{La conjecture de Syracuse}{Lycée Fernand Daguin, Mérignac}{3}{20}

On considère la fonction $A$, qui a tout entier
naturel $n$ associe~:
\[A(n)=\begin{cases} n/2 \text{ si $n$ est pair}\\
3n+1 \text{ si $n$ est impair.} \end{cases}\]

\begin{questions}
\item Calculer $A(1)$, $A(4)$, $A(2)$. 

\item Programmer cette fonction en Python. 

\item On considère
le programme de calcul suivant~: 
\begin{algorithme}{}
1. Choisir un nombre entier $n$ non nul.
2. Affecter $n \leftarrow A(n)$
3. Aller à l'étape 2.
\end{algorithme}

\Par

Que se passe-t-il si $n=1$, $2$, ou $4$~? 

\item La conjecture de Syracuse (nommée ainsi car le problème fut diffusé pour la première fois à l'université de Syracuse, en Amérique, par le mathématicien Helmut Hasse) 
affirme que, quel que soit la valeur initiale de $n$, 
le programme arrive toujours à la suite de 
nombres 1, 4, 2, 1, 4, 2,...

On dit que ce résultat est une \emph{conjecture} car
il semble vrai mais il n'a pas été démontré.

\'Ecrire un algorithme qui permet de vérifier cette conjecture pour n'importe quel nombre entré par l'utilisateur.
\end{questions}
\end{exo}

\begin{corrige}

\begin{questions}
\item $n=1$ est impair, donc $A(1)=3\times 1+1=4$~;
$n=4$ est pair, donc $A(4)=\dfrac{4}{2}=2$~; $n=2$ est pair, 
donc $A(2)=1$. 

\newpage

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-1.2){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-syracuse-fonction.py}}}
\vspace*{-10pt}

\item 
\begin{listing}{En Python}{01-syracuse-fonction.py}\end{listing}

\Par

L'instruction \verb+ n%2+ calcule le reste de la division
euclidienne par 2, qui vaut 0 si et seulement si $n$
est pair. La division \verb+ n//2+ est la division entière.
Il est important de ne pas utiliser \verb+ n/2+ qui
donne un flottant (même si $n$ est pair) et risque
de poser des problèmes pour utiliser la valeur de 
\texttt{A(n)} par la suite. 

\item D'après la première question, si $n$ prend la valeur
$1$, elle prend ensuite la valeur $4$, puis $2$, puis de
nouveau $1$, etc. Si $n=2$ ou $4$, on atteint la valeur
$n=1$ en 1 ou 2 étapes. Le programme donne alors 
la suite 1, 4, 2, 1, 4, 2, etc.

\item À la vue de la réponse à la troisième question, nous arrêtons le programme dès que $n$ atteint la valeur 1. Tant que cette valeur n'est pas atteinte, on remplace la valeur de $n$ par celle de $A(n)$. 

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-syracuse-boucle.py}}}
\vspace*{-10pt}

\begin{listing}{}{01-syracuse-boucle.py}\end{listing}

\enlargethispage*{3em}

Par exemple, pour $n=120$, on obtient~: 
60, 30, 15, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1...
\end{questions}
\end{corrige}



%%%%%%%%%%%%% NEW2017

\begin{exo}{Le nombre d'or}{Lycée Gustave Eiffel, Bordeaux}{3}{20}
Le \emph{nombre d'or} est le nombre positif noté $\varphi$ tel que :
\[
\varphi^2=\varphi+1.
\]
\begin{questions}
\item Expliquer pourquoi $\varphi=1+\dfrac{1}{\varphi}$.
\item Montrer alors que $\varphi=1+\dfrac{1}{1+\frac{1}{\varphi}}$.
\item En s'inspirant des questions précédentes, écrire un algorithme permettant de trouver une valeur approchée du nombre d'or (peu importe la précision).
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Si $\varphi^2=\varphi+1$ alors il est facile de voir que $\varphi\neq0$ donc on peut diviser cette égalité par $\varphi$ :
\[
\dfrac{\varphi^2}{\varphi}=\dfrac{\varphi}{\varphi}+\dfrac{1}{\varphi}\qquad\text{soit :}\qquad\varphi=1+\dfrac{1}{\varphi}.
\]

\item Dans l'égalité montrée à la question précédente, on remplace le $\varphi$ du membre de droite par ce à quoi il est égal, à savoir $1+\dfrac{1}{\varphi}$ :
\[
\varphi=1+\dfrac{1}{\color{DR}\varphi}=1+\dfrac{1}{\color{DR}1+\frac{1}{\varphi}}.
\]
\newpage
\item Ce que nous avons fait à la question 2 peut être répété à l'infini :

\begin{align*}
\varphi & = 1+\dfrac{1}{1+\frac{1}{\color{DR}\varphi}} = 1+\dfrac{1}{1+\dfrac{1}{\color{DR}1+\frac{1}{\color{DB}\varphi}}} = 1+\dfrac{1}{1+\dfrac{1}{\color{DR}1+\frac{1}{\color{DB}1+\frac{1}{\varphi}}}} = \cdots
\end{align*}


Ainsi, en généralisant, on pourrait considérer que :
\[
\varphi = 1+\dfrac{1}{1+\dfrac{1}{1+\frac{1}{1+\frac{1}{1+\cdots}}}}
\]
Ce résultat se démontre, mais pas en classe de Seconde.

Pour calculer une valeur approchée de $\varphi$, on peut essayer de partir d'une variable \texttt{f} valant 1, puis faire une boucle dans laquelle \texttt{f} deviendra \texttt{1}+$\dfrac{1}{\texttt{f}}$.
\Par

\begin{algorithme}{}
Variables
  n est un nombre
  f est un nombre
Initialisation
  f prend la valeur 1
Début
  Pour n allant de 1 à 100
    f prend la valeur 1+1/f
  Fin Pour
  Afficher f
Fin
\end{algorithme}

\Par

Ici, nous avons souhaité répéter 100 fois l'instruction \og \texttt{f} devient \texttt{1}+$\dfrac{1}{\texttt{f}}$ \fg, mais on peut bien sûr changer cette valeur (100) et mettre 200, 300,...

\NathanLiveProg[]{}{}\vspace*{-2em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/IL2M/01-nombre-or.py}}}
\vspace*{-10pt}

\begin{listing}{En Python}{01-nombre-or.py}\end{listing}

\Par

En exécutant ce programme, la valeur affichée est :
\[
1,618034.
\]
\end{questions}
\end{corrige}



\thumb
\AfficheCorrige
