Skip to article frontmatterSkip to article content

Ejercicios de Cadenas

Acerca de

La manipulación de cadenas es una de las tareas más comunes y, en C, una de las más propensas a errores. Estos ejercicios están diseñados para construir una base sólida en el manejo de cadenas de caracteres (estilo C, terminadas en nulo), enfocándose en la implementación de algoritmos comunes desde cero. Es crucial que al resolverlos, se apliquen los principios de manejo de “cadenas seguras” (Regla 0x0030h: Todas las operaciones con cadenas deben ser seguras), pasando siempre la capacidad del búfer para evitar desbordamientos.

1: Análisis de Cadenas

1.1: Contar vocales

Descripción

Escribir una función que cuente el número total de vocales (a, e, i, o, u) en una cadena de texto. La función no debe distinguir entre mayúsculas y minúsculas.

Ayuda (pseudocódigo)
FUNCION contar_vocales(cadena)
VARIABLES:
    contador (entero)
    caracter_actual (caracter)
INICIO
    contador = 0
    PARA cada caracter_actual en cadena HACER
        c = convertir_a_minuscula(caracter_actual)
        SI c == 'a' O c == 'e' O c == 'i' O c == 'o' O c == 'u' ENTONCES
            contador = contador + 1
        FIN SI
    FIN PARA
    RETORNAR contador
FIN FUNCION

1.2: Contabilizador de caracteres

Descripción

Implementar una función que calcule la frecuencia de aparición de cada carácter dentro de una cadena y muestre el resultado para aquellos caracteres que aparecen al menos una vez.

Ayuda (pseudocódigo)
PROCEDIMIENTO contabilizar_caracteres(cadena)
VARIABLES:
    frecuencias (arreglo de 256 enteros)
INICIO
    INICIALIZAR frecuencias con ceros

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

    PARA i DESDE 0 HASTA 255 HACER
        SI frecuencias[i] > 0 ENTONCES
            ESCRIBIR "Carácter '", CARACTER(i), "': ", frecuencias[i], " veces"
        FIN SI
    FIN PARA
FIN PROCEDIMIENTO

1.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.

Ayuda (pseudocódigo)
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

1.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)
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

2: Propiedades de Cadenas

2.1: 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)
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

2.2: 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)
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

2.3: 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)
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

3: Manipulación y Transformación

3.1: 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)
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

3.2: 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)
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

3.3: 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)
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

3.4: 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)
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

3.5: 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)
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

4: Conversión de Base Numérica

4.1: 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)
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

4.2: 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)
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

4.3: Decimal a Binario

Descripción

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

Ayuda (pseudocódigo)
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

4.4: Decimal a Hexadecimal

Descripción

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

Ayuda (pseudocódigo)
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

5: Más Ejercicios de Cadenas

5.1: 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)
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

5.2: 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)
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

5.3: 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)
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

5.4: 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)
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

5.5: 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)
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

5.6: 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)
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

5.7: 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)
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

5.8: 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)
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

5.9: 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)
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

5.10: 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

5.11: 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)
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

5.12: 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)
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

5.13: 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)
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

5.14: 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)
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

5.15: 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)
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

6: Cadenas y Algoritmos

6.1: Distancia de Hamming

Descripción

Implementar una función que calcule la distancia de Hamming entre dos cadenas de igual longitud. Esta distancia es el número de posiciones en las que los caracteres correspondientes son diferentes.

Ayuda (pseudocódigo)
FUNCION distancia_hamming(cadena1, cadena2)
VARIABLES:
    distancia (entero)
INICIO
    SI LONGITUD(cadena1) != LONGITUD(cadena2) RETORNAR -1 // Error

    distancia = 0
    PARA i DESDE 0 HASTA LONGITUD(cadena1)-1 HACER
        SI cadena1[i] != cadena2[i] ENTONCES
            distancia++
        FIN SI
    FIN PARA
    RETORNAR distancia
FIN FUNCION

6.2: 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.

Ayuda (pseudocódigo)
FUNCION lcs(cadena1, cadena2)
VARIABLES:
    dp (matriz 2D)
INICIO
    // ... inicializar y llenar la matriz dp ...
    RETORNAR dp[LONGITUD(cadena1)][LONGITUD(cadena2)]
FIN FUNCION

6.3: 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)
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

6.4: 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)
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

6.5: 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)
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

6.6: 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)
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

6.7: 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)
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

6.8: 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)
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

6.9: 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)
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

6.10: 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)
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
Apunte
3. Arreglos
Apunte
5. Punteros