Ejercicios: Control de Flujo

Acerca de¶

Estos ejercicios tienen como propósito ejercitar la lógica condicional, las estructuras de repetición y el control de flujo estructurado y seguro en C.

Capítulos de Apunte Correspondientes¶

• Introducción al Control de Flujo

Cuestiones de Estilo Aplicables¶

• Estructuras de control y llaves: De acuerdo con la Regla 0x1001h, todas las estructuras de control deben utilizar llaves ({}).

• Prohibición de break y continue: Según la Regla 0x1002h, se encuentra prohibido el uso descontrolado de break y continue. En su lugar, se deben estructurar lazos controlados mediante banderas lógicas booleanas.

• Lazos: Según la Regla 0x1003h, utilizá el lazo for para iteraciones con rango o contador definido y while para lazos controlados por condiciones lógicas.

Estructuras Condicionales¶

Ejercicio 4.1 - Condición de aprobación ⭐⭐☆☆☆¶

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>

int main(void)
{
    int nota = 0;
    printf("Ingrese la nota: ");
    if (scanf("%d", &nota) != 1) {
        printf("Error al leer la nota.\n");
        return 1;
    }

    if (nota >= 6) {
        printf("Promociona\n");
    } else if (nota >= 4) {
        printf("Aprueba\n");
    } else {
        printf("Desaprueba\n");
    }
    return 0;
}

Estructuras de Repetición (Lazos)¶

Ejercicio 4.2 - Cuenta descendente ⭐⭐☆☆☆¶

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main(void) {
    int i = 10;
    while (i >= 1) {
        printf("%d\n", i);
        i = i - 1;
    }
    return 0;
}

Ejercicio 4.3 - Múltiplos de 3 ⭐⭐☆☆☆¶

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main(void) {
    for (int i = 0; i <= 30; i = i + 1) {
        if (i % 3 == 0) {
            printf("%d es múltiplo de 3\n", i);
        }
    }
    return 0;
}

Ejercicio 4.4 - Clave de acceso con do-while ⭐⭐☆☆☆¶

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>

int main(void) {
    int clave = 0;
    int clave_correcta = 1234;

    do {
        printf("Ingrese la clave: ");
        if (scanf("%d", &clave) != 1) {
            printf("Error al leer la clave.\n");
            return 1;
        }

        if (clave != clave_correcta) {
            printf("Clave incorrecta. Reintente.\n");
        }
    } while (clave != clave_correcta);

    printf("Acceso concedido.\n");
    return 0;
}

Control de Flujo Seguro¶

Ejercicio 4.5 - Refactorización de break ⭐⭐☆☆☆¶

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <stdbool.h>

int main(void) {
    int i = 0;
    bool continuar = true;
    while (i < 10 && continuar) {
        printf("valor actual: %d\n", i);
        if (i == 4) {
            continuar = false;
        }
        i++;
    }
    return 0;
}

Ejercicio 4.6 - Refactorización de continue ⭐⭐☆☆☆¶

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main(void) {
    for (int i = 0; i <= 10; i++) {
        if (i % 2 != 0) {
            printf("i = %d\n", i);
        }
    }
    return 0;
}

Ejercicio 4.7 - Lazo de clave con bandera ⭐⭐☆☆☆¶

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <stdbool.h>

int main(void)
{
    int clave = 0;
    int clave_correcta = 1234;
    bool clave_correcta_ingresada = false;

    while (clave_correcta_ingresada == false) {
        printf("Ingrese la clave de acceso: ");
        if (scanf("%d", &clave) != 1) {
            printf("Error al leer la clave.\n");
            return 1;
        }

        if (clave == clave_correcta) {
            printf("Acceso concedido.\n");
            clave_correcta_ingresada = true; // Se modifica el estado de la bandera
        } else {
            printf("Clave incorrecta. Intente nuevamente.\n");
        }
    }
    return 0;
}

Ejercicio 4.8 - s de Práctica ⭐⭐☆☆☆¶

Ejercicio 4.9 - Mayor de dos números reales ⭐⭐☆☆☆¶

Escribí un programa que solicite dos números reales al usuario y muestre cuál es el mayor.

Ejercicio 4.10 - Números del 1 al 100 ⭐⭐☆☆☆¶

Diseñá un programa que imprima en pantalla los números enteros del 1 al 100 utilizando un lazo for.

Ejercicio 4.11 - Suma de pares del 1 al 100 ⭐⭐☆☆☆¶

Desarrollá un algoritmo que sume los números pares comprendidos en el rango del 1 al 100 inclusive.

Ejercicio 4.12 - Verificación de número primo ⭐⭐☆☆☆¶

Escribí un programa que solicite un número entero positivo e indique si es un número primo (divisible únicamente por 1 y por sí mismo).

Ejercicio 4.13 - Estado de aprobación de calificación ⭐⭐⭐☆☆¶

Escribí un programa que pida una calificación (0 a 10) e indique si el estudiante aprobó (calificación mayor o igual a 4).

Ejercicio 4.14 - Contraseña de caracteres iterativa ⭐⭐☆☆☆¶

Escribí un programa que solicite repetidamente una contraseña de caracteres al usuario hasta que coincida con un valor establecido de acceso seguro.

Ejercicio 4.15 - Contar del 1 al 10 ⭐☆☆☆☆¶

Mostrá los números del 1 al 10 usando un lazo for.

Orientación:

• for (int i = 1; i <= 10; i++)

• Imprimí cada número en una línea

Ejercicio 4.16 - Suma de N Números ⭐☆☆☆☆¶

Leé un número N y calculá la suma de los primeros N números naturales.

Orientación:

• Usá lazo for de 1 a N

• Acumulá la suma en una variable

• Alternativa: fórmula directa suma = N × (N+1) / 2

Ejercicio 4.17 - Tabla de Multiplicar ⭐⭐☆☆☆¶

Mostrá la tabla de multiplicar de un número ingresado por el usuario (1 a 10).

Orientación:

• Leé el número

• Lazo de 1 a 10: printf("%d x %d = %d\n", num, i, num * i);

Ejercicio 4.18 - Factorial con While ⭐⭐☆☆☆¶

Calculá el factorial de N usando un lazo while.

Orientación:

• Inicializá resultado = 1, contador = N

• Mientras contador > 0: resultado *= contador, contador--

• Manejá caso especial: 0! = 1

Ejercicio 4.19 - Números Pares en Rango ⭐⭐☆☆☆¶

Mostrá todos los números pares entre dos valores ingresados.

Orientación:

• Leé inicio y fin

• Lazo de inicio a fin

• Usá if (i % 2 == 0) para detectar pares

• Alternativa: for (i = inicio; i <= fin; i += 2) empezando en par

Ejercicio 4.20 - Suma hasta Cero ⭐⭐☆☆☆¶

Leé números enteros hasta que el usuario ingrese 0, luego mostrá la suma total.

Orientación:

• Usá while (true) o do-while

• Leé número

• Si es 0, break

• Caso contrario, sumá al acumulador

Ejercicio 4.21 - Validación de Entrada ⭐⭐⭐☆☆¶

Leé un número entre 1 y 100. Si está fuera de rango, pedí nuevamente hasta que sea válido.

Orientación:

• do-while es ideal aquí

• do { leer numero } while (numero < 1 || numero > 100);

• Mostrá mensaje de error en cada intento inválido

Ejercicio 4.22 - Contar Dígitos ⭐⭐⭐☆☆¶

Contá cuántos dígitos tiene un número entero.

Orientación:

• Usá lazo while (n > 0)

• Dividí por 10 en cada iteración: n /= 10

• Incrementá contador

• Caso especial: 0 tiene 1 dígito

Ejercicio 4.23 - Número Primo ⭐⭐⭐☆☆¶

Determiná si un número es primo probando divisibilidad.

Orientación:

• Si N <= 1: no primo

• Si N = 2: primo

• Probá divisores de 2 a √N

• Si alguno divide exacto: no primo

• Optimización: después del 2, probar solo impares

Ejercicio 4.24 - Secuencia de Fibonacci ⭐⭐⭐☆☆¶

Generá los primeros N números de Fibonacci.

Orientación:

• Inicializá a = 0, b = 1

• Lazo N veces:

  • Mostrá a

  • Calculá siguiente: temp = a + b; a = b; b = temp

Ejercicio 4.25 - Búsqueda en Array ⭐⭐⭐☆☆¶

Buscá un valor en un array. Si lo encontrás, mostrá su posición y break.

Orientación:

• Recorré array con for

• Compará cada elemento con el buscado

• Si coincide: guardá índice, break

• Después del lazo: verificá si se encontró

Ejercicio 4.26 - Menú Interactivo ⭐⭐⭐☆☆¶

Implementá un menú que se repita hasta que el usuario elija “Salir”.

Orientación:

• Lazo while (opcion != SALIR)

• Mostrá menú

• Leé opción

• switch para ejecutar acción

• Opción salir termina el lazo

Ejercicio 4.27 - Mayor y Menor de N Números ⭐⭐⭐☆☆¶

Leé N números y encontrá el mayor y menor.

Orientación:

• Inicializá mayor y menor con el primer número

• Lazo desde el segundo número:

  • Si actual > mayor: actualizar mayor

  • Si actual < menor: actualizar menor

Ejercicio 4.28 - Invertir un Número ⭐⭐⭐⭐☆¶

Invertí los dígitos de un número (ej: 1234 → 4321).

Orientación:

• invertido = 0

• Mientras n > 0:

  • digito = n % 10

  • invertido = invertido * 10 + digito

  • n /= 10

Ejercicio 4.29 - Números Perfectos ⭐⭐⭐⭐☆¶

Encontrá todos los números perfectos hasta N. Un número es perfecto si la suma de sus divisores (excluyéndolo) es igual al número.

Ejemplo: 6 = 1 + 2 + 3

Orientación:

• Lazo externo: de 1 a N

• Lazo interno: encontrar divisores de 2 a n/2

• Sumá divisores

• Si suma == número: es perfecto

Ejercicio 4.30 - Patrón de Asteriscos - Triángulo ⭐⭐⭐⭐☆¶

Dibujá un triángulo de asteriscos de altura N.

Ejemplo (N=5):

*
**
***
****
*****

Orientación:

• Lazo externo: filas (1 a N)

• Lazo interno: columnas (1 a fila_actual)

• Imprimí asterisco en cada columna

• Nueva línea después de cada fila

Ejercicio 4.31 - Máximo Común Divisor (Euclides) ⭐⭐⭐⭐☆¶

Implementá el algoritmo de Euclides iterativo para calcular MCD.

Algoritmo:

mientras b != 0:
    temp = b
    b = a % b
    a = temp
retornar a

Orientación:

• Usá lazo while (b != 0)

• Guardá resto en variable temporal

• Intercambiá valores

Ejercicio 4.32 - Número de Armstrong ⭐⭐⭐⭐☆¶

Determiná si un número es Armstrong (suma de sus dígitos elevados a la cantidad de dígitos igual al número).

Ejemplo: 153 = 1³ + 5³ + 3³ = 153

Orientación:

• Primer lazo: contar dígitos

• Segundo lazo: sumar dígitos elevados a esa potencia

• Comparar suma con número original

• Usá pow() de <math.h>

Ejercicio 4.33 - Simulación de Cajero Automático ⭐⭐⭐⭐⭐¶

Simulá un cajero con saldo inicial. Menú: depositar, retirar, consultar, salir.

Requisitos:

• No permitir retiros mayores al saldo

• Validar montos positivos

• Mostrar saldo después de cada operación

• Lazo hasta que elija salir

Orientación:

• Variable saldo inicial

• Lazo principal con menú

• switch para operaciones

• Validaciones antes de modificar saldo

Ejercicio 4.34 - Criba de Eratóstenes ⭐⭐⭐⭐⭐¶

Encontrá todos los números primos hasta N usando la Criba de Eratóstenes.

Algoritmo:

1. Creá array booleano de tamaño N+1, todos en true

2. Marcá 0 y 1 como no primos

3. Para cada número i de 2 a √N:

   • Si i es primo (marcado true):

     • Marcá todos sus múltiplos como no primos

4. Los que quedaron en true son primos

Orientación:

• Array: bool es_primo[N+1]

• Lazo externo: i de 2 a √N

• Lazo interno: múltiplos de i (desde i², incrementando de i en i)

• Mostrá todos los marcados como primos

Ejercicio 4.35 - s Adicionales de Patrones ⭐⭐☆☆☆¶

Ejercicio 4.36 - Pirámide Centrada ⭐⭐⭐⭐⭐¶

Dibujá una pirámide centrada de asteriscos.

Ejemplo (N=5):

    *
   ***
  *****
 *******
*********

Orientación:

• Para cada fila i (de 0 a N-1):

  • Imprimí (N-i-1) espacios

  • Imprimí (2*i+1) asteriscos

  • Nueva línea

Ejercicio 4.37 - Rombo ⭐⭐⭐⭐⭐¶

Dibujá un rombo de asteriscos.

Orientación:

• Mitad superior: pirámide creciente

• Mitad inferior: pirámide decreciente

• Mismo principio de espacios y asteriscos

Problemas de Lazos Anidados¶

Ejercicio 4.38 - Tabla de Multiplicar Completa ⭐⭐⭐⭐☆¶

Mostrá tabla de multiplicar del 1 al 10 (todas las tablas).

Orientación:

• Lazo externo: números del 1 al 10

• Lazo interno: multiplicadores del 1 al 10

• Formato: “3 x 4 = 12”

Ejercicio 4.39 - Números Primos en Rango ⭐⭐⭐⭐☆¶

Mostrá todos los números primos entre A y B.

Orientación:

• Lazo externo: números de A a B

• Lazo interno: verificar si es primo (función del ejercicio 9)

• Imprimí solo los primos

Problemas de Validación y Control¶

Ejercicio 4.40 - Juego de Adivinanza Mejorado ⭐⭐⭐⭐⭐¶

El programa elige un número aleatorio. El usuario tiene máximo 7 intentos.

Orientación:

• rand() % 100 + 1 para número aleatorio

• Lazo con contador de intentos

• Dar pistas (“muy alto”, “muy bajo”)

• break si adivina

• Después del lazo: verificar si ganó o perdió

Notas Finales¶

Estas consignas cubren todos los aspectos de lazos: for, while, do-while, lazos anidados, control de flujo y validación con repetición.

Ejercicio 4.41 - Mostrar Argumentos ⭐☆☆☆☆¶

Mostrá todos los argumentos recibidos.

Orientación:

1
2
3
4
5
6
int main(int argc, char *argv[]) {
    printf("Cantidad de argumentos: %d\n", argc);
    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }
}

• argv[0] es el nombre del programa

Ejercicio 4.42 - Saludo Personalizado ⭐☆☆☆☆¶

Lee un nombre desde argv y saludá.

Uso: ./saludo Juan

Orientación:

• Verificá: if (argc != 2) { fprintf(stderr, "Uso: %s <nombre>\n", argv[0]); return 1; }

• Usá: printf("Hola, %s!\n", argv[1]);

Ejercicio 4.43 - Suma de Dos Números ⭐⭐☆☆☆¶

Sumá dos números pasados como argumentos.

Uso: ./suma 5 3

Orientación:

• Verificá argc == 3

• Convertí con atoi: int a = atoi(argv[1]);

• O mejor: strtol(argv[1], NULL, 10) para validación

Ejercicio 4.44 - Calculadora Simple ⭐⭐⭐☆☆¶

Implementá calculadora: ./calc <num1> <operador> <num2>

Uso: ./calc 10 + 5

Orientación:

• argc == 4

• argv[2] es el operador: +, -, *, /

• Usá switch o if-else para operación

• Validá división por cero

Ejercicio 4.45 - Flags Booleanos ⭐⭐⭐☆☆¶

Procesá flags opcionales -v (verbose) y -h (help).

Uso: ./programa -v archivo.txt

Orientación:

• Recorré argv buscando strings que empiecen con -

• if (strcmp(argv[i], "-v") == 0) verbose = true;

• Argumentos no-flag son archivos u otros datos

Ejercicio 4.46 - Concatenar Argumentos ⭐⭐☆☆☆¶

Concatená todos los argumentos (excepto argv[0]) en un string.

Uso: ./concat Hola mundo desde C Salida: Hola mundo desde C

Orientación:

• Recorré argv desde índice 1

• Concatená con espacios intermedios

• Usá strcat o manualmente con índices

Ejercicio 4.47 - Conversor de Temperatura ⭐⭐⭐☆☆¶

Convertí temperatura según flags.

Uso: ./temp -c 100 (Celsius a Fahrenheit) Uso: ./temp -f 212 (Fahrenheit a Celsius)

Orientación:

• Flag determina dirección de conversión

• Valor viene después del flag

• Mostrá resultado formateado

Ejercicio 4.48 - Procesar Archivo(s) ⭐⭐⭐☆☆¶

Lee uno o más archivos pasados como argumentos y mostrá su contenido.

Uso: ./cat archivo1.txt archivo2.txt

Orientación:

• Cada argv[i] (i > 0) es un archivo

• Abrí cada uno, leé y mostrá

• Si falla abrir: mostrar error, continuar con siguiente

Ejercicio 4.49 - Flag con Valor ⭐⭐⭐⭐☆¶

Procesá flag que requiere un valor: -n <cantidad>

Uso: ./programa -n 10 archivo.txt

Orientación:

1
2
3
4
5
6
7
8
9
for (int i = 1; i < argc; i++) {
    if (strcmp(argv[i], "-n") == 0) {
        if (i + 1 < argc) {
            cantidad = atoi(argv[++i]);  // Incrementa i
        } else {
            fprintf(stderr, "Flag -n requiere valor\n");
        }
    }
}

Ejercicio 4.50 - Múltiples Flags ⭐⭐⭐⭐☆¶

Implementá programa con varios flags: -v (verbose), -o <salida>, -n <num>

Uso: ./programa -v -o salida.txt -n 100 entrada.txt

Orientación:

• Variables para cada flag

• Lazo procesando argv

• Flags pueden estar en cualquier orden

• Argumentos sin - son archivos de entrada

Ejercicio 4.51 - Validación de Argumentos ⭐⭐⭐☆☆¶

Validá que números sean realmente números.

Orientación:

1
2
3
4
5
6
char *endptr;
long num = strtol(argv[1], &endptr, 10);
if (*endptr != '\0') {
    fprintf(stderr, "Error: '%s' no es un número válido\n", argv[1]);
    return 1;
}

• strtol pone en endptr el primer carácter no-numérico

• Si *endptr != '\0', hay caracteres inválidos

Ejercicio 4.52 - Ayuda Automática ⭐⭐⭐☆☆¶

Mostrá ayuda si se pasa -h o --help, o si argumentos son incorrectos.

Orientación:

1
2
3
4
5
6
7
8
9
10
11
12
13
void mostrar_ayuda(const char *programa) {
    printf("Uso: %s [opciones] archivo\n", programa);
    printf("Opciones:\n");
    printf("  -h, --help    Mostrar esta ayuda\n");
    printf("  -v            Modo verbose\n");
    printf("  -o <archivo>  Archivo de salida\n");
}

if (argc < 2 || strcmp(argv[1], "-h") == 0 || 
    strcmp(argv[1], "--help") == 0) {
    mostrar_ayuda(argv[0]);
    return 0;
}

Ejercicio 4.53 - Grep Simplificado ⭐⭐⭐⭐☆¶

Buscá patrón en archivo(s).

Uso: ./grep "patron" archivo1.txt archivo2.txt

Orientación:

• argv[1] es el patrón

• argv[2...] son archivos

• Leé cada archivo línea por línea

• Si línea contiene patrón (strstr), mostrala

Ejercicio 4.54 - Wc (Word Count) Simplificado ⭐⭐⭐⭐☆¶

Contá líneas, palabras y caracteres de archivos.

Uso: ./wc [-l] [-w] [-c] archivo(s)

Flags:

• -l: solo líneas

• -w: solo palabras

• -c: solo caracteres

• Sin flags: todo

Orientación:

• Procesá flags para saber qué contar

• Para cada archivo, calculá métricas

• Mostrá según flags activos

Ejercicio 4.55 - Sort con Opciones ⭐⭐⭐⭐⭐¶

Ordená líneas de archivo con opciones.

Uso: ./sort [-r] [-n] archivo.txt

Flags:

• -r: orden reverso

• -n: orden numérico (en lugar de lexicográfico)

Orientación:

• Leé archivo completo en array de strings

• Ordená según flags

• Usá qsort con función comparadora apropiada

Ejercicio 4.56 - Procesamiento de Lote ⭐⭐⭐⭐⭐¶

Aplicá operación a múltiples archivos.

Uso: ./batch -op <operacion> archivo1 archivo2 ...

Operaciones: upper, lower, reverse, count

Orientación:

• Flag -op determina operación

• Aplicá a todos los archivos siguientes

• Escribí resultado en archivo.out para cada uno

Ejercicio 4.57 - Configuración desde Archivo y Args ⭐⭐⭐⭐⭐¶

Leé configuración de archivo, permitiendo override por línea de comandos.

Uso: ./programa -c config.txt -n 50

Orientación:

• Leé config.txt primero (formato clave=valor)

• Argumentos de línea de comandos sobrescriben config

• Precedencia: defaults < archivo < args

Ejercicio 4.58 - Pipeline Simulado ⭐⭐⭐⭐⭐¶

Implementá programa que puede leer de stdin o archivo.

Uso:

• ./proceso archivo.txt

• cat archivo.txt | ./proceso

Orientación:

1
2
3
4
5
6
FILE *entrada;
if (argc > 1) {
    entrada = fopen(argv[1], "r");
} else {
    entrada = stdin;  // Lee de stdin
}

• Permite composición estilo Unix

Ejercicio 4.59 - Getopt Simplificado ⭐⭐⭐⭐⭐¶

Implementá tu propia versión simplificada de getopt para parsear flags.

Orientación:

int getopt_simple(int argc, char *argv[], const char *optstring);

• optstring: “vhn:” (v y h sin valor, n con valor)

• Retorna carácter del flag o -1

• Variable global optarg con valor del flag

Ejercicio 4.60 - Sistema de Comandos ⭐⭐⭐⭐⭐¶

Implementá programa con subcomandos estilo Git.

Uso:

• ./tool add archivo.txt

• ./tool remove archivo.txt

• ./tool list

Orientación:

• argv[1] es el subcomando

• argv[2...] son argumentos del subcomando

• Cada subcomando tiene su propia lógica

• switch o tabla de funciones para dispatch

Notas Finales¶

Estas consignas cubren procesamiento de argumentos desde básico hasta sistemas complejos estilo herramientas Unix, esenciales para programas de línea de comandos profesionales.