Édition pédagogique en français

Boucles en C : analyser les chiffres

Calculez la somme des chiffres, inversez un entier et classez le résultat selon sa primalité.

Lisez un entier positif N. Parcourez ses chiffres pour calculer leur somme et construire le nombre inversé. Classez ensuite le nombre inversé : premier, composé, ou ni l’un ni l’autre si sa valeur est inférieure à deux.

Utilisez l’arithmétique entière pour parcourir les chiffres. Les zéros en tête du résultat disparaissent naturellement : 100 devient 1. Les libellés de sortie restent en anglais pour correspondre exactement aux tests.

Entrée

Un entier positif N.

Sortie

Trois lignes : Digit Sum: <somme>, Reversed: <inverse>, puis Status: <Prime|Composite|Neither>.

Contraintes

1 ≤ N ≤ 10⁹ ; limite : 1 seconde et 64 Mo.
Choisissez un type entier assez large pour le résultat inversé.

Indices

Le dernier chiffre vaut n % 10 ; n / 10 supprime ce chiffre.
Construisez le résultat avec reversed = reversed * 10 + digit.
Pour tester la primalité, cherchez des diviseurs jusqu’à la racine carrée.

Code source

#include <stdio.h>
#include <stdbool.h>

// Function to check if a number is prime
bool is_prime(int n) {
    // TODO: Implement prime checking logic (O(sqrt(N)))
    return false;
}

int main(void) {
    int n;
    if (scanf("%d", &n) != 1) {
        return 1;
    }

    // TODO: 1. Calculate sum of digits
    // TODO: 2. Reverse the integer N
    // TODO: 3. Check if reversed integer is Prime

    // Expected print format:
    // printf("Digit Sum: %d\n", sum);
    // printf("Reversed: %d\n", reversed);
    // printf("Status: %s\n", is_prime(reversed) ? "Prime" : "Composite");

    return 0;
}

Ouvrir dans le compilateur

Explication de la solution

Accumulez la somme et le nombre inversé dans une même boucle, puis traitez séparément les valeurs inférieures à 2 ainsi que 2 et 3.

Éliminez les multiples de 2 et de 3, puis essayez les candidats 6k ± 1. La condition divisor <= n / divisor évite de calculer un carré susceptible de déborder.

Le temps est O(log₁₀ N + √R) pour le résultat inversé R, avec O(1) mémoire supplémentaire. Pour 1234, le résultat 4321 est composé : 29 × 149.

Code de la solution

#include <stdio.h>
#include <stdbool.h>

bool is_prime(int n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) return false;
    }
    return true;
}

int main(void) {
    int n;
    if (scanf("%d", &n) != 1) {
        return 1;
    }

    int temp = n;
    int digit_sum = 0;
    int reversed = 0;

    // Loop through digits using modulo and integer division
    while (temp > 0) {
        int rem = temp % 10;
        digit_sum += rem;
        reversed = reversed * 10 + rem;
        temp /= 10;
    }

    printf("Digit Sum: %d\n", digit_sum);
    printf("Reversed: %d\n", reversed);

    if (reversed <= 1) {
        printf("Status: Neither\n");
    } else if (is_prime(reversed)) {
        printf("Status: Prime\n");
    } else {
        printf("Status: Composite\n");
    }

    return 0;
}

Questions fréquentes

Pourquoi le code et certains résultats restent-ils en anglais ?

Les mots-clés C, les identifiants, les commentaires du programme et les sorties attendues restent ceux de la version originale pour conserver un code exécutable et des tests cohérents. Les explications et les consignes sont traduites.