## Codificación y Algoritmos

### Pregunta 1: Explica la complejidad temporal y da un ejemplo de un algoritmo O(n log n)
**Respuesta:** La complejidad temporal mide cómo crece el tiempo de ejecución de un algoritmo en relación con el tamaño de la entrada utilizando la notación Big O. O(n log n) es común en algoritmos de ordenamiento eficientes como Merge Sort y Quick Sort. Aquí está el porqué de que Merge Sort sea O(n log n):
- El "log n" proviene de dividir el arreglo a la mitad repetidamente hasta llegar a elementos individuales
- El "n" proviene de fusionar n elementos en cada nivel
- Ejemplo: Ordenar [5,2,8,1,9] requiere:
  1. Dividir en [5,2] y [8,1,9]
  2. Dividir aún más en elementos individuales
  3. Fusionar de nuevo mientras se ordena: [2,5] y [1,8,9]
  4. Fusión final: [1,2,5,8,9]

### Pregunta 2: Diseña un limitador de tasa para una API
**Respuesta:**
```python
class RateLimiter:
    def __init__(self, requests_per_second):
        self.requests_per_second = requests_per_second
        self.requests = {}
        self.window_size = 1  # ventana de 1 segundo
        
    def is_allowed(self, user_id):
        current_time = time.time()
        # Limpiar solicitudes antiguas
        self.requests[user_id] = [timestamp for timestamp in 
            self.requests.get(user_id, []) if current_time - timestamp   self.window_size]
        
        if len(self.requests.get(user_id, []))   self.requests_per_second:
            self.requests.setdefault(user_id, []).append(current_time)
            return True
        return False
```

Consideraciones clave:
- Utiliza un enfoque de ventana deslizante
- Mantiene el historial de solicitudes por usuario
- Implementación segura para hilos necesaria para producción
- Podría usar Redis para sistemas distribuidos

## Diseño de Sistemas

### Pregunta 3: Diseña un sistema de caché distribuido
**Respuesta:**
1. **Componentes Clave:**
   - Servidores de caché con eliminación LRU
   - Hashing consistente para distribución
   - Replicación para tolerancia a fallos

2. **Diseño de API:**
   ```python
   class DistributedCache:
       def get(key)
       def put(key, value, ttl=None)
       def delete(key)
   ```

3. **Características:**
   - Particionamiento de datos
   - Protocolo de consistencia
   - Invalidación de caché
   - Manejo de claves calientes

4. **Consideraciones de Escalabilidad:**
   - Escalado horizontal
   - Balanceo de carga
   - Detección de fallos
   - Replicación de datos

## Diseño Orientado a Objetos

### Pregunta 4: Diseña un sistema de estacionamiento
**Respuesta:**
```python
class ParkingLot:
    def __init__(self, levels):
        self.levels = [Level(i, 30) for i in range(levels)]

    def park_vehicle(self, vehicle):
        for level in self.levels:
            spot = level.find_available_spot(vehicle.type)
            if spot:
                return spot.park(vehicle)
        return False

class Level:
    def __init__(self, level_num, spots):
        self.spots = [ParkingSpot(i, SpotType.REGULAR) for i in range(spots)]
        
    def find_available_spot(self, vehicle_type):
        return next((spot for spot in self.spots if spot.is_available()), None)

class Vehicle:
    def __init__(self, license_plate, vehicle_type):
        self.license_plate = license_plate
        self.type = vehicle_type
```

Características clave:
- Soporte para múltiples niveles
- Diferentes tipos de vehículos
- Estrategia de asignación de espacios
- Procesamiento de pagos

## Diseño de Bases de Datos

### Pregunta 5: Diseña un esquema para una plataforma de redes sociales
**Respuesta:**
```sql
CREATE TABLE users (
    user_id BIGINT PRIMARY KEY,
    username VARCHAR(50) UNIQUE,
    email VARCHAR(255) UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE posts (
    post_id BIGINT PRIMARY KEY,
    user_id BIGINT REFERENCES users(user_id),
    content TEXT,
    posted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE follows (
    follower_id BIGINT REFERENCES users(user_id),
    following_id BIGINT REFERENCES users(user_id),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (follower_id, following_id)
);
```

Consideraciones:
- Estrategia de indexación
- Enfoque de particionamiento
- Diseño de capa de caché
- Optimización de lectura vs. escritura

## Seguridad y Mejores Prácticas

### Pregunta 6: ¿Cómo asegurarías una API REST?
**Respuesta:**
1. **Autenticación:**
   - Tokens JWT
   - OAuth 2.0
   - Claves API

2. **Autorización:**
   - Control de acceso basado en roles
   - Permisos a nivel de recurso
   - Validación del alcance del token

3. **Protección de Datos:**
   - HTTPS/TLS
   - Validación de entradas
   - Sanitización de parámetros
   - Limitación de tasa

4. **Encabezados de Seguridad:**
   ```python
   headers = {
       'X-Content-Type-Options': 'nosniff',
       'X-Frame-Options': 'DENY',
       'Content-Security-Policy': "default-src 'self'",
       'X-XSS-Protection': '1; mode=block'
   }
   ```

5. **Monitoreo:**
   - Registros de acceso
   - Seguimiento de errores
   - Detección de anomalías