Exercices de Debug avec Eclipse

J’ai codé avec des mouffles et plusieurs de mes algorithmes ne fonctionnent pas. Merci de m’aider à corriger les algorithmes suivants à l’aide du debugger d’Eclipse, je sais que vous en êtes capables.

Exercice 1

public class Exercice1 {

    /**
     * J'ai un problème à l'exécution de ce programme Java.
     */
    public static void main(String[] args) {

        int[] nombres = new int[4];

        for (int i = 0; i < 5; i++) {
            System.out.println("Je vais essayer d'insérer " + i + " dans le tableau à la position " + i);
            nombres[i] = i;
            System.out.println("Succès");
        }

        System.out.print("Voici ce qu'il y a dans le tableau : ");
        for (int i = 1; i < 5; i++) {
            int element = nombres[i];
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

Exercice 2

public class Exercice2 {

    /**
     * Ce programme doit me retourner le complément d'une chaîne d'ADN, mais ça ne fonctionne pas.
     */
    public static void main(String[] args) {
        System.out.println(obtenirComplementADN("AATGCCGGC"));
        System.out.println(obtenirComplementADN("TTACGGCCG"));
        System.out.println(obtenirComplementADN("AATTCCGTACGGA"));
    }

    /**
     * Fonction qui retourne le complément d'une chaîne d'ADN.
     *
     * @param adn la chaîne d'ADN à compléter.
     * @return la chaîne d'ADN complémentaire. Exemple : entrée ("AATGCCGGC") => sortie ("TTACGGCCG").
     */
    public static String obtenirComplementADN(String adn) {
        String resultat = "";
        if (adn != null && !adn.isEmpty()) {
            char[] tableauADN = adn.toCharArray();

            for (char baseADN : tableauADN) {
                switch (baseADN) {
                    case 'A':
                        resultat = resultat.concat("T");
                    case 'T':
                        resultat = resultat.concat("A");
                    case 'C':
                        resultat = resultat.concat("G");
                    case 'G':
                        resultat = resultat.concat("C");
                }
            }
        }
        return resultat;
    }
}

Exercice 3

public class Exercice3 {

    /**
     * Ce programme ne calcule pas correctement la factorielle d'un nombre.
     */
    public static void main(String[] args) {
        System.out.println(factorielleIterative(5));
    }

    /**
     * Implémentation itérative de la factorielle.
     *
     * @param n le nombre dont on veut calculer la factorielle.
     * @return n!
     */
    public static int factorielleIterative(int n) {
        int resultat = 1;
        int i = 1;

        while (i <= n) {
            resultat *= i;
        }

        return resultat;
    }
}

Exercice 4

public class Exercice4 {

    /**
     * Ce programme m'affiche une jolie erreur. Que se passe-t-il ?
     */
    public static void main(String[] args) {
        System.out.println(fibonacciRecursif(5));
    }

    /**
     * Fonction mathématique pour trouver le n-ième nombre de Fibonacci (récursif).
     *
     * @param n l'index du nombre de Fibonacci.
     * @return le n-ième nombre de Fibonacci.
     */
    public static int fibonacciRecursif(int n) {
        int resultat = 0;

        resultat = fibonacciRecursif(n - 1) + fibonacciRecursif(n - 2);

        return resultat;
    }
}

Exercice 5

public class Exercice5 {

    /**
     * Je veux que ce programme affiche un sapin de 20 lignes de haut, mais ça ne fonctionne pas.
     */
    public static void main(String[] args) {
        String[] sapin = dessinerSapin(20);
        for (String ligne : sapin) {
            System.out.println(ligne);
        }
    }

    /**
     * Fonction qui dessine un sapin de hauteur `hauteurSapin`.
     *
     * @param hauteurSapin la hauteur du sapin à dessiner.
     * @return un tableau de chaînes de caractères représentant chaque étage du sapin.
     */
    public static String[] dessinerSapin(int hauteurSapin) {
        String[] sapin = new String[hauteurSapin + 1];
        if (hauteurSapin > 4 && hauteurSapin < 26) {
            for (int i = 0; i < hauteurSapin; i++) {
                sapin[i] = dessinerEtageSapin(i + 1, hauteurSapin);
            }
            sapin[hauteurSapin] = dessinerEtageSapin(2, hauteurSapin);
        }
        return sapin;
    }

    /**
     * Fonction qui dessine un étage du sapin.
     *
     * @param etage le numéro de l'étage à dessiner.
     * @param hauteurSapin la hauteur totale du sapin.
     * @return une chaîne de caractères représentant l'étage du sapin.
     */
    private static String dessinerEtageSapin(int etage, int hauteurSapin) {
        String etageSapin = "";
        int nombreEspaces = hauteurSapin - etage;
        int nombreDiezes = 1 + 2 * (etage - 1);

        for (int i = 0; i < nombreEspaces; i++) {
            etageSapin += " ";
        }

        for (int i = 0; i < nombreDiezes; i++) {
            etageSapin += "#";
        }

        return etageSapin;
    }
}

Corrections des exercices

Exercice 1 : Problème de Tableau

1. Dépassement de Tableau (ArrayIndexOutOfBoundsException)
   • Le tableau nombres est initialisé avec une taille de 4, mais la boucle for essaie d’insérer des éléments jusqu’à l’index 4 (qui n’existe pas, car les indices vont de 0 à 3).
   • Correction : Limiter la boucle à i < nombres.length.
2. Boucle d’Affichage Incorrecte
   • La boucle d’affichage commence à i = 1, ce qui ignore le premier élément (nombres[0]).
   • Correction : Commencer la boucle à i = 0.

public class Exercice1 {

    /**
     * Programme corrigé pour éviter les erreurs de tableau.
     */
    public static void main(String[] args) {

        int[] nombres = new int[4];

        for (int i = 0; i < nombres.length; i++) {
            System.out.println("Je vais essayer d'insérer " + i + " dans le tableau à la position " + i);
            nombres[i] = i;
            System.out.println("Succès");
        }

        System.out.print("Voici ce qu'il y a dans le tableau : ");
        for (int i = 0; i < nombres.length; i++) {
            int element = nombres[i];
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

Explications des Corrections

i < nombres.length : La boucle s'arrête à la dernière position valide du tableau (index 3).
i = 0 dans la boucle d'affichage : Affiche tous les éléments du tableau, y compris nombres[0].

```text
Je vais essayer d'insérer 0 dans le tableau à la position 0
Succès
Je vais essayer d'insérer 1 dans le tableau à la position 1
Succès
Je vais essayer d'insérer 2 dans le tableau à la position 2
Succès
Je vais essayer d'insérer 3 dans le tableau à la position 3
Succès
Voici ce qu'il y a dans le tableau : 0 1 2 3

Exercice 2 : Complément d’ADN

Oubli des break dans le switch

• Sans break, toutes les cases suivantes sont exécutées après une correspondance.
• Exemple : Si baseADN = ‘A’, le code ajoute “T”, puis “A”, puis “G”, puis “C”.
• Correction : Ajouter un break après chaque case.

Concatenation Inefficace

• resultat.concat(“T”) crée une nouvelle chaîne à chaque itération, ce qui est peu performant.
• Correction : Utiliser StringBuilder pour une concatenation efficace.

public class Exercice2_Corrigé {

    /**
     * Programme corrigé pour retourner le complément d'une chaîne d'ADN.
     */
    public static void main(String[] args) {
        System.out.println(obtenirComplementADN("AATGCCGGC"));
        System.out.println(obtenirComplementADN("TTACGGCCG"));
        System.out.println(obtenirComplementADN("AATTCCGTACGGA"));
    }

    /**
     * Fonction corrigée pour retourner le complément d'une chaîne d'ADN.
     */
    public static String obtenirComplementADN(String adn) {
        if (adn == null || adn.isEmpty()) {
            return "";
        }

        StringBuilder resultat = new StringBuilder();
        for (char baseADN : adn.toCharArray()) {
            switch (baseADN) {
                case 'A':
                    resultat.append("T");
                    break;
                case 'T':
                    resultat.append("A");
                    break;
                case 'C':
                    resultat.append("G");
                    break;
                case 'G':
                    resultat.append("C");
                    break;
                default:
                    // Gérer les caractères invalides (optionnel)
                    resultat.append(baseADN);
                    break;
            }
        }
        return resultat.toString();
    }
}

Explications des Corrections

• break : Empêche l’exécution des case suivants après une correspondance.
• StringBuilder : Plus efficace que String.concat() pour les concatenations répétées.
• Gestion des caractères invalides : Ajout d’un default pour gérer les bases ADN non valides (optionnel).

Résultat Attendu :

TTACGGCCG
AATGCCGGC
TTAAGGCATGCCG

Exercice 3 : Factorielle Itérative

Boucle while Infinite : La variable i n’est jamais incrémentée dans la boucle while, ce qui provoque une boucle infinie.

Correction : Incrémenter i à chaque itération (i++).

public class Exercice3_Corrigé {

    /**
     * Programme corrigé pour calculer la factorielle d'un nombre.
     */
    public static void main(String[] args) {
        System.out.println(factorielleIterative(5)); // Doit afficher 120
    }

    /**
     * Implémentation itérative corrigée de la factorielle.
     */
    public static int factorielleIterative(int n) {
        if (n < 0) {
            throw new IllegalArgumentException("La factorielle n'est pas définie pour les nombres négatifs.");
        }

        int resultat = 1;
        int i = 1;

        while (i <= n) {
            resultat *= i;
            i++; // Incrémentation manquante
        }

        return resultat;
    }
}

Explications des Corrections :

• i++ : Incrémente i à chaque itération pour éviter une boucle infinie.
• Gestion des entrées invalides : Ajout d’une vérification pour n < 0.

Résultat attendu : 120

Exercice 4 : Fibonacci Récursif

Condition d’Arrêt Manquante : La fonction n’a pas de cas de base pour n = 0 ou n = 1, ce qui provoque une récursion infinie (jusqu’à StackOverflowError).

Correction : Ajouter des cas de base pour n = 0 et n = 1.

Gestion des Entrées Invalides : La fonction ne gère pas les nombres négatifs.

Correction : Ajouter une vérification pour n < 0.

public class Exercice4 {

    /**
     * Programme corrigé pour calculer le n-ième nombre de Fibonacci.
     */
    public static void main(String[] args) {
        System.out.println(fibonacciRecursif(5)); // Doit afficher 5
    }

    /**
     * Fonction récursive corrigée pour calculer le n-ième nombre de Fibonacci.
     */
    public static int fibonacciRecursif(int n) {
        if (n < 0) {
            throw new IllegalArgumentException("Fibonacci n'est pas défini pour les nombres négatifs.");
        }
        if (n == 0) {
            return 0;
        }
        if (n == 1) {
            return 1;
        }

        return fibonacciRecursif(n - 1) + fibonacciRecursif(n - 2);
    }
}

Explications des Corrections :

• Cas de base : n = 0 retourne 0, et n = 1 retourne 1.
• Gestion des entrées invalides : Lève une exception pour n < 0.

Exercice 5 : Sapin

1. Problème de Logique dans dessinerEtageSapin
   • La variable hashTagNumber est calculée comme 1 + 2 * (treeHeight - 1), ce qui donne toujours la même largeur pour chaque étage, indépendamment de l’étage actuel.
   • Correction : Le nombre de # doit dépendre de l’étage actuel (etage), et non de la hauteur totale du sapin. La formule correcte est 1 + 2 * (etage - 1).
2. Problème d’Affichage
   • La méthode main affiche directement le tableau retourné par dessinerSapin, mais chaque ligne du tableau est null si la condition hauteurSapin > 4 && hauteurSapin < 26 n’est pas respectée.
   • Correction : Initialiser toutes les lignes du tableau avec une chaîne vide par défaut.
3. Problème de Tronc
   • Le tronc du sapin est dessiné avec dessinerEtageSapin(2, hauteurSapin), ce qui ne correspond pas à un tronc centré et de taille fixe.
   • Correction : Dessiner un tronc centré avec un nombre fixe de # (par exemple, 1 ou 3) et un nombre d’espaces calculé pour le centrer.
4. Problème de Boucle dans main
   • La méthode main n’affiche pas correctement chaque ligne du sapin.
   • Correction : Parcourir le tableau et afficher chaque ligne.

---

Proposition de correction :

public class Exercice5 {

    /**
     * Programme corrigé pour afficher un sapin de 20 lignes de haut.
     */
    public static void main(String[] args) {
        String[] sapin = dessinerSapin(20);
        for (String ligne : sapin) {
            System.out.println(ligne);
        }
    }

    /**
     * Fonction corrigée pour dessiner un sapin de hauteur `hauteurSapin`.
     *
     * @param hauteurSapin la hauteur du sapin à dessiner.
     * @return un tableau de chaînes de caractères représentant chaque étage du sapin.
     */
    public static String[] dessinerSapin(int hauteurSapin) {
        String[] sapin = new String[hauteurSapin + 1]; // +1 pour le tronc

        // Initialiser toutes les lignes avec une chaîne vide
        for (int i = 0; i < sapin.length; i++) {
            sapin[i] = "";
        }

        if (hauteurSapin > 0) {
            // Dessiner les étages du sapin
            for (int i = 0; i < hauteurSapin; i++) {
                sapin[i] = dessinerEtageSapin(i + 1, hauteurSapin);
            }
            // Dessiner le tronc
            sapin[hauteurSapin] = dessinerTronc(hauteurSapin);
        }

        return sapin;
    }

    /**
     * Fonction corrigée pour dessiner un étage du sapin.
     *
     * @param etage le numéro de l'étage à dessiner.
     * @param hauteurSapin la hauteur totale du sapin.
     * @return une chaîne de caractères représentant l'étage du sapin.
     */
    private static String dessinerEtageSapin(int etage, int hauteurSapin) {
        String etageSapin = "";
        int nombreEspaces = hauteurSapin - etage;
        int nombreDiezes = 1 + 2 * (etage - 1); // Formule corrigée

        for (int i = 0; i < nombreEspaces; i++) {
            etageSapin += " ";
        }

        for (int i = 0; i < nombreDiezes; i++) {
            etageSapin += "#";
        }

        return etageSapin;
    }

    /**
     * Fonction pour dessiner le tronc du sapin.
     *
     * @param hauteurSapin la hauteur totale du sapin.
     * @return une chaîne de caractères représentant le tronc du sapin.
     */
    private static String dessinerTronc(int hauteurSapin) {
        String tronc = "";
        int nombreEspaces = hauteurSapin - 1;
        int nombreDiezes = 1; // Largeur du tronc

        for (int i = 0; i < nombreEspaces; i++) {
            tronc += " ";
        }

        for (int i = 0; i < nombreDiezes; i++) {
            tronc += "#";
        }

        return tronc;
    }
}