IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

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

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

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

Image d'aperçu.
Aperçu du résultat.

I-3. Démonstration


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
TéléchargerCacher/Afficher le codeSélectionnez

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

Image d'aperçu.
Aperçu du résultat.

II-3. Démonstration


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
TéléchargerCacher/Afficher le codeSélectionnez

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

Image d'aperçu.
Aperçu du résultat.

III-3. Démonstration


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
TéléchargerCacher/Afficher le codeSélectionnez

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

Image d'aperçu.
Aperçu du résultat.

IV-3. Démonstration


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
TéléchargerCacher/Afficher le codeSélectionnez

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

Image d'aperçu.
Aperçu du résultat.

V-3. Démonstration


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
TéléchargerCacher/Afficher le codeSélectionnez

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

Image d'aperçu.
Aperçu du résultat.

VI-3. Démonstration


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
TéléchargerCacher/Afficher le codeSélectionnez

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

Image d'aperçu.
Aperçu du résultat.

VII-3. Démonstration


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
TéléchargerCacher/Afficher le codeSélectionnez

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 : Viadeo Twitter Facebook Share on Google+   

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.