Contenido del curso
Dos Apuntadores
- 3

Patrón de Dos Apuntadores en Algoritmos de Lista
02:56 min - 4

Verificación de Orden en Diccionario Alienígena
02:56 min - 5

Ordenamiento de Palabras en Idiomas Alienígenas
Viendo ahora - 6

Playground: Verifying Alien Dictionary
- 7

Ordenación de Palabras en Diccionario Alienígena
15:07 min - 8

Combinar Listas Ordenadas en un Array Ascendente
02:11 min - 9

Ordenamiento de Listas con Complejidad Óptima y Espacio Constante
11:44 min - 10

Playground: Merge Two Sorted Lists
- 11

Intercalación de Listas Ordenadas en Python
09:04 min - 12

Resolver el problema "Container with Most Water" en Python
01:18 min - 13

Cálculo Óptimo de Área en Listas de Alturas
09:02 min - 14

Playground: Container with Most Water
- 15

Implementación de solución de cálculo de área máxima en Java
15:42 min - 16

Implementación de Trapping Rainwater en Complejidad Lineal
01:02 min - 17

Retos de Algoritmos con Apuntadores en Python
02:44 min - 18

Patrones de Dos Apuntadores: Soluciones a Problemas Comunes en Python
06:43 min
Ventana Deslizante
- 19

Patrón Ventana Deslizante para Análisis de Datos Secuenciales
02:32 min - 20

Subcadena más larga sin caracteres repetidos: patrón ventana deslizante
01:51 min - 21

Algoritmo de Ventana Deslizante para Subcadenas Únicas
11:05 min - 22

Playground: Longest Substring Without Repeating Characters
- 23

Algoritmo Python para Substring más Largo Sin Repeticiones
14:16 min - 24

Retos de Algoritmos: Dos Apuntadores y Subcadenas
01:50 min - 25

Máximos 1s Consecutivos y Subcadenas sin Repeticiones
03:22 min
Búsqueda Binaria
- 26

Algoritmo de búsqueda binaria en listas ordenadas
09:26 min - 27

Búsqueda en Arrays Rotados: Encontrar Entero en Lista Ordenada
02:19 min - 28

Búsqueda Binaria en Arreglos Rotados
04:59 min - 29

Playground: Search in Rotated Arrays
- 30

Búsqueda en Arrays Rotados con C++
10:53 min - 31

Búsqueda eficiente en matriz ordenada MxN
01:44 min - 32

Búsqueda Binaria en Matrices 2D Ordenadas
06:33 min - 33

Playground: Search 2D Array Matrix
- 34

Búsqueda Binaria en Matrices con Python
07:48 min
Próximos pasos
Ordenamiento de Palabras en Idiomas Alienígenas
Resumen
Resolver problemas de ordenamiento lexicográfico en un lenguaje desconocido pone a prueba tu capacidad para descomponer un reto grande en subproblemas manejables. Aquí se explica paso a paso cómo validar que una lista de palabras respeta el orden de un diccionario alienígena, usando estructuras de datos eficientes y técnicas de comparación con apuntadores.
¿Por qué es clave entender las entradas antes de programar?
Antes de escribir una sola línea de código, hay que analizar a fondo los datos de entrada [0:27]. La entrada consiste en una lista de palabras y una string que representa el orden del alfabeto alienígena. Algunas preguntas fundamentales que debes hacerte:
- ¿Todas las palabras tienen la misma longitud?
- ¿Los caracteres de las palabras coinciden exactamente con los del alfabeto proporcionado?
- ¿Puede haber palabras repetidas o caracteres en mayúscula y minúscula mezclados?
- ¿El diccionario tiene un tamaño fijo, como las veintiséis letras del inglés?
Este último punto es especialmente relevante. Si el alfabeto tiene un tamaño fijo como veintiséis, se trata de una constante K [1:42]. Esto significa que cualquier operación que dependa del tamaño del alfabeto es despreciable en términos de complejidad, lo cual simplifica el análisis de rendimiento.
¿Cómo representar el orden del alfabeto de forma eficiente?
El primer subproblema es poder consultar rápidamente la posición de cada letra dentro del orden alienígena. La estructura ideal para esto es una hash table [2:42], porque acceder a cualquier par llave-valor tiene una complejidad de O(1), es decir, tiempo constante.
La idea es construir un mapa donde cada letra se asocie con su posición numérica. Por ejemplo, si el orden es hlabcdefgijkmnopqrstuvwxyz, entonces:
- H → 1.
- L → 2.
- A → 3.
- B → 4.
Con este mapa, comparar el orden relativo de dos letras cualesquiera se reduce a comparar dos números enteros, lo cual es O(1) [3:22].
¿Por qué no comparar cada palabra contra todas las siguientes?
Una primera aproximación podría ser, para cada palabra, verificar que todas las palabras posteriores sean lexicográficamente mayores [3:50]. El problema es que esto genera comparaciones redundantes: si ya verificaste que "hacer" va después de "hábito", y luego verificas que "sonreír" va después de "hacer", no necesitas volver a comparar "sonreír" contra "hábito".
La optimización consiste en usar dos apuntadores y comparar únicamente cada palabra con la siguiente en la lista [4:38]. Así reduces drásticamente el trabajo repetido.
¿Cómo funciona la comparación letra a letra?
Con los dos apuntadores, recorres ambas palabras carácter por carácter [5:10]:
- Si las letras en la posición actual son iguales, avanzas ambos apuntadores.
- Cuando encuentras una letra diferente, consultas el mapa para obtener sus posiciones numéricas.
- Si la posición de la letra de la segunda palabra es mayor, el par está ordenado y pasas al siguiente par de palabras.
- Si es menor, retornas falso inmediatamente, sin necesidad de revisar más palabras.
Por ejemplo, al comparar "hábito" y "hacer": la H y la A coinciden, pero al llegar a B (posición 4) y C (posición 5), verificas que 4 < 5, así que el orden es correcto.
¿Qué pasa cuando una palabra está contenida dentro de otra?
Este es un caso borde que muchos pasan por alto [6:30]. Considera las palabras "conocer" y "cono". Al comparar letra a letra, todas coinciden hasta que "cono" se termina. No hay más caracteres contra los cuales comparar.
En este escenario, la regla es que la palabra más corta debe ir primero [7:15]. Si "conocer" aparece antes que "cono", el orden es incorrecto y debes retornar falso. Los apuntadores solo pueden avanzar hasta la longitud de la palabra más corta; si al terminar no se encontró ninguna diferencia, la palabra más larga debe estar después.
Este tipo de análisis de casos especiales es exactamente lo que se evalúa en entrevistas técnicas y lo que marca la diferencia entre una solución frágil y una robusta.
La lección central es clara: nunca revises algo que ya revisaste. Reutilizar cálculos previos mediante apuntadores estratégicos y acceso constante con hash tables transforma una solución cuadrática en una lineal. ¿Qué otros casos borde se te ocurren? Comparte tu análisis en los comentarios.