Piscine 42 C05 : les exercices corrigés

Le projet C05 se concentre sur l’utilisation de la récursion pour résoudre des problèmes mathématiques classiques, tels que le calcul de la factorielle ou des puissances. Découvres ci-dessous les solutions détaillées et commentées pour le projet C05 de la Piscine de l’école 42.

C05 ex00 : ft_iterative_factorial

🎯 Objectif de ft_iterative_factorial

L’objectif de cet exercice est d’écrire une fonction itérative qui calcule la factorielle d’un nombre donné. La fonction renvoie le résultat de la factorielle du nombre passé en paramètre. Si l’argument n’est pas valide (par exemple, s’il est négatif), la fonction doit renvoyer 0.

🎓 Notions essententielles

  • La factorielle d’un nombre : Comprendre que la factorielle d’un nombre n, notée n!, est le produit de tous les entiers de 1 à n. Par exemple, 5! = 5 * 4 * 3 * 2 * 1 = 120.
  • Les boucles : Utiliser une boucle itérative (par exemple, while ou for) pour calculer la factorielle en multipliant successivement les entiers.
  • Les cas particuliers : Gérer les cas où l’argument est 0, 1 ou un nombre négatif.

💻 Fonctionnement de ft_iterative_factorial

Prototype de la fonction :

La fonction doit être déclarée comme suit : int ft_iterative_factorial(int nb);. Elle prend un seul paramètre, un entier nb, et renvoie un entier représentant la factorielle de nb.

Gestion des cas particuliers :

Si nb est négatif, la fonction doit immédiatement renvoyer 0, car la factorielle n’est pas définie pour les nombres négatifs. La factorielle de 0 est définie comme étant 1.

Calcul de la factorielle :

Utiliser une boucle pour multiplier successivement les entiers de 1 à nb. Initialiser un résultat à 1 et multiplier ce résultat par chaque entier jusqu’à nb.

✅ Le code de ft_iterative_factorial :

				
					int		ft_iterative_factorial(int nb)
{
	int i;
	int res;

	i = 0;
	res = 1;
	if (nb < 0)
		return (0);
	while (++i <= nb)
	{
		res *= i;
	}
	return (res);
}

💡Fonction Main pour tester ft_iterative_factorial

				
					#include <stdio.h>

int	main(void)
{
	printf("%d\n", ft_iterative_factorial(5));
}

C05 ex01 : ft_recursive_factorial

🎯 Objectif de ft_recursive_factorial

L’objectif de cet exercice est d’écrire une fonction récursive qui calcule la factorielle d’un nombre donné. La fonction renvoie le résultat de la factorielle du nombre passé en paramètre. Si l’argument n’est pas valide (par exemple, s’il est négatif), la fonction doit renvoyer 0.

🎓 Notions essententielles

  • La récursion : Comprendre le concept de récursion, où une fonction s’appelle elle-même jusqu’à ce qu’une condition de terminaison soit atteinte.
  • La factorielle d’un nombre : Comprendre que la factorielle d’un nombre n (notée n!) est le produit de tous les entiers de 1 à n. La définition récursive est n! = n * (n-1)! avec 0! = 1.
  • Les cas particuliers : Gérer les cas où l’argument est 0, 1 ou un nombre négatif.

💻 Fonctionnement de ft_recursive_factorial

Prototype de la fonction :

La fonction doit être déclarée comme suit : int ft_recursive_factorial(int nb);. Elle prend un seul paramètre, un entier nb, et renvoie un entier représentant la factorielle de nb.

Gestion des cas particuliers :

Si nb est négatif, la fonction doit immédiatement renvoyer 0, car la factorielle n’est pas définie pour les nombres négatifs. La factorielle de 0 est définie comme étant 1.

Calcul récursif de la factorielle :

Si nb est supérieur à 1, la fonction doit retourner nb * ft_recursive_factorial(nb - 1). La récursion se termine lorsque nb est égal à 0, où la fonction retourne 1.

✅ Le code de ft_recursive_factorial :

				
					int	ft_recursive_factorial(int nb)
{
	if (nb < 0)
		return (0);
	if (nb == 0)
		return (1);
	else
		return (nb * ft_recursive_factorial(nb - 1));
}

💡Fonction Main pour tester ft_recursive_factorial

				
					int main(void)
{
    printf("5! = %d\n", ft_recursive_factorial(5));  // Devrait afficher "5! = 120"
    printf("0! = %d\n", ft_recursive_factorial(0));  // Devrait afficher "0! = 1"
    printf("-5! = %d\n", ft_recursive_factorial(-5)); // Devrait afficher "-5! = 0"
    return (0);
}

C05 ex02 : ft_iterative_power

🎯 Objectif de ft_iterative_power

L’objectif de cet exercice est d’écrire une fonction itérative qui calcule la puissance d’un nombre donné. La fonction doit renvoyer le résultat de l’opération nb élevé à la puissance power. Si power est inférieur à 0, la fonction doit renvoyer 0. Si power est égal à 0, la fonction doit renvoyer 1 (car n’importe quel nombre élevé à la puissance 0 est 1, par convention).

🎓 Notions essententielles

  • Les puissances : Comprendre que la puissance power de nb est égale à nb multiplié par lui-même power fois. Par exemple, nb^3 = nb * nb * nb.
  • Les boucles : Utiliser une boucle itérative pour multiplier successivement le nombre nb par lui-même, power fois.
  • Les cas particuliers : Gérer les cas où power est 0, un nombre négatif, ou d’autres valeurs particulières.

💻 Fonctionnement de ft_iterative_power

Prototype de la fonction :

La fonction doit être déclarée comme suit : int ft_iterative_power(int nb, int power);. Elle prend deux paramètres : un entier nb (la base) et un entier power (l’exposant), et renvoie un entier représentant le résultat de nb élevé à la puissance power.

Gestion des cas particuliers :

    • Si power est inférieur à 0, la fonction doit renvoyer 0, car les puissances négatives ne sont pas gérées dans cet exercice.
    • Si power est égal à 0, la fonction doit renvoyer 1, conformément à la convention mathématique.

Calcul de la puissance :

  1. Initialiser une variable result à 1.
  2. Utiliser une boucle pour multiplier result par nb, power fois.
  3. Retourner result après la boucle.

✅ Le code de ft_iterative_power :

				
					int ft_iterative_power(int nb, int power)
{
    int result;

    if (power < 0)
        return 0;
    result = 1;
    while (power > 0)
    {
        result *= nb;
        power--;
    }
    return result;
}

💡Fonction Main pour tester ft_recursive_power

				
					int main(void)
{
    printf("2^3 = %d\n", ft_iterative_power(2, 3));  // Devrait afficher "2^3 = 8"
    printf("5^0 = %d\n", ft_iterative_power(5, 0));  // Devrait afficher "5^0 = 1"
    printf("10^-2 = %d\n", ft_iterative_power(10, -2)); // Devrait afficher "10^-2 = 0"
    return (0);
}

C05 ex03 : ft_recursive_power

🎯 Objectif de ft_recursive_power

L’objectif de cet exercice est d’écrire une fonction récursive qui calcule la puissance d’un nombre donné. La fonction doit renvoyer le résultat de l’opération nb élevé à la puissance power. Si power est inférieur à 0, la fonction doit renvoyer 0. Si power est égal à 0, la fonction doit renvoyer 1 (car n’importe quel nombre élevé à la puissance 0 est 1, par convention).

🎓 Notions essententielles

  • La récursion : Comprendre le concept de récursion, où une fonction s’appelle elle-même jusqu’à ce qu’une condition de terminaison soit atteinte.
  • Les puissances : Comprendre que la puissance power de nb est égale à nb multiplié par lui-même power fois. Par exemple, nb^3 = nb * nb * nb.
  • Les cas particuliers : Gérer les cas où power est 0, un nombre négatif, ou d’autres valeurs particulières.

💻 Fonctionnement de ft_recursive_power

Prototype de la fonction :

La fonction doit être déclarée comme suit : int ft_recursive_power(int nb, int power);. Elle prend deux paramètres : un entier nb (la base) et un entier power (l’exposant), et renvoie un entier représentant le résultat de nb élevé à la puissance power.

Gestion des cas particuliers :

    • Si power est inférieur à 0, la fonction doit renvoyer 0, car les puissances négatives ne sont pas gérées dans cet exercice.
    • Si power est égal à 0, la fonction doit renvoyer 1, conformément à la convention mathématique.

Calcul récursif de la puissance :

Si power est supérieur à 0, la fonction doit retourner nb * ft_recursive_power(nb, power - 1). La récursion se termine lorsque power est égal à 0, où la fonction retourne 1.

✅ Le code de ft_recursive_power :

				
					int	ft_recursive_power(int nb, int power)
{
	if (power < 0)
		return (0);
	if (power == 0)
return (1);
	return (nb * ft_recursive_power (nb, power -1));
}

💡Fonction Main pour tester ft_recursive_power

				
					#include <stdio.h>

int	main(void)
{
	printf("5^2 = %d\n", ft_recursive_power(5, 2));
	printf("5^0 = %d\n", ft_recursive_power(5, 0));
	printf("5^-1 = %d\n", ft_recursive_power(5, -1));
	printf("5^5 = %d\n", ft_recursive_power(5, 3));
}

📋 Les exercices de C05 :

Les projets C de la piscine 42 :

Retour vers le C04

Vers l'infini et C06

Retour en haut