Saltar al contenido
ES EN
Tema: automático

Ejercicio resuelto: calculadora de fracciones con punteros en C

Acumulador de fracciones en C con paso por valor y por referencia: normalización, operación transaccional, desbordamiento y parte entera por defecto.

Código de Examen C Fundamentos de programación Nivel nota Código probado

Código de Examen: Ejercicio resuelto: calculadora de fracciones con punteros en C
Fundamentos de Programación · Examen finalEjercicio 4 · 2,5 puntos · 30 min

Se quiere programar una calculadora de fracciones que trabaja sobre un acumulador. El acumulador empieza valiendo 0/1 y cada orden lo combina con una fracción leída de la entrada. Todas las fracciones se guardan en forma canónica: numerador y denominador de tipo long long, denominador estrictamente positivo y ambos primos entre sí.

Debe implementar, con estas cabeceras exactas, las funciones: long long mcd(long long a, long long b), que recibe sus argumentos por valor; void normalizar(long long *n, long long *d), que deja en forma canónica la fracción apuntada (precondición: *d != 0); int operar(long long *an, long long *ad, char op, long long bn, long long bd), que aplica acumulador op operando; y void parte_entera(long long n, long long d, long long *e, long long *r).

operar devuelve 0 si la operación es válida, 1 si el operando tiene denominador nulo o se divide por una fracción nula, y 2 si el resultado ya simplificado tiene numerador o denominador con valor absoluto mayor que 1012. Es obligatorio que, en los casos 1 y 2, el acumulador quede exactamente como estaba.

parte_entera calcula la división por defecto (hacia menos infinito): devuelve en *e el mayor entero que no supera n/d y en *r un resto con 0 <= *r < d, de modo que n = e·d + r. Atención: el operador / de C trunca hacia cero.

Entrada (por la entrada estándar): una primera línea con un entero N (0 ≤ N ≤ 1000) y después N líneas, cada una con un operador (+, -, * o /), un espacio y una fracción escrita como n/d sin espacios, con |n| ≤ 106 y |d| ≤ 106. El denominador puede ser negativo o cero y la fracción puede no estar simplificada.

Salida: por cada orden, una línea con el acumulador en la forma num/den si la operación tuvo éxito, la palabra ERROR en el caso 1 o la palabra DESBORDAMIENTO en el caso 2. Al final, una única línea con el formato final: num/den = e + r/den, usando los valores de parte_entera. Si N vale 0, solo se imprime esa línea final.

Entrada de ejemplo

5
+ 1/2
* 2/3
- 3/4
/ 0/5
/ -1/6

Salida esperada

1/2
1/3
-5/12
ERROR
5/2
final: 5/2 = 2 + 1/2
Función normalizar: signo en el numerador y reducción por el máximo común divisor, modificando los argumentos por referencia
0,5
Función operar: cálculo correcto de las cuatro operaciones y modificación del acumulador solo si la operación tiene éxito
1,0
Función parte_entera: división por defecto correcta con numeradores negativos y dos resultados devueltos por puntero
0,5
Programa principal: lectura, mensajes de error y formato de salida exactos
0,5

Pistas

Pista 1 · ¿Qué variable es la que realmente debe cambiar?

El acumulador vive en main; la función solo puede modificarlo si recibe su dirección. El operando, en cambio, no tiene por qué salir modificado: recibirlo por valor le da una copia que puede normalizar sin miedo.

Pista 2 · ¿Cómo garantizo que un error no deja el acumulador a medias?

No escriba en *an ni en *ad mientras calcula. Calcule en variables locales, normalice, compruebe el límite de 1012 y solo entonces copie el resultado. Es el patrón «calcular y confirmar».

Pista 3 · ¿Por qué <code>-7/2</code> no tiene parte entera -3?

En C, -7 / 2 vale -3 y -7 % 2 vale -1. Si el resto sale negativo, súmele el denominador y reste uno a la parte entera; como el denominador canónico es positivo, basta con esa corrección.

Solución

Solución explicada

La solución separa en cuatro funciones lo que se pasa por valor (datos que solo se consultan o que conviene copiar) y lo que se pasa por referencia (resultados que la función debe dejar en variables del llamador). El punto delicado es que operar sea transaccional: o completa la operación o no toca nada.

#include <stdio.h>
#include <stdlib.h>

#define LIMITE 1000000000000LL

enum { OK = 0, ERR_DATO = 1, ERR_DESB = 2 };

/* Paso por valor: a y b son copias, modificarlas no afecta al llamador. */
long long mcd(long long a, long long b)
{
    if (a < 0) a = -a;
    if (b < 0) b = -b;
    while (b != 0) {
        long long t = a % b;
        a = b;
        b = t;
    }
    return a;
}

/* Paso por referencia: deja la fraccion apuntada en forma canonica. */
void normalizar(long long *n, long long *d)
{
    if (*d < 0) {
        *n = -*n;
        *d = -*d;
    }
    long long g = mcd(*n, *d);
    if (g > 1) {
        *n /= g;
        *d /= g;
    }
}

/* Acumulador por referencia, operando por valor. Transaccional. */
int operar(long long *an, long long *ad, char op, long long bn, long long bd)
{
    if (bd == 0) return ERR_DATO;
    normalizar(&bn, &bd);           /* se normaliza la copia local */

    long long rn, rd;
    switch (op) {
    case '+': rn = *an * bd + bn * *ad; rd = *ad * bd; break;
    case '-': rn = *an * bd - bn * *ad; rd = *ad * bd; break;
    case '*': rn = *an * bn;            rd = *ad * bd; break;
    case '/':
        if (bn == 0) return ERR_DATO;
        rn = *an * bd;
        rd = *ad * bn;
        break;
    default:
        return ERR_DATO;
    }

    normalizar(&rn, &rd);
    if (llabs(rn) > LIMITE || rd > LIMITE) return ERR_DESB;

    *an = rn;                        /* confirmacion: unico punto de escritura */
    *ad = rd;
    return OK;
}

/* Division por defecto: n = e*d + r con 0 <= r < d (d > 0). */
void parte_entera(long long n, long long d, long long *e, long long *r)
{
    *e = n / d;
    *r = n % d;
    if (*r < 0) {
        *r += d;
        *e -= 1;
    }
}

int main(void)
{
    int N;
    if (scanf("%d", &N) != 1) N = 0;

    long long an = 0, ad = 1;
    for (int i = 0; i < N; i++) {
        char op;
        long long bn, bd;
        if (scanf(" %c %lld/%lld", &op, &bn, &bd) != 3) break;
        int res = operar(&an, &ad, op, bn, bd);
        if (res == OK)
            printf("%lld/%lld\n", an, ad);
        else if (res == ERR_DATO)
            printf("ERROR\n");
        else
            printf("DESBORDAMIENTO\n");
    }

    long long e, r;
    parte_entera(an, ad, &e, &r);
    printf("final: %lld/%lld = %lld + %lld/%lld\n", an, ad, e, r, ad);
    return 0;
}

mcd es el ejemplo puro de paso por valor: cambia el signo de a y b y los va machacando en el bucle de Euclides, pero trabaja sobre copias, así que quien la llama no ve ningún efecto. Si el numerador es 0, devuelve el denominador y normalizar deja la fracción en 0/1, la representación canónica del cero.

normalizar recibe dos punteros porque tiene dos resultados. Primero pasa el signo al numerador y después divide ambos por el máximo común divisor. Como la precondición garantiza *d != 0, g vale al menos 1 y nunca se divide por cero.

En operar está la decisión clave del ejercicio. El acumulador llega por referencia (an, ad) porque debe cambiar; el operando llega por valor (bn, bd), y por eso la llamada normalizar(&bn, &bd) modifica las copias locales y no las variables de main. La traza del ejemplo lo muestra: tras la última orden, main conserva bn = -1 y bd = 6 tal como se leyeron.

El resultado se calcula en rn y rd. Hay tres salidas anticipadas con return (denominador nulo, división por cero y desbordamiento) y todas ocurren antes de las dos únicas asignaciones a *an y *ad. Eso garantiza el requisito transaccional. En el ejemplo, la orden / 0/5 imprime ERROR y la siguiente parte de -5/12, como si la orden errónea no hubiera existido.

Los productos no desbordan long long: el acumulador nunca supera 1012 en valor absoluto y el operando normalizado no supera 106, así que cada producto queda por debajo de 1018 y una suma de dos, por debajo de 2·1018, lejos del máximo, que ronda 9,2·1018. El caso de prueba de desbordamiento lo comprueba: 1012 se acepta porque el límite es estricto, multiplicar de nuevo por 106 da DESBORDAMIENTO, y restar 1/1000000 también, porque el numerador resultante no se simplifica.

Al dividir por un operando negativo, rd puede salir negativo; en el ejemplo, -5/12 entre -1/6 produce -30/-12, que normalizar convierte en 5/2. Por eso se normaliza siempre antes de comparar rd con el límite.

parte_entera corrige la truncación hacia cero de C. En el caso de negativos, el acumulador termina en -2/3: C da cociente 0 y resto -2; la corrección deja -1 + 1/3. El último caso de prueba comprueba además que dividir el cero es legal y produce 0/1.

Código y tests en GitLab

Traza paso a paso · generada ejecutando el código

Pasoiopbnbdanad
10+1212
21*2313
32-34-512
43/05-512
54/-1652

Casos de prueba

CasoEntradaSalida esperadaSalida realResultado
ejemplo del enunciado5 + 1/2 * 2/3 - 3/4 / 0/5 / -1/61/2 1/3 -5/12 ERROR 5/2 final: 5/2 = 2 + 1/21/2 1/3 -5/12 ERROR 5/2 final: 5/2 = 2 + 1/2OK
sin órdenes0final: 0/1 = 0 + 0/1final: 0/1 = 0 + 0/1OK
negativos, denominador nulo y parte entera por defecto4 - 7/2 + 3/0 * 4/-6 - 3/1-7/2 ERROR 7/3 -2/3 final: -2/3 = -1 + 1/3-7/2 ERROR 7/3 -2/3 final: -2/3 = -1 + 1/3OK
límite de 10^12 y desbordamiento4 + 1000000/1 * 1000000/1 * 1000000/1 - 1/10000001000000/1 1000000000000/1 DESBORDAMIENTO DESBORDAMIENTO final: 1000000000000/1 = 1000000000000 + 0/11000000/1 1000000000000/1 DESBORDAMIENTO DESBORDAMIENTO final: 1000000000000/1 = 1000000000000 + 0/1OK
una sola orden: dividir el cero1 / 3/40/1 final: 0/1 = 0 + 0/10/1 final: 0/1 = 0 + 0/1OK
simplificación de valores grandes3 + 999999/1000000 + 1/1000000 - -5/1999999/1000000 1/1 6/1 final: 6/1 = 6 + 0/1999999/1000000 1/1 6/1 final: 6/1 = 6 + 0/1OK

Salidas reales: código compilado con gcc 14.4.0 (C17) y ejecutado en un contenedor aislado el 22 de noviembre de 2026.

Complejidad

Cada orden hace un número constante de operaciones aritméticas más dos llamadas a mcd. El algoritmo de Euclides tarda O(log min(a, b)) iteraciones, que con valores menores de 2·1018 son a lo sumo unas noventa. El coste total es O(N · log V), con V la magnitud de los valores, es decir, prácticamente lineal en el número de órdenes.

La memoria es O(1): el programa no guarda las órdenes, solo el acumulador y unas pocas variables locales por llamada. Pasar long long por valor cuesta lo mismo que pasar un puntero, así que copiar el operando no penaliza el rendimiento.

Errores típicos

  • Declarar void normalizar(long long n, long long d) por valor: la función reduce sus copias y la fracción del llamador queda sin simplificar.
  • Escribir en *an antes de comprobar el desbordamiento: un error deja el acumulador corrompido y todas las líneas siguientes salen mal.
  • Comprobar el límite antes de normalizar: 1/1 calculado como 10^12/10^12 se rechazaría por error, como muestra el último caso de prueba.
  • Usar directamente n / d y n % d para la parte entera: con -2/3 sale 0 + -2/3 en lugar de -1 + 1/3.
  • Detectar la división por cero mirando bd en lugar de bn: 0/5 es una fracción válida, pero dividir por ella no lo es.
  • Pasar an en lugar de &an en la llamada: es un error de tipos que el compilador señala, pero en examen escrito no hay compilador que lo avise.

Variantes

Devolver una estructura en lugar de usar punteros

Defina typedef struct { long long n, d; } Fraccion; y la firma int operar(Fraccion *acc, char op, Fraccion b). El acumulador sigue pasando por referencia y el operando por valor, ahora como estructura completa copiada. Para parte_entera puede devolverse un struct con e y r, lo que elimina los parámetros de salida.

Deshacer la última operación

Añada la orden u, que restaura el acumulador previo. Basta con que main guarde una copia del acumulador antes de cada operación con éxito; no hay que tocar operar, precisamente porque es transaccional.

En los temarios

Las funciones, los apuntadores y su combinación forman parte del temario de Fundamentos de Programación del Instituto Politécnico Nacional, cuya segunda unidad trata apuntadores, datos estructurados y funciones. Del mismo modo, la unidad de arrays y punteros de Algoritmos y Programación I de la Universidad de Buenos Aires incluye los operadores de punteros que este ejercicio usa en cada llamada con &.

Con otro enfoque, el programa de Programación de la UNAM incluye datos estructurados, relacionados con la variante con struct, y CC3301 de la Universidad de Chile parte de este dominio de C para la programación de sistemas.

Artículo generado mediante AI.larebelion

Kernel

· Dirección de tecnología · España

«Un error que deja el acumulador intacto es diseño; uno que lo deja a medias es una avería esperando turno.»

Comentarios (0)

Todavía no hay comentarios. Puedes ser el primero.

Escribe un comentario