Tipos y variables en C — ejercicios para dominar printf, scanf y operadores

Los tipos y variables en C ejercicios con solución son el cierre perfecto de este primer bloque. Ya viste la teoría y practicaste con programas reales. Ahora toca resolver por tu cuenta con gedit y gcc en Fedora. Cuatro ejercicios en tres niveles con especial atención al error del & en scanf, el más silencioso y peligroso de todos.

Como siempre: intenta resolverlo, usa la pista si llevas más de 10 minutos atascado, compara con la solución al final y no olvides de pegar el código en pythontutor.com para ver su ejecución paso por paso.

Recuerda el flujo de trabajo:

gedit ejercicio.c &
# ... escribes el código ...
gcc ejercicio.c -o ejercicio
./ejercicio

Tipos y variables en C ejercicios — Nivel Básico

Ejercicio 1 — Calculadora de área y perímetro de figuras geométricas

Escribe un programa en C que pida al usuario elegir una figura geométrica (1=cuadrado, 2=rectángulo, 3=círculo) y calcule su área y perímetro.

Las fórmulas son:

• Cuadrado: área = lado², perímetro = 4 × lado
• Rectángulo: área = base × altura, perímetro = 2 × (base + altura)
• Círculo: área = π × radio², perímetro = 2 × π × radio (usa π = 3.14159)

La salida debe ser:

=== CALCULADORA DE FIGURAS ===
1. Cuadrado
2. Rectángulo
3. Círculo
Elige figura: 3
Radio: 5.0

--- Círculo con radio 5.00 ---
Área:      78.54
Perímetro: 31.42

💡 Pista — el error del &: Cuando uses scanf para leer el lado, radio o dimensiones recuerda el & obligatorio. Sin él el programa compila pero el comportamiento es indefinido — a veces parece funcionar y otras crashea. En IC2 esto confunde mucho porque el error no es consistente.

scanf("%f", radio);    // MAL — compila pero falla
scanf("%f", &radio);   // BIEN

Para π define una constante al principio con #define PI 3.14159.

---

Ejercicio 2 — Calculadora de IMC con clasificación

Escribe un programa que pida nombre (solo la inicial), peso en kg y altura en metros, calcule el IMC y lo clasifique según la OMS.

Clasificación:

• IMC < 18.5 → Bajo peso
• 18.5 ≤ IMC < 25 → Peso normal
• 25 ≤ IMC < 30 → Sobrepeso
• IMC ≥ 30 → Obesidad

La fórmula del IMC es: peso / (altura × altura)

La salida debe ser:

Inicial de tu nombre: S
Peso (kg): 70.5
Altura (m): 1.78

--- IMC para S. ---
Peso:   70.50 kg
Altura: 1.78 m
IMC:    22.25
Estado: Peso normal

💡 Pista: Usa float para peso, altura e IMC. La clasificación la haces con if/else if/else — igual que en Python pero con paréntesis en la condición. Para la inicial usa char con scanf(" %c", &inicial) — recuerda el espacio antes de %c para descartar el salto de línea anterior. Y el & es obligatorio también en %c.

---

Tipos y variables en C ejercicios — Nivel Intermedio

Ejercicio 3 — Conversor de bases numéricas

Escribe un programa que pida un número entero en decimal y lo muestre en hexadecimal y en octal. Sin hacer ninguna conversión manual, usa los especificadores de formato de printf.

La salida debe ser:

Introduce un número entero: 255

--- Conversiones de 255 ---
Decimal:     255
Hexadecimal: ff
Hexadecimal: FF
Octal:       377

Luego amplíalo para que también muestre:

• Si el número es par o impar (usando %)
• El número de bytes que ocupa un int en tu sistema (usando sizeof)
• El valor máximo que puede almacenar ese número de bytes

--- Información adicional ---
¿Par o impar?: Par
Tamaño de int: 4 bytes
Valor máximo int: 2147483647

💡 Pista: Los especificadores de formato para bases son %x (hex minúsculas), %X (hex mayúsculas) y %o (octal). No necesitas ninguna función especial — printf hace la conversión solo. Para el máximo de int incluye <limits.h> y usa la constante INT_MAX. El & en scanf sigue siendo obligatorio aunque el ejercicio parezca sencillo.

---

Tipos y variables en C ejercicios — Desafío Final

Ejercicio 4 — Calculadora científica básica

Este ejercicio mezcla todo lo del bloque. Escribe una calculadora que pida dos números y muestre todos estos resultados de una vez:

=== CALCULADORA CIENTÍFICA ===
Número A: 15
Número B: 4

--- Operaciones básicas ---
A + B  = 19
A - B  = 11
A * B  = 60
A / B  = 3      (división entera)
A / B  = 3.7500 (división real)
A % B  = 3      (módulo/resto)

--- Potencias y raíces ---
A²     = 225
B²     = 16
A³     = 3375

--- Información de tipos ---
A como int:    15
A como float:  15.000000
A como hex:    f
A como octal:  17
sizeof(int):   4 bytes
sizeof(float): 4 bytes

--- Comparaciones ---
A > B:  1
A == B: 0
A != B: 1

💡 Pistas:

• Para las potencias no hay operador ** en C, multiplica manualmente: a*a para el cuadrado, a*a*a para el cubo
• Para mostrar A como float usa el cast: (float)a
• El & en scanf es obligatorio para los dos números, si lo olvidas en uno de los dos el programa puede crashear o dar resultados incorrectos sin ningún mensaje de error claro
• Para sizeof no necesitas ningún include, es un operador del lenguaje. Úsalo así: sizeof(int)

---

Soluciones Comentadas

Solución Ejercicio 1:

#include <stdio.h>
#define PI 3.14159

int main() {
    int figura;
    float area, perimetro;

    printf("=== CALCULADORA DE FIGURAS ===\n");
    printf("1. Cuadrado\n");
    printf("2. Rectángulo\n");
    printf("3. Círculo\n");
    printf("Elige figura: ");
    scanf("%d", &figura);    /* & obligatorio */

    if (figura == 1) {
        float lado;
        printf("Lado: ");
        scanf("%f", &lado);    /* & obligatorio */
        area = lado * lado;
        perimetro = 4 * lado;
        printf("\n--- Cuadrado con lado %.2f ---\n", lado);
    }
    else if (figura == 2) {
        float base, altura;
        printf("Base: ");
        scanf("%f", &base);
        printf("Altura: ");
        scanf("%f", &altura);
        area = base * altura;
        perimetro = 2 * (base + altura);
        printf("\n--- Rectángulo %.2f x %.2f ---\n", base, altura);
    }
    else if (figura == 3) {
        float radio;
        printf("Radio: ");
        scanf("%f", &radio);    /* & obligatorio */
        area = PI * radio * radio;
        perimetro = 2 * PI * radio;
        printf("\n--- Círculo con radio %.2f ---\n", radio);
    }
    else {
        printf("Figura no válida\n");
        return 1;
    }

    printf("Área:      %.2f\n", area);
    printf("Perímetro: %.2f\n", perimetro);

    return 0;
}

Solución Ejercicio 2:

#include <stdio.h>

int main() {
    char inicial;
    float peso, altura, imc;

    printf("Inicial de tu nombre: ");
    scanf(" %c", &inicial);    /* espacio + & obligatorio */
    printf("Peso (kg): ");
    scanf("%f", &peso);
    printf("Altura (m): ");
    scanf("%f", &altura);

    imc = peso / (altura * altura);

    printf("\n--- IMC para %c. ---\n", inicial);
    printf("Peso:   %.2f kg\n", peso);
    printf("Altura: %.2f m\n",  altura);
    printf("IMC:    %.2f\n",    imc);
    printf("Estado: ");

    if (imc < 18.5)       printf("Bajo peso\n");
    else if (imc < 25.0)  printf("Peso normal\n");
    else if (imc < 30.0)  printf("Sobrepeso\n");
    else                  printf("Obesidad\n");

    return 0;
}

Solución Ejercicio 3:

#include <stdio.h>
#include <limits.h>

int main() {
    int numero;

    printf("Introduce un número entero: ");
    scanf("%d", &numero);    /* & obligatorio */

    printf("\n--- Conversiones de %d ---\n", numero);
    printf("Decimal:     %d\n", numero);
    printf("Hexadecimal: %x\n", numero);
    printf("Hexadecimal: %X\n", numero);
    printf("Octal:       %o\n", numero);

    printf("\n--- Información adicional ---\n");
    printf("¿Par o impar?: %s\n",  (numero % 2 == 0) ? "Par" : "Impar");
    printf("Tamaño de int: %lu bytes\n", sizeof(int));
    printf("Valor máximo int: %d\n",     INT_MAX);

    return 0;
}

Solución Ejercicio 4:

#include <stdio.h>

int main() {
    int a, b;

    printf("=== CALCULADORA CIENTÍFICA ===\n");
    printf("Número A: ");
    scanf("%d", &a);    /* & obligatorio */
    printf("Número B: ");
    scanf("%d", &b);    /* & obligatorio */

    printf("\n--- Operaciones básicas ---\n");
    printf("A + B  = %d\n",     a + b);
    printf("A - B  = %d\n",     a - b);
    printf("A * B  = %d\n",     a * b);
    printf("A / B  = %d\n",     a / b);
    printf("A / B  = %.4f\n",   (float)a / b);
    printf("A %% B  = %d\n",    a % b);

    printf("\n--- Potencias y raíces ---\n");
    printf("A²     = %d\n",     a * a);
    printf("B²     = %d\n",     b * b);
    printf("A³     = %d\n",     a * a * a);

    printf("\n--- Información de tipos ---\n");
    printf("A como int:    %d\n",   a);
    printf("A como float:  %f\n",   (float)a);
    printf("A como hex:    %x\n",   a);
    printf("A como octal:  %o\n",   a);
    printf("sizeof(int):   %lu bytes\n",   sizeof(int));
    printf("sizeof(float): %lu bytes\n",   sizeof(float));

    printf("\n--- Comparaciones ---\n");
    printf("A > B:  %d\n",  (a > b));
    printf("A == B: %d\n",  (a == b));
    printf("A != B: %d\n",  (a != b));

    return 0;
}

---

Chuletario — Tipos y variables en C

/* ============================================
   CHULETARIO — Tipos y variables en C
   Sergio Learns · sergiolearns.com
   ============================================ */

/* TIPOS BÁSICOS */
int    x = 5;        /* entero — 4 bytes */
char   c = 'A';      /* carácter — 1 byte */
float  f = 3.14;     /* decimal simple — 4 bytes */
double d = 3.14;     /* decimal doble — 8 bytes */

/* MODIFICADORES */
unsigned int  u = 0;  /* solo positivos */
short int     s = 0;  /* rango menor */
long int      l = 0;  /* rango mayor */
long long int ll = 0; /* rango muy grande */

/* DECLARACIÓN */
int a;               /* sin valor inicial — contiene basura */
int b = 0;           /* con valor inicial — siempre así */
int x, y, z;         /* varias del mismo tipo */

/* LITERALES */
int dec = 1234;      /* decimal */
int hex = 0x1234;    /* hexadecimal — empieza por 0x */
int oct = 01234;     /* octal — empieza por 0 ← cuidado */
char car = 'A';      /* carácter entre comillas simples */

/* OPERADORES ARITMÉTICOS */
a + b    /* suma */
a - b    /* resta */
a * b    /* multiplicación */
a / b    /* división — ENTERA si a y b son int */
a % b    /* módulo (resto) */

/* DIVISIÓN — LA TRAMPA MÁS COMÚN */
7 / 3           /* → 2     (entera — ambos int) */
7.0 / 3         /* → 2.333 (real — uno es float) */
(float)7 / 3    /* → 2.333 (cast explícito) */

/* OPERADORES LÓGICOS */
a == b   /* igual — DOBLE = para comparar */
a != b   /* distinto */
a > b    /* mayor */
a < b    /* menor */
a >= b   /* mayor o igual */
a <= b   /* menor o igual */
a && b   /* AND lógico */
a || b   /* OR lógico */
!a       /* NOT lógico */

/* NO HAY BOOLEANO EN C */
/* 0 = falso, cualquier otro = verdadero */
int aprobado = (nota >= 5.0);  /* vale 1 o 0 */

/* PRE/POST INCREMENTO */
x++    /* usa x, luego suma 1 */
++x    /* suma 1, luego usa x */
x--    /* usa x, luego resta 1 */
--x    /* resta 1, luego usa x */

/* ASIGNACIÓN COMPUESTA */
a += 3;   /* a = a + 3 */
a -= 2;   /* a = a - 2 */
a *= 4;   /* a = a * 4 */
a /= 2;   /* a = a / 2 */
a %= 3;   /* a = a % 3 */

/* PRINTF — ESCRIBIR */
printf("%d\n",   entero);    /* int */
printf("%ld\n",  largo);     /* long */
printf("%f\n",   flotante);  /* float */
printf("%lf\n",  doble);     /* double */
printf("%c\n",   caracter);  /* char */
printf("%s\n",   cadena);    /* string */
printf("%x\n",   entero);    /* hexadecimal */
printf("%o\n",   entero);    /* octal */
printf("%.2f\n", flotante);  /* 2 decimales */

/* SCANF — LEER — & SIEMPRE OBLIGATORIO */
scanf("%d",  &entero);    /* leer int */
scanf("%f",  &flotante);  /* leer float */
scanf("%lf", &doble);     /* leer double */
scanf(" %c", &caracter);  /* leer char — espacio antes */
/*             ↑
   espacio descarta saltos de línea anteriores */

/* CAST — CONVERSIÓN EXPLÍCITA DE TIPOS */
(float)entero    /* convierte int a float */
(int)flotante    /* convierte float a int (trunca) */

/* SIZEOF — TAMAÑO EN BYTES */
sizeof(int)      /* → 4 */
sizeof(float)    /* → 4 */
sizeof(double)   /* → 8 */
sizeof(char)     /* → 1 */

/* ERRORES TÍPICOS */
/* 1. Olvidar & en scanf → comportamiento indefinido */
/* 2. División entera inesperada → usar (float) o .0 */
/* 3. %d con float o %f con int → resultado incorrecto */
/* 4. Variable sin inicializar → valor basura */
/* 5. Octal accidental → 010 no es 10, es 8 */
/* 6. Olvidar ; al final de instrucción → error compilación */

---

Types and variables in C — exercises to master printf, scanf and operators

Types and variables in C exercises close out this first block. Theory and practice done, now solve on your own. Four exercises, three levels, with special focus on the & in scanf,the most silent and dangerous mistake of all.

Baisc Level

Exercise 1 — Area and perimeter calculator

Write a program that asks the user to choose a shape (1=square, 2=rectangle, 3=circle) and calculates its area and perimeter. Use #define PI 3.14159.

💡 Hint — the & mistake: Every scanf needs &. Without it the program compiles but behaviour is undefined — sometimes it seems to work, sometimes it crashes with no clear error message.

scanf("%f", radio);     // WRONG
scanf("%f", &radio);    // RIGHT

Exercise 2 — BMI calculator

Ask for a name initial, weight in kg and height in metres. Calculate BMI and classify: < 18.5 Underweight, 18.5-25 Normal, 25-30 Overweight, ≥ 30 Obese.

Formula: weight / (height * height)

💡 Hint: Use float for weight, height and BMI. For the initial use scanf(" %c", &initial) — the space before %c discards previous newlines. The & is mandatory for %c too.

Intermediate Level

Exercise 3 — Number base converter

Ask for an integer and display it in decimal, hexadecimal (lower and upper case) and octal using only printf format specifiers. Then add: odd/even check, sizeof(int) and INT_MAX.

💡 Hint: %x = hex lowercase, %X = hex uppercase, %o = octal. No conversion function needed — printf does it. Include <limits.h> for INT_MAX.

Final Challenge

Exercise 4 — Basic scientific calculator

Ask for two integers A and B. Show: all arithmetic operations (including integer and real division), powers up to cube, A displayed as int/float/hex/octal, sizeof for int and float, and comparison results.

💡 Hints:

• No ** in C — multiply manually: a*a for square, a*a*a for cube
• For float display use cast: (float)a
• & is mandatory for BOTH numbers in scanf
• sizeof needs no include — it’s a language operator

(Solutions same as Spanish version above)

Cheat sheet — Types and variables in C

/* ============================================
   CHEAT SHEET — Types and variables in C
   Sergio Learns · sergiolearns.com
   ============================================ */

/* BASIC TYPES */
int    x = 5;
char   c = 'A';
float  f = 3.14;
double d = 3.14;

/* MODIFIERS */
unsigned int u = 0;
short int    s = 0;
long int     l = 0;

/* ALWAYS INITIALISE */
int x = 0;    /* never leave uninitialised */

/* LITERALS */
int dec = 1234;     /* decimal */
int hex = 0x1234;   /* hexadecimal */
int oct = 01234;    /* octal ← careful with leading 0 */

/* ARITHMETIC */
a / b           /* INTEGER if both int */
(float)a / b    /* REAL — explicit cast */
7.0 / 3         /* REAL — one operand is float */

/* NO BOOLEAN IN C */
int passed = (grade >= 5.0);  /* 1 or 0, never true/false */

/* PRE/POST INCREMENT */
x++    /* use then increment */
++x    /* increment then use */

/* PRINTF */
printf("%d\n",   integer);
printf("%f\n",   float_var);
printf("%.2f\n", float_var);   /* 2 decimal places */
printf("%c\n",   character);
printf("%x\n",   integer);     /* hexadecimal */
printf("%o\n",   integer);     /* octal */

/* SCANF — & ALWAYS MANDATORY */
scanf("%d",  &integer);
scanf("%f",  &float_var);
scanf(" %c", &character);   /* space before %c */

/* CAST */
(float)integer   /* int to float */
(int)float_var   /* float to int (truncates) */

/* SIZEOF */
sizeof(int)     /* → 4 */
sizeof(float)   /* → 4 */
sizeof(char)    /* → 1 */

/* COMMON MISTAKES */
/* 1. Missing & in scanf → undefined behaviour */
/* 2. Integer division → use (float) or .0 */
/* 3. Wrong format specifier → incorrect output */
/* 4. Uninitialised variable → garbage value */
/* 5. Accidental octal → 010 is 8, not 10 */
/* 6. Missing ; → compile error */