Edición didáctica en español. El código y sus salidas conservan el original.

Ejercicios de bucles: dígitos, inversión y primalidad

Suma los dígitos de un entero, invierte su orden y clasifica el número invertido.

Lee un entero positivo N. Calcula la suma de sus dígitos y construye el entero invertido mediante operaciones aritméticas, sin convertirlo en cadena. Clasifica el resultado como primo, compuesto o ninguno de los dos si es menor o igual que uno.

Imprime exactamente tres líneas con las etiquetas Digit Sum:, Reversed: y Status:. Los valores posibles de estado son Prime, Composite y Neither. Conserva estas palabras en inglés: forman parte del contrato de salida y de las pruebas.

Entrada

Un entero positivo N.

Salida

Digit Sum: <suma>
Reversed: <invertido>
Status: <Prime|Composite|Neither>

Restricciones

1 <= N <= 1.000.000.000
Tiempo: 1 segundo. Memoria: 64 MB.
Usa un tipo suficientemente ancho para el entero invertido.

Pistas

Obtén el último dígito con % 10 y elimínalo con / 10.
Actualiza reversed = reversed * 10 + digit.
Para probar primalidad, basta buscar divisores hasta la raíz del número.

Código C

#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;
}

Abrir en el compilador

Solución y explicación

Recorre una copia de N y acumula la suma y la inversión. Los ceros finales desaparecen al invertir un entero: 100 se convierte en 1.

Trata primero los valores menores que dos y los divisibles por dos o tres. Después puedes probar candidatos 6k - 1 y 6k + 1. Para evitar desbordamientos, compara el divisor con n / divisor.

El coste es O(log10(N) + sqrt(invertido)) y el espacio auxiliar O(1). 4321 es compuesto, porque 29 × 149 = 4321.

Código de la solución

#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;
}

Preguntas frecuentes

¿Por qué el código y la salida siguen en inglés?

Las palabras clave, los identificadores y los textos que verifican las pruebas se conservan para no cambiar el programa. Las explicaciones y los controles están traducidos.