I dizionari, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i più difficili, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: spesso ci sono più strade giuste. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano qualche test e si rompono su un altro.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
La palestra
1 · La biglietteria
In italiano. Chiedo al listino il prezzo della zona. Se la zona non c'è, la risposta è None.
def prezzo_corsa(listino: dict[str, float], zona: str) -> float | None:
return listino.get(zona)get senza ripiego dà già None quando la chiave manca: non serve nessun if.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return listino[zona] | Con «luna»: KeyError: 'luna', la macchinetta si blocca | test_zona_che_non_esiste_da_none |
return listino.get(zona, 0) | La luna costa 0 euro: un prezzo inventato, non «non c'è» | test_zona_che_non_esiste_da_none |
if listino.get(zona): return listino[zona] | Una zona che costa 0.0 è «falsa» per l'if: la navetta gratis sparisce | test_una_zona_gratis_non_e_una_zona_che_manca |
La terza è la più subdola: if valore: non chiede «c'è?», chiede «è vero?». E 0, 0.0, "", [] e {} per Python sono falsi. Per sapere se una chiave c'è, si chiede con in, o si confronta con is None.
2 · Il tabellone
In italiano.
- Parto da una lista vuota.
- Per ogni stazione e la sua lucina:
- se la lucina è spenta, la stazione va nella lista.
- Alla fine la restituisco in ordine alfabetico.
def stazioni_chiuse(stato: dict[str, bool]) -> list[str]:
chiuse = []
for stazione, aperta in stato.items():
if not aperta:
chiuse.append(stazione)
return sorted(chiuse)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return chiuse senza sorted | L'ordine è quello del dizionario, non quello alfabetico | test_solo_le_chiuse_in_ordine_alfabetico |
for stazione in stato: e poi if not stazione: | Il for dà solo le chiavi: l'if guarda il nome della stazione, che non è mai vuoto. Nessuna stazione è chiusa | test_solo_le_chiuse_in_ordine_alfabetico |
Con il for sulle chiavi va bene anche if not stato[stazione]:. Con .items() è più leggibile: il valore ha già un nome.
3 · Il tornello
In italiano. È l'esempio B: per ogni badge, se l'ho già visto aggiungo uno, altrimenti parte da uno.
def conta_timbrature(badge_letti: list[str]) -> dict[str, int]:
conteggi = {}
for badge in badge_letti:
if badge in conteggi:
conteggi[badge] = conteggi[badge] + 1
else:
conteggi[badge] = 1
return conteggiVa bene anche la versione corta: conteggi[badge] = conteggi.get(badge, 0) + 1.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Solo conteggi[badge] = conteggi[badge] + 1 | Al primo badge la chiave non c'è: KeyError: 'B-01' | test_conta_ogni_badge, test_un_badge_solo |
Solo conteggi[badge] = 1 | Nessun errore, ma ogni badge vale sempre 1 | test_conta_ogni_badge |
4 · Chi è passato dove
In italiano.
- Per ogni coppia, la spacchetto: prima il badge, poi la stazione.
- Se la stazione non ha ancora una lista, gliene do una vuota.
- Sempre: aggiungo il badge alla lista della sua stazione.
def per_stazione(timbrature: list[tuple[str, str]]) -> dict[str, list[str]]:
gruppi = {}
for badge, stazione in timbrature:
if stazione not in gruppi:
gruppi[stazione] = []
gruppi[stazione].append(badge)
return gruppiIl disegno.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
gruppi[stazione] = [badge] | A ogni giro la lista viene sostituita: resta solo l'ultimo badge di ogni stazione | test_raggruppa_nell_ordine_di_arrivo, test_lo_stesso_badge_due_volte_conta_due_volte |
Solo gruppi[stazione].append(badge) | La prima volta la lista non esiste: KeyError: 'Porta Codice' | gli stessi due |
5 · Il deposito dei treni
In italiano.
- Per ogni treno, prendo il suo codice.
- Se quel codice è già nel dizionario, mi fermo con un errore che dice quale.
- Altrimenti metto il treno nel dizionario, con il codice come chiave.
def indice_per_codice(treni: list[dict]) -> dict[str, dict]:
indice = {}
for treno in treni:
codice = treno["codice"]
if codice in indice:
raise ValueError(f"Codice duplicato: {codice}")
indice[codice] = treno
return indiceIl disegno.
Il controllo va prima di scrivere: dopo, il primo treno sarebbe già stato sovrascritto.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
| Nessun controllo sui doppioni | Il secondo M12 prende il posto del primo, in silenzio | test_codice_duplicato_e_un_errore |
indice[treno] = treno | Un dizionario non può fare da chiave: TypeError: unhashable type: 'dict' | test_dal_codice_al_treno, test_codice_duplicato_e_un_errore |
6 · Il tabellone dei ritardi
In italiano.
- Parto da un dizionario nuovo, vuoto.
- Per ogni treno del tabellone, con i suoi minuti:
- scrivo nel nuovo dizionario i minuti più il suo ritardo; se non ne ha, zero.
def applica_ritardi(tempi: dict[str, int], ritardi: dict[str, int]) -> dict[str, int]:
aggiornati = {}
for treno, minuti in tempi.items():
aggiornati[treno] = minuti + ritardi.get(treno, 0)
return aggiornatiGirare sui tempi risolve due problemi insieme: ogni treno del tabellone c'è, e i ritardi dei treni che non esistono non li incontri mai.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
aggiornati = tempi, poi le modifiche | Una scatola, due etichette: il tabellone appeso cambia anche lui | test_il_tabellone_originale_non_cambia |
Girare sui ritardi con tempi[treno] + ritardo | Il ritardo di M99 cerca M99 nei tempi: KeyError: 'M99' | test_i_treni_che_non_esistono_si_ignorano |
7 · Gli oggetti smarriti
In italiano.
- Parto da una copia del primo deposito.
- Per ogni oggetto del secondo, con la sua quantità:
- quanti ne ho già (zero se è nuovo) più quanti ne arrivano.
def unisci_depositi(primo: dict[str, int], secondo: dict[str, int]) -> dict[str, int]:
unito = dict(primo)
for oggetto, quanti in secondo.items():
unito[oggetto] = unito.get(oggetto, 0) + quanti
return unitoPasso per passo, con {"ombrello": 3, "guanto": 1} e {"ombrello": 2, "sciarpa": 4}:
| Giro | oggetto, quanti | unito.get(oggetto, 0) | unito dopo il giro |
|---|---|---|---|
| prima | — | — | {"ombrello": 3, "guanto": 1} (la copia) |
| 1 | "ombrello", 2 | 3 | {"ombrello": 5, "guanto": 1} |
| 2 | "sciarpa", 4 | 0 | {"ombrello": 5, "guanto": 1, "sciarpa": 4} |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return {**primo, **secondo} | Le due stelle aprono i dizionari uno dopo l'altro: per «ombrello» vince il secondo, 2. Non somma | test_somma_gli_oggetti_in_comune |
unito = primo | Il deposito di Porta Codice viene modificato | test_i_depositi_di_partenza_non_cambiano |
8 · La stazione più affollata
In italiano.
- Il migliore, all'inizio, non c'è.
- Scorro le stazioni in ordine alfabetico.
- Se non ho ancora un migliore, o questa stazione ha più passaggi del migliore, diventa lei il migliore.
- Alla fine restituisco il migliore: se il dizionario era vuoto, è ancora
None.
def stazione_piu_affollata(passaggi: dict[str, int]) -> str | None:
migliore = None
for stazione in sorted(passaggi):
if migliore is None or passaggi[stazione] > passaggi[migliore]:
migliore = stazione
return miglioreIl disegno.
Passo per passo, con {"Ponte Ciclo": 50, "Largo Lista": 50, "Via Variabile": 10}. sorted dà le chiavi in ordine alfabetico: Largo Lista, Ponte Ciclo, Via Variabile.
| Giro | stazione | Passaggi | Confronto | migliore dopo il giro |
|---|---|---|---|---|
| 1 | Largo Lista | 50 | migliore è None | Largo Lista |
| 2 | Ponte Ciclo | 50 | 50 > 50? No | Largo Lista |
| 3 | Via Variabile | 10 | 10 > 50? No | Largo Lista |
Il pari merito si risolve da solo: con > (e non >=) il primo in ordine alfabetico non viene mai scavalcato da uno uguale.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return max(passaggi, key=passaggi.get) | Corto ed elegante, ma a pari merito vince il primo inserito, non il primo in ordine alfabetico. E con il dizionario vuoto: ValueError: max() iterable argument is empty | test_pari_merito_vince_l_ordine_alfabetico, test_nessun_dato |
Partire da massimo = 0 | Una stazione con zero passaggi non supera mai zero: risposta None | test_anche_con_zero_passaggi_una_stazione_c_e |
La seconda è la trappola di piu_alta in Liste e cicli: il punto di partenza è il primo elemento, non un numero inventato.
La storia
Livello 1 · La rubrica
In italiano. Per ogni persona, nel dizionario: chiave il badge, valore il nome.
def rubrica(persone: list[dict]) -> dict[str, str]:
elenco = {}
for persona in persone:
elenco[persona["badge"]] = persona["nome"]
return elencoNel registro vero: B-03 è di Nadia Russo, guardia giurata.
Livello 2 · Il conto
In italiano. Come il tornello, ma il badge sta dentro la timbratura.
def quante_timbrature(timbrature: list[dict]) -> dict[str, int]:
conteggi = {}
for timbratura in timbrature:
badge = timbratura["badge"]
if badge in conteggi:
conteggi[badge] = conteggi[badge] + 1
else:
conteggi[badge] = 1
return conteggiNel registro vero: B-03 ha timbrato 4 volte.
Livello 3 · I percorsi
In italiano. Raggruppo le timbrature intere per badge; l'ordine resta quello del registro, perché l'append aggiunge in fondo.
def percorsi(timbrature: list[dict]) -> dict[str, list[dict]]:
tragitti = {}
for timbratura in timbrature:
badge = timbratura["badge"]
if badge not in tragitti:
tragitti[badge] = []
tragitti[badge].append(timbratura)
return tragittiNel registro vero, il percorso di B-03:
22:00 Porta Codice entrata
00:32 Porta Codice uscita
00:33 Vecchia Fiera entrata
00:48 Vecchia Fiera uscitaUn minuto tra Porta Codice e Vecchia Fiera. Qualcosa non torna.
La trappola. Con tragitti[badge] = [timbratura] ogni badge tiene solo la sua ultima timbratura. Il test del livello 3 diventa rosso, e con lui tre test del livello 5, che usa percorsi: un errore in una funzione si porta dietro tutte quelle che la usano. Se il livello 5 è rosso senza motivo, controlla prima il 3.
Livello 4 · Chi è ancora dentro
In italiano.
- Ogni badge ha un saldo che parte da zero.
- Entrata: +1. Uscita: −1.
- Alla fine tengo i badge con il saldo sopra zero, in ordine alfabetico.
def ancora_dentro(timbrature: list[dict]) -> list[str]:
saldo = {}
for timbratura in timbrature:
badge = timbratura["badge"]
if badge not in saldo:
saldo[badge] = 0
if timbratura["verso"] == "entrata":
saldo[badge] = saldo[badge] + 1
else:
saldo[badge] = saldo[badge] - 1
dentro = []
for badge, conto in saldo.items():
if conto > 0:
dentro.append(badge)
return sorted(dentro)Due schemi in fila: prima contare, poi setacciare il risultato.
Nel registro vero: ancora dentro B-05 e B-08.
La trappola. Tenere «chi è entrato almeno una volta» invece del saldo: dentro finiscono tutti. Rossi: test_livello_4_chi_ha_piu_entrate_che_uscite, test_livello_4_tutti_usciti.
Livello 5 · Il badge impossibile
In italiano.
- Per ogni badge prendo il suo percorso (livello 3).
- Confronto ogni timbratura con quella prima.
- Se la stazione cambia e sono passati meno di cinque minuti, il badge è sospetto.
- Ogni sospetto una volta sola; alla fine in ordine alfabetico.
def badge_impossibili(timbrature: list[dict]) -> list[str]:
sospetti = []
for badge, tragitto in percorsi(timbrature).items():
for i in range(1, len(tragitto)):
prima = tragitto[i - 1]
dopo = tragitto[i]
cambia_stazione = prima["stazione"] != dopo["stazione"]
attesa = minuti(dopo["ora"]) - minuti(prima["ora"])
if cambia_stazione and attesa < MINUTI_TRA_STAZIONI and badge not in sospetti:
sospetti.append(badge)
return sorted(sospetti)Il range parte da 1, non da 0: la prima timbratura non ha una «prima» con cui confrontarsi.
Passo per passo, sul percorso di B-03:
i | prima | dopo | Cambia stazione? | Attesa | Sospetto? |
|---|---|---|---|---|---|
| 1 | 22:00 Porta Codice | 00:32 Porta Codice | no | 152 | no |
| 2 | 00:32 Porta Codice | 00:33 Vecchia Fiera | sì | 1 | sì |
| 3 | 00:33 Vecchia Fiera | 00:48 Vecchia Fiera | no | 15 | no (e c'è già) |
Nel registro vero: l'unico badge impossibile è B-03. Nadia Russo è uscita da Porta Codice alle 00:32; un minuto dopo «lei» entrava a Vecchia Fiera. Il badge ha un gemello.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
attesa <= MINUTI_TRA_STAZIONI | Cinque minuti esatti diventano impossibili: Sergio Colombo, che va da Largo Lista a Ponte Ciclo in cinque minuti, finisce tra i sospetti | test_livello_5_cinque_minuti_bastano |
| Nessun controllo sulla stazione | Uscire e rientrare dallo stesso tornello in un minuto diventa un viaggio impossibile | test_livello_5_la_stessa_stazione_non_e_un_viaggio, test_livello_5_due_stazioni_in_due_minuti |
Senza badge not in sospetti | Un badge con due salti sospetti compare due volte | test_livello_5_ogni_badge_una_volta_sola_e_in_ordine |
Livello 6 · Chi è entrato lì vicino
In italiano.
- Trasformo in minuti l'inizio e la fine dell'intervallo.
- Per ogni timbratura, la tengo se: è un'entrata, e la stazione è tra quelle cercate, e l'ora (in minuti) sta tra inizio e fine, estremi compresi.
def entrati_tra(timbrature: list[dict], stazioni: list[str], da: str, a: str) -> list[str]:
inizio = minuti(da)
fine = minuti(a)
entrati = []
for timbratura in timbrature:
quando = minuti(timbratura["ora"])
if (
timbratura["verso"] == "entrata"
and timbratura["stazione"] in stazioni
and inizio <= quando <= fine
):
entrati.append(timbratura["badge"])
return entratiinizio <= quando <= fine è un modo di Python per scrivere inizio <= quando and quando <= fine. Le parentesi intorno all'if servono solo per andare a capo.
Nel registro vero, tra le 00:48 e le 00:58 a Ponte Ciclo o Piazza Query entra un badge solo: B-08, alle 00:53 a Ponte Ciclo.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
da <= timbratura["ora"] <= a sulle stringhe | Funziona per caso finché non si passa la mezzanotte: tra «23:50» e «00:10» le 23:55 non ci sono più | test_livello_6_a_cavallo_della_mezzanotte |
< al posto di <= | Chi entra proprio all'ora di inizio o di fine viene escluso | test_livello_6_gli_estremi_sono_compresi |
| Nessun controllo sul verso | Entrano anche le uscite | test_livello_6_le_uscite_non_contano, test_livello_6_solo_le_entrate_nelle_stazioni_giuste |
Il finale
- Livello 5: il badge B-03 è stato in due posti insieme. È di Nadia Russo (livello 1), ma alle 00:32 lei usciva da Porta Codice: è il suo badge, non è lei. Qualcuno ha un clone.
- Livello 3: il clone entra a Vecchia Fiera alle 00:33 ed esce alle 00:48. La Chiave Rossa sparisce alle 00:40: in mezzo.
- Livello 6: nei dieci minuti dopo, nelle stazioni vicine entra solo B-08, alle 00:53 a Ponte Ciclo. Pietro Galli rientra alle 00:51, ma a Largo Lista, che non è vicina. Ivo Brambati entra a Piazza Query, ma alle 01:10: troppo tardi.
- Livello 2 e 4: B-08 a fine notte è ancora dentro. Elena Marchi pure, ma non si è mai mossa da Via Variabile: il suo turno finisce alle 5.
B-08 è di Dario Sala, l'elettricista: l'unico che sa cosa farsene di una chiave del quadro elettrico.
python storia/verifica.py "Dario Sala"