## Codifica   Algoritmi

### Domanda 1: Spiega la complessità temporale e fornisci un esempio di un algoritmo O(n log n)
**Risposta:** La complessità temporale misura come il tempo di esecuzione di un algoritmo cresce rispetto alla dimensione dell'input utilizzando la notazione Big O. O(n log n) è comune in algoritmi di ordinamento efficienti come Merge Sort e Quick Sort. Ecco perché Merge Sort è O(n log n):
- Il "log n" deriva dalla divisione dell'array a metà ripetutamente fino a raggiungere elementi singoli
- Il "n" deriva dalla fusione di n elementi a ciascun livello
- Esempio: Ordinare [5,2,8,1,9] richiede:
  1. Dividere in [5,2] e [8,1,9]
  2. Ulteriore divisione in elementi singoli
  3. Fusione mentre si ordina: [2,5] e [1,8,9]
  4. Fusione finale: [1,2,5,8,9]

### Domanda 2: Progetta un limitatore di velocità per un'API
**Risposta:**
```python
class RateLimiter:
    def __init__(self, requests_per_second):
        self.requests_per_second = requests_per_second
        self.requests = {}
        self.window_size = 1  # finestra di 1 secondo
        
    def is_allowed(self, user_id):
        current_time = time.time()
        # Pulisci le richieste vecchie
        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
```

Considerazioni chiave:
- Utilizza un approccio a finestra scorrevole
- Mantiene la cronologia delle richieste per utente
- Implementazione thread-safe necessaria per la produzione
- Potrebbe utilizzare Redis per sistemi distribuiti

## Design di Sistemi

### Domanda 3: Progetta un sistema di cache distribuita
**Risposta:**
1. **Componenti Chiave:**
   - Server di cache con espulsione LRU
   - Hashing consistente per distribuzione
   - Replica per tolleranza ai guasti

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

3. **Caratteristiche:**
   - Partizionamento dei dati
   - Protocollo di coerenza
   - Invalidazione della cache
   - Gestione delle chiavi calde

4. **Considerazioni di Scalabilità:**
   - Scalabilità orizzontale
   - Bilanciamento del carico
   - Rilevamento dei guasti
   - Replica dei dati

## Design Orientato agli Oggetti

### Domanda 4: Progetta un sistema di parcheggio
**Risposta:**
```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
```

Caratteristiche chiave:
- Supporto per più livelli
- Diversi tipi di veicoli
- Strategia di assegnazione dei posti
- Elaborazione dei pagamenti

## Design del Database

### Domanda 5: Progetta uno schema per una piattaforma di social media
**Risposta:**
```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)
);
```

Considerazioni:
- Strategia di indicizzazione
- Approccio di partizionamento
- Design del layer di cache
- Ottimizzazione per letture vs scritture

## Sicurezza   Migliori Pratiche

### Domanda 6: Come proteggeresti un'API REST?
**Risposta:**
1. **Autenticazione:**
   - Token JWT
   - OAuth 2.0
   - Chiavi API

2. **Autorizzazione:**
   - Controllo degli accessi basato sui ruoli
   - Permessi a livello di risorsa
   - Validazione dello scope del token

3. **Protezione dei Dati:**
   - HTTPS/TLS
   - Validazione degli input
   - Sanitizzazione dei parametri
   - Limitazione della velocità

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

5. **Monitoraggio:**
   - Log di accesso
   - Tracciamento degli errori
   - Rilevamento delle anomalie