• Analyse théorique du code :

✓ La variable n est initialisée à 0 et la variable k est initialisée à 1.

✓ La boucle do-while s'exécute au moins une fois car k est initialisé à 1.

✓ Si n est pair, le message "n est pair" est affiché, n est augmenté de 3 et la boucle continue.

✓ Si n est un multiple de 3, le message "n est multiple de 3" est affiché, n est augmenté de 5 et la boucle continue.

✓ Si n est un multiple de 5, le message "n est multiple de 5" est affiché, suivi d'un saut de ligne, et la boucle s'arrête avec l'instruction break.

✓ Si aucun des tests précédents n'est vrai, n est simplement augmenté de 1 et la boucle continue.

✓ À la fin de la boucle, la valeur finale de n est affichée.

Testons maintenant ce code sur Eclipse pour voir si notre analyse est correcte.

Voici le code :

Le résultat attendu est :

0 est pair

3 est multiple de 3

9 est multiple de 3

15 est multiple de 3

20 est multiple de 5

La valeur finale de n est : 20

Output :

Le résultat obtenu correspond bien à notre analyse théorique, donc notre réponse est correcte.

• Si on remplace k par 0 dans le code fourni on aura comme résultat : 0 est pair

La valeur finale de n à la sortie de la boucle est 3.

➢ En remplaçant la boucle do-while par while : Si nous initialisons la valeur de k à 0, la boucle ne sera jamais exécutée car la condition de la boucle while sera fausse dès le départ. Le code affichera simplement "La valeur finale de n à la sortie de la boucle est 0".

Voici le code modifié :

Le résultat obtenu est simplement :

La valeur finale de n à la sortie de la boucle est 0

Par conséquent, la boucle do-while s'exécute au moins une fois, tandis que la boucle while ne s'exécutera pas du tout si la condition est initialement fausse. La différence entre les deux boucles est donc que la boucle do-while s'exécute au moins une fois, tandis que la boucle while peut ne pas s'exécuter du tout si la condition est initialement fausse.

Tips and tricks :

➢ Voici quelques astuces générales sur l'utilisation de do-while et while :

• La boucle while est utile lorsque vous voulez exécuter une boucle tant qu'une condition est vraie. Si la condition n'est jamais vraie, la boucle ne sera jamais exécutée.

• La boucle do-while est similaire à la boucle while, mais elle garantit que le bloc de code à l'intérieur de la boucle est exécuté au moins une fois, peu importe la valeur de la condition.

• Il est important de s'assurer que la condition de la boucle est mise à jour correctement dans le bloc de code à l'intérieur de la boucle, sinon vous risquez de créer une boucle infinie.

• L'utilisation des instructions continue et break peut aider à contrôler l'exécution de la boucle. Continue permet de sauter une itération de la boucle et d'aller directement à la suivante, tandis que break permet de sortir de la boucle.

➢ Voici le programme Java pour déterminer la nième valeur de la suite de Fibonacci de manière itérative :

Le programme commence par demander à l'utilisateur d'entrer un nombre entier supérieur à 2. Si l'utilisateur entre un nombre inférieur ou égal à 2, le programme redemandera à l'utilisateur de saisir une nouvelle valeur.

Ensuite, le programme utilise une boucle for pour calculer la nième valeur de la suite de Fibonacci. Le premier et le deuxième terme de la suite sont initialisés à 1, et le troisième terme est calculé en additionnant les deux termes précédents. Les termes suivants sont calculés de la même manière, jusqu'à ce que la nième valeur soit atteinte.

➢ Voici maintenant le programme Java pour déterminer la nième valeur de la suite de Fibonacci de manière récursive :

Le programme commence également par demander à l'utilisateur d'entrer un nombre entier supérieur à 2, et redemande une nouvelle valeur si l'utilisateur entre un nombre inférieur ou égal à 2.

Ensuite, le programme utilise une méthode récursive pour calculer la nème valeur de la suite de Fibonacci. La méthode prend en entrée le nombre n et renvoie le nème terme de la suite de Fibonacci. Si n est inférieur ou égal à 2, la méthode renvoie 1. Sinon, elle renvoie la somme des deux termes précédents de la suite de Fibonacci (calculés en appelant récursivement la méthode fib).

Notez que la méthode récursive peut être moins efficace que la méthode itérative pour de grandes valeurs de n, car elle utilise beaucoup de mémoire et effectue des appels de méthode récursive.

Tips and tricks :

• Avant de commencer à écrire une fonction, définissez clairement ce que la fonction doit faire et ce que ses entrées et sorties doivent être.

• N'oubliez pas de déclarer le type de retour de la fonction avant son nom. Si la fonction ne retourne rien, utilisez le type "void".

• Les noms de fonction devraient être des verbes ou des phrases verbales qui décrivent clairement ce que la fonction fait. Par exemple, dans les deux exemples de code donnés, le nom "fib" pour la fonction qui calcule les valeurs de la suite de Fibonacci est un choix judicieux car il décrit clairement l'action de la fonction.

• Les fonctions peuvent prendre des paramètres. Déclarez-les entre les parenthèses juste après le nom de la fonction. Si plusieurs paramètres sont nécessaires, séparez-les par des virgules.

• Les fonctions doivent être conçues pour être réutilisables et génériques autant que possible, pour minimiser la duplication de code.

• Les fonctions récursives peuvent être utiles pour des problèmes mathématiques tels que le calcul de la suite de Fibonacci, mais elles peuvent également être gourmandes en ressources si elles ne sont pas correctement optimisées. Dans ces cas-là, une approche itérative peut être plus efficace.

➢ La récursivité :

✓ Comprendre le concept de récursivité : une fonction récursive est une fonction qui s'appelle elle-même. Il est important de bien comprendre comment cela fonctionne et comment les appels récursifs sont effectués pour éviter les boucles infinies.

✓ Avoir une condition d'arrêt : il est important d'avoir une condition d'arrêt dans une fonction récursive, c'est à-dire une condition qui arrête l'appel récursif et renvoie une valeur.

✓ Éviter les appels récursifs inutiles : il est important d'éviter les appels récursifs inutiles, car cela peut entraîner des performances médiocres ou même des erreurs de dépassement de pile. Il faut donc s'assurer que chaque appel récursif a un but et contribue à la résolution du problème.

✓ Utiliser la récursivité pour résoudre des problèmes récursifs : la récursivité est utile pour résoudre des problèmes qui ont une structure récursive. Par exemple, les problèmes de tri, les problèmes de recherche et les problèmes de parcours de graphes sont souvent résolus de manière récursive.

Notez que le programme utilise la classe Arrays pour trier les éléments de t3 et trouver les valeurs maximale et minimale de t3. Ces méthodes sont très pratiques et évitent de devoir écrire notre propre code pour ces opérations.

Tips and tricks :

• Arrays est une classe Java qui fournit des méthodes pour travailler avec des tableaux. Certaines méthodes utiles incluent sort pour trier un tableau dans l'ordre croissant, max et min pour trouver la valeur maximale et minimale d'un tableau, et toString pour obtenir une chaîne de caractères représentant le tableau. Assurez-vous de connaître les différentes méthodes disponibles dans la classe Arrays et comment les utiliser.

• La méthode Math.random retourne un nombre aléatoire compris entre 0 et 1. Vous pouvez utiliser cette méthode pour générer des valeurs aléatoires dans votre code. Par exemple, pour générer un nombre aléatoire compris entre 5 et 99, vous pouvez multiplier le résultat de Math.random par 95 (la différence entre 99 et 5) et ajouter 5 (la valeur minimale).

• L'allocation dynamique vous permet de créer des tableaux dont la taille est déterminée à l'exécution plutôt qu'à la compilation. En Java, vous pouvez utiliser l'opérateur new pour allouer de la mémoire pour un tableau. Par exemple, int[] t1 = new int[taille]; crée un tableau d'entiers de taille taille. Assurez-vous de valider la taille saisie par l'utilisateur pour éviter les erreurs de mémoire.

• Pour parcourir un tableau, vous pouvez utiliser une boucle for classique ou une boucle for-each. La boucle for-each est utile lorsque vous n'avez pas besoin de connaître l'indice de chaque élément du tableau. Par exemple, for (int val : t2) parcourt chaque élément de t2 et stocke sa valeur dans la variable val.

Ce code utilise un tableau d'entiers occurrences pour stocker les occurrences de chaque somme possible. Il utilise ensuite une boucle for pour simuler 70000 lancers de deux dés et mettre à jour le tableau d'occurrences en fonction de chaque lancer.

Ensuite, le code utilise une deuxième boucle for pour afficher les résultats du nombre d'occurrences de chaque somme possible. Le code conserve également la somme la plus fréquente et son nombre d'occurrences dans les variables mostFrequentSum et maxOccurrence. Enfin, le code affiche la somme la plus fréquente ainsi que son nombre d'occurrences.

Le chiffre obtenu pour la somme la plus fréquente dépendra de la simulation. En général, la somme la plus fréquente devrait être autour de 7, car il y a plus de combinaisons possibles pour obtenir cette somme que pour les autres sommes.

Cependant, il est possible que le résultat soit différent en raison de la nature aléatoire de la simulation.

Notez que la méthode Math.random() renvoie un nombre aléatoire compris entre 0 et 1. Pour simuler le lancer d'un dé à 6 faces, on peut multiplier ce nombre par 6 et ajouter 1 (pour obtenir une valeur entre 1 et 6).

Lorsque le code est compilé et exécuté, il affiche :

Tips and tricks :

• Utilisation d'un tableau pour stocker les occurrences : Le tableau est une structure de données très pratique pour stocker des occurrences, car il permet de stocker facilement et efficacement des valeurs en utilisant un indice. Dans ce code, le tableau occurrences est utilisé pour stocker le nombre d'occurrences de chaque somme de deux dés.

• Utilisation de Math.random() pour générer des nombres aléatoires : La méthode Math.random() est une méthode pratique pour générer des nombres aléatoires. Elle renvoie un double compris entre 0 (inclus) et 1 (exclus). Pour générer un nombre aléatoire compris entre a et b, on peut utiliser la formule : (int) (Math.random() * (b-a+1)) + a.

• Trouver la somme la plus fréquente : Pour trouver la somme la plus fréquente, on peut parcourir le tableau occurrences en recherchant la plus grande valeur. On peut utiliser une variable maxOccurrences pour stocker le nombre maximum d'occurrences et une variable maxSum pour stocker la somme correspondante. On peut utiliser une boucle for pour itérer sur le tableau et comparer chaque valeur avec maxOccurrences. Si une valeur est supérieure à maxOccurrences, on met à jour maxOccurrences et maxSum.

La méthode operation prend en entrée deux valeurs réelles x et y ainsi qu'un caractère op. Elle renvoie le résultat correspondant à l'opération indiquée par op, qui peut être +, -, * ou /. Si op est un autre caractère, la méthode effectue une addition par défaut.

Le programme principal (méthode main) appelle la méthode operation quatre fois avec des valeurs connues de x, y et des opérateurs différents, et affiche les résultats.

Tips and tricks :

• La structure de contrôle switch est utilisée pour évaluer différentes valeurs d'une variable et exécuter le code correspondant au cas correspondant.

• Utilisation de la méthode sc.next().charAt(0); pour lire un caractère depuis l'entrée utilisateur :

L'objet Scanner permet de lire l'entrée utilisateur depuis la console. Pour lire un caractère, on utilise la sc.next().charAt(0); qui permet de lire le premier caractère de la prochaine chaîne de caractères saisie par l'utilisateur. Dans l'exemple donné, cette méthode est utilisée pour lire le caractère d'opération saisi par l'utilisateur (dans la variable 'op'). Le caractère saisi est ensuite utilisé dans la structure de contrôle switch pour déterminer quelle opération arithmétique doit être effectuée.

Par exemple, si l'utilisateur entre le caractère "+", la méthode sc.next().charAt(0); retournera le caractère '+'.

Le code fournit une implémentation de deux méthodes permettant de travailler avec des nombres premiers.

La première méthode, « boolean premierTest (int n) », prend en entrée un nombre entier n et renvoie un booléen true si n est un nombre premier et false sinon. Elle vérifie si n est divisible par tous les nombres entre 2 et n/2, si oui, elle renvoie false, sinon elle renvoie true.

La deuxième méthode, « void chercherNbPremier(int n) », prend en entrée un nombre entier n et affiche à l'écran tous les nombres premiers compris entre 2 et n en utilisant la fonction premierTest. Elle utilise une boucle for pour parcourir tous les entiers entre 2 et n, et appelle la fonction premierTest pour chaque entier. Si premierTest renvoie true, l'entier est affiché à l'écran.

Dans le programme principal, la méthode chercherNbPremier est appelée avec n=100 pour afficher tous les nombres premiers entre 2 et 100. Le temps d'exécution de la méthode chercherNbPremier est également calculé en utilisant la fonction System.currentTimeMillis() pour mesurer le temps écoulé avant et après l'exécution de la méthode. Ce temps est affiché à l'écran en secondes avec une précision de 5 chiffres après la virgule.

Enfin, le code a été optimisé pour améliorer les performances. Pour cela, la méthode premierTest ne teste que les diviseurs impairs plutôt que tous les diviseurs entre 2 et n/2, car si un nombre n est divisible par un nombre pair, alors il est aussi divisible par 2 et n ne peut donc pas être un nombre premier. Cette optimisation permet de réduire le nombre de tests effectués et donc d'améliorer les performances du programme.

Tips and tricks :

• La méthode System.currentTimeMillis() est utilisée pour mesurer le temps d'exécution d'une partie du code. Voici quelques astuces pour son utilisation :

1. Appeler la méthode System.currentTimeMillis() avant et après le bloc de code à mesurer.

2. Soustraire le temps de fin du temps de début pour obtenir le temps écoulé en millisecondes.

3. Diviser le temps écoulé par 1000.0 pour obtenir le temps écoulé en secondes.

4. Utilisez la méthode printf pour afficher le temps écoulé avec un nombre précis de décimales.

Tips and tricks :

• La fonction affseq() affiche une séquence de nombres de 0 à n en utilisant la récursivité descendante. L'idée principale est que la fonction appelle elle-même avec un paramètre réduit à chaque appel jusqu'à atteindre la condition d'arrêt, qui est lorsque n est égal à 0. À ce stade, la fonction affiche simplement 0 et retourne.

• La fonction affseqInv() affiche une séquence de nombres de n à 0 en utilisant la récursivité. L'astuce ici consiste à placer l'affichage du nombre avant l'appel récursif. De cette façon, les nombres sont affichés dans l'ordre décroissant.

• La fonction somme_un_a() calcule la somme des nombres de 1 à n en utilisant la récursivité ascendante. L'idée principale est que la fonction appelle elle-même avec un paramètre qui est augmenté à chaque appel jusqu'à atteindre la condition d'arrêt, qui est lorsque n est égal à 1. À ce stade, la fonction retourne simplement 1.

• La fonction facto() calcule la factorielle d'un nombre en utilisant la récursivité descendante. L'astuce ici consiste à appeler la fonction elle-même avec un paramètre réduit à chaque appel jusqu'à atteindre la condition d'arrêt, qui est lorsque n est égal à 0 ou 1. À ce stade, la fonction retourne simplement 1.

La méthode construitTriangle remplit le tableau 2D triangle avec les coefficients de Pascal en utilisant les règles décrites dans l'énoncé.

La méthode creer_HauteurTriangle initialise la structure de données 2D pour stocker les coefficients, en créant d'abord un tableau 2D de taille nbNiveaux et en initialisant les tableaux relatifs à chaque niveau avec la taille appropriée. La méthode afficheTriangle affiche simplement le contenu de triangle à l'écran.

La méthode main demande à l'utilisateur d'entrer le nombre de niveaux pour le triangle de Pascal, initialise la structure de données avec la méthode creer_HauteurTriangle, remplit le tableau avec les coefficients de Pascal en appelant construitTriangle, puis affiche le résultat avec afficheTriangle.

Tips and tricks :

• Pour déclarer une matrice en Java, vous devez utiliser la syntaxe suivante :

type[][] nomMatrice = new type[nbLignes][nbColonnes];

Par exemple, pour déclarer une matrice d'entiers de 3 lignes et 4 colonnes :

int[][] matrice = new int[3][4];

• Vous pouvez également créer une matrice avec un nombre variable de colonnes pour chaque ligne. Pour cela, vous devez déclarer la matrice en utilisant un tableau à une dimension, puis initialiser chaque élément avec un tableau à une dimension de taille variable.

type[][] nomMatrice = new type[nbLignes][];

for (int i = 0; i < nbLignes; i++) { nomMatrice[i] = new type[nbColonnes]; }

• Pour accéder aux éléments d'une matrice, vous pouvez utiliser les indices de ligne et de colonne. L'indice de la première ligne et de la première colonne est 0. Pour accéder à un élément spécifique,

utilisez la syntaxe suivante : nomMatrice[ligne][colonne]

Pour passer une matrice en tant qu'argument à une méthode, vous devez spécifier le type de la matrice suivi de deux paires de crochets. Par exemple, pour une méthode qui prend en entrée une matrice d'entiers de taille variable :

public static void maMethode(int[][] matrice) { // Code }

For each :

• Pour afficher une matrice à l'aide d'une boucle for each, vous pouvez utiliser la syntaxe suivante :

int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

  for (int[] row : matrix) {

    for (int value : row) {
       System.out.print(value + " ");
      }
    System.out.println();

}