Exercices en Java (06-Tableaux)

Ce sixième chapitre concerne les tableaux.
Il comporte sept exercices. Le premier est un exercice sur le Tri bulle. Le deuxième exercice porte sur le jet de dés. Le troisième est sur la Tortue graphique. Le quatrième exercice porte sur le crible d'Eratosthène. Le cinquième et le sixième sont sur le tri par sélection et la recherche binaire. Le dernier exercice est sur le parcours de labyrinthe.

Les principales notions abordées sont les suivantes :

Notion de tableau ;
Déclaration de tableaux ;
Allocation de la mémoire ;
Initialisation des tableaux ;
Accéder aux valeurs d'un tableau ;
Utiliser des tableaux pour le stockage, le tri, la recherche ;
Passer un tableau à une méthode ;
Tableaux multidimensionnels.

Pour faire et comprendre ces exercices, vous aurez besoin d'un certain nombre de notions sur le Java en rapport avec le chapitre. Pour cela, vous pouvez consulter les tutoriels java de developpez à l'adresse suivante : https://java.developpez.com/cours/Cours en Java

La documentation de l'API sur le site de Sun est aussi une mine d'or : http://java.sun.com/javase/6/docs/api/ ♪

Article lu fois.

L'auteur

Sébastien ESTIENNE

L'article

Publié le 22 juillet 2007 - Mis à jour le 23 décembre 2007

Version hors-ligne

ePub, Azw et Mobi

Liens sociaux

I. Tri Bulle▲

I-1. Énoncé▲

Le tri de données est un problème qui revient souvent. Le tri bulle est un tri simple qui n'est pas fait pour de grands tableaux. Écrivez l'algorithme du tri à bulle. (Cet algorithme consiste à comparer les différentes valeurs adjacentes d'un tableau et à les échanger si besoin est. À chaque passage du tableau, un élément supplémentaire est trié. Le nombre de passages nécessaires pour trier le tableau dans son intégralité est donc de la taille du tableau moins un.)
Améliorez-le ensuite sachant qu'à chaque passage supplémentaire une valeur de plus est triée à la fin du tableau. Ainsi à chaque passage le nombre de comparaisons nécessaires diminue de 1.
Il est possible que le tableau soit trié avant que tous les passages du tableau ne soient effectués. La deuxième amélioration consiste donc à vérifier que si aucune permutation n'a été faite, d'arrêter l'algorithme de tri.

Note : ce tri est à titre d'exemple. La bibliothèque Java fournit une classe Arrays qui offre différentes fonctions dont une recherche binaire et un de tri performant basé sur le tri rapide.

Classes de l'API utilisées :

I-2. Aperçu▲

I-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

I-4. Solution▲

TriBulle.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier: TriBulle.java
 * Crée le: 13 décembre 2006.
 * Modifié: 7 juillet 2007.
 * Auteurs: Sébastien ESTIENNE.
 * SiteWeb: http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre6;



import java.awt.BorderLayout;
import java.awt.Container;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;



/**
 * <p>Tri bulle amélioré.</p>
 * @author Sébastien ESTIENNE.
 */
public class TriBulle extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;


   /**
    * <p>Construction de l'application.</p>
    */
   public TriBulle()
   {
      // Appel du constructeur de la classe JFrame.
      super("Tri Bulle");

      // Obtenir le panneau de contenu et changer son layout en un FlowLayout.
      Container conteneur = getContentPane();
      conteneur.setLayout(new BorderLayout());

      // Zone de texte de sortie.
      JTextArea zoneSortie = new JTextArea();
      zoneSortie.setEditable(false);

      // Ajoute la zone de sortie au conteneur.
      conteneur.add(new JScrollPane(zoneSortie));

      // Tableau des valeurs à trier.
      int[] tableau = {5, 56, 34, 43, 17, 25, 8, 65, 31, 52};

      // Chaine de caractère de sortie.
      StringBuilder sortie = new StringBuilder();

      // Ajoute à la chaine de sortie les valeurs de départ du tableau.
      sortie.append("Valeurs de départ du tableau:\n");
      for(int i = 0; i < tableau.length; i++)
      {
         sortie.append("  ").append(tableau[i]);
      }

      // Trie le tableau.
      triBulle(tableau);

      // Ajoute à la chaine de sortie les valeurs triées du tableau.
      sortie.append("\n\n");
      sortie.append("Valeurs triées du tableau:\n");
      for(int i = 0; i < tableau.length; i++)
      {
         sortie.append("  ").append(tableau[i]);
      }

      // Met à jour la zone de sortie.
      zoneSortie.setText(sortie.toString());

      // Modifie les propriétés de la fenêtre.
      setSize(300, 150);
      setLocation(100, 100);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Effectue un tri bulle.</p>
    * @param tableau Les valeurs à trier.
    */
   public void triBulle(int[] tableau)
   {
      // Nombre de passages nécessaires pour trier le tableau d'entiers.
      for(int i = 1; i < tableau.length; i++)
      {
         // Indique s'il faut continuer le tri ou non.
         boolean continuer = false;

         // Un passage dans le tableau permettant de trier un élément.
         for(int j = 0; j < tableau.length - i; j++)
         {
            // Compare une paire d'éléments et les permute si le premier est supérieur au second.
            if(tableau[j] > tableau[j + 1])
            {
               permuter(tableau, j, j + 1);
               continuer = true;
            }
         }

         // Si aucune permutation n'a été effectuée, alors le tableau est déjà trié.
         if(!continuer)
         {
            break;
         }
      }
   }


   /**
    * <p>Permutte deux éléments d'un tableau.</p>
    * @param tableau Le tableau concerné.
    * @param i L'indice du premier élément.
    * @param j L'indice du second élément.
    */
   public void permuter(int[] tableau, int i, int j)
   {
      // Variable temporaire pour la permutation.
      int temp;

      temp = tableau[i];
      tableau[i] = tableau[j];
      tableau[j] = temp;
   }


   /**
    * <p>Lance l'application.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new TriBulle();
   }
}

II. Jet de dés▲

II-1. Énoncé▲

Écrivez une application qui simule grâce à des nombres aléatoires un lancer de deux dés. Il existe 36 combinaisons et la somme des deux dés est comprise entre 2 et 12 avec certaines sommes plus fréquentes que d'autres. Simulez 36000 lancers et stockez la fréquence de chaque somme dans un tableau. Affichez ensuite les résultats dans une zone de texte et vérifiez que les fréquences sont correctes.
Ajoutez aussi un bouton afin de pouvoir effectuer de nouvelles séries de lancers de dés.

Fréquence des possibilités :

2: 1
3: 2
4: 3
5: 4
6: 5
7: 6
8: 5
9: 4
10: 3
11: 2
12: 1

Classes de l'API utilisées :

II-2. Aperçu▲

II-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

II-4. Solution▲

JetDeDes.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier: JetDeDes.java
 * Crée le: 17 décembre 2006.
 * Modifié: 7 juillet 2007.
 * Auteurs: Sébastien ESTIENNE.
 * SiteWeb: http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre6;



import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;



/**
 * <p>Calcule la fréquence de la somme de lancers de deux dés.</p>
 * @author Sébastien ESTIENNE.
 */
public class JetDeDes extends JFrame implements ActionListener
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;

   /** Nombre de lancers. */
   private static final int NB_LANCERS = 36000;

   /** Tableau de fréquence des sommes des lancers de dés. */
   private int[] tableau = new int[13];

   /** Zone de texte de sortie. */
   private JTextArea zoneSortie;

   /** Bouton permettant d'effectuer une série de lancers. */
   private JButton boutonLancer;


   /**
    * <p>Construction de l'application.</p>
    */
   public JetDeDes()
   {
      // Appel du constructeur de la classe JFrame.
      super("Jet de dés");

      // Création de la zone de sortie.
      this.zoneSortie = new JTextArea();
      this.zoneSortie.setEditable(false);

      // Création du bouton de lancement.
      this.boutonLancer = new JButton("Lancer");

      // Ajoute une action sur le bouton.
      this.boutonLancer.addActionListener(this);

      // Conteneur.
      Container conteneur = getContentPane();

      // Ajoute les composants au conteneur.
      conteneur.add(new JScrollPane(this.zoneSortie), BorderLayout.CENTER);
      conteneur.add(this.boutonLancer, BorderLayout.SOUTH);

      // Modifie les propriétés de la fenêtre.
      setSize(300, 200);
      setLocation(100, 100);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Traite une série de lancers de dés.</p>
    * @param actionEvent Un événement sémantique qui indique qu'une action s'est produite dans le
    *        composant concerné.
    */
   public void actionPerformed(ActionEvent actionEvent)
   {
      // Effectue la série de lancers.
      lancer();

      // Initialise le texte de sortie.
      StringBuilder sortie = new StringBuilder("Fréquence des résultats des lancers de dés:\n");
      for(int i = 2; i < this.tableau.length; i++)
      {
         sortie.append(i).append(" : ").append(this.tableau[i]).append('\n');
      }

      // Met à jour la zone de sortie.
      this.zoneSortie.setText(sortie.toString());
   }


   /**
    * <p>Effectue une série de lancers de dés.</p>
    */
   public void lancer()
   {
      // Résultats des lancers de dés.
      int d1, d2;

      // Initialise le tableau.
      for(int i = 0; i < this.tableau.length; i++)
      {
         this.tableau[i] = 0;
      }

      // Effectue les lancers.
      for(int i = 0; i < JetDeDes.NB_LANCERS; i++)
      {
         // Lance les dés.
         d1 = 1 + (int) (Math.random() * 6);
         d2 = 1 + (int) (Math.random() * 6);

         // Ajoute le résultat du lancer.
         this.tableau[d1 + d2]++;
      }
   }


   /**
    * <p>Lance l'application.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new JetDeDes();
   }
}

III. Tortue Graphique▲

III-1. Énoncé▲

Le langage Logo est connu pour le concept de la tortue graphique. Elle permet de dessiner sur une feuille. La tortue a deux états : relevée et descendue.
Lorsque celle-ci est relevée, elle peut se déplacer librement et quand elle est descendue, elle laisse une trace de ses mouvements.
Écrivez un applet avec les fonctionnalités suivantes :
La feuille de dessin est représentée par un tableau de 20 par 20. La position de la tortue et de son état sont conservés dans des variables. Au départ la tortue est sur la case 0,0 et relevée. Les commandes de déplacement de la tortue sont stockées dans un tableau.

La liste des commandes est :

1 : Relever la tortue ;
2 : Abaisser la tortue ;
3 : Tourner vers la droite ;
4 : Tourner vers la gauche ;
5,n : Avancer de n cases ;
6 : Afficher la feuille de dessin.

Quand la tortue fait une trace sur une case, la valeur de la case dans le tableau est ajustée à 1. Pour l'affichage de la feuille, utilisez des astérisques ( '* ' ) et des points ( '. ' ) à police de caractères fixe (monospaced) dans un JTextArea.
Voici un exemple de programme simple :
5, 3, 3, 5, 8, 2, 5, 8, 4, 5, 8, 4, 5, 8, 4, 5, 8, 1, 3, 5, 5, 3, 5, 5, 2, 5, 8, 3, 5, 8, 3, 5, 8, 3, 5, 8, 1

Sélectionnez

                    . . . . . . . . . . . . . . . . . . . .
                    . . . . . . . . . . . . . . . . . . . .
                    . . . . . . . . . . . . . . . . . . . .
                    . . . . . . . . * * * * * * * * * . . .
                    . . . . . . . . * . . . . . . . * . . .
                    . . . . . . . . * . . . . . . . * . . .
                    . . . . . . . . * . . . . . . . * . . .
                    . . . . . . . . * . . . . . . . * . . .
                    . . . * * * * * * * * * . . . . * . . .
                    . . . * . . . . * . . * . . . . * . . .
                    . . . * . . . . * . . * . . . . * . . .
                    . . . * . . . . * * * * * * * * * . . .
                    . . . * . . . . . . . * . . . . . . . .
                    . . . * . . . . . . . * . . . . . . . .
                    . . . * . . . . . . . * . . . . . . . .
                    . . . * . . . . . . . * . . . . . . . .
                    . . . * * * * * * * * * . . . . . . . .
                    . . . . . . . . . . . . . . . . . . . .
                    . . . . . . . . . . . . . . . . . . . .
                    . . . . . . . . . . . . . . . . . . . .

Classes de l'API utilisées :

III-2. Aperçu▲

III-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

III-4. Solution▲

TortueGraphique.java

Cacher/Afficher le codeSélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
213.
214.
215.
216.
217.
218.
219.
220.
221.
222.
223.
224.
225.
226.
227.
228.
229.
230.
231.
232.
233.
234.
235.
236.
237.
238.
239.
240.
241.
242.
243.
244.
245.
246.
247.
248.
249.
250.
251.
252.
253.
254.
255.
256.

/*
 * Fichier: TortueGraphique.java
 * Crée le: 18 décembre 2006.
 * Modifié: 7 juillet 2007.
 * Auteurs: Sébastien ESTIENNE.
 * SiteWeb: http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre6;



import java.awt.Container;
import java.awt.Font;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;



/**
 * <p>Simulation de la tortue graphique.</p>
 * @author Sébastien ESTIENNE.
 */
public class TortueGraphique extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;

   /** Taille de la feuille de dessin. */
   private static final int TAILLE = 20;

   /** Direction : vers la droite. */
   private static final int DROITE = 0;

   /** Direction : vers le haut. */
   private static final int HAUT = 1;

   /** Direction : vers la gauche. */
   private static final int GAUCHE = 2;

   /** Direction : vers le bas. */
   private static final int BAS = 3;

   /** État de la tortue : Relevée. */
   private static final int RELEVE = 0;

   /** État de la tortue : Abaissée. */
   private static final int ABAISSE = 1;

   /** Tableau représentant la feuille de dessin. */
   private boolean[][] feuille;

   /** Position de la tortue. */
   private int px = 0, py = 0;

   /** État de la tortue. */
   private int etat = TortueGraphique.RELEVE;

   /** Direction de la tortue. */
   private int direction = TortueGraphique.DROITE;

   /** Zone de texte de sortie. */
   private JTextArea zoneSortie;


   /**
    * <p>Construction de l'application.</p>
    */
   public TortueGraphique()
   {
      // Appel du constructeur de la classe JFrame.
      super("Tortue Graphique");

      // Initialise la zone de texte de sortie.
      this.zoneSortie = new JTextArea();
      this.zoneSortie.setEditable(false);
      this.zoneSortie.setFont(new Font("Monospaced", Font.BOLD, 10));

      // Conteneur.
      Container conteneur = getContentPane();

      // Ajoute les composants au conteneur.
      conteneur.add(new JScrollPane(this.zoneSortie));

      // Initialisation.
      this.feuille = new boolean[TortueGraphique.TAILLE][TortueGraphique.TAILLE];
      this.px = 0;
      this.py = 0;
      this.etat = TortueGraphique.RELEVE;
      this.direction = TortueGraphique.DROITE;

      // Programme.
      int[] pgm = {5, 3, 3, 5, 8, 2, 5, 8, 4, 5, 8, 4, 5, 8, 4, 5, 8, 1, 3, 5, 5, 3, 5, 5, 2, 5, 8,
            3, 5, 8, 3, 5, 8, 3, 5, 8, 1, 6};

      // Lance un programme.
      lancer(pgm);

      // Modifie les propriétés de la fenêtre.
      setSize(280, 340);
      setLocation(100, 100);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Lance un programme de contrôle de tortue graphique.</p>
    * @param programme Le programme à lancer.
    */
   public void lancer(int[] programme)
   {
      int i = 0;
      while(i < programme.length)
      {
         switch(programme[i])
         {
         // Relever la tortue.
         case 1:
            this.etat = TortueGraphique.RELEVE;
            break;
         // Abaisser la tortue.
         case 2:
            this.etat = TortueGraphique.ABAISSE;
            this.feuille[this.py][this.px] = true;
            break;
         // Tourner vers la droite.
         case 3:
            this.direction = (this.direction + 3) % 4;
            break;
         // Tourner vers la gauche.
         case 4:
            this.direction = (this.direction + 1) % 4;
            break;
         // Avancer de n cases.
         case 5:
            if(i < programme.length - 1)
            {
               tracer(programme[++i]);
            }
            break;
         // Affiche la feuille de dessin.
         case 6:
            this.zoneSortie.setText(representerFeuille());
            break;
         default:
            break;
         }
         i++;
      }
   }


   /**
    * <p>Trace un trait de la longueur indiquée suivant la direction courante.</p> <p>L'algorithme
    * pourrait être optimisé.</p>
    * @param nb Le nombre de cases.
    */
   public void tracer(int nb)
   {
      for(int i = 0; i < nb; i++)
      {
         switch(this.direction)
         {
         case TortueGraphique.DROITE:
            if(this.px < TortueGraphique.TAILLE - 1)
            {
               this.px++;
            }
            break;
         case TortueGraphique.HAUT:
            if(this.py > 0)
            {
               this.py--;
            }
            break;
         case TortueGraphique.GAUCHE:
            if(this.px > 0)
            {
               this.px--;
            }
            break;
         case TortueGraphique.BAS:
            if(this.py < TortueGraphique.TAILLE - 1)
            {
               this.py++;
            }
            break;
         default:
            break;
         }

         if(this.etat == TortueGraphique.ABAISSE)
         {
            this.feuille[this.py][this.px] = true;
         }
      }
   }


   /**
    * <p>Construit une représentation de la feuille de dessin.</p>
    * @return Retourne une représentation de la feuille de dessin.
    */
   public String representerFeuille()
   {
      StringBuilder sortie = new StringBuilder();

      // Construit la représentation de la feuille de dessin.
      for(int i = 0; i < this.feuille.length; i++)
      {
         for(int j = 0; j < this.feuille[0].length; j++)
         {
            if(this.feuille[i][j])
            {
               sortie.append("* ");
            }
            else
            {
               sortie.append(". ");
            }
         }
         sortie.append('\n');
      }

      return sortie.toString();
   }


   /**
    * <p>Lance l'application.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new TortueGraphique();
   }
}

IV. Crible d'Eratosthène▲

IV-1. Énoncé▲

Le crible d'Eratosthène permet de trouver les nombres premiers. Un nombre premier est un entier naturel strictement supérieur à 1 qui n'admet que deux diviseurs distincts : 1 et lui-même. Son fonctionnement est le suivant :

utilisez un tableau de booléens où les indices correspondent aux nombres. Une valeur à true indique que c'est un nombre premier, à false que non ;
parcourez ce tableau en commençant à l'indice 2. Si l'indice courant est à true alors mettez à false tous les éléments à true multiples de l'indice.

Écrivez un programme qui affiche tous les nombres premiers entre 1 et 1000.

Classes de l'API utilisées :

IV-2. Aperçu▲

IV-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

IV-4. Solution▲

CribleEratosthene.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier: CribleEratosthene.java
 * Crée le: 04 janvier 2007.
 * Modifié: 7 juillet 2007.
 * Auteurs: Sébastien ESTIENNE.
 * SiteWeb: http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre6;



import java.awt.BorderLayout;
import java.awt.Container;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;



/**
 * <p>Trouve des nombres premiers avec le crible d'Eratosthène.</p>
 * @author Sébastien ESTIENNE.
 */
public class CribleEratosthene extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;

   /** Taille du tableau. */
   private static final int TAILLE = 1000;


   /**
    * <p>Construction de l'application.</p>
    */
   public CribleEratosthene()
   {
      // Appel du constructeur de la classe JFrame.
      super("Crible d'Eratosthène");

      // Conteneur.
      Container conteneur = getContentPane();

      // Ajoute les composants au conteneur.
      JTextArea zoneSortie = new JTextArea();
      zoneSortie.setEditable(false);
      conteneur.add(new JScrollPane(zoneSortie), BorderLayout.CENTER);

      // Initialisation du tableau d'indication de nombres premiers.
      boolean[] tableau = new boolean[CribleEratosthene.TAILLE];
      for(int i = 0; i < tableau.length; i++)
      {
         tableau[i] = true;
      }

      // Crible d'ératosthène.
      // Parcours du tableau.
      for(int i = 2; i < tableau.length; i++)
      {
         // Vérifie que l'élément est un nombre premier.
         if(tableau[i])
         {
            // Parcours du reste du tableau.
            for(int j = i + 1; j < tableau.length; j++)
            {
               // Teste si l'indice est un nombre premier.
               if(tableau[j] && j % i == 0)
               {
                  tableau[j] = false;
               }
            }
         }
      }

      // Enregistrement du résultat.
      StringBuilder sortie = new StringBuilder();
      for(int i = 2; i < tableau.length; i++)
      {
         if(tableau[i])
         {
            sortie.append(i).append("\n");
         }
      }

      // Met à jour la zone de sortie.
      zoneSortie.setText(sortie.toString());

      // Modifie les propriétés de la fenêtre.
      setSize(250, 200);
      setLocation(100, 100);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Lance l'application.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new CribleEratosthene();
   }
}

V. Tri Par Sélection▲

V-1. Énoncé▲

Le tri par sélection recherche l'élément le plus petit du tableau et l'échange avec le premier élément. Ensuite, on recommence cette opération avec le sous tableau commençant par le deuxième élément. Le tableau est entièrement trié lorsque le sous tableau ne contient plus qu'un seul sous élément.
Écrivez un tel algorithme.

Note : ce tri est à titre d'exemple. La bibliothèque Java fournit une classe Arrays qui offre différentes fonctions dont une recherche binaire et un de tri performant basé sur le tri rapide.

Classes de l'API utilisées :

V-2. Aperçu▲

V-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

V-4. Solution▲

TriParSelection.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier: TriParSelection.java
 * Crée le: 04 janvier 2007.
 * Modifié: 7 juillet 2007.
 * Auteurs: Sébastien ESTIENNE.
 * SiteWeb: http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre6;



import java.awt.Container;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;



/**
 * <p>Effectue un tri par sélection.</p>
 * @author Sébastien ESTIENNE.
 */
public class TriParSelection extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;


   /**
    * <p>Construction de l'application.</p>
    */
   public TriParSelection()
   {
      // Appel du constructeur de la classe JFrame.
      super("Tri Par Sélection");

      // Zone de texte de sortie.
      JTextArea zoneSortie = new JTextArea();
      zoneSortie.setEditable(false);

      // Conteneur.
      Container conteneur = getContentPane();

      // Ajoute la zone de sortie au conteneur.
      conteneur.add(new JScrollPane(zoneSortie));

      // Tableau des valeurs à trier.
      int[] tableau = {5, 56, 34, 43, 17, 25, 8, 65, 31, 52};

      // Chaine de caractère de sortie.
      StringBuilder sortie = new StringBuilder();

      // Ajoute à la chaine de sortie les valeurs de départ du tableau.
      sortie.append("Valeurs de départ du tableau:\n");
      for(int i = 0; i < tableau.length; i++)
      {
         sortie.append("  ").append(tableau[i]);
      }

      // Trie le tableau.
      triParSelection(tableau);

      // Ajoute à la chaine de sortie les valeurs triées du tableau.
      sortie.append("\n\n");
      sortie.append("Valeurs triées du tableau:\n");
      for(int i = 0; i < tableau.length; i++)
      {
         sortie.append("  ").append(tableau[i]);
      }

      // Met à jour la zone de sortie.
      zoneSortie.setText(sortie.toString());

      // Modifie les propriétés de la fenêtre.
      setSize(300, 150);
      setLocation(100, 100);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Effectue un tri par sélection.</p>
    * @param tableau Les valeurs à trier.
    */
   public void triParSelection(int[] tableau)
   {
      // Parcours du tableau.
      for(int i = 0; i < tableau.length - 1; i++)
      {
         int min = i;
         
         // Recherche de l'indice minimum.
         for(int j = i + 1; j < tableau.length; j++)
         {
            if(tableau[j] < tableau[min])
            {
               min = j;
            }
         }

         // Permutation.
         if(i != min)
         {
            permuter(tableau, i, min);
         }
      }
   }


   /**
    * <p>Permutte deux éléments d'un tableau.</p>
    * @param tableau Le tableau concerné.
    * @param i L'indice du premier élément.
    * @param j L'indice du second élément.
    */
   public void permuter(int[] tableau, int i, int j)
   {
      // Variable temporaire pour la permutation.
      int temp;

      temp = tableau[i];
      tableau[i] = tableau[j];
      tableau[j] = temp;
   }


   /**
    * <p>Lance l'application.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new TriParSelection();
   }
}

VI. Recherche binaire▲

VI-1. Énoncé▲

La recherche binaire fonctionne sur un tableau trié. L'algorithme compare à la clé recherchée la valeur de l'élément au milieu du tableau. Si les deux valeurs sont égales alors on renvoie l'indice sinon on continue la recherche avec la moitié du tableau correspondant au résultat de la comparaison des deux valeurs. La recherche continue jusqu'à ce que l'on trouve l'élément ou jusqu'à ce que le sous tableau ne contienne plus qu'un seul élément différent de la clé, indiquant que celle-ci n'est pas dans le tableau.
Écrivez un tel programme.

Classes de l'API utilisées :

VI-2. Aperçu▲

VI-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

VI-4. Solution▲

RechercheBinaire.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier: RechercheBinaire.java
 * Crée le: 04 janvier 2007.
 * Modifié: 7 juillet 2007.
 * Auteurs: Sébastien ESTIENNE.
 * SiteWeb: http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre6;



import java.awt.Container;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;



/**
 * <p>Effectue une recherche binaire avec un tableau trié.</p>
 * @author Sébastien ESTIENNE.
 */
public class RechercheBinaire extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;


   /**
    * <p>Construction de l'application.</p>
    */
   public RechercheBinaire()
   {
      // Appel du constructeur de la classe JFrame.
      super("Recherche Binaire");

      // Zone de texte de sortie.
      JTextArea zoneSortie = new JTextArea();
      zoneSortie.setEditable(false);

      // Conteneur.
      Container conteneur = getContentPane();

      // Ajoute la zone de sortie au conteneur.
      conteneur.add(new JScrollPane(zoneSortie));

      // Tableau des valeurs à trier.
      int[] tableau = {5, 8, 17, 25, 31, 34, 43, 52, 56, 65};

      // Chaine de caractère de sortie.
      StringBuilder sortie = new StringBuilder();

      // Ajoute à la chaine de sortie les valeurs du tableau.
      sortie.append("Valeurs du tableau:\n");
      for(int i = 0; i < tableau.length; i++)
      {
         sortie.append("  ").append(tableau[i]);
      }
      sortie.append("\n\n");

      // Effectue une recherche binaire.
      int valeur = 17;
      int element = rechercheBinaire(tableau, valeur);
      if(element != -1)
      {
         sortie.append("Valeur ").append(valeur).append(" trouvée à l'élément ").append(element)
               .append("\n");
      }
      else
      {
         sortie.append("Valeur ").append(valeur).append(" introuvable!\n");
      }

      // Met à jour la zone de sortie.
      zoneSortie.setText(sortie.toString());

      // Modifie les propriétés de la fenêtre.
      setSize(300, 150);
      setLocation(100, 100);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Effectue une recherche binaire.</p>
    * @param tableau Le tableau de valeurs.
    * @param cle L'élément à rechercher.
    * @return L'indice de la clé ou -1 si elle n'a pas été trouvée.
    */
   public int rechercheBinaire(int[] tableau, int cle)
   {
      // Indice de l'élément du bas.
      int bas = 0;

      // Indice de l'élément du haut.
      int haut = tableau.length - 1;

      // Indice de l'élément du milieu.
      int milieu;

      // Parcours jusqu'à l'indice haut.
      while(bas <= haut)
      {
         // Calcule l'élément du milieu.
         milieu = (bas + haut) / 2;

         // La clé a été trouvée.
         if(cle == tableau[milieu])
         {
            return milieu;
         }

         // Modifie l'indice du haut du tableau.
         if(cle < tableau[milieu])
         {
            haut = milieu - 1;
         }
         // Modifie l'indice du bas du tableau.
         else
         {
            bas = milieu + 1;
         }
      }

      // Clé introuvable.
      return -1;
   }


   /**
    * <p>Lance l'application.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new RechercheBinaire();
   }
}

VII. Parcours de labyrinthe▲

VII-1. Énoncé▲

L'algorithme le plus simple qui permet de trouver la sortie d'un labyrinthe (si elle existe), est de garder toujours sa main droite le long du mur en suivant les changements de direction avec cette même main. Évidemment ce n'est certainement pas le plus court… mais on trouve la sortie ainsi.
Écrivez une méthode récursive qui implémente cet algorithme. Utilisez aussi un JTextArea pour afficher une représentation du labyrinthe et ajoutez un bouton permettant de suivre étape par étape le parcours dans le labyrinthe.

Sélectionnez

                    # # # # # # # # # # # # 
                    # . . . # . . . . . . # 
                    . . # . # . # # # # . # 
                    # # # . # . . . . # . # 
                    # . . . . # # # . # . . 
                    # # # # . # . # . # . # 
                    # . . # . # . # . # . # 
                    # # . # . # . # . # . # 
                    # . . . . . . . . # . # 
                    # # # # # # . # # # . # 
                    # . . . . . . # . . . # 
                    # # # # # # # # # # # #

Classes de l'API utilisées :

VII-2. Aperçu▲

VII-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

VII-4. Solution▲

ParcoursLabyrinthe.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier: ParcoursLabyrinthe.java
 * Crée le: 04 janvier 2007.
 * Modifié: 7 juillet 2007.
 * Auteurs: Sébastien ESTIENNE.
 * SiteWeb: http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre6;



import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextArea;



/**
 * <p>Effectue une recherche binaire avec un tableau trié.</p>
 * @author Sébastien ESTIENNE.
 */
public class ParcoursLabyrinthe extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;

   /** Le labyrinthe. */
   private boolean[][] labyrinthe = {
         {false, false, false, false, false, false, false, false, false, false, false, false},
         {false, true, true, true, false, true, true, true, true, true, true, false},
         {true, true, false, true, false, true, false, false, false, false, true, false},
         {false, false, false, true, false, true, true, true, true, false, true, false},
         {false, true, true, true, true, false, false, false, true, false, true, true},
         {false, false, false, false, true, false, true, false, true, false, true, false},
         {false, true, true, false, true, false, true, false, true, false, true, false},
         {false, false, true, false, true, false, true, false, true, false, true, false},
         {false, true, true, true, true, true, true, true, true, false, true, false},
         {false, false, false, false, false, false, true, false, false, false, true, false},
         {false, true, true, true, true, true, true, false, true, true, true, false},
         {false, false, false, false, false, false, false, false, false, false, false, false}};

   /** Position courante en x dans le labyrinthe. */
   private int x = 0;

   /** Position courante en y dans le labyrinthe. */
   private int y = 0;

   /** Position de départ en x dans le labyrinthe. */
   private final int xd = 0;

   /** Position de départ en y dans le labyrinthe. */
   private final int yd = 2;

   /** Direction : vers la droite. */
   private static final int DROITE = 0;

   /** Direction : vers le bas. */
   private static final int BAS = 1;

   /** Direction : vers la gauche. */
   private static final int GAUCHE = 2;

   /** Direction : vers le haut. */
   private static final int HAUT = 3;

   /** La direction courante. */
   private int direction = ParcoursLabyrinthe.DROITE;

   /** Zone de texte de sortie. */
   private JTextArea zoneSortie;

   /** Bouton de parcours du labyrinthe. */
   private JButton boutonSuite;


   /**
    * <p>Construction de l'application.</p>
    */
   public ParcoursLabyrinthe()
   {
      // Appel du constructeur de la classe JFrame.
      super("Parcours Labyrinthe");

      // Initialisation.
      this.x = 0;
      this.y = 2;
      this.direction = ParcoursLabyrinthe.DROITE;

      // Initialisation de la zone de sortie.
      this.zoneSortie = new JTextArea();
      this.zoneSortie.setFont(new Font("Monospaced", Font.BOLD, 10));
      this.zoneSortie.setEditable(false);
      mettreAJourLabyrinthe();

      // Initialisation du bouton.
      this.boutonSuite = new JButton("Suite");
      this.boutonSuite.addActionListener(new ActionListener()
      {
         /**
          * Invoqué lorsqu'une action se produit.
          * @param e
          */
         public void actionPerformed(ActionEvent e)
         {
            avancer();
            mettreAJourLabyrinthe();
         }
      });

      // Conteneur.
      Container conteneur = getContentPane();

      // Ajoute les composants au conteneur.
      conteneur.add(this.zoneSortie, BorderLayout.CENTER);
      conteneur.add(this.boutonSuite, BorderLayout.SOUTH);

      // Modifie les propriétés de la fenêtre.
      setSize(200, 240);
      setLocation(100, 100);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Algorithme permettant d'avancer dans le labyrinthe.</p>
    */
   public void avancer()
   {
      // Vérification de terminaison.
      if(this.x == this.xd && this.y == this.yd || this.x > 0 && this.y > 0
            && this.x < this.labyrinthe[0].length && this.y < this.labyrinthe.length)
      {
         switch(this.direction)
         {
         // Direction de déplacement : Droite.
         case ParcoursLabyrinthe.DROITE:
            // Pas de mur sur la droite : dans un angle.
            if(this.y + 1 < this.labyrinthe.length && this.labyrinthe[this.y + 1][this.x])
            {
               this.direction = ParcoursLabyrinthe.BAS;
               this.y++;
            }
            // Un mur selon la direction de déplacement.
            else if(this.x + 1 < this.labyrinthe[0].length && !this.labyrinthe[this.y][this.x + 1])
            {
               // Changement de direction suivant le mur.
               if(this.y - 1 >= 0 && this.labyrinthe[this.y - 1][this.x])
               {
                  this.direction = ParcoursLabyrinthe.HAUT;
                  this.y--;
               }
               // Impasse : demi-tour.
               else
               {
                  this.direction = ParcoursLabyrinthe.GAUCHE;
                  this.x--;
               }
            }
            // Case libre devant : déplacement selon la direction.
            else if(this.x + 1 < this.labyrinthe[0].length)
            {
               this.x++;
            }
            break;
         // Direction de déplacement : Bas.
         case ParcoursLabyrinthe.BAS:
            // Pas de mur sur la droite : dans un angle.
            if(this.x - 1 >= 0 && this.labyrinthe[this.y][this.x - 1])
            {
               this.direction = ParcoursLabyrinthe.GAUCHE;
               this.x--;
            }
            // Un mur selon la direction de déplacement.
            else if(this.y + 1 < this.labyrinthe.length && !this.labyrinthe[this.y + 1][this.x])
            {
               // Changement de direction suivant le mur.
               if(this.x + 1 < this.labyrinthe[0].length && this.labyrinthe[this.y][this.x + 1])
               {
                  this.direction = ParcoursLabyrinthe.DROITE;
                  this.x++;
               }
               // Impasse : demi-tour.
               else
               {
                  this.direction = ParcoursLabyrinthe.HAUT;
                  this.y--;
               }
            }
            // Case libre devant : déplacement selon la direction.
            else if(this.y + 1 < this.labyrinthe.length)
            {
               this.y++;
            }
            break;
         // Direction de déplacement : Gauche.
         case ParcoursLabyrinthe.GAUCHE:
            // Pas de mur sur la droite : dans un angle.
            if(this.y - 1 >= 0 && this.labyrinthe[this.y - 1][this.x])
            {
               this.direction = ParcoursLabyrinthe.HAUT;
               this.y--;
            }
            // Un mur selon la direction de déplacement.
            else if(this.x - 1 >= 0 && !this.labyrinthe[this.y][this.x - 1])
            {
               // Changement de direction suivant le mur.
               if(this.y + 1 < this.labyrinthe[0].length && this.labyrinthe[this.y + 1][this.x])
               {
                  this.direction = ParcoursLabyrinthe.BAS;
                  this.y++;
               }
               // Impasse : demi-tour.
               else
               {
                  this.direction = ParcoursLabyrinthe.DROITE;
                  this.x++;
               }
            }
            // Case libre devant : déplacement selon la direction.
            else if(this.x - 1 >= 0)
            {
               this.x--;
            }
            break;
         // Direction de déplacement : Haut.
         case ParcoursLabyrinthe.HAUT:
            // Pas de mur sur la droite : dans un angle.
            if(this.x + 1 < this.labyrinthe.length && this.labyrinthe[this.y][this.x + 1])
            {
               this.direction = ParcoursLabyrinthe.DROITE;
               this.x++;
            }
            // Un mur selon la direction de déplacement.
            else if(this.y - 1 >= 0 && !this.labyrinthe[this.y - 1][this.x])
            {
               // Changement de direction suivant le mur.
               if(this.x - 1 >= 0 && this.labyrinthe[this.y][this.x - 1])
               {
                  this.direction = ParcoursLabyrinthe.GAUCHE;
                  this.x--;
               }
               // Impasse : demi-tour.
               else
               {
                  this.direction = ParcoursLabyrinthe.BAS;
                  this.y++;
               }
            }
            // Case libre devant : déplacement selon la direction.
            else if(this.y - 1 >= 0)
            {
               this.y--;
            }
            break;
         default:
            break;
         }
      }
   }


   /**
    * <p>Met à jour le labyrinthe.</p>
    */
   public void mettreAJourLabyrinthe()
   {
      StringBuilder sortie = new StringBuilder();

      // Parcours le labyrinthe.
      for(int i = 0; i < this.labyrinthe.length; i++)
      {
         for(int j = 0; j < this.labyrinthe.length; j++)
         {
            // Position courante dans le labyrinthe.
            if(i == this.y && j == this.x)
            {
               sortie.append("X ");
            }
            // Case libre.
            else if(this.labyrinthe[i][j])
            {
               sortie.append(". ");
            }
            // Mur.
            else
            {
               sortie.append("# ");
            }
         }
         sortie.append("\n");
      }

      // Mise à jour.
      this.zoneSortie.setText(sortie.toString());
   }


   /**
    * <p>Lance l'application.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new ParcoursLabyrinthe();
   }
}

VIII. Remerciements▲

Je tiens à remercier Ricky81, Hikage pour les conseils, remarques et relectures.
Je remercie aussi www.developpez.com me permettant de publier cet article et Nono40 pour ses outils.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants :

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2007 Sébastien ESTIENNE. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.