\documentclass[10pt]{article}

% Packages
\usepackage{fullpage}
\usepackage{multicol}
\setlength{\textheight}{24.1cm}

% Titre
\title{TD-1 Rappels\\ Enumerations, Structures, Tableaux, Chaines de
Caract\`eres} \date{Ann\'ee 2002} \author{}
\pagestyle{plain}

\begin{document}

\maketitle

{ \bf Les \'Enum\'erations }\\

En $C++$, on peut enrichir les types de base (entiers, r\'eels,
caract\`eres \dots) en d\'efinissant des types compos\'es.  Une
premi\`ere possibilit\'e est d'utiliser l'\'enum\'eration qui
introduit des constantes particuli\`eres.
\begin{verbatim}
#include<iostream>
typedef enum mouvement {monte,descend};
int main(){
int i;
mouvement cabine_mvt=??;
if (cabine_mvt==monte) cout << ``elle monte''
   else cout << ``elle descend''
}
\end{verbatim}
{\tt monte} et {\tt descend} sont alors des constantes du langage et
sont des entit\'es de type {\tt mouvement}.\\


{ \bf Les Structures }\\

Une seconde extension des types de base est construite sur les
structures, par exemple, pour d\'efinir dans le programme principal une
cabine $c$ de couleur jaune et qui monte, on pourra \'ecrire:
\begin{verbatim}
#include<iostream>
typedef enum mouvement {monte, descend};
typedef enum couleur {bleu,jaune,rouge};

typedef struct cabine {
  mouvement sens;
  couleur aspect;
};
int main(){
 cabine c;
 c.sens=monte;
 c.aspect=jaune;
}
\end{verbatim}

{\bf Les Tableaux}\\

Ils permettent de regrouper en une seule entit\'e des donn\'ees de
type identique, y compris des structures ou des \'enum\'erations.

\begin{verbatim}
#include<iostream>
#include<cstdlib>
#include<ctime>

const int dim = 10;
typedef enum couleur {bleu,jaune,rouge};
typedef couleur flash[dim];

int main(){
 flash t;
 int i;

 srand(time(NULL));

 for(i=0;i<dim;i++) {
   switch (rand() % 3){
     case 0 : flash[i]=bleu;break;
     case 1 : flash[i]=jaune;break;
     default: flash[i]=rouge;
   }
 }
} 
\end{verbatim}
Remarquez que la num\'erotation des cases du tableau va de 0 \`a 9,
(ce qui fait 10 \'elements). Lorsque les tableaux sont pass\'es en
param\`etre \`a une fonction ou une proc\'edure, ils le sont toujours
par r\'ef\'erence (on en verra l'explication dans quelques cours avec
les pointeurs).

\underline{Compl\'ements :} Pour g\'en\'erer un entier al\'eatoirement
on peut utiliser la fonction {\bf rand()}. Pour restreindre cet entier
par exemple dans l'intervalle $[0..9]$, il suffit de prendre son reste
modulo 10 : {\bf $x=132 ~\% ~10$} est \'equivalent \`a {\bf $x=2$}.\\
Pour que le g\'en\'erateur de nombres al\'eatoires donne des
r\'esultats diff\'erents pour deux ex\'ecutions diff\'erentes, il faut
\^etre capable de l'initialiser diff\'erement entre deux
ex\'ecutions. Pour cela une possibilit\'e est de l'initialiser en
fonction de l'heure courante. Cela peut \^etre fait au debut du
programme principal en invoquant la proc\'edure {\bf
srand(time(NULL))}. {\bf rand} et {\bf srand} sont d\'efinies dans le
fichier ent\^ete {\bf cstdlib}, et {\bf time} dans le fichier ent\^ete
{\bf ctime} qu'il ne faut pas oublier d'inclure au debut du programme.


\begin{description}
\item [Exercice 1~(TD)]: D\'efinir un type carte bleue qui contienne
un champ {\bf montant} qui mod\'elise l'argent disponible, un champ
{\bf code} qui contienne le code secret, un champ {\bf type\_carte}
qui sera soit visa, soit mastercard.

\item [Exercice 2~(TD)]: Donner une structure de donn\'ees qui
permette de repr\'esenter un jeu de 32 cartes complet.

\item [Exercice 3~(TD-TP)]: Ecrire une fonction qui donne la valeur
d'une carte \`a la belote. (Attention il y a un atout). La
correspondance des valeurs est donn\'ee par le tableau :\\

\begin{tabular}{|l|l|l|l|l|l|l|l|l|}
\hline
carte    & 7 & 8 & 9 & 10 & valet & dame & roi & as \\
\hline
standard & 0 & 0 & 0 & 10 & 2 & 3 & 4 & 11\\
\hline
atout	 & 0 & 0 & 14& 10 & 20 & 3 & 4 & 11\\
\hline
\end{tabular}

\end{description}

{\bf Les Chaines de caract\`eres} \\

Une chaine de caract\`ere est constitu\'ee d'une suite de
caract\`eres. Ceux--ci sont repr\'esent\'es en interne par des codes d\'efinis
par la norme ASCII ({\em American Standard for Information
Interchange}). A titre d'information on a la correspondance ~: {\tiny
\begin{verbatim}
  0 NUL  1 SOH  2 STX  3 ETX  4 EOT  5 ENQ  6 ACK  7 BEL
  8 BS   9 HT  10 NL  11 VT  12 NP  13 CR  14 SO  15 SI
 16 DLE 17 DC1 18 DC2 19 DC3 20 DC4 21 NAK 22 SYN 23 ETB
 24 CAN 25 EM  26 SUB 27 ESC 28 FS  29 GS  30 RS  31 US
 32 SP  33 !   34 "   35 #   36 $   37 %   38 &   39 '
 40 (   41 )   42 *   43 +   44 ,   45 -   46 .   47 /
 48 0   49 1   50 2   51 3   52 4   53 5   54 6   55 7
 56 8   57 9   58 :   59 ;   60 <   61 =   62 >   63 ?
 64 @   65 A   66 B   67 C   68 D   69 E   70 F   71 G
 72 H   73 I   74 J   75 K   76 L   77 M   78 N   79 O
 80 P   81 Q   82 R   83 S   84 T   85 U   86 V   87 W
 88 X   89 Y   90 Z   91 [   92 \   93 ]   94 ^   95 _
 96 `   97 a   98 b   99 c  100 d  101 e  102 f  103 g
104 h  105 i  106 j  107 k  108 l  109 m  110 n  111 o
112 p  113 q  114 r  115 s  116 t  117 u  118 v  119 w
120 x  121 y  122 z  123 {  124 |  125 }  126 ~  127 DEL
\end{verbatim} %$
}

Par exemple le code de 'A' est 65. Cela explique que l'on puisse faire
sur les caract\`ere certaines op\'erations comme on le fait pour les
entiers : 'A' + 32 c'est 'a', ou bien qu'on puisse tester si 'A'
$\leq$ 'a'.

Le type caract\`ere en C est traduit par {\tt char}, le type
cha\^{\i}ne de caract\`ere est {\tt string}. Ce dernier est d\'efini
dans le fichier ent\^ete \verb+<string>+

Par exemple {\tt "une cha\^{\i}ne"} est une cha\^{\i}ne de type {\tt
string}. Les cha\^{\i}nes sont munies des op\'erations suivantes :

\begin{itemize}
	\item la concat\'enation~: {\tt "c" + s1} qui retourne une cha\^{\i}ne
	\item {\tt s.length()} qui retourne la longueur de {\tt s}
	\item le test du vide de la cha\^{\i}ne est fait par~: {\tt s.empty()}
	\item le $n$-\`eme caract\`ere est donn\'e par~: {\tt s[n-1]}.
	\item pour extraire une sous-cha\^{\i}ne~: {\tt s.substr(position,longueur)}
	\item ins\'erer une cha\^{\i}ne~: {\tt s.insert(position,s1)}
\end{itemize}

Attention, comme pour les tableaux, les positions utilis\'ees dans une
cha\^{\i}ne de caract\`eres ne doivent pas d\'epasser la longueur de
la cha\^{\i}ne~! Par contre il est \`a noter que le passage des {\tt
string} en param\`etre est libre soit par {\tt valeur} soit par {\tt
r\'ef\'erence}, il ne s'agit donc pas d'un tableau de caract\`eres que
l'on aurait maquill\'e!

On peut remarquer la fa\c{c}on dont on invoque les ``fonctions d'un
objet'' de type {\tt string}.

\begin{description}
\item [Exercice 4~(TD)]: Ex\'ecuter \`a la main les lignes suivantes
\begin{verbatim}
 string s;
 bool b;
 int k;
 ...
 s = "Bonjour";
 s = s + " tout le monde !";
 cout << s << " contient " << s.length() << " caracteres"
 b = s.empty();
 cout << s[4];
 cout << s.substr(3,6);
 s.insert(1,"- ");
\end{verbatim}

\item [Exercice 5~(TP)]: Ecrire une fonction qui prend comme
param\`etre un caract\`ere et renvoie le caract\`ere majuscule s'il
s'agit d'une lettre ou le caract\`ere initial sinon.  Ecrire une
proc\'edure qui transforme, dans une cha\^{i}ne, tout caract\`ere
minuscule en majuscule.


\item [Exercice 6~(TP)]: Ecrire un programme qui transforme une
cha\^{\i}ne de caract\`eres en un palindrome.

Par exemple~: {\tt taratata} sera transform\'ee en {\tt
taratataatatarat}\\

{\bf Exercices compl\'ementaires }\\
\item [Exercice 7~] : On peut remarquer que le plus petit palindrome
qui \'etend {\tt abb} est {\tt abba}. On veut \'ecrire un programme
qui transforme une cha\^{\i}ne de caract\`eres en plus petit palindrome
qui l'\'etend. Pour cela :
 \begin{itemize}
	\item \'ecrire une fonction {\tt bool est\_palindrome(string s)}
	\item \'ecrire une fonction {\tt int position\_plus\_grand\_suffixe\_palindrome(string s)}
	\item Utiliser les fonctions pr\'ec\'edente pour r\'esoudre le probl\`eme.
 \end{itemize}


\item [Exercice 8~]: Ecrivez une proc\'edure qui m\'elange un jeu de
32 cartes tel qu'on l'aura d\'efini \`a l'exercice 2.

\item [Exercice 9~]: Supposons que le code d'une carte bleue soit
choisi au hasard lors de sa cr\'eation, \'ecrire {\bf
initialise\_carte( \dots ma\_carte, \dots depot\_initial, \dots
type\_choisi)}, qui retournera le code.

\pagebreak
\item [Exercice 10~]:
\begin{itemize}

   \item [a)~] Ecrire une proc\'edure $triangle(a,b)$ qui, supposant
que le tableau $a$ soit une ligne du triangle de Pascal, calcule la
ligne suivante en la pla\c{c}ant dans $b$.

   \item [b)~] Ecrire une proc\'edure $permute\_g(a)$ qui permute
   circulairement les \'el\'ements d'un tableau $a$, en les
   d\'epla\c{c}ant d'une case vers la gauche, le premier \'el\'ement
   devenant le dernier.

   \item [c)~] Idem avec $permute\_d$ qui permute les \'el\'ement du
   tableau de la m\^eme fa\c{c}on, mais vers la droite.

   \item [d)~] Ecrire une proc\'edure $triangle\_direct(a)$ qui
calcule la ligne suivante du triangle de Pascal, sans l'aide de
tableaux auxilliaires.

%%   \item [e)~] On suppose que les tableaux $a$ et $b$ de taille $n$
%%   sont d\'ej\`a tri\'es. Ecrire une proc\'edure $fusion(a,b,c)$ qui
%%   d\'efinit le tableau c de dimension $2n$ par insertion tri\'ee des
%%   \'el\'ements de $a$ et de $b$.

   \item [e)~] Soient deux tableaux $a$ et $b$ de taille $n$ dont les 
   \'el\'elements sont d\'ej\`a tri\'es et un tableau $c$ de taille $2n$ vide.
   Ecrire une fonction $fusion(a,b,c)$ qui fusionne les \'el\'ements des 
   tableaux $a$ et $b$ dans le tableau $c$ de telle sorte que les 
   \'el\'ements du tableau $c$ soient eux aussi tri\'es.
   

\end{itemize}

\end{description}

\pagebreak
\section*{Correction}
\small

\underline{Consignes } Essayez de traiter les exercices 5 et 6 en
TP. Par contre faites bien les 4 premiers en TD.


\begin{description}

\item [Exercice 1 :~] A noter le choix qui est fait d'avoir un code
stock\'e dans un tableau d'entier. On pourra indiquer les
cons\'equences que \c{c}a a : il faudra s'assurer que l'on a bien des
chiffres via les fonctions de d\'efinition d'une carte.

\begin{verbatim}
#include <iostream>

typedef enum geree_par {visa,mastercard};

typedef struct carte_bleue {
  int montant;
  int code[4];
  geree_par type_carte;
};

int main(){
  carte_bleue c;

  c.montant = 100;
  c.code[0]=1
  c.code[1]=4
  c.code[2]=1
  c.code[3]=8;
  c.type_carte=visa;
}
\end{verbatim}

\item [Exercice 2 :~] Pour le TP, je deconseillerai de commencer par
celui l\`a qui est un peu long \`a taper, autant faire les autres
d'abord. Pour les m\^emes raisons on n'est pas oblig\'e de donner la
correction compl\`ete en TD. \\

A remarquer : on utilise les switch-case pour d\'ecrire les
\'enum\'erations. Ne pas oublier le break !

Pour d\'efinir toutes les cartes j'ai construit des tableaux de
correspondance qui associent un num\'ero \`a chaque constantes d'un
type \'enum\'er\'e.

Il est int\'eressant de souligner que l'on peut utiliser le m\^eme nom
{\tt affiche} pour diff\'erents types, sans qu'il y ait ambiguit\'e.

{\small
\begin{verbatim}
#include <iostream>
#include <cstdlib>
#include <ctime>

typedef enum couleur {coeur,trefle,pique,carreau};
typedef enum valeur {as,roi,dame,valet,dix,neuf,huit,sept};

typedef struct carte {
  couleur c;
  valeur v;
};

typedef carte jeu_c[32];

void affiche(couleur c){
 switch(c) {
   case coeur   : cout << "coeur";   break;
   case trefle  : cout << "trefle";  break;
   case pique   : cout << "pique";   break;
   case carreau : cout << "carreau"; break;
   }
}

void affiche(valeur v){
 switch(v) {
   case as    : cout << "as";    break;
   case roi   : cout << "roi";   break;
   case dame  : cout << "dame";  break;
   case valet : cout << "valet"; break;
   case dix   : cout << 10 ;     break;
   case neuf  : cout << 9;       break;
   case huit  : cout << 8;       break;
   case sept  : cout << 7;       break;
   }
}

void affiche(carte c){
 affiche(c.v);
 cout <<" de ";
 affiche(c.c);
 cout << endl;
}

void affiche(jeu_c j){
 int i;
 for (i=0;i<32;i++){
   affiche(j[i]);
 }
}

int main(){
  int i,j,n=0;
  jeu_c jeu;

  couleur corresp_couleur[4]={coeur,trefle,pique,carreau};
  valeur corresp_valeur[8]={as,roi,dame,valet,dix,neuf,huit,sept};

  for (i=0;i<8;i++){
   for (j=0;j<4;j++){
    jeu[n].c=corresp_couleur[j];
    jeu[n].v=corresp_valeur[i];
    n++;
   }
  }
 affiche(jeu);
}
\end{verbatim}
}

\item [Exercice 3 :~] Il faudra discuter avec les \'etudiants de la
fa\c{c}on d'introduire l'atout dans le contexte de la fonction.

{\small
\begin{verbatim}
#include <iostream>

typedef enum couleur {coeur,trefle,pique,carreau};
typedef enum valeur {as,roi,dame,valet,dix,neuf,huit,sept};

typedef struct carte {
  couleur c;
  valeur v;
};

int valeur(carte c,couleur atout){
  switch (c.v) {
  case as : return 11;
  case dix : return 10;
  case roi : return 4;
  case dame : return 3;
  case valet : {
    if (c.c==atout) 
      return 20;
    else return 2;
  }
  case neuf : {
    if (c.c==atout) return 14;
    else return 0;
  }
  default : return 0;
  }
}

int main(){
  carte x;

  x.v =neuf;
  x.c=coeur;

  cout << valeur(x,coeur) << " " << valeur(x,pique);
}
\end{verbatim}}

\item [Exercice 4 :~] Il y a 23 caract\`eres avec les espaces, {\tt b}
recoit {\tt faux}, {\tt s[4]} est 'o' puisqu'on commence \`a z\'ero,
"jour t" est la sous cha\^{\i}ne, et le resultat de l'insertion est
"B- onjour tout le monde !"

\item [Exercice 5 :~] Il faut remarquer les comparaisons directes entre
caract\`eres via leur code ASCII, ce qui permet le changement
d'origine.

Il ne faut pas oublier le passage en r\'ef\'erence de la chaine, qui
n'est d\'ecid\'ement pas un tableau. Ici encore j'ai donn\'e le m\^eme
nom {\tt minToMaj} aux 2 fonctions.

{\small
\begin{verbatim}
#include<iostream>
#include<string>

char minToMaj(char c){
 if (('a'<= c) && (c<='z')) return (c-'a'+'A');
 else return c;
}

void minToMaj(string &s){
 int i;
 for (i=0;i<s.length();i++){
 s[i]= minToMaj(s[i]);
 }
}

int main(){
 string s;
 cin >> s;
 minToMaj(s);
 cout << s;
}
\end{verbatim}
}

\item [Exercice 6 :~] Ici encore je l'ai fait avec une boucle en sens
inverse. On peut poser la question en prenant {\tt i} croissant.
{\small
\begin{verbatim}
#include <string>
#include<iostream>

int main(){
   int i;
   string s,pal;
   cin >> s;
   pal=s; // rq c'est une copie
   for (i=s.length()-1;i>=0;i--){
      pal=pal+s[i];
   }
   cout << pal << endl;
   cout << s << endl;
}
\end{verbatim}
}
\item [Exercice 7 :~]
{\small
\begin{verbatim}
#include <iostream>
#include <string>

bool est_palindrome(string s){
   int i;
   bool res=true;
   int L=s.length();
   for(i=0;i<=L/2-1;i++){  // Rq en exercice on peut donner une solution avec un while
      res=res && (s[i]==s[L-1-i]);
   }
   return res;
}

int position_plus_grand_suffixe_palindrome(string s){
   int i;
   string s1;
   i=0;
   s1=s;
   while ( i < s.length() && !(est_palindrome(s1)) ){
      i++;
      s1=s.substr(i,s.length()-i);
   }
   return i;
}

void donnePalindrome(string &s){
   int i=position_plus_grand_suffixe_palindrome(s);
   //qq cas particulier
   if (i!=s.length()-1 | s.length()==1) i--;
   for (;i>=0;i--){
      s+=s[i];
   }
}

int main(){
   string c;
   while(true){
      cin >> c;
      cout << "qui est un palindrome :" << est_palindrome(c) <<endl;
      donnePalindrome(c);
      cout << c << endl;
   }
}
\end{verbatim}
}

\item [Exercice 8~:] Pour m\'elanger, j'ai choisi d'effectuer un
nombre al\'eatoire de permutations entre 2 cartes du jeu. On peut
imaginer d'autres fa\c{c}on de m\'elanger, par exemple on coupe le
paquet et on intercale les cartes. C'est peut \^etre une source
d'exercices originaux pour IF121 (on passe de trier \`a m\'elanger
:o)).

{\small
\begin{verbatim}
// echange les cartes de j de positions pos1 et pos2
// elles doivent etre entre 0 et 31 !
void echange(jeu_c j, int pos1, int pos2){
 carte aux;
 aux=j[pos1];
 j[pos1]=j[pos2];
 j[pos2]=aux;
}

// melange le jeu en effectuant moins de mille echange de cartes 2 a 2
void melange(jeu_c j){
int nb, pos1,pos2;
srand(time(NULL));
 
 for (nb=rand()%1000;nb >0;nb--){
  pos1=rand()%32;
  pos2=rand()%32;
  echange(j,pos1,pos2);
 }
}

.... et on ajoute ca au main()
 melange(jeu);
 cout << "une fois melange ca donne" << endl;
 affiche(jeu); 
....
\end{verbatim}}


\item [Exercice 9 :~] Insister sur le profil.  Pour varier les
plaisirs je n'ai pas tir\'e 4 chiffres au hazard, mais un seul nombre
de 4 chiffres.

\begin{verbatim}
#include <iostream>

#include <cstdlib>
#include <ctime>

typedef enum geree_par {visa,mastercard};

typedef struct carte_bleue {
  int montant;
  int code[4];
  geree_par type_carte;
};

int initialise_carte(carte_bleue &c,int depot_initial, geree_par type_choisi){
  int code_genere;
  code_genere = rand()%10000;

  c.montant=depot_initial;
  c.type_carte=type_choisi;
  c.code[3]=code_genere%10;
  code_genere=code_genere/10;
  c.code[2]=code_genere%10;
  code_genere=code_genere/10;
  c.code[1]=code_genere%10;
  code_genere=code_genere/10;
  c.code[0]=code_genere%10;

  return code_genere;
}

int main(){
  carte_bleue c;

  srand(time(NULL));

  cout << initialise_carte(c,100,visa) << endl;
}
\end{verbatim}

\item [Exercice 10 a) :~] Le triangle de Pascal est la matrice des
$C_n^p$. Elle se calcule de bas en haut avec la r\`egle $C_{n+1}^p =
C_n^{p-1} + C_n^p$.
\begin{verbatim}
#include <iostream>

const int dim=10;
typedef int tableau[dim];

void triangle(tableau a, tableau b){
  int i;

  b[0]=1;
  // on suppose que les entiers non significatifs sont nuls
  for(i=1;i<dim;i++){
    b[i]=a[i]+a[i-1];
  }
}

void affiche(tableau t){
  int i;
  
  for(i=0;i<dim;i++){
    cout << t[i] << " ";
  }
  cout << endl;
}

void init(tableau t){
  int i;
  for (i=0;i<dim;i++){
    t[i]=0;
  }
}

int main(){
  tableau a,b;

  init(a);
  init(b);
  a[0]=1; a[1]=2; a[2]=1;

  triangle(a,b);
  affiche(b);
}
\end{verbatim}

\item [Exercice 10 b) :~] Attention, la derni\`ere case du tableau a
pour num\'ero $dim-1$ (mon bug).
\begin{verbatim}
#include <iostream>

const int dim=10;
typedef int tableau[dim];

void affiche(tableau t){
  int i;
  
  for(i=0;i<dim;i++){
    cout << t[i] << " ";
  }
  cout << endl;
}

void init(tableau t){
  int i;
  for (i=0;i<dim;i++){
    t[i]=0;
  }
}

void permute_g(tableau t){
  int i,aux;

  aux=t[0];
  for(i=1;i<dim;i++){
    t[i-1]=t[i];
  }
  t[dim-1]=aux;
}

int main(){
  tableau a;

  init(a);
  a[0]=1; a[1]=2; a[2]=1;

  permute_g(a);
  affiche(a);

}
\end{verbatim}
\item [Exercice 10 c) :~] L\`a il ne faut rien \'ecraser, la boucle se
d\'eroule donc dans l'autre sens.
\begin{verbatim}
#include <iostream>

const int dim=10;
typedef int tableau[dim];

void affiche(tableau t){
  int i;
  
  for(i=0;i<dim;i++){
    cout << t[i] << " ";
  }
  cout << endl;
}

void init(tableau t){
  int i;
  for (i=0;i<dim;i++){
    t[i]=0;
  }
}

void permute_d(tableau t){
  int i,aux;

  aux=t[dim-1];
  for(i=dim-1;i>0;i--){
    t[i]=t[i-1];
  }
  t[0]=aux;
}

int main(){
  tableau a;

  init(a);
  a[0]=1; a[1]=2; a[2]=1;

  permute_d(a);
  affiche(a);
}
\end{verbatim}

\item [Exercice 10 d) :~] La seule remarque c'est que \c{c}a se fait
directement, sans rien \'ecraser si on lit de droite \`a gauche.
\begin{verbatim}
#include <iostream>

const int dim=10;
typedef int tableau[dim];

void affiche(tableau t){
  int i;
  
  for(i=0;i<dim;i++){
    cout << t[i] << " ";
  }
  cout << endl;
}

void init(tableau t){
  int i;
  for (i=0;i<dim;i++){
    t[i]=0;
  }
}

void triangle_direct(tableau t){
  int i,aux;

  for(i=dim-1;i>0;i--){
    t[i]=t[i-1]+t[i];
  }
  t[0]=1;
}

int main(){
  tableau a;

  init(a);
  a[0]=1; a[1]=2; a[2]=1;

  triangle_direct(a);
  affiche(a);

  triangle_direct(a);
  affiche(a);
}
\end{verbatim}
\item [Exercice 9 e) :~]
\begin{verbatim}
#include <iostream>

const int dim=3;
typedef int tableau1[dim];
typedef int tableau2[dim*2];

void affiche1(tableau1 t){
  int i;
  
  for(i=0;i<dim;i++){
    cout << t[i] << " ";
  }
  cout << endl;
}

void affiche2(tableau2 t){
  int i;
  
  for(i=0;i<2*dim;i++){
    cout << t[i] << " ";
  }
  cout << endl;
}


void fusionne(tableau1 a, tableau1 b, tableau2 res){
  int i,j,k;

  j=0;
  k=0;

  for(i=0;i<2*dim;i++){
    if( (k==dim) | ( (j<dim) && (a[j]<= b[k]) ) ) {
      res[i]=a[j];
      j++;
    }
    else {
      res[i]=b[k];
      k++;
    };
  }

}

int main(){
  tableau1 a,b;
  tableau2 c;
  
  a[0]=1; a[1]=2; a[2]=4;
  b[0]=2; b[1]=3; b[2]=5;
  
  affiche1(a);
  affiche1(b);

  fusionne(a,b,c);
  affiche2(c);
}
\end{verbatim}

\end{description}

\end{document}
