## Codage   Algorithmes

### Question 1 : Expliquez la complexité temporelle et donnez un exemple d'algorithme O(n log n)
**Réponse :** La complexité temporelle mesure comment le temps d'exécution d'un algorithme croît par rapport à la taille de l'entrée en utilisant la notation Big O. O(n log n) est courant dans les algorithmes de tri efficaces comme le Tri Fusion et le Tri Rapide. Voici pourquoi le Tri Fusion est O(n log n) :
- Le "log n" provient de la division répétée du tableau en deux jusqu'à atteindre des éléments uniques
- Le "n" provient de la fusion de n éléments à chaque niveau
- Exemple : Trier [5,2,8,1,9] nécessite :
  1. Diviser en [5,2] et [8,1,9]
  2. Diviser encore en éléments uniques
  3. Fusionner tout en triant : [2,5] et [1,8,9]
  4. Fusion finale : [1,2,5,8,9]

### Question 2 : Concevez un limiteur de taux pour une API
**Réponse :**
```python
class RateLimiter:
    def __init__(self, requests_per_second):
        self.requests_per_second = requests_per_second
        self.requests = {}
        self.window_size = 1  # fenêtre de 1 seconde
        
    def is_allowed(self, user_id):
        current_time = time.time()
        # Nettoyer les anciennes requêtes
        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
```

Considérations clés :
- Utilise une approche de fenêtre glissante
- Maintient l'historique des requêtes par utilisateur
- Mise en œuvre thread-safe nécessaire pour la production
- Pourrait utiliser Redis pour les systèmes distribués

## Conception de Systèmes

### Question 3 : Concevez un système de cache distribué
**Réponse :**
1. **Composants Clés :**
   - Serveurs de cache avec éviction LRU
   - Hachage cohérent pour la distribution
   - Réplication pour la tolérance aux pannes

2. **Conception de l'API :**
   ```python
   class DistributedCache:
       def get(key)
       def put(key, value, ttl=None)
       def delete(key)
   ```

3. **Fonctionnalités :**
   - Partitionnement des données
   - Protocole de cohérence
   - Invalidation du cache
   - Gestion des clés chaudes

4. **Considérations de Scalabilité :**
   - Scalabilité horizontale
   - Équilibrage de charge
   - Détection de pannes
   - Réplication des données

## Conception Orientée Objet

### Question 4 : Concevez un système de stationnement
**Réponse :**
```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
```

Fonctionnalités clés :
- Support de plusieurs niveaux
- Différents types de véhicules
- Stratégie d'attribution des places
- Traitement des paiements

## Conception de Bases de Données

### Question 5 : Concevez un schéma pour une plateforme de médias sociaux
**Réponse :**
```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)
);
```

Considérations :
- Stratégie d'indexation
- Approche de partitionnement
- Conception de couche de cache
- Optimisation de lecture vs écriture

## Sécurité   Meilleures Pratiques

### Question 6 : Comment sécuriseriez-vous une API REST ?
**Réponse :**
1. **Authentification :**
   - Jetons JWT
   - OAuth 2.0
   - Clés API

2. **Autorisation :**
   - Contrôle d'accès basé sur les rôles
   - Permissions au niveau des ressources
   - Validation de la portée des jetons

3. **Protection des Données :**
   - HTTPS/TLS
   - Validation des entrées
   - Assainissement des paramètres
   - Limitation de taux

4. **En-têtes de Sécurité :**
   ```python
   headers = {
       'X-Content-Type-Options': 'nosniff',
       'X-Frame-Options': 'DENY',
       'Content-Security-Policy': "default-src 'self'",
       'X-XSS-Protection': '1; mode=block'
   }
   ```

5. **Surveillance :**
   - Journaux d'accès
   - Suivi des erreurs
   - Détection d'anomalies