\documentclass[10pt,french]{article}

% Packages
\usepackage{fullpage}
\usepackage{multicol}
\usepackage{babel}
\usepackage[latin1]{inputenc}

\newcounter{numeroquestion}

\def\Exo{\addtocounter{numeroquestion}{1}
     {\mbox{}\\\bf Exercice \arabic{numeroquestion} :}\ }

\pagestyle{plain}

\begin{document}

\begin{center}
{\huge IF122 : Contrôle intermédiaire}
\end{center}

Chaque exercice est noté sur 4. Il est donc fortement conseillé de ne
faire que 5 exercices et de les faire bien que de faire 6 exercices et de les
faire mal.\\
Les fonctions récursives doivent respecter les contraintes données en TD/TP.

\Exo{\tt Vu en TD/TP...}\\
Soit le type suivant:
\begin{verbatim}
typedef struct {
  int taille;
  float *contenu;
} Tableau;
\end{verbatim}
\'Ecrire la fonction concaténant deux tableaux (on supposera l'existence d'une
fonction capable de créer un tableau dont le prototype est : {\tt Tableau
creer\_tableau(int taille);}).

\Exo {\tt Les variables (1)}\\
Identifier toutes les déclarations de variable et indiquer leurs
caractéristiques:
\begin{itemize}
\item locale, globale, argument;
\item passage par valeur, par référence, ne s'applique pas à ce type de
variable; 
\item statique, non statique, ne s'applique pas à ce type de variable.
\end{itemize}

\begin{verbatim}
static int v = 1;
int w = 0;

int f(int v) {
  v=v+1;
  return v;
}
int g() {
  v++;
  return v-1;
}
int h(int &v) {
  v = v - w;
  return v;
}
int i(int w) {
  static int v = 10;
  w = v+1;
  return v;
}
int j(int v) {
  return f(v)+1;
}
\end{verbatim}

\Exo {\tt Les variables (2)}\\
Les fonctions précédentes sont utilisées dans le programme suivant. Donner
l'affichage obtenu:
\begin{verbatim} 
int main() {
  int w = 5;
  cout << v;
  cout << w;
  cout << f(v);
  cout << g();
  cout << i(v);
  cout << j(5);
  cout << h(v);
  cout << i(2);
}
\end{verbatim} 

\Exo {\tt Les pointeurs}\\
Commenter TOUTES les lignes du programme suivant et identifier les éventuelles
erreurs:
\begin{verbatim}
#include<iostream>
int main() {
  int *pe1 = new int[5];
  int **pe2 = new (int*)[6];

  pe2[0] = pe1;
 
  for(int i = 0; i < 6; i++) {
    cin >> pe1[i];
  }
  for(int i = 0; i < 6; i++) {
    cout << pe2[0][i];
  }
}
\end{verbatim}

\Exo {\tt Liste et récursivité (1)}\\
Le but de cet exercice est de gérer des listes triées (par ordre croissant).
Nous allons donc écrire une nouvelle fonction de construction dont l'objectif
est d'insérer un élément dans une liste triée de manière à obtenir une nouvelle
liste triée. Nous appellerons cette fonction {\tt cons\_sorted}.
\begin{itemize}
\item Quelle est la liste triée la plus simple dans laquelle on peut ajouter un
nouvel élément ?
\item Dans quelle situation doit-on insérer l'élément en tête de la liste ?
\item Quel est l'appel récursif à effectuer si l'élément ne doit pas être inséré
en tête de la liste ?
\item \'Ecrire la fonction complète.
\end{itemize}

\Exo {\tt Liste et récursivité (2)}\\
Le but de cet exercice est de déterminer si un élément se trouve dans une liste
triée, et si c'est le cas, de renvoyer la sous-liste à partir de laquelle se
trouve l'élément. Si l'élément n'est pas dans la liste, la liste vide est
renvoyée. Exemple : search\_sorted(4, (2,3,4,7)) nous renvoie (4,7).
\begin{itemize}
\item Quelle est la liste triée la plus simple pour laquelle on sait qu'on ne
pourra pas trouver l'élément recherché ?
\item La liste étant triée, à partir de quel moment sait-on que l'élément
recherché ne pourra pas être trouvé dans la suite de la liste ?
\item Dans quel cas a-t-on trouvé l'élément recherché ?
\item \'Ecrire la fonction complète.
\end{itemize}

\end{document}
