\thumb

%%% 01

\begin{qcm}{Savoir traduire un programme}{5} % titre , temps
\enlargethispage*{3em}
Pour chacune des questions suivantes, quatre propositions sont faites, mais une seule est correcte. Laquelle ?

\begin{questions}
\item \begin{listing}[language=fortran]{En Fortran}{06-01-01.txt}\end{listing}

\Par

Ce programme :

\begin{tabularx}{\linewidth}{@{}Zl@{~}X@{}}
\choix & convertit une température réelle exprimée en degrés Fahrenheit en degrés Centigrade; \\
\choix & convertit une température réelle exprimée en degrés Centigrade en Fahrenheit;\\
\choix & convertit une température entière exprimée en degrés Fahrenheit en degrés Centigrade;\\
\choix & convertit une température entière exprimée en degrés Centigrade en Fahrenheit.
\end{tabularx}

\item\resetchoix \begin{listing}[language=java]{En Java}{06-01-02.txt}\end{listing}

\Par

Ce programme:

\begin{tabularx}{\linewidth}{@{}Zl@{~}X@{}}
\choix & affiche l'antécédent de 4 par la fonction $x\mapsto3x+5$;\\
\choix & affiche l'image de 4 par la fonction $x\mapsto3x+5$;\\
\choix & affiche les antécédents de tous les entiers de l'intervalle $[4~;10]$ par la fonction $x\mapsto3x+5$;\\
\choix & affiche les images de tous les entiers de l'intervalle $[4~;10]$ par la fonction $x\mapsto3x+5$.
\end{tabularx}
\end{questions}
\end{qcm}

\begin{corrige}
\begin{questions}
\item Réponse \choix[c]. La déclaration \og \texttt{
integer :: ...} \fg{} permet d'affirmer que les variables sont entières et non réelles. Et en effectuant une recherche sur le Fortran, on peut en effet voir que déclarer une variable comme un nombre réel se fait par le type \og real \fg, et non \og integer \fg.

\item Réponse \choix[d]. La boucle \og while \fg{} montre que les instructions suivantes sont répétées tant que $x\leqslant10$ et dans la boucle, on voit que $x$ reçoit la valeur $x+1$ à chaque fois; donc les valeurs prises par $x$ sont : 4, 5, 6, 7, 8, 9 et 10. De plus, dans cette boucle, $y=3x+5$ donc $y$ représente l'image de $x$ par la fonction $x\mapsto3x+5$. Le programme affiche donc bien les images de toutes les valeurs entières de $x$ dans l'intervalle $[4~;10]$.
\end{questions}
\end{corrige}

%%% 02

\begin{vf}{Rédaction de programmes}{5} % titre , temps
\nathanliveVideo
\label{video:ch6programmeC}

\begin{listing}[language=C]{En C}{06-02.txt}\end{listing}

\Par

Ce programme est-il correctement écrit?
\end{vf}

\begin{corrige}
\rput(-0.5,0.1){\nathanliveVidWithoutText}
On peut remarquer que les variables $x$ et $y$ sont déclarées avec le type \og double \fg. Or, $y$ prend la valeur \texttt{convert(x)}, qui est une fonction de type \og int \fg; il y a donc ici une confusion de types.

Pour que le programme fonctionne, il faudrait déclarer la fonction ainsi : \og \texttt{double convert(x)} \fg.
\end{corrige}


\sectionnn{Interpréter un langage}

%%% 03

\begin{exo}{Programme en Java}{\null}{1}{5} 
\enlargethispage*{3em}
\begin{listing}[language=java]{En Java}{06-03.txt}\end{listing}

\Par

Que fait ce programme?
\end{exo}

\begin{corrige}
Ce programme est composé de deux parties :
\begin{itemize}
\item la première partie est \textit{a priori} la partie principale (le terme \og main \fg{} confirme que c'est le cas). Sont déclarées dans cette partie une table de valeurs\linebreak (12, $-5$, 7, ...) ainsi qu'une variable \texttt{elt} de type \textit{long}. La boucle \og for \fg{} parcourt le tableau de valeurs et teste si \texttt{elt} est égale à la valeur sur laquelle on est, auquel cas la boucle \og for \fg{} est rompue (\og break \fg) et la fonction \texttt{afficher} est appelée (fonction qui est hors de la boucle!);

\item la seconde partie est justement la définition de la fonction \texttt{afficher}, qui prend deux arguments : le premier est un entier de type \texttt{int}, le second un entier de type \texttt{long}. Cette fonction teste si le premier argument (\texttt{rang}) vaut 8 (dernier rang de la table), auquel cas cela signifie que l'argument \texttt{elt} n'est pas dans la table, et un message est affiché. Sinon, l'argument \texttt{elt} est trouvé et un message est affiché.
\end{itemize}
Finalement, ce programme affiche si un élément informé à l'avance est trouvé ou pas dans la table.
\newpage
\end{corrige}

%%% 04

\newpage
\begin{exo}{Programme PHP}{\null}{1}{10} 
\begin{listing}[language=php]{En PHP}{06-04.txt}\end{listing}

\Par

Que fait ce programme?
\end{exo}

\begin{corrige}
La 1\iere{} ligne du programme affecte une valeur à une variable texte; d'après le nom donné à la variable, il s'agit du chemin vers une image, donc d'un répertoire dans lequel se trouve une image.

La seconde ligne définit un tableau (\og array \fg) de 4 valeurs.

Ensuite, l'instruction \texttt{foreach} ressemble à \og for \fg{} : il s'agit alors d'une boucle. Son argument (\texttt{\$arr as \$value}) fait référence au tableau précédemment défini. On peut donc traduire cela par le fait que l'on va parcourir ce tableau et que chaque valeur sera désignée par la variable \texttt{\$value}.

L'instruction \texttt{echo} signifie que l'on affiche quelque chose. La suite ressemble à du HTML et la balise \texttt{<img src='...'>} nous dit que l'on affiche une image, donc le nom est le répertoire suivi de la valeur sur laquelle on est. Concrètement, le code HTML engendré par le programme PHP est :

\Par

\begin{tabular}{@{\qquad}>{\ttfamily}l}
<img src='/images/4.png'/>\\
<img src='/images/7.png'/>\\
<img src='/images/19.png'/>\\
<img src='/images/23.png'/>
\end{tabular}

\Par

Ce programme affiche donc 4 images.
\end{corrige}

%%% 05

\begin{exo}{Programme en C}{\null}{1}{10} 
\enlargethispage*{3em}
\nathanliveVideo
\label{video:ch6progCbis}

\begin{listing}[language=C]{En C}{06-05.txt}\end{listing}

\Par

Qu'affiche ce programme?
\end{exo}

\begin{corrige}
\rput(-0.5,0.1){\nathanliveVidWithoutText}
Ce programme est composé de 3 parties principales (hors en-tête):
\begin{itemize}
\item \textit{la partie main}, qui va exécuter le programme principal. On y déclare un tableau à 3 valeurs (8,4,6). On appelle ensuite les fonctions \texttt{tri} et \texttt{affiche};

\item \textit{la fonction \texttt{tri}}, qui prend pour arguments un entier $n$ et un tableau de valeurs. Dans cette fonction, on parcourt le tableau et on inverse l'ordre de deux valeurs consécutives si la première est supérieure à la seconde. Ainsi, cette fonction trie dans l'ordre croissant les valeurs du tableau;

\item \textit{la fonction \texttt{affiche}}, qui prend les mêmes arguments que la fonction précédente, et dans laquelle on parcourt le tableau pour en afficher les valeurs une à une.
\end{itemize}
Ce programme affiche donc le tableau de valeurs après avoir trié ces dernières dans l'ordre croissant.

\begin{Remarque}
la présence d'un astérisque après \texttt{int} signifie que la variable \texttt{table} \og pointe \fg{} vers un emplacement en mémoire contenant un entier (\texttt{int}) ou un tableau d'entiers. On appelle cela un \textit{pointeur}.
\end{Remarque}
\end{corrige}

%%% 06
\newpage
\begin{exo}{Un autre programme en PHP}{\null}{2}{5} 
\begin{listing}[language=php]{En PHP}{06-06.txt}\end{listing}

\Par

Que fait ce programme?
\end{exo}

\begin{corrige}
Cette façon d'écrire un programme n'est pas la plus naturelle que l'on puisse imaginer, mais c'est une syntaxe répandue de nos jours (on utilise ici une \textit{classe}... Nous n'en dirons pas plus car il faudrait faire tout un cours dessus). On peut tout de même tenter de comprendre ce que fait ce programme.

La présence d'accolades après \og class MaClasse \fg{} nous laisse à penser que ce qui suit est un groupe d'instructions, où \texttt{\$attribut} est une variable. On y définit ensuite une fonction \texttt{MaMethode()} qui affiche (\og echo \fg) une phrase : \og Bonjour \fg{} suivi de la valeur de la variable \texttt{\$attribut}.

En dehors de cette classe, il semblerait que la variable \texttt{\$attribut} prenne la valeur \og Gwendoline \fg.

\Par

Ce programme affiche donc : \og Bonjour Gwendoline. \fg.

\textit{Remarque :}  
on est d'accord qu'il y a bien plus simple pour afficher ce\linebreak résultat...
\end{corrige}


\sectionnn{\'Ecriture de programmes}

%%% 07

\begin{exo}{Prototyper une fonction}{\null}{1}{5} 
Dans chacun des cas suivants, prototyper les fonctions demandées. 
\begin{questions}
\item La fonction \texttt{convert} convertit une durée exprimée en minutes en une durée exprimée en heures et minutes. Elle affiche le résultat sous la forme \og ... h ... min \fg.

\item La fonction \texttt{FarToCel} convertit une température en degré Fahrenheit en degré Celsius. Elle renvoie le résultat sous forme de nombre.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item La fonction \texttt{convert} admet un argument : un entier (la durée en minutes). Le résultat est un texte. 

\item La fonction \texttt{FarToCel} admet un argument : un nombre réel (un flottant), et renvoie un nombre réel (un flottant).

En C, le prototype sera :


\Par

\qquad\texttt{double FarToCel(double temp);}
\end{questions}
\end{corrige}

%%% 08

\begin{exo}{Convertisseur de temps}{\null}{1}{15} 
\nathanliveVideo
\label{video:ch6convertisseurtemps}

\'Ecrire un programme dans le langage de votre choix ayant :
\begin{itemize}
\item une partie principale qui demande un temps (exprimé en minutes);
\item une fonction \texttt{convert1} qui convertit le temps saisi en temps exprimé en heures et minutes;
\item une fonction \texttt{convert2} qui convertit le temps saisi en temps exprimé en heure décimale (par exemple, 90 minutes est convertit en 1,5 heure).
\end{itemize}
\end{exo}

\begin{corrige}
\enlargethispage*{4em}
\begin{listing}{En Python}{06-11-01.py}\end{listing}

\rput(-0.4,7.1){\nathanliveProgWithoutText}
\newpage

\begin{listing}[language=C]{En C}{06-11-02.c}\end{listing}

\begin{listing}[language=php]{En PHP}{06-11-03.php}\end{listing}
\end{corrige}

%%% 09

\begin{exo}{Modularisation}{\null}{3}{60} 
\nathanliveVideo
\label{video:ch6modularisation}

\'Ecrire un programme en Python répondant au cahier des charges suivant :
\begin{itemize}
\item saisir deux nombres entiers nommés $a$ et $b$ (si les nombres entrés ne sont pas entiers, demander à nouveau leurs saisies);

\item créer une fonction \texttt{pgcd(a,b)} qui renvoie le pgcd des deux arguments;

\item créer une fonction \texttt{simplify(a,b)} qui retourne (sous forme de tableau) la simplification de la fraction $\dfrac{a}{b}$, simplification obtenue à l'aide de la fonction \texttt{pgcd};

\item créer une fonction \texttt{listprimes} qui renvoie un tableau contenant tous les nombres premiers jusqu'à \texttt{max(a,b)};

\item créer une fonction \texttt{decomp(n)} qui décompose en produits de facteurs premiers l'argument et qui retourne le résultat sous forme d'un dictionnaire (en faisant appel à la fonction \texttt{listprimes});

\item créer une fonction \texttt{ppcm(a,b)} qui renvoie le plus petit multiple commun des deux arguments;

\item affiche la fraction simplifiée $\dfrac{a}{b}$ et $\text{ppcm}(a,b)$.
\end{itemize}

Pour cela, on s'appuiera sur les résultats mathématiques suivants :
\begin{itemize}
\item un nombre $n$ est premier s'il n'admet aucun diviseur autre que 1 et lui-même;
\item la décomposition en produit de facteurs premiers d'un nombre $n$ est de la forme :
\[
n = p_1^{n_1} \times p_2^{n_2} \times \cdots \times p_k^{n_k}
\]
où les $p_i$ sont des nombres premiers et les $n_i$, des nombres entiers;
\item le ppcm de deux nombres s'obtient à l'aide de leur décomposition en produit de facteurs premiers. Par exemple, $78=2\times3\times13$ et $45=2\times3^2\times5$ donc $\text{ppcm}(78,45)=2\times3^2\times5\times13$ (on prend tous les facteurs premiers avec l'exposant le plus grand).
\end{itemize}
\end{exo}

\begin{corrige}
\rput(-0.5,0.1){\nathanliveVidWithoutText}
Dans cet exercice, on voit l'importance de la modularisation d'un programme, c'est-à-dire la présence de plusieurs fonctions. Cela permet de rendre plus lisible le programme, mais surtout de rendre plus pratique leur appel, surtout si on doit appeler une fonction plusieurs fois.\enlargethispage*{3em}


\begin{listing}{}{06-12-01.txt}\nathanliveProgWithoutText\end{listing}

\newpage
\enlargethispage*{\baselineskip}

\begin{listing}{}{06-12-02.txt}\end{listing}

\begin{Remarque}
pour la fonction \texttt{ppcm}, on s'appuie sur la définition brute, ce qui rend le code assez compliqué. Mais il existe en mathématiques un résultat très intéressant qui stipule que $\text{ppcm}(a,b)=\dfrac{ab}{\text{pgcd}(a,b)}$.

Ainsi, notre fonction aurait pu s'écrire :

\Par

\qquad\texttt{def ppcm(a,b): return a*b/pgcd(a,b)}

\Par

D'où l'importance des théorèmes mathématiques : ils peuvent simplifier\linebreak certains codes...
\end{Remarque}
\end{corrige}




\thumb
\AfficheCorrige
