correction

ING 1 - POO Java année 2015 -2016
TD n°2
Exercice préliminaire
Écrire en Java tous les exercices vus en cours : discriminant,…
Exercice 1
Écrire un programme qui affecte des valeurs aléatoires à un tableau de 100 entiers et calcule la
moyenne des éléments du tableau.
Modifier ce programme de manière à afficher la valeur minimale et maximale du tableau.
// initialisayion aléatoire d'un tableau et calcul de la moyenne
public class Ex0201 {
public static void main(String [] args){
int [] t = new int[100];
int somme = 0;
for(int i = 0; i < t.length; i++){
t[i] = (int) (Math.random()*50);
somme = somme + t[i];
System.out.print(t[i] + " ");
}
}
System.out.println("\n" + (double) somme/(double) t.length);
}
Exercice 2 :
Le code suivant permet de générer des nombres aléatoires entre 0 et 99 :
import java.util.Random;
public class Ex0202 {
public static void main(String args[]) {
Random r = new Random();
int i;
final int nombre = 100;
for(i = 0; i < nombre; i++)
System.out.println(r.nextInt(100));
}
}
Taper ce code et tester le. Modifier le pour générer 100 nombres aléatoires entre 0 et 1000.
Exercice 3 :
En vous inspirant du code écrit précédemment, créer un tableau de 200 valeurs entières où chaque
cellule contient une valeur aléatoire entre 1 et 100.
Afficher ces différentes valeurs et calculer leur moyenne.
Exercice 4 :
Même exercice que le précédent en calculant la plus petite et la plus grande valeur contenue dans le
tableau.
Exercice 5 :
É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 36 000 lancers et stockez la fréquence de chaque somme dans un
tableau. Affichez ensuite les résultats et vérifiez que les fréquences sont correctes.
public class Ex0206 {
public static void main(String [] args){
// 1 tableau pour stocker les lancers de dés
int [] des = new int[13];
int de1, de2;
// mise à zéro des éléments du tableau
for(int i = 0; i < des.length; i++)
des[i] = 0;
// lancement de 36000 paires de dés
for(int i = 0; i < 36000; i++){
de1 = (int) (Math.random() * 6) + 1;
de2 = (int) (Math.random() * 6) + 1;
des[de1 + de2]++;
}
// affichage des fréquences
for(int i = 0; i < des.length; i++)
System.out.println("il y a " + des[i] + " " + i);
}
}
Exercice 6 : crible d’Ératosthène
On désire recherche tous les nombres premiers compris entre 2 et une certaine valeur maximale n.
Le crible est la structure qui contient la suite d’entiers ; il est représenté dans notre cas par un
tableau Java.
Compléter le pseudo-code suivant et le traduire en Java.
Algorithme Crible d’Ératosthène
initialiser le crible /* la case i du tableau contient la valeur i + 1 */
vide ← faux
répéter
/* le plus petit nombre contenu dans le crible est premier */
– afficher ce nombre sur la sortie standard
– l’enlever du crible avec tous ses multiples
si le crible est vide alors
vide ← vrai
finsi
jusqu’à vide
Exercice 7 :
Écrire un algorithme réalisant le décalage d’une case vers la gauche d’un tableau de 10 entiers
rempli aléatoirement, même question avec décalage d’une case vers la droit.
Note : l’élément de la cellule la plus à gauche (respectivement à droite) dans le cas d’un décalage à
gauche (respectivement à droite) sera reporté dans la cellule la plus à droite (respectivement à
gauche).
import java.util.Random;
// Exercice sur le décalage dans un tableau
public class Ex0207 {
public static void main(String [] args){
Random r = new Random();
// 1 tableau pour stocker 10 entiers
int [] tab = new int[10];
int val;
// valauers aléatoires entre [0,20[ pour chaque cellule du tableau et
affichage
for(int i = 0; i < tab.length; i++){
tab[i] = r.nextInt(20);
System.out.print(tab[i] + " ");
}
System.out.print("\n");
// décalage à gauche d'une case et affichage
val = tab[0]; // sauvegarde de la valeur la plus à gauche
for(int i = 1; i < tab.length; i++)
tab[i - 1] = tab[i];
tab[tab.length - 1] = val;
for(int i = 0; i < tab.length; i++)
System.out.print(tab[i] + " ");
System.out.print("\n");
}
Exercice 8 :
Soit un tableau T avec T(i)={0,1}. Écrire un algorithme qui retourne la position i dans le tableau
telle que T[i] est le début de la plus longue suite consécutive de zéros. Afficher la taille de cette
suite.
Exercice 9 :
Soit T un tableau de 100 éléments de type entier.
Remplissez le tableau avec les nombres de la suite de Fibonacci c’est-à-dire :
• T[0] = 0
• T[1] = 1
• T[2] = 1
• T[3] = 2
• …
• T[n] = T[n-2] + T[n-1]
// Exercice sur la suite de Fibonacci
public class Ex0209 {
public static void main(String [] args){
final int n = 20;
// 1 tableau pour stocker n entiers
int [] tab = new int[20];
// les deux premières valeurs
tab[0] = 0;
tab[1] = 1;
// calcul de la suite
for(int i = 2; i < tab.length; i++)
tab[i] = tab[i - 1] + tab[i - 2];
for(int i = 0; i < tab.length; i++)
System.out.print(tab[i] + " ");
System.out.print("\n");
}
}
Exercice 10 :
Écrire un algorithme qui prend un tableau d’entiers en paramètres et répond true si ce tableau est
trié décroissant, false sinon.