Entrevistas de Microsoft y Google: La Cruda Realidad

Si alguna vez has soñado con trabajar en Microsoft, Google, Meta, Amazon o cualquier otra Big Tech, necesitas saber algo: las entrevistas técnicas son brutales. No importa cuántos proyectos hayas construido, cuánto código hayas escrito o cuántos años de experiencia tengas. Si no puedes resolver un problema de algoritmos en 45 minutos, no pasas. Así de simple.

En este artículo voy a contarte exactamente cómo son estas entrevistas, qué esperan de ti, y compartiré una historia personal que cambió mi perspectiva sobre la programación cuando tenía apenas 13 años.

La estructura de una entrevista técnica

Las entrevistas técnicas en las Big Tech siguen un patrón bastante estandarizado:

1. Introducción (5 minutos)

• Te presentas
• El entrevistador se presenta
• Conversan brevemente sobre tu experiencia

2. El problema (40 minutos)

Aquí comienza lo real. Te dan un problema y tienes que:

• Entender el problema: Hacer preguntas clarificadoras
• Pensar en voz alta: Explicar tu razonamiento
• Proponer una solución: Empezar con fuerza bruta si es necesario
• Optimizar: Mejorar tu solución inicial
• Codificar: Escribir código limpio y funcional
• Probar: Verificar con casos de prueba
• Analizar complejidad: Explicar Big O

3. Preguntas finales (5 minutos)

• Tus preguntas sobre la empresa
• Retroalimentación (a veces)

La regla no escrita: Si no resuelves el problema en esos 45 minutos, probablemente no avanzarás. No importa qué tan cerca estuviste. No importa si solo te faltaba un detalle. El tiempo es inflexible.

Las estructuras de datos que DEBES dominar

No puedes pasar estas entrevistas sin dominar estas estructuras fundamentales:

1. Arrays y Strings

La base de todo. Si no manejas arrays con fluidez, estás muerto.

#include <stdio.h>
#include <stdlib.h>

// Estructura para almacenar el resultado
typedef struct {
    int* indices;
    int size;
} Result;

// Ejemplo: Encontrar dos índices que sumen un target
Result* twoSum(int* nums, int numsSize, int target) {
    Result* result = (Result*)malloc(sizeof(Result));
    result->indices = (int*)malloc(2 * sizeof(int));
    result->size = 0;
    
    // Hash map simple usando un array auxiliar
    // Para simplificar, usamos búsqueda O(n²)
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] + nums[j] == target) {
                result->indices[0] = i;
                result->indices[1] = j;
                result->size = 2;
                return result;
            }
        }
    }
    
    return result;
}

// Complejidad: O(n²) tiempo, O(1) espacio
// Con hash map sería O(n) tiempo, O(n) espacio

2. Hash Maps (Estructuras de mapeo)

Tu mejor amigo para optimizar búsquedas de O(n²) a O(n).

#include <stdio.h>
#include <string.h>

#define MAX_CHARS 256

// Ejemplo: Contar frecuencia de caracteres
void countFrequency(char* s, int* freq) {
    // Inicializar frecuencias en 0
    for (int i = 0; i < MAX_CHARS; i++) {
        freq[i] = 0;
    }
    
    // Contar frecuencias
    for (int i = 0; s[i] != '\0'; i++) {
        freq[(unsigned char)s[i]]++;
    }
}

void printFrequency(char* s) {
    int freq[MAX_CHARS];
    countFrequency(s, freq);
    
    printf("Frecuencias de caracteres:\n");
    for (int i = 0; i < MAX_CHARS; i++) {
        if (freq[i] > 0) {
            printf("'%c': %d\n", i, freq[i]);
        }
    }
}

3. Stacks y Queues

Fundamentales para problemas de validación y procesamiento secuencial.

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

#define MAX_SIZE 1000

// Stack simple
typedef struct {
    char data[MAX_SIZE];
    int top;
} Stack;

void initStack(Stack* s) {
    s->top = -1;
}

void push(Stack* s, char c) {
    if (s->top < MAX_SIZE - 1) {
        s->data[++(s->top)] = c;
    }
}

char pop(Stack* s) {
    if (s->top >= 0) {
        return s->data[(s->top)--];
    }
    return '\0';
}

bool isEmpty(Stack* s) {
    return s->top == -1;
}

// Ejemplo: Validar paréntesis balanceados
bool isValid(char* s) {
    Stack stack;
    initStack(&stack);
    
    for (int i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        
        if (c == '(' || c == '{' || c == '[') {
            push(&stack, c);
        } else {
            if (isEmpty(&stack)) return false;
            
            char top = pop(&stack);
            if ((c == ')' && top != '(') ||
                (c == '}' && top != '{') ||
                (c == ']' && top != '[')) {
                return false;
            }
        }
    }
    
    return isEmpty(&stack);
}

4. Linked Lists

Los clásicos. Siempre aparecen en entrevistas.

#include <stdio.h>
#include <stdlib.h>

typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;

// Crear un nuevo nodo
ListNode* createNode(int val) {
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

// Ejemplo: Invertir una lista enlazada
ListNode* reverseList(ListNode* head) {
    ListNode* prev = NULL;
    ListNode* current = head;
    
    while (current != NULL) {
        ListNode* nextTemp = current->next;
        current->next = prev;
        prev = current;
        current = nextTemp;
    }
    
    return prev;
}

// Imprimir lista
void printList(ListNode* head) {
    while (head != NULL) {
        printf("%d", head->val);
        if (head->next != NULL) printf(" -> ");
        head = head->next;
    }
    printf("\n");
}

5. Trees (Árboles)

Especialmente árboles binarios y BSTs.

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

typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// Crear un nuevo nodo
TreeNode* createTreeNode(int val) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// Ejemplo: Validar si es un BST
bool isValidBSTHelper(TreeNode* root, long min, long max) {
    if (root == NULL) return true;
    
    if (root->val <= min || root->val >= max) return false;
    
    return isValidBSTHelper(root->left, min, root->val) && 
           isValidBSTHelper(root->right, root->val, max);
}

bool isValidBST(TreeNode* root) {
    return isValidBSTHelper(root, LONG_MIN, LONG_MAX);
}

6. Graphs (Grafos)

La estructura más compleja pero también la más poderosa.

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_VERTICES 100

// Cola para BFS
typedef struct {
    int data[MAX_VERTICES];
    int front, rear;
} Queue;

void initQueue(Queue* q) {
    q->front = q->rear = 0;
}

void enqueue(Queue* q, int val) {
    q->data[q->rear++] = val;
}

int dequeue(Queue* q) {
    return q->data[q->front++];
}

bool isQueueEmpty(Queue* q) {
    return q->front == q->rear;
}

// Ejemplo: BFS para encontrar el camino más corto
int shortestPath(int graph[][MAX_VERTICES], int n, int start, int end) {
    Queue q;
    initQueue(&q);
    
    bool visited[MAX_VERTICES] = {false};
    int distance[MAX_VERTICES] = {0};
    
    enqueue(&q, start);
    visited[start] = true;
    
    while (!isQueueEmpty(&q)) {
        int node = dequeue(&q);
        
        if (node == end) return distance[node];
        
        for (int neighbor = 0; neighbor < n; neighbor++) {
            if (graph[node][neighbor] && !visited[neighbor]) {
                visited[neighbor] = true;
                distance[neighbor] = distance[node] + 1;
                enqueue(&q, neighbor);
            }
        }
    }
    
    return -1; // No hay camino
}

Los patrones que te salvarán la vida

Más importante que memorizar problemas es reconocer patrones. Aquí están los más comunes:

1. Two Pointers

Dos punteros moviéndose sobre una estructura.

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>

// Ejemplo: Verificar si es palíndromo
bool isPalindrome(char* s) {
    int left = 0;
    int right = strlen(s) - 1;
    
    while (left < right) {
        // Ignorar caracteres no alfanuméricos
        while (left < right && !isalnum(s[left])) left++;
        while (left < right && !isalnum(s[right])) right--;
        
        if (tolower(s[left]) != tolower(s[right])) {
            return false;
        }
        
        left++;
        right--;
    }
    
    return true;
}

2. Sliding Window

Una ventana deslizante sobre un array.

#include <stdio.h>

// Ejemplo: Máximo de k elementos consecutivos
int maxSumSubarray(int arr[], int n, int k) {
    if (n < k) return -1;
    
    int maxSum = 0;
    int windowSum = 0;
    
    // Calcular suma de la primera ventana
    for (int i = 0; i < k; i++) {
        windowSum += arr[i];
    }
    maxSum = windowSum;
    
    // Deslizar la ventana
    for (int i = k; i < n; i++) {
        windowSum += arr[i] - arr[i - k];
        if (windowSum > maxSum) {
            maxSum = windowSum;
        }
    }
    
    return maxSum;
}

int main() {
    int arr[] = {2, 1, 5, 1, 3, 2};
    int k = 3;
    int n = sizeof(arr) / sizeof(arr[0]);
    
    printf("Máximo de %d elementos consecutivos: %d\n", 
           k, maxSumSubarray(arr, n, k));
    return 0;
}

3. Binary Search

No solo para arrays ordenados, también para espacios de solución.

#include <stdio.h>

// Ejemplo: Búsqueda binaria clásica
int binarySearch(int arr[], int n, int target) {
    int left = 0;
    int right = n - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;  // Evita overflow
        
        if (arr[mid] == target) {
            return mid;
        }
        
        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return -1;  // No encontrado
}

4. Recursion y Backtracking

Para problemas de exploración de soluciones.

#include <stdio.h>
#include <string.h>

#define MAX_RESULT 100

int resultCount = 0;
int results[MAX_RESULT][10];
int resultSizes[MAX_RESULT];

// Ejemplo: Generar todas las permutaciones
void permuteHelper(int nums[], int numsSize, int current[], int currentSize, 
                   bool used[]) {
    if (currentSize == numsSize) {
        // Guardar permutación
        for (int i = 0; i < numsSize; i++) {
            results[resultCount][i] = current[i];
        }
        resultSizes[resultCount] = numsSize;
        resultCount++;
        return;
    }
    
    for (int i = 0; i < numsSize; i++) {
        if (!used[i]) {
            current[currentSize] = nums[i];
            used[i] = true;
            permuteHelper(nums, numsSize, current, currentSize + 1, used);
            used[i] = false;
        }
    }
}

void permute(int nums[], int numsSize) {
    int current[10];
    bool used[10] = {false};
    resultCount = 0;
    
    permuteHelper(nums, numsSize, current, 0, used);
    
    printf("Permutaciones:\n");
    for (int i = 0; i < resultCount; i++) {
        printf("[");
        for (int j = 0; j < resultSizes[i]; j++) {
            printf("%d", results[i][j]);
            if (j < resultSizes[i] - 1) printf(", ");
        }
        printf("]\n");
    }
}

5. BFS / DFS

Para recorrer grafos y árboles.

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// DFS Preorder (raíz -> izquierda -> derecha)
void dfs(TreeNode* root) {
    if (root == NULL) return;
    
    printf("%d ", root->val);
    dfs(root->left);
    dfs(root->right);
}

// BFS usando cola
typedef struct QueueNode {
    TreeNode* treeNode;
    struct QueueNode* next;
} QueueNode;

typedef struct {
    QueueNode* front;
    QueueNode* rear;
} Queue;

Queue* createQueue() {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->front = q->rear = NULL;
    return q;
}

void enqueueTree(Queue* q, TreeNode* node) {
    QueueNode* temp = (QueueNode*)malloc(sizeof(QueueNode));
    temp->treeNode = node;
    temp->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = temp;
        return;
    }
    
    q->rear->next = temp;
    q->rear = temp;
}

TreeNode* dequeueTree(Queue* q) {
    if (q->front == NULL) return NULL;
    
    QueueNode* temp = q->front;
    TreeNode* node = temp->treeNode;
    q->front = q->front->next;
    
    if (q->front == NULL) q->rear = NULL;
    
    free(temp);
    return node;
}

void bfs(TreeNode* root) {
    if (root == NULL) return;
    
    Queue* q = createQueue();
    enqueueTree(q, root);
    
    while (q->front != NULL) {
        TreeNode* node = dequeueTree(q);
        printf("%d ", node->val);
        
        if (node->left) enqueueTree(q, node->left);
        if (node->right) enqueueTree(q, node->right);
    }
}

La matemática del Big O

No basta con resolver el problema. Tienes que poder analizar tu solución y explicar su complejidad.

Complejidades temporales comunes

Notación	Nombre	Ejemplo
O(1)	Constante	Acceso a array por índice
O(log n)	Logarítmica	Binary Search
O(n)	Lineal	Recorrer un array
O(n log n)	Linearítmica	Merge Sort, Quick Sort
O(n²)	Cuadrática	Dos bucles anidados
O(2ⁿ)	Exponencial	Recursión sin memoización
O(n!)	Factorial	Todas las permutaciones

Reglas para calcular Big O

1. Ignora constantes: O(2n) → O(n)
2. Ignora términos menores: O(n² + n) → O(n²)
3. Operaciones diferentes se suman: O(A + B)
4. Bucles anidados se multiplican: O(A * B)

#include <stdio.h>

// ¿Cuál es la complejidad?
int ejemplo(int arr[], int n) {
    int sum = 0;                    // O(1)
    
    // Primer bucle
    for (int i = 0; i < n; i++) {   // O(n)
        sum += arr[i];              // O(1)
    }
    
    // Bucles anidados
    for (int i = 0; i < n; i++) {   // O(n)
        for (int j = 0; j < n; j++) { // O(n)
            printf("%d %d\n", arr[i], arr[j]); // O(1)
        }
    }
    
    return sum;
}

// Respuesta: O(1) + O(n) + O(n²) = O(n²)

Mi historia personal: El reto que me marcó

Cuando tenía 13 años, ya llevaba algunos años programando. Había hecho plugins de Minecraft en Java, estaba aprendiendo desarrollo web, y me sentía bastante confiado en mis habilidades. Creía que sabía programar bien.

Hasta que un amigo mayor, que estudiaba ingeniería en sistemas, me dijo: “A ver, si eres tan bueno, resuelve este problema que nos dieron en la universidad.”

Me pasó un archivo de texto con un problema. Lo leí y pensé: “¿Esto es todo? Fácil.”

El problema era exactamente el que voy a compartir contigo ahora.

El Reto: Reverse Nodes in k-Group

Este es un clásico de nivel Hard en LeetCode y en entrevistas técnicas de las Big Tech.

El Problema

Dada una lista enlazada, revierte los nodos de la lista de k en k y devuelve la lista modificada. Si el número de nodos no es múltiplo de k, los nodos restantes al final deben quedarse como están.

Ejemplo 1:

Entrada: 1 -> 2 -> 3 -> 4 -> 5, k = 2
Salida:  2 -> 1 -> 4 -> 3 -> 5

Ejemplo 2:

Entrada: 1 -> 2 -> 3 -> 4 -> 5, k = 3
Salida:  3 -> 2 -> 1 -> 4 -> 5

Mi experiencia con este problema

Mi amigo me dio 45 minutos para resolverlo. Yo pensé: “Claro, lo hago en 20.”

Primer intento (minuto 0-15): Comencé a escribir código frenéticamente. Pensé que podía hacerlo con dos punteros y un contador. Escribí como 50 líneas de código… y no funcionaba. Los enlaces se rompían, perdía nodos, era un desastre.

Segundo intento (minuto 15-30): “Ok, déjame pensar mejor.” Intenté usar una pila para guardar k nodos, invertirlos, y reconectarlos. El código se volvió aún más complejo. Seguía sin funcionar correctamente.

Tercer intento (minuto 30-45): Empecé a desesperarme. El tiempo se acababa. Intenté otra aproximación con recursión. Escribí algo que medio funcionaba para casos simples, pero fallaba con casos edge.

Resultado: Fracasé. No pude resolverlo en 45 minutos.

Mi amigo me miró y me dijo algo que nunca olvidaré:

“En las empresas grandes, no importa cuánto sepas de frameworks o cuántas apps hayas hecho. Si no puedes resolver problemas como este, no pasas. Así de simple.”

Esa experiencia me humilló profundamente, pero también me enseñó algo valioso: saber programar no es lo mismo que saber resolver problemas algorítmicos.

La solución (que aprendí después)

Después de ese fracaso, dediqué días a entender este problema. Aquí está la solución:

Solución 1: Recursiva (Elegante pero con limitaciones)

Esta fue la primera solución que aprendí. Es elegante y fácil de entender:

#include <stdio.h>
#include <stdlib.h>

typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;

// Crear un nuevo nodo
ListNode* createNode(int val) {
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

// Solución recursiva
ListNode* reverseKGroupRecursive(ListNode* head, int k) {
    // Paso 1: Verificar si hay al menos k nodos
    int count = 0;
    ListNode* current = head;
    
    while (current != NULL && count < k) {
        current = current->next;
        count++;
    }
    
    // Si no hay k nodos, retornar sin cambios
    if (count < k) return head;
    
    // Paso 2: Invertir los primeros k nodos
    ListNode* prev = NULL;
    current = head;
    
    for (int i = 0; i < k; i++) {
        ListNode* nextTemp = current->next;
        current->next = prev;
        prev = current;
        current = nextTemp;
    }
    
    // Paso 3: Recursión para el resto de la lista
    if (head != NULL) {
        head->next = reverseKGroupRecursive(current, k);
    }
    
    return prev;
}

El problema con esta solución:

Aunque funciona perfectamente y pasaría una entrevista estándar, tiene una limitación crítica:

• Stack Overflow: Si tienes una lista de 1 millón de nodos con k=2, harás 500,000 llamadas recursivas. Esto llenará la pila de memoria (stack) y causará un Segmentation Fault.
• Espacio: O(n/k) por la recursión. En el peor caso O(n).

Para sistemas de producción, kernels de Linux, o sistemas embebidos, necesitas la versión iterativa.

Solución 2: Iterativa “Production Ready” (O(1) espacio)

Esta es la solución que usarías en código de producción real. Es más difícil de escribir, pero es óptima:

// Solución iterativa - O(1) espacio
ListNode* reverseKGroup(ListNode* head, int k) {
    if (head == NULL || k == 1) return head;
    
    // Dummy node para manejar fácilmente el cambio de cabeza
    ListNode dummy;
    dummy.val = 0;
    dummy.next = head;
    
    ListNode* prevGroupEnd = &dummy;  // Final del grupo anterior
    
    while (1) {
        // Verificar si hay k nodos disponibles
        ListNode* kth = prevGroupEnd;
        for (int i = 0; i < k; i++) {
            kth = kth->next;
            if (kth == NULL) {
                // No hay suficientes nodos, terminamos
                return dummy.next;
            }
        }
        
        // Guardar el siguiente grupo
        ListNode* nextGroupStart = kth->next;
        
        // Invertir el grupo actual
        ListNode* prev = nextGroupStart;  // Conectar al siguiente grupo
        ListNode* curr = prevGroupEnd->next;
        
        // Invertir k nodos
        for (int i = 0; i < k; i++) {
            ListNode* next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
        }
        
        // Reconectar con el grupo anterior
        ListNode* newGroupStart = prev;
        ListNode* newGroupEnd = prevGroupEnd->next;
        
        prevGroupEnd->next = newGroupStart;
        prevGroupEnd = newGroupEnd;
    }
    
    return dummy.next;
}

// Función auxiliar para imprimir la lista
void printList(ListNode* head) {
    while (head != NULL) {
        printf("%d", head->val);
        if (head->next != NULL) printf(" -> ");
        head = head->next;
    }
    printf("\n");
}

// Función para crear una lista de ejemplo
ListNode* createList(int values[], int size) {
    if (size == 0) return NULL;
    
    ListNode* head = createNode(values[0]);
    ListNode* current = head;
    
    for (int i = 1; i < size; i++) {
        current->next = createNode(values[i]);
        current = current->next;
    }
    
    return head;
}

// Probar la solución
int main() {
    int values[] = {1, 2, 3, 4, 5};
    int size = sizeof(values) / sizeof(values[0]);
    
    ListNode* head = createList(values, size);
    
    printf("Original: ");
    printList(head);
    
    head = reverseKGroup(head, 2);
    
    printf("Invertida (k=2): ");
    printList(head);
    // Output: 2 -> 1 -> 4 -> 3 -> 5
    
    // Probar con k=3
    int values2[] = {1, 2, 3, 4, 5};
    ListNode* head2 = createList(values2, 5);
    
    printf("\nOriginal: ");
    printList(head2);
    
    head2 = reverseKGroup(head2, 3);
    
    printf("Invertida (k=3): ");
    printList(head2);
    // Output: 3 -> 2 -> 1 -> 4 -> 5
    
    return 0;
}

Por qué esta solución es superior:

1. O(1) espacio: No usa recursión, solo variables locales
2. Dummy Node: Simplifica el manejo del cambio de cabeza
3. Un solo bucle: Todo se hace iterativamente
4. Production Ready: Puede manejar listas de millones de nodos sin problemas
5. Sin riesgo de Stack Overflow: Perfecto para sistemas críticos

Análisis de complejidad (Solución Iterativa):

• Tiempo: O(n) - visitamos cada nodo exactamente una vez
• Espacio: O(1) - solo usamos variables locales, sin recursión

Por qué este problema es difícil

1. Manejo de punteros: Tienes que mantener múltiples referencias sin perder nodos
2. Casos edge: ¿Qué pasa si k = 1? ¿Si k > longitud de la lista?
3. Reconexión: Después de invertir un grupo, debes conectarlo correctamente con el siguiente
4. Recursión o iteración: Ambos enfoques son válidos pero no obvios
5. Gestión de memoria en C: Tienes que ser cuidadoso con los punteros
6. Trade-off recursivo vs iterativo: La solución recursiva es más elegante pero tiene O(n/k) espacio y riesgo de stack overflow. La iterativa es O(1) espacio pero más compleja de implementar.
7. Dummy Node: No es obvio usar un nodo ficticio para simplificar el manejo del cambio de cabeza

En una entrevista real:

• La solución recursiva te hará pasar (es correcta)
• Pero si mencionas sus limitaciones y propones la iterativa, demostrarás que piensas como un ingeniero senior
• En Google/Microsoft nivel L5+, esperan que conozcas ambas soluciones

Lo que aprendí

Después de ese día, entendí que necesitaba:

1. Practicar algoritmos sistemáticamente: No solo hacer proyectos
2. Entender patrones: No memorizar soluciones
3. Pensar antes de codificar: 10 minutos pensando > 30 minutos corrigiendo
4. Dominar estructuras básicas: Especialmente linked lists, trees y graphs
5. Dominar el manejo de memoria y punteros: Fundamental en C

Cómo prepararte para estas entrevistas

1. Practica en plataformas dedicadas

• LeetCode: El estándar de oro (easy, medium, hard)
• HackerRank: Bueno para principiantes
• CodeSignal: Similar al formato de entrevistas reales
• AlgoExpert: Explicaciones excelentes (de pago)

2. Estudia sistemáticamente

Semanas 1-2: Fundamentos

• Arrays, strings, hash maps
• Two pointers, sliding window
• 20-30 problemas easy

Semanas 3-4: Estructuras intermedias

• Stacks, queues, linked lists
• Recursión básica
• 30-40 problemas easy/medium

Semanas 5-6: Árboles y grafos

• Binary trees, BSTs
• BFS, DFS
• 20-30 problemas medium

Semanas 7-8: Avanzado

• Dynamic programming
• Backtracking
• Problemas hard

3. Simula entrevistas reales

• Usa un temporizador de 45 minutos
• Resuelve en una pizarra o papel primero
• Explica tu razonamiento en voz alta
• Plataformas como Pramp para mock interviews

4. Aprende a comunicarte

Las entrevistas técnicas no son solo sobre código:

• Clarifica el problema: Haz preguntas antes de codificar
• Piensa en voz alta: El entrevistador quiere ver tu proceso
• Empieza simple: Una solución O(n²) es mejor que ninguna solución
• Optimiza después: Explica cómo podrías mejorarla
• Prueba tu código: Usa casos de prueba antes de decir “terminé”

5. Mantén la calma bajo presión

Es normal sentirse nervioso. Estrategias:

• Respira profundo antes de empezar
• Si te trabas, explica qué estás pensando
• Pide un minuto para reorganizar tus ideas
• Si el entrevistador da hints, úsalos

La verdad incómoda

Aquí está lo que nadie te dice:

1. Estas entrevistas no miden tu capacidad real como developer: Puedes ser un excelente ingeniero de software y fallar estas entrevistas. Y puedes pasar estas entrevistas y ser mediocre en el trabajo real.

2. Es un juego de números: Hasta developers experimentados tienen tasa de éxito del 30-40%. Vas a fallar. Mucho. Es parte del proceso.

3. La suerte importa: El problema que te toque puede ser uno que ya resolviste o uno que nunca has visto. Esa diferencia puede cambiar todo.

4. El sistema es imperfecto: Google, Microsoft, y otras Big Tech lo saben. Pero no han encontrado una mejor alternativa que sea escalable.

5. Vale la pena prepararte: Aunque el sistema sea imperfecto, los salarios y beneficios en estas empresas justifican el esfuerzo. Un software engineer en Google puede ganar entre $150k-$300k+ al año.

Recursos recomendados

Libros

• “Cracking the Coding Interview” de Gayle Laakmann McDowell (la biblia)
• “Elements of Programming Interviews” (más avanzado)
• “Algorithm Design Manual” de Steven Skiena
• “The C Programming Language” de Kernighan & Ritchie (para dominar C)

Cursos

• Grokking the Coding Interview (patterns)
• AlgoExpert (comprehensive)
• Coursera: Algorithms Specialization (teoría sólida)
• CS50 de Harvard (fundamentos sólidos en C)

YouTube

• NeetCode: Explicaciones excelentes de problemas de LeetCode
• Tech Dummies: Mock interviews
• Back To Back SWE: Deep dives en algoritmos

Mi reflexión final

Ese día a los 13 años, cuando fracasé en resolver el problema que mi amigo me dio, cambió mi perspectiva completamente. Me di cuenta de que el mundo de la programación es mucho más amplio de lo que pensaba.

No es suficiente saber frameworks. No es suficiente haber construido proyectos. Para entrar a las Big Tech, necesitas dominar los fundamentos algorítmicos.

¿Es justo? Probablemente no.
¿Es la realidad? Absolutamente sí.

Hoy, varios años después, puedo resolver ese problema en menos de 15 minutos. No porque sea más inteligente, sino porque dediqué tiempo a entender los patrones, a practicar sistemáticamente, y a aprender de mis fracasos.

Si tu objetivo es trabajar en Microsoft, Google, Meta, Amazon, o cualquier otra Big Tech, prepárate. Va a ser difícil. Vas a fallar muchas veces. Pero cada problema que resuelves, cada patrón que reconoces, cada estructura que dominas, te acerca un paso más.

Y cuando finalmente recibas esa oferta, vas a saber que te la ganaste.