Calcul de la factorielle avec récursion

Exemple de programme qui calcule la factorielle d'un nombre entier via une fonction récursive.

#include <stdio.h>

int calculer_factorielle(int valeur);

int main() {
    int entree;
    printf("Entrez un entier positif : ");
    scanf("%d", &entree);
    if (entree < 0) {
        printf("Erreur : entrée invalide.\n");
    } else {
        int resultat = calculer_factorielle(entree);
        printf("%d! = %d\n", entree, resultat);
    }
    return 0;
}

int calculer_factorielle(int valeur) {
    if (valeur == 0) {
        return 1;
    } else {
        return valeur * calculer_factorielle(valeur - 1);
    }
}

Somme des entiers de 0 à n par récursion

Ce code utilise la récursivité pour additionner tous les entiers de 0 à n.

#include <stdio.h>

int additionner_jusqua(int limite);

int main() {
    int limite;
    printf("Entrez un entier non négatif : ");
    scanf("%d", &limite);
    if (limite < 0) {
        printf("Erreur : entrée invalide.\n");
    } else {
        int somme = additionner_jusqua(limite);
        printf("La somme est : %d\n", somme);
    }
    return 0;
}

int additionner_jusqua(int limite) {
    if (limite == 0) {
        return 0;
    } else {
        return limite + additionner_jusqua(limite - 1);
    }
}

Génération de la suite de Fibonacci

Implémentation récursive pour calculer le n-ième nombre de la suite de Fibonacci.

#include <stdio.h>

int fibonacci(int terme);

int main() {
    int terme;
    printf("Entrez la position dans la suite : ");
    scanf("%d", &terme);
    int valeur = fibonacci(terme);
    if (valeur == -1) {
        printf("Erreur : terme invalide.\n");
    } else {
        printf("Le terme %d est : %d\n", terme, valeur);
    }
    return 0;
}

int fibonacci(int terme) {
    if (terme <= 0) {
        return -1;
    } else if (terme == 1 || terme == 2) {
        return 1;
    } else {
        return fibonacci(terme - 1) + fibonacci(terme - 2);
    }
}

Conversion d'un entier en binaire

Programme qui convertit un entier décimal en sa représentation binaire à l'aide de la récursivité.

#include <stdio.h>

void afficher_binaire(int nombre);

int main() {
    int nombre;
    printf("Entrez un entier positif : ");
    scanf("%d", &nombre);
    if (nombre < 0) {
        printf("Erreur : entrée invalide.\n");
    } else {
        afficher_binaire(nombre);
        printf("\n");
    }
    return 0;
}

void afficher_binaire(int nombre) {
    if (nombre == 0) {
        return;
    } else {
        afficher_binaire(nombre / 2);
        printf("%d", nombre % 2);
    }
}

Calcul de la somme des chiffres d'un entier

Implémentation récursive pour additionner tous les chiffres d'un nombre entier.

#include <stdio.h>

int sommer_chiffres(int nombre);

int main() {
    int nombre;
    printf("Entrez un entier : ");
    scanf("%d", &nombre);
    int resultat = sommer_chiffres(nombre);
    printf("La somme des chiffres est : %d\n", resultat);
    return 0;
}

int sommer_chiffres(int nombre) {
    if (nombre == 0) {
        return 0;
    } else {
        return (nombre % 10) + sommer_chiffres(nombre / 10);
    }
}

Calcul du produit des chiffres d'un entier

Utilisation de la récursivité pour multiplier tous les chiffres d'un nombre entier.

#include <stdio.h>

int multiplier_chiffres(int nombre);

int main() {
    int nombre;
    printf("Entrez un entier non nul : ");
    scanf("%d", &nombre);
    if (nombre == 0) {
        printf("0\n");
    } else {
        int produit = multiplier_chiffres(nombre);
        printf("Le produit des chiffres est : %d\n", produit);
    }
    return 0;
}

int multiplier_chiffres(int nombre) {
    if (nombre >= 0 && nombre <= 9) {
        return nombre;
    } else {
        return (nombre % 10) * multiplier_chiffres(nombre / 10);
    }
}

Inversion des mots dans une chaîne de caractères

Programme qui inverse l'ordre des mots dans une chaîne en utilisant des fonctions récursives pour inverser les sous-chaînes.

#include <stdio.h>
#include <string.h>

void inverser_caracteres(char *debut, char *fin);

int main() {
    char phrase[100];
    printf("Entrez une phrase : ");
    fgets(phrase, sizeof(phrase), stdin);
    phrase[strcspn(phrase, "\n")] = '\0'; // Supprimer le saut de ligne

    // Inverser toute la phrase
    inverser_caracteres(phrase, phrase + strlen(phrase) - 1);

    // Inverser chaque mot individuellement
    char *courant = phrase;
    while (*courant != '\0') {
        char *debut_mot = courant;
        while (*courant != ' ' && *courant != '\0') {
            courant++;
        }
        inverser_caracteres(debut_mot, courant - 1);
        if (*courant == ' ') {
            courant++;
        }
    }

    printf("Phrase inversée : %s\n", phrase);
    return 0;
}

void inverser_caracteres(char *debut, char *fin) {
    while (debut < fin) {
        char temp = *debut;
        *debut = *fin;
        *fin = temp;
        debut++;
        fin--;
    }
}