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.0

Exercice 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.2

Exercice 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.0

La 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