\element{Adresse} {
	\begin{questionmult}{changement de valeur d'une variable}
		Comment peut-on changer la valeur d'une variable à l'aide d'une fonction ?
		\begin{reponses}
			\bonne{En passant l'adresse de la variable en question
					en argument de la fonction.}
			\mauvaise{En passant la variable en question en argument de la fonction.}
			\bonne{En passant la variable en question ainsi que son adresse
						en argument de la fonction.}
			\mauvaise{On ne peut pas faire cela en C.}
		\end{reponses}
	\end{questionmult}
}

\begin{myverbbox}{\EchangeUn}
void echange(int* a, int* b){
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

\end{myverbbox}

\begin{myverbbox}{\EchangeDeux}
void echange(int* a, int* b){
    int* tmp;
    tmp = a;
    *a = *b;
    *b = *tmp;
}

\end{myverbbox}

\begin{myverbbox}{\EchangeTrois}
void echange(int a, int b){
    int tmp = a;
    a = b;
    b = tmp;
}

\end{myverbbox}

\begin{myverbbox}{\EchangeQuatre}
void echange(int* a, int* b){
    int tmp = &a;
    &a = &b;
    &b = tmp;
}

\end{myverbbox}

\begin{myverbbox}{\EchangeCinq}
void echange(int* a, int* b){
    int* tmp = &a;
    &a = &b;
    &b = &tmp;
}

\end{myverbbox}

\element{Adresse} {
	\begin{questionmult}{Echange de variables}
		Parmi les fonctions suivantes, quelles sont celles qui réalisent
		un échange des variables passées en paramètres ?
		\begin{multicols}{2}
			\begin{reponses}
				\bonne		{	\begin{minipage}[c]{4cm}
									\EchangeUn
								\end{minipage}
							}
				\bonne		{	\begin{minipage}[c]{4cm}
									\EchangeDeux
								\end{minipage}
							}
				\mauvaise	{	\begin{minipage}[c]{4cm}
									\EchangeTrois
								\end{minipage}	
							}
				\mauvaise	{	\begin{minipage}[c]{4cm}
									\EchangeQuatre
								\end{minipage}
							}
				\mauvaise	{	\begin{minipage}[c]{4cm}
									\EchangeCinq
								\end{minipage}
							}
			\end{reponses}
		\end{multicols}
	\end{questionmult}
}

\begin{myverbbox}{\CodeAvecAdresse}
/*01*/#include <stdio.h>
/*02*/
/*03*/void echange(int* a, int* b){
/*04*/    int tmp = *a;
/*05*/    *a = *b;
/*06*/    *b = tmp;
/*07*/}
/*08*/
/*09*/int main(void){
/*10*/    int a, b;
/*11*/    printf("Donnez moi deux entiers, svp : ");
/*12*/    scanf("%d%d", &a, &b);
/*13*/    printf("Avant l'appel de la fonction echange, a et b valent : %d et %d\n",
				a, b);
/*14*/    echange(&a, &b);
/*15*/    printf("Après l'appel de la fonction echange, a et b valent : %d et %d\n", 
				a, b);
/*18*/}
\end{myverbbox}

\element{Utilisation de pointeurs} {
	\begin{questionmult}{Declaration de variable}
		Considérons le programme suivant :
		\begin{center}
			\CodeAvecAdresse
		\end{center}
		Parmi les affirmations suivantes, lesquelles sont exactes ?
		\begin{reponses}
			\mauvaise{La fonction {\tt echange} prend des entiers en paramètres}
			\bonne{La fonction {\tt echange} prend des adresses en paramètres}
			\mauvaise{La fonction {\tt scanf} prend une chaine de caractères, puis
						une ou des variables de type {\tt int} en paramètres}
			\bonne{La fonction {\tt scanf} prend une chaine de caractères, puis
						des adresses en paramètres}
			\bonne{La ligne 14 ne provoque pas d'erreur de compilation.}		
			\mauvaise{La ligne 14 provoque une erreur de compilation.}		
		\end{reponses}
	\end{questionmult}
}

\begin{myverbbox}{\ComprehensionDeCodeUn}
#include <stdio.h>

int main(void){
    int i;
    int n = 5;
    for (i = 0; i < n; i = i + 1) {
        printf("%d\t", i);
        if (i % 2 == 0)
            printf("\n %d", i);
    }
}
\end{myverbbox}

\begin{myverbbox}{\ResultatUn}
0    1    2    3    4
0    2    4

\end{myverbbox}

\begin{myverbbox}{\ResultatDeux}
0	
0    1    2
2    3    4
4

\end{myverbbox}

\begin{myverbbox}{\ResultatTrois}
0	
0    1    2
2    3    4
4    5

\end{myverbbox}

\begin{myverbbox}{\ResultatQuatre}
0    0	
1    2    2
3    4

\end{myverbbox}

\begin{myverbbox}{\ResultatCinq}
0    0	
1    2    2
3    4    4

\end{myverbbox}

\element{Comprehension de code} {
	\begin{question}{Comprehension de code 1}
		Quel est le rendu lors de l'exécution du programme suivant ?
		\begin{center}
			\ComprehensionDeCodeUn
		\end{center}
		\begin{multicols}{3}
			\begin{reponses}
				\mauvaise	{	\begin{minipage}{3cm}
									\ResultatUn
								\end{minipage}
						}
				\bonne	{	\begin{minipage}{3cm}
									\ResultatDeux
								\end{minipage}
						}
				\mauvaise	{	\begin{minipage}{3cm}
								\ResultatTrois
							\end{minipage}
						}
				\mauvaise	{	\begin{minipage}{3cm}
									\ResultatQuatre
								\end{minipage}
						}
				\mauvaise	{	\begin{minipage}{3cm}
									\ResultatCinq
								\end{minipage}
						}
			\end{reponses}
		\end{multicols}
	\end{question}
}

\begin{myverbbox}{\ComprehensionDeCodeDeux}
#include <stdio.h>

int main(void){
    int i;
    int n = 5;
    for (i = 0; i < n/2; i=i+1) {
        if (i * i > n)
            printf("%d ", i);
    }
}
\end{myverbbox}

\element{Comprehension de code} {
	\begin{question}{Comprehension de code 2}
		Quel est le rendu lors de l'exécution du programme suivant ?
		\begin{center}
			\ComprehensionDeCodeDeux
		\end{center}
		\begin{multicols}{2}
			\begin{reponses}
				\bonne{Le programme n'affiche rien}
				\mauvaise{{\tt 2}}
				\mauvaise{{\tt 1 2}}
				\mauvaise{{\tt 0 1 2}}
				\mauvaise{{\tt 0 1}}
				\mauvaise{{\tt 1}}
			\end{reponses}
		\end{multicols}
	\end{question}
}

\begin{myverbbox}{\ComprehensionDeCodeTrois}
#include <stdio.h>

int main(void){
    int i;
    int n = 5;
    for (i = 0; i < n/2; i=i+1) {
        if (i * i <= n)
            printf("%d ", i);
    }
}
\end{myverbbox}

\element{Comprehension de code} {
	\begin{question}{Comprehension de code 3}
		Quel est le rendu lors de l'exécution du programme suivant ?
		\begin{center}
			\ComprehensionDeCodeTrois
		\end{center}
		\begin{multicols}{2}
			\begin{reponses}
				\mauvaise{Le programme n'affiche rien}
				\mauvaise{{\tt 2}}
				\mauvaise{{\tt 1 2}}
				\bonne{{\tt 0 1}}
				\mauvaise{{\tt 0 1 2}}
				\mauvaise{{\tt 1}}
			\end{reponses}
		\end{multicols}
	\end{question}
}

\begin{myverbbox}{\ComprehensionDeCodeQuatre}
#include <stdio.h>

int main(void){
    int i;
    int n = 4;
    for (i = 0; i < n/2; i=i+1) {
        if (i * i >= n)
            printf("%d ", i);
    }
}
\end{myverbbox}

\element{Comprehension de code} {
	\begin{question}{Comprehension de code 4}
		Quel est le rendu lors de l'exécution du programme suivant ?
		\begin{center}
			\ComprehensionDeCodeQuatre
		\end{center}
		\begin{multicols}{2}
			\begin{reponses}
				\bonne{Le programme n'affiche rien}
				\mauvaise{{\tt 2}}
				\mauvaise{{\tt 1 2}}
				\mauvaise{{\tt 0 1}}
				\mauvaise{{\tt 0 1 2}}
				\mauvaise{{\tt 1}}
			\end{reponses}
		\end{multicols}
	\end{question}
}


\begin{myverbbox}{\ErreurSyntaxeUn}
#include <stdio.h>

int main(void) {
    int i;
    for(i=0; i<3; i+=1)
       printf("%d",i);
    return 0
}
\end{myverbbox}

\element{QCM Deux erreur de syntaxe} {
	\begin{question}{erreur de syntaxe 2 V1}
		Le fichier {\tt .c} suivant contient potentiellement des erreurs de syntaxes. 
		\begin{center}
			\ErreurSyntaxeUn
		\end{center}
		Combien y en a t-il ?
		\begin{reponseshoriz}
			\mauvaise{0}
			\bonne{1}
			\mauvaise{2}
			\mauvaise{3}
		\end{reponseshoriz}
	\end{question}
}

\begin{myverbbox}{\ErreurSyntaxeTrois}
#include <stdio.h>

int main(void) {
    int i;
    for(i=0, i==3; i+=1)
       printf("%d",i);
    return 0
}
\end{myverbbox}

\element{QCM Deux erreur de syntaxe} {
	\begin{question}{erreur de syntaxe 2 V2}
		Le fichier {\tt .c} suivant contient potentiellement des erreurs de syntaxes. 
		\begin{center}
			\ErreurSyntaxeTrois
		\end{center}
		Combien y en a t-il ?
		\begin{reponseshoriz}
			\mauvaise{0}
			\mauvaise{1}
			\bonne{2}
			\mauvaise{3}
		\end{reponseshoriz}
	\end{question}
}

\begin{myverbbox}{\ErreurSyntaxeQuatre}
#include <stdio.h>

int main(void) {
    int i=10;
    for(i=0; i==3, i+=1)
       printf(i);
    return 0;
}
\end{myverbbox}

\element{QCM Deux erreur de syntaxe} {
	\begin{question}{erreur de syntaxe 2 V3}
		Le fichier {\tt .c} suivant contient potentiellement des erreurs de syntaxes. 
		\begin{center}
			\ErreurSyntaxeQuatre
		\end{center}
		Combien y en a t-il ?
		\begin{reponseshoriz}
			\mauvaise{0}
			\mauvaise{1}
			\bonne{2}
			\mauvaise{3}
		\end{reponseshoriz}
	\end{question}
}

\element{Syntaxe C} {
	\begin{questionmult}{for 1}
		La parenthèse suivant un {\tt for}
		\begin{reponses}
			\bonne{contient obligatoirement et exactement
						2 points virgules ({\tt ;}) }
			\mauvaise{peut-être laissée vide}
			\mauvaise{contient obligatoirement et exactement
						3 points virgules ({\tt ;})}
			\bonne{peut contenir des expressions vides}
		\end{reponses}
	\end{questionmult}
}

\element{Syntaxe C} {
	\begin{question}{for 2}
		La condition d'une boucle {\tt for} est :
		\begin{reponses}
			\mauvaise{testée juste après l'exécution du bloc}
			\mauvaise{toujours testée juste après l'évaluation de l'expression 
						d'incrémentation}
			\bonne{testée juste avant l'exécution du bloc}
			\mauvaise{toujours testée une seule fois}
		\end{reponses}
	\end{question}
}

\element{Syntaxe C} {
	\begin{questionmult}{boucle infinie}
		On peut écrire une boucle infinie avec:
		\begin{multicols}{2}
			\begin{reponses}
				\bonne{une boucle {\tt for}}
				\bonne{une boucle {\tt while}}
				\bonne{une boucle {\tt do while}}
				\mauvaise{impossible en C}
			\end{reponses}
		\end{multicols}
	\end{questionmult}
}

\element{Syntaxe C} {
	\begin{question}{condition}
		L'instruction (ou le bloc) d'une boucle est exécutée lorsque la condition est
		$\ldots$ 
		\begin{reponseshoriz}
			\bonne{$\ldots$ vraie}
			\mauvaise{$\ldots$ fausse}
		    \mauvaise{$\ldots$ évaluée pour la deuxième fois}
		\end{reponseshoriz}
	\end{question}
}

\element{Break} {
	\begin{question}{break dans un switch}
		A quoi sert un {{\tt break}} dans un {{\tt switch}} ?
		\begin{multicols}{2}
			\begin{reponses}
				\mauvaise{\`a sortir du programme}
				\bonne{\`a sortir du {\tt switch}}
				\mauvaise{\`a passer au test suivant}
				\mauvaise{\`a décider du vainqueur}
			\end{reponses}
		\end{multicols}
	\end{question}
}


\begin{myverbbox}{\resultatBoucleUn}
#include <stdio.h>

int main(void){
   int a = 2;
   for(a=0;a<10;a+=1)
      printf("+");   
   printf("\n");
   return 0;
}
\end{myverbbox}

\element{resultboucle} {
	\begin{question}{resultatboucle V1}
	Qu'affiche le programme suivant ?\\
		\begin{center}
			\resultatBoucleUn
		\end{center}
		\begin{multicols}{2}
			\begin{reponses}
			  \mauvaise{9 fois le caractère+ sur une seule ligne}
			  \bonne{10 fois le caractère + sur une seule ligne}
			  \mauvaise{10 lignes contenant chacune le caractère +}
			  \mauvaise{rien}
			  \mauvaise{11 fois le caractère+ sur une seule ligne}
            	  \mauvaise{11 lignes contenant chacune le caractère +}
			\end{reponses}
		\end{multicols}
	\end{question}
}
\begin{myverbbox}{\resultatBoucleDeux}
#include <stdio.h>

int main(void){
   int a = 2;
   for(a=0;a<10;a+=1){
      printf("+");   
      printf("\n");
   }
   return 0;
}
\end{myverbbox}

\element{resultboucle} {
	\begin{question}{resultatBoucle V2}
	Qu'affiche le programme suivant ?\\
		\begin{center}
			\resultatBoucleDeux
		\end{center}
		\begin{multicols}{2}
			\begin{reponses}
				\mauvaise{9 fois le caractère+ sur une seule ligne}
				\mauvaise{10 fois le caractère + sur une seule ligne}
				\bonne{10 lignes contenant chacune le caractère +}
				\mauvaise{rien}
				\mauvaise{11 fois le caractère + sur une seule ligne}
        			\mauvaise{11 lignes contenant chacune le caractère +}
			\end{reponses}
		\end{multicols}
	\end{question}
}
\begin{myverbbox}{\resultatBoucleTrois}
#include <stdio.h>

int main(void){
   int a = 2;
   for(a=0;a<5;a+=1)
      printf("+\n+\n");   
   printf("+\n");
   return 0;
}      
\end{myverbbox}

\element{resultboucle} {
	\begin{question}{resultatboucle V3}
	Qu'affiche le programme suivant ?\\
		\begin{center}
			\resultatBoucleTrois
		\end{center}
		\begin{multicols}{2}
			\begin{reponses}
				\mauvaise{8 fois le caractère +, sur une seule ligne}
				\mauvaise{10 fois le caractère +, sur une seule ligne}
				\mauvaise{10 lignes contenant chacune le caractère +}
				\mauvaise{Rien}
				\mauvaise{11 fois le caractère +, sur une seule ligne}
        	        \bonne{11 lignes contenant chacune le caractère +}
			\end{reponses}
		\end{multicols}
	\end{question}
}

\begin{myverbbox}{\BoucleWhile}
int main(){
  int n = 10, m = 0;
  while(n >= 0 && m <= n){
    if(n%2 == 0)
      n = n/2;
    else{
      n = n-1; m = m+1;
    }
  }
  printf("%d et %d\n", n, m);
  return 0;
}
\end{myverbbox}

\begin{myverbbox}{\BoucleDoWhile}
int main(){
  int n = 10, m = 0;
  do{
    m = m+1;
    n = n-1;
  }while(m < n);
  printf("%d et %d\n", n, m);
  return 0;
}
\end{myverbbox}

\begin{myverbbox}{\BoucleFor}
int main(){
  int i;
  int somme = 0;
  for(i = 0; i < 10; i++){
  	if(i%2 != 0)
  	somme = somme + i;
  }
  printf("%d", somme);
  return 0;
}
\end{myverbbox}

\element{boucles}{
	\begin{question}{boucle while}
	Qu'affiche le programme?
	\begin{center}
			\BoucleWhile
		\end{center}
		\begin{reponseshoriz}
			\bonne{{\tt 0 et 2}}
			\mauvaise{{\tt 5 et 6}}
			\mauvaise{{\tt 2 et 1}}		
			\mauvaise{{\tt 1 et 1}}
		\end{reponseshoriz}
	\end{question}
}

\element{boucles}{
	\begin{question}{boucle dowhile}
	Qu'affiche le programme?
	\begin{center}
			\BoucleDoWhile
		\end{center}
		\begin{reponseshoriz}
			\bonne{{\tt 5 et 5}}
			\mauvaise{{\tt 4 et 6}}
			\mauvaise{{\tt 6 et 4}}		
			\mauvaise{{\tt 5 et 4}}
		\end{reponseshoriz}
	\end{question}
}

\element{boucles}{
	\begin{question}{boucle for}
	Qu'affiche le programme?
	\begin{center}
			\BoucleFor
		\end{center}
		\begin{reponseshoriz}
		\bonne{{\tt 25}}
		\mauvaise{{\tt 45}}
		\mauvaise{{\tt 30}}		
		\mauvaise{{\tt 20}}
		\end{reponseshoriz}
	\end{question}
}

\element{fonction} {
	\begin{questionmult}{en-tete fonction}
          On souhaite définir une fonction stockant deux entiers saisis par
          l'utilisateur. Quelle sont les en-têtes possibles de cette fonction ?
          \begin{reponses}
			\bonne{{\tt void saisirDeuxEntiers(int *n, int *m)}}
			\mauvaise{{\tt void saisirDeuxEntiers(int n, int m)}}
			\bonne{{\tt int saisirDeuxEntiers(int *n, int *m)}}
			\mauvaise{{\tt int saisirDeuxEntiers(int n, int m)}}
			\mauvaise{{\tt int, int saisirDeuxEntiers(int *n, int *m)}}
			\mauvaise{{\tt int, int saisirDeuxEntiers(int n, int m)}}
		\end{reponses}
	\end{questionmult}
}

\element{fonction} {
	\begin{questionmult}{appel fonction}
          On suppose que {\tt n} et {\tt m} sont deux variables de type {\tt int}
          et que l'on se donne des fonctions dont les en-têtes
          sont {\tt void f(int a, int *b)} et {\tt int g(int c)}.
          Parmi les instructions suivantes, lesquelles sont correctes ?
          \begin{multicols}{3}
          	\begin{reponses}
				\mauvaise{{\tt n = f(0, m)}}
				\mauvaise{{\tt n+m = g(m)}}
				\bonne{{\tt f(n, \&m)}}
				\mauvaise{{\tt f(\&n, m)}}
				\bonne{{\tt f(g(n), \&m)}}
				\mauvaise{{\tt f(n, *m)}}
			\end{reponses}
		\end{multicols}
	\end{questionmult}
}