placer point d'arrêt a la ligne 4 puis f5 pour suivre la valeur de j,
dans cette exercice, j'ai appris le débogage avec point d'arrêt ainsi qu'à suivre une variable dans une boucle
Exercice 2:
j'ai modifier la fonction pour rajouter un tableau et affecter j à tab[i], j'ai placer mon poit d'arrêt à la ligne 6 puis f5
dans cette exercice, j'ai appris à visualiser le remplissage du tableau a chaque itération grâce au débogage.
Exercice 3:
j'ai placer 3 points d'arrêt: ligne 2, ligne 5 et ligne 11 les valeurs par points d'arrêt sont:
ligne 2: x = 10, y = 20
ligne 5: x = 20, y = 10
ligne 11: x = 10, y = 20,
un nom parlant pour cette fonction serai "echange de valeur". Le programme ne fonctionne pas comme voulue car x et y sont passés par valeur, donc les modifications dans la fonction n'affectent pas x et y.
dans cette exercice, j'ai appris pourquoi le programme n'echanger pas de valeurs et comment régler le problème
Exercice 4:
Cela fonctionne avec le tableau car les tableaux sont passés par référence, ce qui permet à la fonction de modifier directement le contenu du tableau
Si on rajoute xy = [100, 200], le dernier console.log affiche [20, 10], car xy = [100, 200] créer un nouveau tableau avec les nouvelles valeurs, donc ne modifie pas le tableau avec les valeurs initiales, etant donnée que le premier tableau reste inchangé, l'échange reste toujours visible et ce sont eux qui s'affiche au deuxième console.log
dans cette exercice, j'ai appris à echanger des valeurs dans un tableau, et qu'avec 2 valeurs seulement l'inicial est gardé
Exercice 5:
À la ligne 1, la variable globale j est initialisée avec 10 tandiq qu'à la ligne 8, dans chaque itération de la boucle, une nouvelle variable locale j est créée avec une valeur calculée (2 * i), masquant les variables j des portées supérieures.
La portée des variables j est déterminée par leur déclaration (let), qui limite leur visibilité au bloc dans lequel elles sont définies.
dans cette exercice, j'ai appris que les variables déclarées avec let ont une portée limitée au bloc où elles sont définies, et qu'une variable locale peut masquer une variable globale ou d'une portée supérieure sans la modifier.
Exercice 6:
En exécutant le programme pas à pas, j'ai constater que modifier tab1 affecte aussi tab2
En exécutant le programme pas à pas, j'ai constater que modifier tab1 n'affecte pas tab2
J'en déduis qu'à la ligne 2 l'opérateur ([...]), "change" tab2 en une copie indépendante de tab1, ainsi on peut modifier tab1 sans affecter tab2
dans cette exercice, j'ai appris à utiliser l'operateur ([...]) qui sert a modifier indépendament des tableaux.
Exercice 7:
La fonction deb7 prend deux arguments x et y.
La fonction actuel calcule le produit de x et y en ajoutant x à lui-même y fois (via une boucle for).
La fonction effectue une multiplication en utilisant des additions répétées, mais elle ne tient pas compte de l'ordre des arguments. Par exemple, deb7(3, 5) et deb7(5, 3) devraient donner le même résultat, mais la boucle s'exécute un nombre de fois égal à y, ce qui peut être inefficace si y est beaucoup plus grand que x
Pour optimiser la fonction, j'ai fait en sorte que la boucle s'exécute le plus petit nombre de fois possible. J'ai donc fait en sorte d'échanger les valeurs de x et y si y < x
Le programme fonctionne correctement pour des nombres négatifs, mais l'ordre des arguments n'est pas bien géré, par exemple : quand je fais deb7(3, -5), la boucle ne s'exécute pas correctement, car y (le nombre d'itérations) sera négatif, ce qui est invalide pour une boucle for
Le programme fonctionne correctement pour ce cas, car l'échange des valeurs de x et y permet à la boucle de s'exécuter correctement, cependant, le programme ne gère pas tous les cas où y est négatif. Par exemple, si deb7(-5, -3) est appelé, la boucle ne fonctionnera pas correctement, car y (le nombre d'itérations) sera négatif
Pour gérer les cas où y est négatif, je vais d'abbord vérifier si y est négatif, si y est négatif, je vais faire en sorte de convertir y en positif et ajuster le signe de x pour que le résultat final reste correct
J'ai modifié mon programme pour qu'avant d'entrer dans la boucle, le programme affiche les valeurs de x et y après les éventuelles corrections (inversion de signe ou échange) pour vérifier que l'optimisation est bien appliquée
Les test avec les valeurs données fonctionnent
dans cette exercice, j'ai appris à gerer des nombres négatifs dans un algorithme, optimisation des boucles ainsi qu'à utiliser le débogage dans des situations concrètes
Exercice 8:
Prenons comme exemple n=5, voici les différentes étapes:
Étape 1 : Appel initial deb8(5)
Paramètre n : 5.
Mémoire : valeur pas encore calculée.
Appel récursif : deb8(4).
Étape 2 : Appel récursif deb8(4)
Paramètre n : 4.
Mémoire :valeur pas encore calculée.
Appel récursif : deb8(3).
Étape 3 : Appel récursif deb8(3)
Paramètre n : 3.
Mémoire : pas encore calculée.
Appel récursif : deb8(2).
Étape 4 : Appel récursif deb8(2)
Paramètre n : 2.
Mémoire :valeur pas encore calculée.
Appel récursif : deb8(1).
Étape 5 : Appel récursif deb8(1)
Paramètre n : 1.
Mémoire :valeur pas encore calculée.
Appel récursif : deb8(0).
Étape 6 : Appel récursif deb8(0) (cas de base)
Paramètre n : 0.
Mémoire : Retourne 1 (cas de base).
Étape 7 : Résolution des appels récursifs
Les appels récursifs se résolvent dans l'ordre inverse :
deb8(1) :
valeur = 1 * 1 = 1.
Retourne 1.
deb8(2) :
valeur = 2 * 1 = 2.
Retourne 2.
deb8(3) :
valeur = 3 * 2 = 6.
Retourne 6.
deb8(4) :
valeur = 4 * 6 = 24.
Retourne 24.
deb8(5) :
valeur = 5 * 24 = 120.
Retourne 120.
États finaux de la mémoire
Paramètre global n : 5.
Valeur finale retournée : 120.
Un nom plus approprié pour cette fonction serai donc calculeFactorielle, car la fonction calcule la factorielle d'un nombre
La fonction fonctionne correctement pour des valeurs positives de n, cependant, elle ne gère pas les cas où n est négatif, ce qui entraînerait une récursion infinie et un dépassement de pile (stack overflow).
Pour éviter les problèmes avec des valeurs négatives, j'ai ajouter une vérification au début de la fonction pour s'assurer que n est un entier positif ou nul, si n est négatif, je fais lever une exception. De plus je vais faire une version itérative pour otpimiser le programme car la version actuelle utilise une approche récursive qui peut entraîner un dépassement de pile pour des valeurs de n très grandes
