Domande e risposte per colloqui da software engineer (2026): coding, fondamentali, design e comportamentali

I colloqui per software engineer seguono uno schema familiare nella maggior parte delle aziende: una chiamata con il recruiter, uno o due round di coding, un round di system design per i ruoli mid-level e senior e un round comportamentale. Qui sotto trovi 20 domande di colloquio per software engineer con risposte, raggruppate per round. Ogni esempio di codice è stato testato contro una versione brute force su migliaia di input casuali prima della pubblicazione.

Cosa valuta ogni round

I colloqui per neolaureati sono per lo più coding e comportamentali. I colloqui senior aggiungono più system design e si aspettano risposte più approfondite sui progetti passati. Per la chiamata con il recruiter, vedi le nostre domande del colloquio telefonico di selezione.

Domande di coding

In ogni round di coding, dichiara il tuo approccio prima di scrivere, indica la complessità di tempo e spazio e verifica con un piccolo esempio alla fine. La nostra cheat sheet sulla Big O copre la parte sulla complessità.

1. Two sum: restituisci gli indici di due numeri la cui somma dà un target

Memorizza l'indice di ogni numero in una hash map. Per ogni nuovo numero, controlla se il suo complemento è già nella mappa.

def two_sum(nums, target):
    seen = {}
    for i, x in enumerate(nums):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []

print(two_sum([2, 7, 11, 15], 9))  # [0, 1]

O(n) di tempo e O(n) di spazio. La versione brute force controlla ogni coppia in O(n²), e gli intervistatori di solito vogliono che tu lo dica per primo e poi lo migliori.

2. Parentesi valide: verifica che ogni parentesi sia chiusa nell'ordine giusto

Inserisci le parentesi aperte in uno stack. Quando trovi una parentesi chiusa, in cima allo stack deve esserci la sua parentesi aperta corrispondente.

def is_valid(s):
    pairs = {")": "(", "]": "[", "}": "{"}
    stack = []
    for ch in s:
        if ch in pairs:
            if not stack or stack.pop() != pairs[ch]:
                return False
        else:
            stack.append(ch)
    return not stack

print(is_valid("([]{})"), is_valid("(]"))  # True False

O(n) di tempo e O(n) di spazio. L'ultima riga conta: una stringa come "((" lascia elementi nello stack e quindi non è valida.

3. Unire intervalli sovrapposti

Ordina per ora di inizio, poi estendi l'ultimo intervallo unito oppure ne inizi uno nuovo.

def merge_intervals(intervals):
    merged = []
    for start, end in sorted(intervals):
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

print(merge_intervals([[1, 3], [2, 6], [8, 10], [15, 18]]))
# [[1, 6], [8, 10], [15, 18]]

O(n log n) di tempo a causa dell'ordinamento. Chiedi se intervalli che si toccano, come [1, 2] e [2, 3], vanno uniti. Questa versione li unisce.

4. Invertire una lista concatenata

Percorri la lista una volta sola e fai puntare ogni nodo a quello precedente.

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

def reverse_list(head):
    prev = None
    while head:
        head.next, prev, head = prev, head, head.next
    return prev

O(n) di tempo e O(1) di spazio extra. Se l'assegnazione multipla sembra troppo furba per l'intervistatore, scrivila su tre righe con una variabile temporanea. La chiarezza batte la brevità.

5. Restituisci i k elementi più frequenti

Conta con una hash map, poi prendi i k conteggi più alti con un heap.

from collections import Counter
import heapq

def top_k_frequent(nums, k):
    counts = Counter(nums)
    return [x for x, _ in heapq.nlargest(k, counts.items(), key=lambda p: p[1])]

print(top_k_frequent([1, 1, 1, 2, 2, 3], 2))  # [1, 2]

O(n log k) di tempo. Una possibile domanda di approfondimento è l'ordinamento a bucket per frequenza, che arriva a O(n).

6. Progetta una cache LRU con get e put in O(1)

Ti servono una ricerca veloce e un riordino veloce per uso recente. Una hash map più una lista doppiamente concatenata fanno entrambe le cose. In Python, OrderedDict è esattamente questa combinazione.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.data = OrderedDict()

    def get(self, key):
        if key not in self.data:
            return -1
        self.data.move_to_end(key)
        return self.data[key]

    def put(self, key, value):
        if key in self.data:
            self.data.move_to_end(key)
        self.data[key] = value
        if len(self.data) > self.capacity:
            self.data.popitem(last=False)

Alcuni intervistatori ti chiederanno di costruire tu la lista concatenata. Spiega prima la struttura: la mappa punta ai nodi della lista, il nodo più recente sta a un'estremità e l'eliminazione avviene dall'altra.

7. Cammino più breve in una griglia con muri

La ricerca in ampiezza (BFS) trova il cammino più breve quando ogni passo ha lo stesso costo.

from collections import deque

def shortest_path(grid):
    rows, cols = len(grid), len(grid[0])
    if grid[0][0] or grid[rows - 1][cols - 1]:
        return -1
    queue = deque([(0, 0, 0)])
    seen = {(0, 0)}
    while queue:
        r, c, steps = queue.popleft()
        if (r, c) == (rows - 1, cols - 1):
            return steps
        for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
            nr, nc = r + dr, c + dc
            if 0 <= nr < rows and 0 <= nc < cols and not grid[nr][nc] and (nr, nc) not in seen:
                seen.add((nr, nc))
                queue.append((nr, nc, steps + 1))
    return -1

print(shortest_path([[0, 0, 0], [1, 1, 0], [0, 0, 0]]))  # 4

O(rows × cols) di tempo e spazio. Segna le celle come viste quando le aggiungi alla coda, non quando le rimuovi, altrimenti la stessa cella finisce in coda molte volte.

8. Trova la prima versione difettosa

Le versioni da 1 a n sono buone fino a un certo punto e difettose dopo. La ricerca binaria trova la prima difettosa con O(log n) controlli.

def first_bad_version(n, is_bad):
    lo, hi = 1, n
    while lo < hi:
        mid = (lo + hi) // 2
        if is_bad(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo

Lo schema vale per qualsiasi domanda sì o no che cambia una sola volta, e capita spesso. Per un elenco di problemi che coprono questi schemi, vedi la Blind 75.

Domande di fondamentali di informatica

9. Qual è la differenza tra processo e thread?

Un processo è un programma in esecuzione con il proprio spazio di memoria. I thread girano dentro un processo e condividono la sua memoria. I thread costano meno da creare e tra cui passare, e possono condividere dati direttamente, ma proprio per questa condivisione servono i lock e possono verificarsi le race condition. I processi sono isolati, quindi un crash in uno non abbatte gli altri.

10. Qual è la differenza tra TCP e UDP?

TCP stabilisce una connessione e garantisce una consegna ordinata e affidabile, con ritrasmissione e controllo del flusso. UDP invia pacchetti indipendenti senza garanzie di consegna o di ordine e con meno overhead. Usa TCP per pagine web, API e trasferimento di file. UDP va bene per voce, video e giochi in diretta, dove un pacchetto in ritardo è comunque inutile. Le nostre domande di colloquio sulle reti di computer vanno più a fondo.

11. Cosa succede quando digiti un URL nel browser e premi Invio?

Il browser risolve il dominio in un indirizzo IP tramite DNS, apre una connessione TCP e, per HTTPS, esegue l'handshake TLS. Invia una richiesta HTTP e il server, spesso dietro un load balancer, restituisce una risposta. Il browser analizza l'HTML, richiede il CSS, il JavaScript e le immagini a cui fa riferimento, e disegna la pagina. Approfondisci la parte che sceglie l'intervistatore.

12. Come funziona una hash table e qual è la sua complessità temporale?

Una funzione hash associa ogni chiave a un bucket di un array. Ricerche, inserimenti e cancellazioni sono O(1) in media. Quando due chiavi finiscono nello stesso bucket, la tabella gestisce la collisione con il concatenamento o sondando un altro slot, e si ridimensiona quando è troppo piena. Il caso peggiore è O(n) se molte chiavi collidono.

13. Quando sceglieresti un database SQL invece di uno NoSQL?

Scegli SQL quando i dati sono relazionali, ti servono join e transazioni e lo schema è abbastanza stabile: ordini, pagamenti, account utente. Scegli un document store o un key-value store quando i pattern di accesso sono semplici, la forma dei dati varia o devi scalare le scritture su molte macchine. Molti sistemi usano entrambi. La risposta che gli intervistatori cercano è il compromesso, non un vincitore. Le nostre domande di colloquio sulle API REST coprono il livello delle API che di solito si trova sopra.

Domande di system design

14. Progetta un accorciatore di URL

Chiarisci prima i requisiti: quanti nuovi link al giorno, quante letture, se i link scadono, se sono ammessi alias personalizzati. Poi copri l'API (creazione e redirect), come generi i codici brevi (un contatore codificato in base 62, oppure un codice casuale con controllo di unicità), lo storage (un key-value store da codice a URL) e una cache per i link popolari, perché le letture superano di gran lunga le scritture. Chiudi con analytics e prevenzione degli abusi, se resta tempo. Trovi il progetto completo nella nostra guida al system design.

15. Progetta un rate limiter

Parti da dove viene eseguito (al gateway API, per utente o per chiave API) e da cosa succede quando un client supera il limite (HTTP 429 con un tempo di attesa prima di riprovare). La scelta comune è il token bucket: ogni client ha un secchio che si riempie a una velocità fissa e contiene un numero massimo di token, e ogni richiesta ne consuma uno. Permette brevi picchi e fa rispettare una media. Con più server, tieni i contatori in uno storage condiviso come Redis, così ogni server vede lo stesso conteggio. Per esercitarti di più, vedi le nostre domande di colloquio di system design.

Domande comportamentali

Usa una struttura chiara per ogni storia: la situazione, cosa hai fatto e il risultato, con i numeri quando li hai.

16. Parlami di te

Prepara una versione di due minuti della tua carriera che finisca con il motivo per cui vuoi questo ruolo. Cita uno o due progetti con risultati concreti. La nostra guida a parlami di te contiene esempi.

17. Parlami di un bug difficile che hai risolto

Risposta di esempio: "Il nostro servizio di checkout ha iniziato ad andare in timeout qualche volta al giorno, senza uno schema. Ho aggiunto gli ID delle richieste ai log e ho scoperto che ogni timeout arrivava da un'unica query sul database, eseguita solo quando un carrello conteneva più di 50 articoli. Alla colonna usata nel join mancava un indice. Ho aggiunto l'indice, la query lenta è passata da circa 4 secondi a meno di 50 millisecondi, e ho inserito un alert sulla latenza di quella query per accorgerci prima la prossima volta."

18. Parlami di un disaccordo con un collega

Risposta di esempio: "Un collega voleva riscrivere il nostro servizio di notifiche in un nuovo framework, e io pensavo che il rischio fosse troppo alto prima del lancio. Invece di discutere in riunione, ho proposto che ciascuno scrivesse il costo e il rischio. Abbiamo concordato di sistemare i due problemi peggiori del codice attuale prima del lancio e di pianificare la riscrittura per il trimestre successivo. Il lancio è uscito in orario e due mesi dopo abbiamo fatto la riscrittura con un piano di test adeguato."

19. Parlami di un progetto fallito

Scegli un fallimento reale in cui avevi una parte di responsabilità. Spiega cosa è andato storto, cosa faresti diversamente e cosa hai cambiato dopo. Gli intervistatori cercano onestà e capacità di imparare, non un curriculum perfetto.

20. Perché vuoi lavorare qui?

Collega qualcosa di specifico del prodotto o del lavoro di ingegneria dell'azienda alla tua esperienza. "Uso la vostra API da due anni e vorrei lavorare sul lato piattaforma" batte "siete un'ottima azienda".

Domande da fare all'intervistatore

• Come si svolge una settimana tipica per chi lavora in questo team?
• Come viene pianificato il lavoro e chi decide le priorità?
• Come funzionano la code review e il deployment qui?
• Che cosa significherebbe avere successo nei primi sei mesi?
• Qual è il problema tecnico più difficile su cui sta lavorando il team?

Per altri spunti, vedi domande da fare alla fine di un colloquio.

Come prepararsi

1. Scegli un linguaggio e usalo per ogni esercizio. Python è la scelta più comune perché il codice è breve. Le nostre domande di colloquio su Python coprono il linguaggio stesso.
2. Esercitati per schema, non per quantità: hash map, due puntatori, sliding window, ricerca binaria, BFS e DFS, heap e programmazione dinamica.
3. Risolvi i problemi ad alta voce con un timer. Una soluzione corretta ma silenziosa ottiene un punteggio più basso di una spiegata con chiarezza.
4. Esercitati nell'editor che userai. Molte aziende usano CoderPad, che ha una sandbox gratuita.
5. Prepara cinque storie dal tuo lavoro che puoi adattare alla maggior parte delle domande comportamentali.
6. Per i ruoli mid-level e senior, fai almeno qualche sessione completa di system design con qualcuno che ti fa domande di approfondimento.