Ejercicios de Cadenas

Prerrequisitos y Entorno de Ejecución Requerido¶

Para compilar y verificar las soluciones de este módulo bajo el estándar C11 estricto de cátedra, se requiere:

Compilador C11: GCC 9+ o Clang 11+ configurado con flags -Wall -Wextra -Werror -pedantic -std=c11.
Entorno POSIX: Linux o WSL con utilidades estándar y verificación de límites de memoria.
Herramientas de Verificación: Valgrind (memcheck) y AddressSanitizer (-fsanitize=address,undefined) para garantizar la ausencia de desbordamientos de búfer (buffer overflow) y lectura pasada el byte nulo (\0).
Conocimientos Previos: Cadenas estilo C terminadas en nulo (\0), calificador const char *, capacidad física de búfer vs longitud (strlen), y clasificación de caracteres (<ctype.h>).

Objetivos Pedagógicos y Competencias (Taxonomía de Bloom)¶

Nivel 2 (Comprensión): Comprender la estructura de cadenas como arreglos continuos terminados en centinela nulo y el riesgo de off-by-one.
Nivel 3 (Aplicación): Implementar algoritmos seguros de copia, concatenación, tokenización, búsqueda y formateo en C11.
Nivel 4 (Análisis): Evaluar interfaces seguras que reciben explícitamente la capacidad máxima del búfer destino y previenen truncamiento no controlado.
Andamiaje Progresivo: Ejercicios andamiados con contratos formales (precondiciones/postcondiciones), tablas de vectores de prueba y suites ejecutables con assert().

Capítulos de Apunte Correspondientes¶

capitulo-cadenas
capitulo-arreglos

Cuestiones de Estilo Aplicables¶

Seguridad en Búferes: Al escribir sobre una cadena de destino, la función debe recibir explícitamente el parámetro size_t capacidad_maxima y garantizar la terminación en \0 bajo cualquier circunstancia (0x5003h: Utilizá guardas de inclusión en todos los archivos de cabecera).
Punteros de lectura const: Toda cadena fuente que no deba modificarse debe ser calificada como const char *str.

Análisis de Cadenas¶

Ejercicio 2.03b.01 - Contar Vocales ⭐⭐☆☆☆¶

Exercise 1

Escribí una función pura que cuente el número total de vocales ('a', 'e', 'i', 'o', 'u') en una cadena ASCII, sin distinguir entre mayúsculas y minúsculas.

size_t contar_vocales(const char *cadena);

Tabla de Vectores de Prueba:

Cadena de Entrada	Salida Esperada	Comentario
`"Hola Mundo"`	`4`	Coincidencias: ‘o’, ‘a’, ‘u’, ‘o’
`"AEIOU aeiou"`	`10`	Mayúsculas y minúsculas indistintas
`"Rhythm & Crypts"`	`0`	Cero vocales en el texto
`""`	`0`	Cadena vacía inmediata
`NULL`	`0`	Puntero nulo seguro

```c #include <stdio.h> #include <stddef.h> #include <ctype.h> #include <assert.h> size_t contar_vocales(const char *cadena) { if (cadena == NULL) { return 0; } size_t contador = 0; for (size_t i = 0; cadena[i] != '\0'; ++i) { char c = (char)tolower((unsigned char)cadena[i]); if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') { contador++; } } return contador; } int main(void) { assert(contar_vocales("Hola Mundo") == 4); assert(contar_vocales("AEIOU aeiou") == 10); assert(contar_vocales("Rhythm & Crypts") == 0); assert(contar_vocales("") == 0); assert(contar_vocales(NULL) == 0); return 0; } ```


(ej_b2_c03b_02)=
### Ejercicio 2.03b.02 - Contabilizador de Caracteres y Frecuencia ⭐⭐☆☆☆

:::{exercise}
:label: ej_b2_c03b_02_contabilizador

Implementá una función pura que compute el histograma de frecuencias de caracteres ASCII en una cadena:
```c
void contar_frecuencias_ascii(const char *cadena, size_t frecuencias[256]);
```

**Tabla de Vectores de Prueba:**

| Cadena de Entrada | Consulta de Frecuencia | Resultado Esperado |
| :--- | :--- | :--- |
| `"banana"` | `'a'`, `'n'`, `'b'` | `'a'=3, 'n'=2, 'b'=1` |
| `""` (vacía) | Cualquier carácter | `0` para todas las entradas |
| `NULL` | Cualquier carácter | Seguro ante `NULL`, sin alteraciones |

::::{solution}
```c
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>

void contar_frecuencias_ascii(const char *cadena, size_t frecuencias[256]) {
    if (frecuencias == NULL) {
        return;
    }
    memset(frecuencias, 0, 256 * sizeof(size_t));
    if (cadena == NULL) {
        return;
    }
    for (size_t i = 0; cadena[i] != '\0'; ++i) {
        unsigned char c = (unsigned char)cadena[i];
        frecuencias[c]++;
    }
}

int main(void) {
    size_t f[256];
    contar_frecuencias_ascii("banana", f);
    assert(f[(unsigned char)'a'] == 3);
    assert(f[(unsigned char)'n'] == 2);
    assert(f[(unsigned char)'b'] == 1);
    assert(f[(unsigned char)'z'] == 0);

    contar_frecuencias_ascii("", f);
    for (size_t i = 0; i < 256; ++i) {
        assert(f[i] == 0);
    }

    contar_frecuencias_ascii(NULL, f);
    for (size_t i = 0; i < 256; ++i) {
        assert(f[i] == 0);
    }

    return 0;
}
```


(ej_b2_c03b_03)=
### Ejercicio 2.03b.03 - b.3 - ¿Es un número válido? ⭐⭐☆☆☆

#### Descripción
Desarrollar una función que verifique si una cadena de texto representa un
número de punto flotante válido. La validación debe seguir un conjunto de reglas
específicas.

:::{tip} Lógica y Consideraciones

-   **Reglas de Validación:**
    1.  Puede tener un signo opcional (`+` o `-`) únicamente al principio.
    2.  Debe contener al menos un dígito.
    3.  Puede contener como máximo un punto decimal (`.`).
    4.  Todos los demás caracteres deben ser dígitos (`0`-`9`).
-   **Proceso:**
    1.  Recorrer la cadena carácter por carácter.
    2.  Usar banderas (variables booleanas) para llevar un registro de si ya se
        encontró un punto decimal.
    3.  Manejar el signo solo en la primera posición.
    4.  Verificar que cada carácter sea un dígito o un punto (en la posición
        correcta).

Ayuda (pseudocódigo)

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
26
27
28
29
FUNCION es_numero_valido(cadena)
VARIABLES:
    tiene_punto (booleano)
    tiene_digito (booleano)
    i (entero)
INICIO
    tiene_punto = FALSO, tiene_digito = FALSO
    i = 0

    // Comprobar signo opcional
    SI cadena[0] == '+' O cadena[0] == '-' ENTONCES
        i = 1
    FIN SI

    // Recorrer el resto de la cadena
    MIENTRAS cadena[i] != FIN_DE_CADENA HACER
        SI es_digito(cadena[i]) ENTONCES
            tiene_digito = VERDADERO
        SINO SI cadena[i] == '.' ENTONCES
            SI tiene_punto ENTONCES RETORNAR FALSO // Más de un punto
            tiene_punto = VERDADERO
        SINO
            RETORNAR FALSO // Carácter no válido
        FIN SI
        i = i + 1
    FIN MIENTRAS

    RETORNAR tiene_digito // Debe tener al menos un dígito
FIN FUNCION

Ejercicio 2.03b.04 - b.4 - ¿Es alfabética? ⭐⭐☆☆☆¶

Descripción¶

Crear una función que determine si una cadena contiene únicamente caracteres alfabéticos (de la ‘a’ a la ‘z’, mayúsculas o minúsculas).

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
FUNCION es_alfabetica(cadena)
INICIO
    PARA cada caracter c en cadena HACER
        SI NO es_letra(c) ENTONCES
            RETORNAR FALSO
        FIN SI
    FIN PARA
    RETORNAR VERDADERO
FIN FUNCION

Propiedades de Cadenas¶

Ejercicio 2.03b.05 - b.5 - Palíndromo ⭐⭐☆☆☆¶

Descripción¶

Implementar una función que verifique si una cadena es un palíndromo, es decir, si se lee igual de izquierda a derecha que de derecha a izquierda. La verificación debe ignorar espacios en blanco y no debe ser sensible a mayúsculas/minúsculas.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
FUNCION es_palindromo_complejo(cadena)
VARIABLES:
    izquierda, derecha (enteros)
INICIO
    izquierda = 0, derecha = LONGITUD(cadena) - 1
    MIENTRAS izquierda < derecha HACER
        MIENTRAS NO es_alfabetico(cadena[izquierda]) Y izquierda < derecha HACER
            izquierda = izquierda + 1
        FIN MIENTRAS
        MIENTRAS NO es_alfabetico(cadena[derecha]) Y izquierda < derecha HACER
            derecha = derecha - 1
        FIN MIENTRAS

        SI convertir_a_minuscula(cadena[izquierda]) != convertir_a_minuscula(cadena[derecha]) ENTONCES
            RETORNAR FALSO
        FIN SI
        izquierda = izquierda + 1
        derecha = derecha - 1
    FIN MIENTRAS
    RETORNAR VERDADERO
FIN FUNCION

Ejercicio 2.03b.06 - b.6 - Anagrama ⭐⭐☆☆☆¶

Descripción¶

Escribir una función que determine si una cadena es un anagrama de otra (es decir, si ambas tienen los mismos caracteres con la misma frecuencia), ignorando mayúsculas/minúsculas y espacios.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
FUNCION son_anagramas(cadena1, cadena2)
VARIABLES:
    frecuencias (arreglo de 26 enteros)
INICIO
    INICIALIZAR frecuencias con ceros

    PARA cada caracter c en cadena1 HACER
        SI es_alfabetico(c) ENTONCES
            frecuencias[posicion_alfabeto(c)]++
        FIN SI
    FIN PARA

    PARA cada caracter c en cadena2 HACER
        SI es_alfabetico(c) ENTONCES
            frecuencias[posicion_alfabeto(c)]--
        FIN SI
    FIN PARA

    PARA i DESDE 0 HASTA 25 HACER
        SI frecuencias[i] != 0 RETORNAR FALSO
    FIN PARA

    RETORNAR VERDADERO
FIN FUNCION

Ejercicio 2.03b.07 - b.7 - Pangrama ⭐⭐☆☆☆¶

Descripción¶

Verificar si una cadena es un pangrama, es decir, si contiene todas las letras del alfabeto inglés al menos una vez. La verificación debe ser insensible a mayúsculas/minúsculas.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
FUNCION es_pangrama(cadena)
VARIABLES:
    letras_vistas (arreglo booleano de 26 posiciones)
INICIO
    INICIALIZAR letras_vistas con FALSO

    PARA cada caracter c en cadena HACER
        SI es_alfabetico(c) ENTONCES
            letras_vistas[posicion_alfabeto(c)] = VERDADERO
        FIN SI
    FIN PARA

    PARA i DESDE 0 HASTA 25 HACER
        SI letras_vistas[i] == FALSO RETORNAR FALSO
    FIN PARA

    RETORNAR VERDADERO
FIN FUNCION

Manipulación y Transformación¶

Ejercicio 2.03b.08 - b.8 - Tokenización ⭐⭐☆☆☆¶

Descripción¶

Dividir una cadena en una secuencia de “tokens” (subcadenas) basándose en un carácter delimitador. La función strtok de C es un ejemplo clásico de esto.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
FUNCION mi_strtok(cadena, delimitador)
VARIABLES ESTATICAS:
    ultimo_puntero
INICIO
    SI cadena != NULL ENTONCES
        ultimo_puntero = cadena
    FIN SI

    SI *ultimo_puntero == FIN_DE_CADENA RETORNAR NULL

    token_inicio = ultimo_puntero
    MIENTRAS *ultimo_puntero != delimitador Y *ultimo_puntero != FIN_DE_CADENA HACER
        ultimo_puntero++
    FIN MIENTRAS

    SI *ultimo_puntero != FIN_DE_CADENA ENTONCES
        *ultimo_puntero = '\0'
        ultimo_puntero++
    FIN SI

    RETORNAR token_inicio
FIN FUNCION

Ejercicio 2.03b.09 - b.9 - Compresión RLE (Run-Length Encoding) ⭐⭐☆☆☆¶

Descripción¶

Implementar una forma simple de compresión de cadenas llamada Run-Length Encoding. Esta técnica compacta una cadena reemplazando secuencias de caracteres idénticos por el número de repeticiones seguido del carácter.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
FUNCION comprimir_rle(cadena)
VARIABLES:
    resultado (cadena)
    contador, i (enteros)
INICIO
    i = 0
    MIENTRAS i < LONGITUD(cadena) HACER
        contador = 1
        MIENTRAS i+1 < LONGITUD(cadena) Y cadena[i] == cadena[i+1] HACER
            contador++, i++
        FIN MIENTRAS
        AÑADIR numero_a_cadena(contador) a resultado
        AÑADIR cadena[i] a resultado
        i++
    FIN MIENTRAS
    RETORNAR resultado
FIN FUNCION

Ejercicio 2.03b.10 - b.10 - Desduplicador ⭐⭐☆☆☆¶

Descripción¶

Escribir una función que elimine los caracteres duplicados de una cadena, conservando únicamente la primera aparición de cada carácter. La modificación puede ser in-place.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
PROCEDIMIENTO desduplicar(REF cadena)
VARIABLES:
    vistos (arreglo booleano de 256)
    p_lectura, p_escritura (enteros)
INICIO
    INICIALIZAR vistos con FALSO
    p_lectura = 0, p_escritura = 0

    MIENTRAS cadena[p_lectura] != FIN_DE_CADENA HACER
        caracter_actual = cadena[p_lectura]
        SI vistos[CODIGO_ASCII(caracter_actual)] == FALSO ENTONCES
            vistos[CODIGO_ASCII(caracter_actual)] = VERDADERO
            cadena[p_escritura] = caracter_actual
            p_escritura++
        FIN SI
        p_lectura++
    FIN MIENTRAS
    cadena[p_escritura] = FIN_DE_CADENA
FIN PROCEDIMIENTO

Ejercicio 2.03b.11 - b.11 - Número a cadena con formato ⭐⭐⭐☆☆¶

Descripción¶

Transformar un número entero largo en una cadena de texto, insertando separadores de miles (puntos o comas) para mejorar la legibilidad.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
FUNCION formatear_numero(numero)
VARIABLES:
    cadena_simple, cadena_formateada (cadenas)
    longitud, num_separadores, j (enteros)
INICIO
    cadena_simple = convertir_a_cadena(numero)
    longitud = LONGITUD(cadena_simple)
    // ... calcular num_separadores ...
    // ... reservar memoria para cadena_formateada ...

    j = 0
    PARA i DESDE 0 HASTA longitud-1 HACER
        // Lógica para insertar separador cada 3 dígitos desde la derecha
        // ...
        AÑADIR cadena_simple[i] a cadena_formateada
    FIN PARA

    RETORNAR cadena_formateada
FIN FUNCION

Ejercicio 2.03b.12 - b.12 - Búsqueda de subcadena ⭐⭐⭐☆☆¶

Descripción¶

Implementar una función que busque la primera ocurrencia de una subcadena (needle o aguja) dentro de una cadena principal (haystack o pajar). Es una reimplementación de la función strstr.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
FUNCION buscar_subcadena(haystack, needle)
VARIABLES:
    n, m, i, j (enteros)
INICIO
    n = LONGITUD(haystack)
    m = LONGITUD(needle)

    PARA i DESDE 0 HASTA n - m HACER
        j = 0
        MIENTRAS j < m Y haystack[i+j] == needle[j] HACER
            j = j + 1
        FIN MIENTRAS

        SI j == m ENTONCES
            RETORNAR i // Subcadena encontrada en el índice i
        FIN SI
    FIN PARA

    RETORNAR -1 // No encontrada
FIN FUNCION

Conversión de Base Numérica¶

Ejercicio 2.03b.13 - b.13 - Binario a decimal ⭐⭐⭐⭐☆¶

Descripción¶

Convertir una cadena que representa un número en formato binario (compuesta de '0’s y '1’s) a su valor entero decimal correspondiente.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
FUNCION binario_a_decimal(cadena_binaria)
VARIABLES:
    decimal (entero)
INICIO
    decimal = 0
    PARA cada caracter c en cadena_binaria HACER
        decimal = (decimal * 2) + (c - '0')
    FIN PARA
    RETORNAR decimal
FIN FUNCION

Ejercicio 2.03b.14 - b.14 - Hexadecimal a decimal ⭐⭐☆☆☆¶

Descripción¶

Convertir una cadena que representa un número en formato hexadecimal (dígitos 0-9 y letras A-F, insensibles a mayúsculas) a su valor entero decimal.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
FUNCION hexadecimal_a_decimal(cadena_hex)
VARIABLES:
    decimal (entero)
    valor_digito (entero)
INICIO
    decimal = 0
    PARA cada caracter c en cadena_hex HACER
        SI c >= '0' Y c <= '9' ENTONCES
            valor_digito = c - '0'
        SINO SI c >= 'a' Y c <= 'f' ENTONCES
            valor_digito = c - 'a' + 10
        SINO SI c >= 'A' Y c <= 'F' ENTONCES
            valor_digito = c - 'A' + 10
        FIN SI
        decimal = (decimal * 16) + valor_digito
    FIN PARA
    RETORNAR decimal
FIN FUNCION

Ejercicio 2.03b.15 - b.15 - Decimal a binario ⭐⭐⭐⭐☆¶

Descripción¶

Convertir un número entero decimal a su representación en una cadena de texto binaria.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
FUNCION decimal_a_binario(n)
VARIABLES:
    cadena_inversa, cadena_final (cadenas)
INICIO
    SI n == 0 RETORNAR "0"

    MIENTRAS n > 0 HACER
        resto = n MOD 2
        AÑADIR caracter(resto) a cadena_inversa
        n = n / 2
    FIN MIENTRAS

    cadena_final = invertir_cadena(cadena_inversa)
    RETORNAR cadena_final
FIN FUNCION

Ejercicio 2.03b.16 - b.16 - Decimal a hexadecimal ⭐⭐☆☆☆¶

Descripción¶

Convertir un número entero decimal a su representación en una cadena de texto hexadecimal.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
FUNCION decimal_a_hexadecimal(n)
VARIABLES:
    cadena_inversa, cadena_final (cadenas)
    mapa_hex = "0123456789ABCDEF"
INICIO
    SI n == 0 RETORNAR "0"

    MIENTRAS n > 0 HACER
        resto = n MOD 16
        AÑADIR mapa_hex[resto] a cadena_inversa
        n = n / 16
    FIN MIENTRAS

    cadena_final = invertir_cadena(cadena_inversa)
    RETORNAR cadena_final
FIN FUNCION

Más Ejercicios de Cadenas¶

Ejercicio 2.03b.17 - b.17 - Invertir palabras en una frase ⭐⭐☆☆☆¶

Descripción¶

Escribir una función que tome una frase y la modifique de tal manera que cada palabra individual quede invertida, pero el orden de las palabras en la frase se mantenga intacto.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
PROCEDIMIENTO invertir_subcadena(REF cadena, inicio, fin)
    MIENTRAS inicio < fin HACER
        INTERCAMBIAR(cadena[inicio], cadena[fin])
        inicio++, fin--
    FIN MIENTRAS
FIN PROCEDIMIENTO

PROCEDIMIENTO invertir_palabras(REF frase)
VARIABLES:
    inicio_palabra, i (enteros)
INICIO
    inicio_palabra = 0
    PARA i DESDE 0 HASTA LONGITUD(frase) HACER
        SI frase[i] == ' ' O frase[i] == FIN_DE_CADENA ENTONCES
            // Se encontró el final de una palabra
            invertir_subcadena(frase, inicio_palabra, i - 1)
            inicio_palabra = i + 1
        FIN SI
    FIN PARA
FIN PROCEDIMIENTO

Ejercicio 2.03b.18 - b.18 - Invertir orden de las palabras ⭐⭐☆☆☆¶

Descripción¶

Escribir una función que invierta el orden de las palabras en una frase. Por ejemplo, “Hola Mundo desde C” se convertiría en “C desde Mundo Hola”.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
PROCEDIMIENTO invertir_orden_palabras(REF frase)
INICIO
    // Paso 1: Invertir toda la frase
    invertir_subcadena(frase, 0, LONGITUD(frase) - 1)

    // Paso 2: Invertir cada palabra individualmente
    invertir_palabras(frase)
FIN PROCEDIMIENTO

Ejercicio 2.03b.19 - b.19 - Capitalización (Title Case) ⭐⭐⭐⭐☆¶

Descripción¶

Implementar una función que convierta una cadena a “Title Case”, donde la primera letra de cada palabra está en mayúscula y el resto de las letras de la palabra están en minúscula.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
PROCEDIMIENTO a_title_case(REF cadena)
INICIO
    convertir_a_minuscula_toda_la_cadena(cadena)
    capitalizar(cadena[0])

    PARA i DESDE 1 HASTA LONGITUD(cadena)-1 HACER
        SI cadena[i-1] == ' ' ENTONCES
            capitalizar(cadena[i])
        FIN SI
    FIN PARA
FIN PROCEDIMIENTO

Ejercicio 2.03b.20 - b.20 - Contar palabras ⭐⭐☆☆☆¶

Descripción¶

Desarrollar una función que cuente el número de palabras en una cadena. Se puede considerar que las palabras están separadas por uno o más espacios.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
FUNCION contar_palabras(cadena)
VARIABLES:
    contador, estado (enteros)
INICIO
    contador = 0
    estado = FUERA_DE_PALABRA

    PARA cada caracter c en cadena HACER
        SI c == ' ' O c == '\n' O c == '\t' ENTONCES
            estado = FUERA_DE_PALABRA
        SINO SI estado == FUERA_DE_PALABRA ENTONCES
            estado = DENTRO_DE_PALABRA
            contador = contador + 1
        FIN SI
    FIN PARA
    RETORNAR contador
FIN FUNCION

Ejercicio 2.03b.21 - b.21 - Eliminar espacios extra ⭐⭐☆☆☆¶

Descripción¶

Crear una función que elimine los espacios en blanco redundantes de una cadena: espacios al principio, al final y múltiples espacios entre palabras, dejando solo un espacio entre cada palabra.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
PROCEDIMIENTO eliminar_espacios_extra(REF cadena)
VARIABLES:
    p_lectura, p_escritura (enteros)
INICIO
    p_lectura = 0, p_escritura = 0
    MIENTRAS cadena[p_lectura] != FIN_DE_CADENA HACER
        // Copiar caracteres que no son espacios
        MIENTRAS cadena[p_lectura] != ' ' Y cadena[p_lectura] != FIN_DE_CADENA HACER
            cadena[p_escritura++] = cadena[p_lectura++]
        FIN MIENTRAS
        // Omitir múltiples espacios
        MIENTRAS cadena[p_lectura] == ' ' HACER
            p_lectura++
        FIN MIENTRAS
        // Añadir un solo espacio si no estamos al final
        SI cadena[p_lectura] != FIN_DE_CADENA ENTONCES
            cadena[p_escritura++] = ' '
        FIN SI
    FIN MIENTRAS
    cadena[p_escritura] = FIN_DE_CADENA
FIN PROCEDIMIENTO

Ejercicio 2.03b.22 - b.22 - Recorte de cadena (Trim) ⭐⭐⭐☆☆¶

Descripción¶

Implementar una función trim que modifique una cadena para eliminar todos los espacios en blanco (o cualquier otro carácter de espaciado como tabuladores o saltos de línea) que se encuentren al principio y al final de la misma.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
PROCEDIMIENTO trim(REF cadena)
VARIABLES:
    longitud, i, inicio (enteros)
INICIO
    longitud = LONGITUD(cadena)

    // Recortar final
    i = longitud - 1
    MIENTRAS i >= 0 Y es_espacio(cadena[i]) HACER
        i--
    FIN MIENTRAS
    cadena[i + 1] = FIN_DE_CADENA

    // Recortar inicio
    inicio = 0
    MIENTRAS cadena[inicio] != FIN_DE_CADENA Y es_espacio(cadena[inicio]) HACER
        inicio++
    FIN MIENTRAS

    // Mover la cadena si es necesario
    SI inicio > 0 ENTONCES
        mover_bloque_memoria(cadena, cadena + inicio, LONGITUD(cadena) - inicio + 1)
    FIN SI
FIN PROCEDIMIENTO

Ejercicio 2.03b.23 - b.23 - Reemplazar subcadena ⭐⭐⭐☆☆¶

Descripción¶

Escribir una función que reemplace todas las ocurrencias de una subcadena por otra dentro de una cadena principal. La función debe manejar cambios en la longitud de la cadena, lo que usualmente requiere memoria dinámica.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
FUNCION reemplazar_subcadena(original, buscar, reemplazar)
VARIABLES:
    nueva_cadena (cadena)
    i, j (enteros)
INICIO
    // ... calcular tamaño de nueva_cadena y reservar memoria ...
    i = 0, j = 0
    MIENTRAS i < LONGITUD(original) HACER
        SI subcadena_en(original, i) == buscar ENTONCES
            COPIAR reemplazar en nueva_cadena en la posición j
            i = i + LONGITUD(buscar)
            j = j + LONGITUD(reemplazar)
        SINO
            nueva_cadena[j] = original[i]
            i++, j++
        FIN SI
    FIN MIENTRAS
    nueva_cadena[j] = FIN_DE_CADENA
    RETORNAR nueva_cadena
FIN FUNCION

Ejercicio 2.03b.24 - b.24 - Validación de email (Simple) ⭐☆☆☆☆¶

Descripción¶

Crear una función que verifique si una cadena tiene un formato de correo electrónico básico. No busca ser exhaustiva (lo cual es muy complejo), sino validar una estructura mínima.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
FUNCION es_email_simple_valido(email)
VARIABLES:
    pos_arroba, pos_ultimo_punto (enteros)
INICIO
    pos_arroba = encontrar_caracter(email, '@')
    SI pos_arroba == NO_ENCONTRADO O pos_arroba == 0 ENTONCES
        RETORNAR FALSO
    FIN SI

    // Verificar que no haya más de un @
    // ...

    pos_ultimo_punto = encontrar_ultima_posicion(email, '.')
    SI pos_ultimo_punto == NO_ENCONTRADO O pos_ultimo_punto < pos_arroba + 2 ENTONCES
        RETORNAR FALSO
    FIN SI

    RETORNAR VERDADERO
FIN FUNCION

Ejercicio 2.03b.25 - b.25 - Cifrado César ⭐⭐☆☆☆¶

Descripción¶

Implementar el Cifrado César, un tipo de cifrado por sustitución en el que cada letra en el texto original es reemplazada por una letra un número fijo de posiciones más adelante en el alfabeto, de forma circular.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
FUNCION cifrado_cesar(cadena, desplazamiento)
VARIABLES:
    resultado (cadena)
INICIO
    PARA cada caracter c en cadena HACER
        SI es_letra_minuscula(c) ENTONCES
            nuevo_car = 'a' + (c - 'a' + desplazamiento) MOD 26
            AÑADIR nuevo_car a resultado
        SINO SI es_letra_mayuscula(c) ENTONCES
            nuevo_car = 'A' + (c - 'A' + desplazamiento) MOD 26
            AÑADIR nuevo_car a resultado
        SINO
            AÑADIR c a resultado
        FIN SI
    FIN PARA
    RETORNAR resultado
FIN FUNCION

Ejercicio 2.03b.26 - b.26 - Descifrado César ⭐⭐☆☆☆¶

Descripción¶

Escribir la función complementaria que descifre un mensaje cifrado con el Cifrado César, conociendo el desplazamiento. Es la operación inversa al ejercicio anterior.

Ayuda (pseudocódigo)

FUNCION descifrado_cesar(cadena, desplazamiento)
INICIO
    // La lógica es la misma que el cifrado, pero con -desplazamiento
    RETORNAR cifrado_cesar(cadena, 26 - desplazamiento)
FIN FUNCION

Ejercicio 2.03b.27 - b.27 - Encontrar el carácter más frecuente ⭐⭐☆☆☆¶

Descripción¶

Desarrollar una función que encuentre y devuelva el carácter que aparece con más frecuencia en una cadena. Si hay empates, puede devolver cualquiera de los más frecuentes.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
FUNCION caracter_mas_frecuente(cadena)
VARIABLES:
    frecuencias (arreglo de 256 enteros)
    max_frecuencia, char_mas_frecuente (enteros)
INICIO
    // ... llenar arreglo de frecuencias ...

    max_frecuencia = -1
    PARA i DESDE 0 HASTA 255 HACER
        SI frecuencias[i] > max_frecuencia ENTONCES
            max_frecuencia = frecuencias[i]
            char_mas_frecuente = i
        FIN SI
    FIN PARA
    RETORNAR CARACTER(char_mas_frecuente)
FIN FUNCION

Ejercicio 2.03b.28 - b.28 - Comparación de cadenas (Ignorando mayúsculas) ⭐⭐⭐☆☆¶

Descripción¶

Implementar su propia versión de la función strcasecmp, que compara dos cadenas sin diferenciar entre mayúsculas y minúsculas.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
FUNCION comparar_sin_caso(s1, s2)
INICIO
    MIENTRAS *s1 != FIN_DE_CADENA Y *s2 != FIN_DE_CADENA HACER
        c1 = convertir_a_minuscula(*s1)
        c2 = convertir_a_minuscula(*s2)
        SI c1 != c2 ENTONCES
            RETORNAR c1 - c2
        FIN SI
        s1++, s2++
    FIN MIENTRAS
    RETORNAR convertir_a_minuscula(*s1) - convertir_a_minuscula(*s2)
FIN FUNCION

Ejercicio 2.03b.29 - b.29 - Extraer subcadena ⭐⭐⭐☆☆¶

Descripción¶

Crear una función que extraiga una porción de una cadena. La función debe recibir la cadena original, una posición de inicio y una longitud, y devolver una nueva cadena con la subcadena extraída.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
FUNCION extraer_subcadena(cadena, inicio, longitud)
VARIABLES:
    subcadena (cadena)
INICIO
    // ... reservar memoria para subcadena ...
    COPIAR_MEMORIA(subcadena, cadena + inicio, longitud)
    subcadena[longitud] = FIN_DE_CADENA
    RETORNAR subcadena
FIN FUNCION

Ejercicio 2.03b.30 - b.30 - Justificar texto (Simple) ⭐☆☆☆☆¶

Descripción¶

Implementar una función que justifique una línea de texto a un ancho específico, insertando espacios adicionales entre las palabras de la manera más uniforme posible.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
FUNCION justificar_texto(linea, ancho)
VARIABLES:
    num_palabras, num_espacios, espacios_por_hueco, espacios_extra
INICIO
    // ... contar palabras y caracteres ...
    // ... calcular espacios a insertar ...

    // ... construir la nueva cadena ...
    RETORNAR cadena_justificada
FIN FUNCION

Ejercicio 2.03b.31 - b.31 - Acrónimo ⭐⭐☆☆☆¶

Descripción¶

Escribir una función que genere un acrónimo a partir de una frase, tomando la primera letra de cada palabra.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
FUNCION generar_acronimo(frase)
VARIABLES:
    acronimo (cadena)
    es_inicio_de_palabra (booleano)
INICIO
    acronimo = ""
    es_inicio_de_palabra = VERDADERO

    PARA cada caracter c en frase HACER
        SI es_letra(c) Y es_inicio_de_palabra ENTONCES
            AÑADIR convertir_a_mayuscula(c) a acronimo
            es_inicio_de_palabra = FALSO
        SINO SI c == ' ' ENTONCES
            es_inicio_de_palabra = VERDADERO
        FIN SI
    FIN PARA
    RETORNAR acronimo
FIN FUNCION

Cadenas y Algoritmos¶

Ejercicio 2.03b.32 - Distancia de Hamming entre Cadenas ⭐⭐☆☆☆¶

Exercise cadenas-32

La distancia de Hamming entre dos cadenas de igual longitud es el número de posiciones en las cuales los caracteres correspondientes son distintos. Es ampliamente utilizada en teoría de códigos correctores y bioinformática.

Implementá la función:

long calcular_distancia_hamming(const char *s1, const char *s2);

Precondiciones: s1 != NULL, s2 != NULL.
Comportamiento: Si las cadenas difieren en longitud o si algún puntero es NULL, la función debe retornar -1 como señal de error. Si son de idéntica longitud, retorna el total de discrepancias posicionales ( $0 \le d \le longitud$ ).

Tabla de Vectores de Prueba Obligatorios¶

Caso de Prueba	Cadena 1 (`s1`)	Cadena 2 (`s2`)	Retorno Esperado	Justificación Técnica
Cadenas Idénticas	`"karolin"`	`"karolin"`	`0`	Cero diferencias
Diferencias Múltiples	`"karolin"`	`"kathrin"`	`3`	Diferencias en ‘r’/‘t’, ‘o’/‘h’, ‘l’/‘r’
Discrepancia Total	`"1011101"`	`"0100010"`	`7`	Todos los bits complementarios
Longitudes Distintas	`"hola"`	`"mundo!"`	`-1`	Longitud no coincidente
Puntero Nulo	`NULL`	`"test"`	`-1`	Manejo defensivo

```c #include <stdio.h> #include <string.h> #include <assert.h> long calcular_distancia_hamming(const char *s1, const char *s2) { if (s1 == NULL || s2 == NULL) { return -1; } size_t len1 = strlen(s1); size_t len2 = strlen(s2); if (len1 != len2) { return -1; } long distancia = 0; for (size_t i = 0; i < len1; i++) { if (s1[i] != s2[i]) { distancia++; } } return distancia; } int main(void) { // Caso idénticas assert(calcular_distancia_hamming("karolin", "karolin") == 0); // Caso 3 diferencias assert(calcular_distancia_hamming("karolin", "kathrin") == 3); // Caso 100% diferentes assert(calcular_distancia_hamming("1011101", "0100010") == 7); // Cadenas vacías (longitud 0) assert(calcular_distancia_hamming("", "") == 0); // Longitudes desiguales assert(calcular_distancia_hamming("hola", "mundo!") == -1); assert(calcular_distancia_hamming("abc", "ab") == -1); // Punteros nulos assert(calcular_distancia_hamming(NULL, "abc") == -1); assert(calcular_distancia_hamming("abc", NULL) == -1); return 0; } ```


(ej_b2_c03b_33)=
### Ejercicio 2.03b.33 - b.33 - Subsecuencia común más larga (LCS) ⭐⭐☆☆☆

#### Descripción
Escribir una función que encuentre la longitud de la subsecuencia común más
larga (LCS) entre dos cadenas. Una subsecuencia no tiene por qué ser contigua.

:::{tip} Lógica y Consideraciones

-   **Algoritmo:** Este es un problema clásico de programación dinámica.
-   **Proceso:**
    1.  Crear una matriz 2D `dp` de tamaño `(longitud1+1) x (longitud2+1)`.
    2.  `dp[i][j]` almacenará la longitud de la LCS de `cadena1[0..i-1]` y
        `cadena2[0..j-1]`.
    3.  Llenar la matriz usando la recurrencia:
        -   Si `cadena1[i-1] == cadena2[j-1]`, entonces `dp[i][j] = 1 +
            dp[i-1][j-1]`.
        -   Si no, `dp[i][j] = MAXIMO(dp[i-1][j], dp[i][j-1])`.
-   **Salida:** El resultado es el valor en `dp[longitud1][longitud2]`.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
FUNCION lcs(cadena1, cadena2)
VARIABLES:
    dp (matriz 2D)
INICIO
    // ... inicializar y llenar la matriz dp ...
    RETORNAR dp[LONGITUD(cadena1)][LONGITUD(cadena2)]
FIN FUNCION

Ejercicio 2.03b.34 - b.34 - Validación de IP simple ⭐☆☆☆☆¶

Descripción¶

Crear una función que verifique si una cadena representa una dirección IPv4 válida. Debe consistir en cuatro números entre 0 y 255, separados por puntos.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
FUNCION es_ipv4_valida(cadena)
VARIABLES:
    tokens (arreglo de cadenas)
    num (entero)
INICIO
    tokens = dividir_cadena(cadena, '.')
    SI LONGITUD(tokens) != 4 RETORNAR FALSO

    PARA cada token en tokens HACER
        SI token está vacío O NO es_numero(token) RETORNAR FALSO
        num = convertir_a_entero(token)
        SI num < 0 O num > 255 RETORNAR FALSO
    FIN PARA

    RETORNAR VERDADERO
FIN FUNCION

Ejercicio 2.03b.35 - b.35 - Convertir a `snake_case` ⭐⭐☆☆☆¶

Descripción¶

Implementar una función que convierta una cadena en camelCase o PascalCase a snake_case. Esto implica insertar un guion bajo antes de cada letra mayúscula y convertir toda la cadena a minúsculas.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
FUNCION a_snake_case(cadena)
VARIABLES:
    resultado (cadena)
INICIO
    PARA cada caracter c en cadena HACER
        SI es_mayuscula(c) Y resultado NO está vacío ENTONCES
            AÑADIR '_' a resultado
        FIN SI
        AÑADIR convertir_a_minuscula(c) a resultado
    FIN PARA
    RETORNAR resultado
FIN FUNCION

Ejercicio 2.03b.36 - b.36 - Convertir a `camelCase` ⭐⭐☆☆☆¶

Descripción¶

Implementar una función que convierta una cadena en snake_case a camelCase. Esto implica eliminar los guiones bajos y poner en mayúscula la letra que les seguía.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
FUNCION a_camel_case(cadena)
VARIABLES:
    resultado (cadena)
    capitalizar (booleano)
INICIO
    capitalizar = FALSO
    PARA cada caracter c en cadena HACER
        SI c == '_' ENTONCES
            capitalizar = VERDADERO
        SINO SI capitalizar ENTONCES
            AÑADIR convertir_a_mayuscula(c) a resultado
            capitalizar = FALSO
        SINO
            AÑADIR c a resultado
        FIN SI
    FIN PARA
    RETORNAR resultado
FIN FUNCION

Ejercicio 2.03b.37 - b.37 - Rotación de cadena ⭐⭐⭐☆☆¶

Descripción¶

Escribir una función que determine si una cadena s2 es una rotación de otra cadena s1.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
FUNCION es_rotacion(s1, s2)
INICIO
    SI LONGITUD(s1) != LONGITUD(s2) RETORNAR FALSO

    temp = s1 + s1 // Concatenación
    SI buscar_subcadena(temp, s2) != NO_ENCONTRADO ENTONCES
        RETORNAR VERDADERO
    SINO
        RETORNAR FALSO
    FIN SI
    FIN FUNCION

Ejercicio 2.03b.38 - b.38 - Eliminar comentarios ⭐⭐☆☆☆¶

Descripción¶

Crear una función que reciba una cadena (que puede representar una o más líneas de código) y elimine los comentarios de estilo C (//... hasta el final de la línea y /*...*/ incluyendo el contenido).

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
FUNCION eliminar_comentarios(codigo)
VARIABLES:
    resultado (cadena)
    estado (entero)
INICIO
    estado = NORMAL
    PARA i DESDE 0 HASTA LONGITUD(codigo)-1 HACER
        SI estado == NORMAL Y codigo[i] == '/' Y codigo[i+1] == '/' ENTONCES
            estado = DENTRO_DE_COMENTARIO_LINEA
        SINO SI estado == NORMAL Y codigo[i] == '/' Y codigo[i+1] == '*' ENTONCES
            estado = DENTRO_DE_COMENTARIO_BLOQUE
        SINO SI estado == DENTRO_DE_COMENTARIO_LINEA Y codigo[i] == '\n' ENTONCES
            estado = NORMAL
            AÑADIR '\n' a resultado
        SINO SI estado == DENTRO_DE_COMENTARIO_BLOQUE Y codigo[i] == '*' Y codigo[i+1] == '/' ENTONCES
            estado = NORMAL
            i++ // Saltar el '/'
        SINO SI estado == NORMAL ENTONCES
            AÑADIR codigo[i] a resultado
        FIN SI
    FIN PARA
    RETORNAR resultado
FIN FUNCION

Ejercicio 2.03b.39 - b.39 - Análisis de URL simple ⭐☆☆☆☆¶

Descripción¶

Dada una URL en formato de cadena, escribir una función que la analice y extraiga sus componentes principales: protocolo, host y ruta.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
PROCEDIMIENTO analizar_url(url, REF protocolo, REF host, REF ruta)
VARIABLES:
    pos_protocolo, pos_host_inicio, pos_ruta_inicio (enteros)
INICIO
    pos_protocolo = encontrar_caracter(url, ':')
    protocolo = extraer_subcadena(url, 0, pos_protocolo)

    // ... lógica similar para host y ruta ...
FIN PROCEDIMIENTO

Ejercicio 2.03b.40 - b.40 - Generador de “Slugs” ⭐⭐☆☆☆¶

Descripción¶

Un “slug” es una versión de una cadena amigable para URLs. Escribir una función que convierta un título en un slug: debe estar en minúsculas, los espacios deben ser reemplazados por guiones y se deben eliminar todos los caracteres no alfanuméricos.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
FUNCION generar_slug(titulo)
VARIABLES:
    slug (cadena)
INICIO
    PARA cada caracter c en titulo HACER
        c_min = convertir_a_minuscula(c)
        SI es_alfanumerico(c_min) ENTONCES
            AÑADIR c_min a slug
        SINO SI es_espacio(c_min) Y ultimo_char(slug) != '-' ENTONCES
            AÑADIR '-' a slug
        FIN SI
    FIN PARA
    RETORNAR slug
FIN FUNCION

Ejercicio 2.03b.41 - b.41 - Primer carácter no repetido ⭐⭐☆☆☆¶

Descripción¶

Implementar una función que encuentre y devuelva el primer carácter en una cadena que no se repite en el resto de la cadena.

Ayuda (pseudocódigo)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
FUNCION primer_no_repetido(cadena)
VARIABLES:
    frecuencias (arreglo de 256 enteros)
INICIO
    // ... llenar arreglo de frecuencias ...

    PARA cada caracter c en cadena HACER
        SI frecuencias[CODIGO_ASCII(c)] == 1 ENTONCES
            RETORNAR c
        FIN SI
    FIN PARA

    RETORNAR CARACTER_NULO // No se encontró ninguno
FIN FUNCION

Ejercicio 2.03b.42 - Extracción Segura de Subcadena ⭐⭐⭐☆☆¶

Exercise 2

Implementá una función defensiva que extraiga una porción de una cadena de caracteres:

bool subcadena_segura(const char *origen, size_t inicio, size_t longitud,
                      char *destino, size_t cap_destino);

La función debe copiar hasta longitud caracteres comenzando desde la posición inicio de la cadena origen hacia el búfer destino. Debe asegurar siempre la terminación en \0. Si inicio supera la longitud de origen o si el búfer de destino no tiene capacidad suficiente para albergar la subcadena y el terminador nulo, debe rechazar la operación retornando false y dejando una cadena vacía en destino si cap_destino > 0.

Nivel de Bloom: Nivel 3 (Aplicación) y Nivel 4 (Análisis).
Conceptos requeridos: Aritmética de punteros, límites de memoria (0x5003h: Utilizá guardas de inclusión en todos los archivos de cabecera), validación defensiva contra buffer overruns.
Techo conceptual: Prohibido el uso de strncpy o funciones inseguras sin validación de capacidad.

Contrato de la Función¶

Firma: bool subcadena_segura(const char *origen, size_t inicio, size_t longitud, char *destino, size_t cap_destino);
Precondiciones: origen != NULL, destino != NULL, cap_destino > 0.
Postcondiciones: Retorna true y escribe la subcadena en destino garantizando el terminador nulo.

Tabla de Vectores de Prueba¶

Tipo de Caso	Cadena Origen	Inicio / Longitud	Capacidad Destino	Retorno	Cadena Destino	Justificación Técnica
Normal	`"Estructura de Datos"`	`inicio=0, len=10`	`16`	`true`	`"Estructura"`	Copia exacta de prefijo
Normal	`"Programacion"`	`inicio=3, len=4`	`5`	`true`	`"gram"`	Extracción interna con tamaño justo
Borde (Fin de cadena)	`"UNRN"`	`inicio=2, len=10`	`10`	`true`	`"RN"`	Trunca sanamente al alcanzar `\0`
Error (Fuera de rango)	`"Hola"`	`inicio=10, len=2`	`8`	`false`	`""`	Índice inicial fuera de los límites
Error (Capacidad escasa)	`"Algoritmos"`	`inicio=0, len=5`	`5`	`false`	`""`	Búfer insuficiente (necesita 6 con `\0`)

Solution to Exercise 2

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>

bool subcadena_segura(const char *origen, size_t inicio, size_t longitud,
                      char *destino, size_t cap_destino)
{
    if (origen == NULL || destino == NULL || cap_destino == 0)
    {
        return false;
    }

    size_t len_origen = strlen(origen);
    if (inicio > len_origen)
    {
        destino[0] = '\0';
        return false;
    }

    // Determinar cuántos caracteres reales se pueden leer desde 'inicio'
    size_t disponibles = len_origen - inicio;
    size_t a_copiar = (longitud < disponibles) ? longitud : disponibles;

    // Verificar si cabe la subcadena + '\0'
    if (a_copiar + 1 > cap_destino)
    {
        destino[0] = '\0';
        return false;
    }

    for (size_t i = 0; i < a_copiar; i++)
    {
        destino[i] = origen[inicio + i];
    }
    destino[a_copiar] = '\0';

    return true;
}

int main(void)
{
    char buf[32];

    // Caso normal prefijo
    assert(subcadena_segura("Estructura de Datos", 0, 10, buf, sizeof(buf)) == true);
    assert(strcmp(buf, "Estructura") == 0);

    // Caso normal interno con capacidad justa
    char buf_justo[5];
    assert(subcadena_segura("Programacion", 3, 4, buf_justo, sizeof(buf_justo)) == true);
    assert(strcmp(buf_justo, "gram") == 0);

    // Caso borde alcanza fin de cadena
    assert(subcadena_segura("UNRN", 2, 10, buf, sizeof(buf)) == true);
    assert(strcmp(buf, "RN") == 0);

    // Caso error: inicio fuera de rango
    assert(subcadena_segura("Hola", 10, 2, buf, sizeof(buf)) == false);
    assert(buf[0] == '\0');

    // Caso error: capacidad escasa (necesita 6 bytes incluyendo '\0')
    char buf_chico[5];
    assert(subcadena_segura("Algoritmos", 0, 5, buf_chico, sizeof(buf_chico)) == false);
    assert(buf_chico[0] == '\0');

    return 0;
}

Ejercicio 2.03b.43 - Tokenizador Dinámico de Cadenas ⭐⭐⭐☆☆¶

Exercise cadenas-43

El parseo de comandos, archivos de configuración CSV y expresiones requiere fraccionar un flujo de texto en componentes discretos (tokens) asignados dinámicamente.

Implementá dos funciones para la tokenización segura y gestión de memoria:

char **tokenizar_cadena(const char *origen, char delimitador, size_t *cant_tokens):
- Recorre la cadena origen y separa las palabras delimitadas por el carácter delimitador.
- Se ignoran delimitadores contiguos consecutivos y delimitadores al inicio/fin (no genera tokens vacíos).
- Reserva memoria dinámica para un arreglo de punteros char ** de tamaño cant_tokens + 1 terminado en NULL.
- Para cada token, reserva con malloc el tamaño exacto necesario (longitud + 1) y copia la subcadena.
- Ante falla de asignación en cualquier etapa, debe liberar todos los bloques reservados previamente (prevención de memory leak) y retornar NULL.
void liberar_tokens(char **tokens):
- Libera secuencialmente cada cadena apuntada y finalmente el bloque del vector de punteros. Es segura ante tokens == NULL.

Nivel de Bloom: Nivel 4 (Análisis / Síntesis).
Conceptos requeridos: Punteros dobles char **, asignación dinámica escalonada, terminación en centinela NULL, manejo estricto de fallas de asignación.

Tabla de Vectores de Prueba Obligatorios¶

Caso de Prueba	Cadena Entrada	Delimitador	Cantidad de Tokens	Tokens Obtenidos	Centinela Final
Normal	`"hola,mundo,lenguaje,c"`	`','`	`4`	`{"hola", "mundo", "lenguaje", "c"}`	`NULL`
Delimitadores Múltiples	`" sistemas operativos "`	`' '`	`2`	`{"sistemas", "operativos"}`	`NULL`
Sin Delimitador	`"computadora"`	`':'`	`1`	`{"computadora"}`	`NULL`
Cadena Vacía / Solo Delims	`",,,"`	`','`	`0`	`{}` (arreglo con centinela `NULL`)	`NULL`

Solution to Exercise cadenas-43

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

void liberar_tokens(char **tokens) {
    if (tokens == NULL) {
        return;
    }
    for (size_t i = 0; tokens[i] != NULL; i++) {
        free(tokens[i]);
    }
    free(tokens);
}

char **tokenizar_cadena(const char *origen, char delimitador, size_t *cant_tokens) {
    if (cant_tokens == NULL) {
        return NULL;
    }
    *cant_tokens = 0;
    if (origen == NULL) {
        return NULL;
    }

    // 1. Contar tokens
    size_t count = 0;
    const char *p = origen;
    while (*p != '\0') {
        while (*p == delimitador) {
            p++;
        }
        if (*p != '\0') {
            count++;
            while (*p != '\0' && *p != delimitador) {
                p++;
            }
        }
    }

    // 2. Asignar vector de punteros (+1 para centinela NULL)
    char **resultado = (char **)malloc((count + 1) * sizeof(char *));
    if (resultado == NULL) {
        return NULL;
    }

    // 3. Extraer y copiar tokens
    size_t idx = 0;
    p = origen;
    while (*p != '\0' && idx < count) {
        while (*p == delimitador) {
            p++;
        }
        if (*p != '\0') {
            const char *inicio = p;
            while (*p != '\0' && *p != delimitador) {
                p++;
            }
            size_t len = (size_t)(p - inicio);
            resultado[idx] = (char *)malloc(len + 1);
            if (resultado[idx] == NULL) {
                // Liberar memoria previa ante falla
                resultado[idx] = NULL;
                liberar_tokens(resultado);
                return NULL;
            }
            memcpy(resultado[idx], inicio, len);
            resultado[idx][len] = '\0';
            idx++;
        }
    }
    resultado[count] = NULL;
    *cant_tokens = count;
    return resultado;
}

int main(void) {
    size_t n = 0;

    // Caso Normal
    char **t1 = tokenizar_cadena("hola,mundo,lenguaje,c", ',', &n);
    assert(t1 != NULL);
    assert(n == 4);
    assert(strcmp(t1[0], "hola") == 0);
    assert(strcmp(t1[1], "mundo") == 0);
    assert(strcmp(t1[2], "lenguaje") == 0);
    assert(strcmp(t1[3], "c") == 0);
    assert(t1[4] == NULL);
    liberar_tokens(t1);

    // Múltiples delimitadores contiguos
    char **t2 = tokenizar_cadena("  sistemas   operativos ", ' ', &n);
    assert(t2 != NULL);
    assert(n == 2);
    assert(strcmp(t2[0], "sistemas") == 0);
    assert(strcmp(t2[1], "operativos") == 0);
    assert(t2[2] == NULL);
    liberar_tokens(t2);

    // Sin delimitadores
    char **t3 = tokenizar_cadena("computadora", ':', &n);
    assert(t3 != NULL);
    assert(n == 1);
    assert(strcmp(t3[0], "computadora") == 0);
    assert(t3[1] == NULL);
    liberar_tokens(t3);

    // Cadena vacía o solo delimitadores
    char **t4 = tokenizar_cadena(",,,", ',', &n);
    assert(t4 != NULL);
    assert(n == 0);
    assert(t4[0] == NULL);
    liberar_tokens(t4);

    // Puntero nulo
    assert(tokenizar_cadena(NULL, ' ', &n) == NULL);

    return 0;
}

Prerrequisitos y Entorno de Ejecución Requerido¶

Objetivos Pedagógicos y Competencias (Taxonomía de Bloom)¶

Capítulos de Apunte Correspondientes¶

Cuestiones de Estilo Aplicables¶

Análisis de Cadenas¶

Ejercicio 2.03b.01 - Contar Vocales ⭐⭐☆☆☆¶

Ejercicio 2.03b.04 - b.4 - ¿Es alfabética? ⭐⭐☆☆☆¶

Descripción¶

Propiedades de Cadenas¶

Ejercicio 2.03b.05 - b.5 - Palíndromo ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.06 - b.6 - Anagrama ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.07 - b.7 - Pangrama ⭐⭐☆☆☆¶

Descripción¶

Manipulación y Transformación¶

Ejercicio 2.03b.08 - b.8 - Tokenización ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.09 - b.9 - Compresión RLE (Run-Length Encoding) ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.10 - b.10 - Desduplicador ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.11 - b.11 - Número a cadena con formato ⭐⭐⭐☆☆¶

Descripción¶

Ejercicio 2.03b.12 - b.12 - Búsqueda de subcadena ⭐⭐⭐☆☆¶

Descripción¶

Conversión de Base Numérica¶

Ejercicio 2.03b.13 - b.13 - Binario a decimal ⭐⭐⭐⭐☆¶

Descripción¶

Ejercicio 2.03b.14 - b.14 - Hexadecimal a decimal ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.15 - b.15 - Decimal a binario ⭐⭐⭐⭐☆¶

Descripción¶

Ejercicio 2.03b.16 - b.16 - Decimal a hexadecimal ⭐⭐☆☆☆¶

Descripción¶

Más Ejercicios de Cadenas¶

Ejercicio 2.03b.17 - b.17 - Invertir palabras en una frase ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.18 - b.18 - Invertir orden de las palabras ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.19 - b.19 - Capitalización (Title Case) ⭐⭐⭐⭐☆¶

Descripción¶

Ejercicio 2.03b.20 - b.20 - Contar palabras ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.21 - b.21 - Eliminar espacios extra ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.22 - b.22 - Recorte de cadena (Trim) ⭐⭐⭐☆☆¶

Descripción¶

Ejercicio 2.03b.23 - b.23 - Reemplazar subcadena ⭐⭐⭐☆☆¶

Descripción¶

Ejercicio 2.03b.24 - b.24 - Validación de email (Simple) ⭐☆☆☆☆¶

Descripción¶

Ejercicio 2.03b.25 - b.25 - Cifrado César ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.26 - b.26 - Descifrado César ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.27 - b.27 - Encontrar el carácter más frecuente ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.28 - b.28 - Comparación de cadenas (Ignorando mayúsculas) ⭐⭐⭐☆☆¶

Descripción¶

Ejercicio 2.03b.29 - b.29 - Extraer subcadena ⭐⭐⭐☆☆¶

Descripción¶

Ejercicio 2.03b.30 - b.30 - Justificar texto (Simple) ⭐☆☆☆☆¶

Descripción¶

Ejercicio 2.03b.31 - b.31 - Acrónimo ⭐⭐☆☆☆¶

Descripción¶

Cadenas y Algoritmos¶

Ejercicio 2.03b.32 - Distancia de Hamming entre Cadenas ⭐⭐☆☆☆¶

Ejercicio 2.03b.34 - b.34 - Validación de IP simple ⭐☆☆☆☆¶

Descripción¶

Ejercicio 2.03b.35 - b.35 - Convertir a snake_case ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.36 - b.36 - Convertir a camelCase ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.37 - b.37 - Rotación de cadena ⭐⭐⭐☆☆¶

Descripción¶

Ejercicio 2.03b.38 - b.38 - Eliminar comentarios ⭐⭐☆☆☆¶

Descripción¶

Ejercicio 2.03b.39 - b.39 - Análisis de URL simple ⭐☆☆☆☆¶

Ejercicio 2.03b.35 - b.35 - Convertir a `snake_case` ⭐⭐☆☆☆¶

Ejercicio 2.03b.36 - b.36 - Convertir a `camelCase` ⭐⭐☆☆☆¶