La fonction max en Java : Exercices corrigés
La fonction max est une méthode de la classe Math en Java qui permet de retourner le plus grand des deux nombres donnés en argument. Elle est souvent utilisée dans de nombreux programmes Java pour comparer des valeurs et effectuer des opérations conditionnelles.
Dans cet article, nous allons explorer différents exercices corrigés qui utilisent la fonction max pour illustrer son utilisation dans des contextes pratiques.
Exercice 1 : Comparaison de deux nombres
Écrivez un programme Java qui prend deux nombres en entrée de l’utilisateur, puis utilise la fonction max pour déterminer et afficher le plus grand des deux nombres.
import java.util.Scanner;
public class MaxNumber {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Demander à l'utilisateur d'entrer deux nombres
System.out.print("Entrez le premier nombre : ");
double num1 = scanner.nextDouble();
System.out.print("Entrez le deuxième nombre : ");
double num2 = scanner.nextDouble();
// Utiliser la fonction max pour trouver le plus grand nombre
double maxNumber = Math.max(num1, num2);
// Afficher le résultat
System.out.println("Le plus grand nombre est : " + maxNumber);
scanner.close();
}
}Exemple d’exécution :
Entrez le premier nombre : 10
Entrez le deuxième nombre : 5
Le plus grand nombre est : 10.0Exercice 2 : Trouver le plus grand nombre dans un tableau
Écrivez un programme Java qui trouve et affiche le plus grand nombre dans un tableau donné.
public class MaxInArray {
public static void main(String[] args) {
double[] numbers = {10.5, 20.3, 5.8, 30.2, 15.7};
// Initialiser la variable pour stocker le maximum
double maxNumber = numbers[0];
// Parcourir le tableau pour trouver le maximum
for (double num : numbers) {
maxNumber = Math.max(maxNumber, num);
}
// Afficher le résultat
System.out.println("Le plus grand nombre dans le tableau est : " + maxNumber);
}
}Exemple d’exécution :
Le plus grand nombre dans le tableau est : 30.2Exercice 3 : Comparaison de plusieurs nombres
Écrivez un programme Java qui prend un nombre indéterminé d’arguments en ligne de commande et affiche le plus grand de ces nombres.
public class MaxCommandLine {
public static void main(String[] args) {
// Vérifier s'il y a au moins un argument
if (args.length == 0) {
System.out.println("Aucun argument fourni.");
return;
}
// Convertir le premier argument en double et l'initialiser comme maximum
double maxNumber = Double.parseDouble(args[0]);
// Parcourir les arguments pour trouver le maximum
for (int i = 1; i < args.length; i++) {
double num = Double.parseDouble(args[i]);
maxNumber = Math.max(maxNumber, num);
}
// Afficher le résultat
System.out.println("Le plus grand nombre parmi les arguments est : " + maxNumber);
}
}Exemple d’exécution :
$ java MaxCommandLine 15 25 10 30
Le plus grand nombre parmi les arguments est : 30.0La fonction max en Java est un outil puissant pour comparer des valeurs et effectuer des opérations basées sur des conditions. En pratiquant les exercices ci-dessus, vous devriez avoir une meilleure compréhension de son utilisation dans divers contextes de programmation.
Exercice 4 : Comparaison de plusieurs tableaux
Écrivez un programme Java qui prend plusieurs tableaux de nombres en entrée et trouve le plus grand nombre parmi tous les tableaux.
public class MaxInArrays {
public static void main(String[] args) {
double[][] arrays = {
{10.5, 20.3, 5.8, 30.2, 15.7},
{40.1, 25.6, 12.9, 35.4},
{100.8, 75.3, 90.6}
};
// Initialiser la variable pour stocker le maximum
double maxNumber = arrays[0][0];
// Parcourir tous les tableaux pour trouver le maximum
for (double[] array : arrays) {
for (double num : array) {
maxNumber = Math.max(maxNumber, num);
}
}
// Afficher le résultat
System.out.println("Le plus grand nombre parmi tous les tableaux est : " + maxNumber);
}
}Exercice 5 : Utilisation de la fonction max avec des types non numériques
Écrivez un programme Java qui compare des chaînes de caractères alphabétiques et trouve la première chaîne dans l’ordre alphabétique.
public class MaxString {
public static void main(String[] args) {
String[] strings = {"banana", "apple", "orange", "grape"};
// Initialiser la première chaîne comme maximum
String maxString = strings[0];
// Parcourir les chaînes pour trouver la première dans l'ordre alphabétique
for (String str : strings) {
maxString = (str.compareTo(maxString) > 0) ? str : maxString;
}
// Afficher le résultat
System.out.println("La première chaîne dans l'ordre alphabétique est : " + maxString);
}
}Exercice 6 : Trouver le deuxième plus grand nombre dans un tableau
Écrivez un programme Java qui trouve et affiche le deuxième plus grand nombre dans un tableau donné.
public class SecondMaxInArray {
public static void main(String[] args) {
double[] numbers = {10.5, 20.3, 5.8, 30.2, 15.7};
// Initialiser les deux premiers nombres comme maximum et deuxième maximum
double maxNumber = numbers[0];
double secondMaxNumber = Double.MIN_VALUE;
// Parcourir le tableau pour trouver le deuxième maximum
for (double num : numbers) {
if (num > maxNumber) {
secondMaxNumber = maxNumber;
maxNumber = num;
} else if (num > secondMaxNumber && num != maxNumber) {
secondMaxNumber = num;
}
}
// Afficher le résultat
System.out.println("Le deuxième plus grand nombre dans le tableau est : " + secondMaxNumber);
}
}Ces exercices avancés vous donneront une bonne pratique dans l’utilisation de la fonction max en Java dans divers contextes et avec différents types de données.
Voici quelques exercices complexes qui nécessitent une compréhension approfondie de la fonction max en Java :
Exercice 7 : Tri décroissant
Écrivez un programme Java qui prend un tableau de nombres en entrée, puis trie ce tableau dans l’ordre décroissant en utilisant la fonction max.
import java.util.Arrays;
public class ReverseSort {
public static void main(String[] args) {
double[] numbers = {10.5, 20.3, 5.8, 30.2, 15.7};
// Initialiser un tableau pour stocker les nombres triés
double[] sortedNumbers = new double[numbers.length];
// Parcourir le tableau original et ajouter les nombres triés dans l'ordre décroissant
for (int i = 0; i < numbers.length; i++) {
double maxNumber = Double.MIN_VALUE;
int maxIndex = -1;
for (int j = 0; j < numbers.length; j++) {
if (numbers[j] > maxNumber) {
maxNumber = numbers[j];
maxIndex = j;
}
}
sortedNumbers[i] = maxNumber;
numbers[maxIndex] = Double.MIN_VALUE; // Marquer le nombre comme déjà utilisé
}
// Afficher le tableau trié
System.out.println("Tableau trié dans l'ordre décroissant : " + Arrays.toString(sortedNumbers));
}
}Exercice 8 : Calcul de la moyenne des nombres sans le plus petit et le plus grand
Écrivez un programme Java qui prend un tableau de nombres en entrée, puis calcule la moyenne de ces nombres en excluant le plus petit et le plus grand nombre.
public class AverageExcludingMinMax {
public static void main(String[] args) {
double[] numbers = {10.5, 20.3, 5.8, 30.2, 15.7};
// Trouver le plus petit et le plus grand nombre
double minNumber = numbers[0];
double maxNumber = numbers[0];
for (double num : numbers) {
minNumber = Math.min(minNumber, num);
maxNumber = Math.max(maxNumber, num);
}
// Calculer la somme des nombres en excluant le plus petit et le plus grand
double sum = 0;
for (double num : numbers) {
if (num != minNumber && num != maxNumber) {
sum += num;
}
}
// Calculer la moyenne
double average = sum / (numbers.length - 2); // Soustraire 2 pour exclure les min et max
// Afficher le résultat
System.out.println("La moyenne des nombres (en excluant le plus petit et le plus grand) est : " + average);
}
}Exercice 9 : Calcul de la médiane
Écrivez un programme Java qui prend un tableau de nombres en entrée, puis calcule et affiche la médiane de ces nombres.
import java.util.Arrays;
public class Median {
public static void main(String[] args) {
double[] numbers = {10.5, 20.3, 5.8, 30.2, 15.7};
// Trier le tableau
Arrays.sort(numbers);
// Trouver la médiane
double median;
int middle = numbers.length / 2;
if (numbers.length % 2 == 0) {
median = (numbers[middle - 1] + numbers[middle]) / 2;
} else {
median = numbers[middle];
}
// Afficher le résultat
System.out.println("La médiane des nombres est : " + median);
}
}Ces exercices complexes mettent en œuvre des concepts avancés de manipulation de tableaux et d’algorithmes de traitement de données en utilisant la fonction max en Java. Ils offrent une excellente opportunité d’améliorer vos compétences de programmation et de maîtriser l’utilisation de cette fonctionnalité.
Voici un QCM (Questionnaire à Choix Multiples) portant sur le sujet de la fonction max en Java :
Question 1 :
Quelle est la fonction Java utilisée pour obtenir le plus grand nombre entre deux valeurs ?
a) maxValue()
b) Math.max()
c) maxNumber()
d) findMax()
Question 2 :
Quel est le type de données retourné par la fonction Math.max() ?
a) double
b) int
c) float
d) boolean
Question 3 :
Quel est le résultat de l’appel Math.max(5, 8) ?
a) 8
b) 5
c) 13
d) -1
Question 4 :
Quelle bibliothèque est nécessaire pour utiliser la fonction Math.max() en Java ?
a) java.util
b) java.lang
c) java.math
d) java.util.Math
Question 5 :
Quelle est la complexité temporelle de la fonction Math.max() lorsqu’elle est utilisée pour comparer deux nombres ?
a) O(1)
b) O(log n)
c) O(n)
d) O(n^2)
Question 6 :
Comment trouver le plus grand nombre dans un tableau de nombres en Java en utilisant la fonction Math.max() ?
a) En comparant chaque nombre dans le tableau avec le maximum précédent
b) En triant le tableau dans l’ordre croissant
c) En calculant la moyenne de tous les nombres
d) En utilisant une boucle infinie
Question 7 :
Quel est le résultat de l’appel Math.max(Double.NaN, 5.0) ?
a) 5.0
b) NaN
c) Une erreur de compilation
d) Une exception NullPointerException
Question 8 :
La fonction Math.max() peut-elle être utilisée pour comparer des chaînes de caractères en Java ?
a) Oui
b) Non
c) Seulement si les chaînes sont converties en nombres
d) Seulement si les chaînes sont de la même longueur
Question 9 :
Quel est le résultat de l’appel Math.max(10, Integer.MAX_VALUE) ?
a) 10
b) Integer.MAX_VALUE
c) Une erreur de compilation
d) Une exception ArithmeticException
Question 10 :
La fonction Math.max() retourne le maximum de deux nombres. Comment peut-on utiliser cette fonction pour obtenir le deuxième plus grand nombre dans un tableau ?
a) En appelant la fonction deux fois avec des valeurs différentes
b) En triant le tableau dans l’ordre décroissant
c) En ignorant le maximum trouvé lors du premier appel
d) En soustrayant le maximum trouvé lors du premier appel du maximum global du tableau
Réponses :
- b)
Math.max() - a)
double - a) 8
- a)
java.util - a) O(1)
- a) En comparant chaque nombre dans le tableau avec le maximum précédent
- a)
5.0 - b) Non
- b)
Integer.MAX_VALUE - c) En ignorant le maximum trouvé lors du premier appel
Assurez-vous de réviser vos réponses avant de consulter les solutions.
Autres articles
