## Codificação   Algoritmos

### Pergunta 1: Explique a complexidade de tempo e dê um exemplo de um algoritmo O(n log n)
**Resposta:** A complexidade de tempo mede como o tempo de execução de um algoritmo cresce em relação ao tamanho da entrada usando a notação Big O. O(n log n) é comum em algoritmos de ordenação eficientes, como Merge Sort e Quick Sort. Aqui está o porquê de Merge Sort ser O(n log n):
- O "log n" vem da divisão do array ao meio repetidamente até chegarmos a elementos únicos
- O "n" vem da fusão de n elementos em cada nível
- Exemplo: Ordenar [5,2,8,1,9] requer:
  1. Dividir em [5,2] e [8,1,9]
  2. Dividir ainda mais em elementos únicos
  3. Fusão enquanto ordena: [2,5] e [1,8,9]
  4. Fusão final: [1,2,5,8,9]

### Pergunta 2: Desenhe um limitador de taxa para uma API
**Resposta:**
```python
class RateLimiter:
    def __init__(self, requests_per_second):
        self.requests_per_second = requests_per_second
        self.requests = {}
        self.window_size = 1  # janela de 1 segundo
        
    def is_allowed(self, user_id):
        current_time = time.time()
        # Limpar requisições antigas
        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
```

Considerações principais:
- Usa abordagem de janela deslizante
- Mantém histórico de requisições por usuário
- Implementação thread-safe necessária para produção
- Poderia usar Redis para sistemas distribuídos

## Design de Sistemas

### Pergunta 3: Desenhe um sistema de cache distribuído
**Resposta:**
1. **Componentes Chave:**
   - Servidores de cache com remoção LRU
   - Hashing consistente para distribuição
   - Replicação para tolerância a falhas

2. **Design da API:**
   ```python
   class DistributedCache:
       def get(key)
       def put(key, value, ttl=None)
       def delete(key)
   ```

3. **Recursos:**
   - Particionamento de dados
   - Protocolo de consistência
   - Invalidação de cache
   - Tratamento de chave quente

4. **Considerações de Escala:**
   - Escalonamento horizontal
   - Balanceamento de carga
   - Detecção de falhas
   - Replicação de dados

## Design Orientado a Objetos

### Pergunta 4: Desenhe um sistema de estacionamento
**Resposta:**
```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
```

Recursos principais:
- Suporte a múltiplos níveis
- Diferentes tipos de veículos
- Estratégia de atribuição de vagas
- Processamento de pagamento

## Design de Banco de Dados

### Pergunta 5: Desenhe um esquema para uma plataforma de mídia social
**Resposta:**
```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)
);
```

Considerações:
- Estratégia de indexação
- Abordagem de particionamento
- Design da camada de cache
- Otimização de leitura vs. escrita

## Segurança   Melhores Práticas

### Pergunta 6: Como você protegeria uma API REST?
**Resposta:**
1. **Autenticação:**
   - Tokens JWT
   - OAuth 2.0
   - Chaves de API

2. **Autorização:**
   - Controle de acesso baseado em funções
   - Permissões em nível de recurso
   - Validação de escopo de token

3. **Proteção de Dados:**
   - HTTPS/TLS
   - Validação de entrada
   - Sanitização de parâmetros
   - Limitação de taxa

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

5. **Monitoramento:**
   - Logs de acesso
   - Rastreamento de erros
   - Detecção de anomalias