Liste e cicli, 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 · Il cartello della linea
In italiano. La prima fermata è nella scatola 0, l'ultima nella scatola -1, e quante sono lo dice len. Le metto insieme in una frase.
def cartello(fermate: list[str]) -> str:
return f"Da {fermate[0]} a {fermate[-1]}, {len(fermate)} fermate"Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
fermate[1] per la prima | Si conta da 0: la scatola 1 è la seconda fermata. Il cartello dice «Da Via Variabile a Piazza Query» | test_la_linea_intera, test_una_linea_di_due_fermate, test_una_linea_di_tre_fermate |
fermate[len(fermate)] per l'ultima | Con 5 fermate cerca la scatola 5, che non c'è: IndexError: list index out of range | gli stessi tre |
fermate[4] per l'ultima | Con 5 fermate funziona, per caso. Con 2 o 3: IndexError | test_una_linea_di_due_fermate, test_una_linea_di_tre_fermate |
La terza è la più insidiosa: il primo esempio che provi è verde, e pensi di aver finito. Un numero scritto a mano funziona con una lista sola; [-1] funziona con tutte.
2 · Quanti in ritardo
In italiano.
- Il conto parte da zero.
- Per ogni ritardo: se è almeno la soglia, il conto sale di uno.
- Dopo il ciclo, restituisco il conto.
def quanti_in_ritardo(ritardi: list[int], soglia: int) -> int:
conteggio = 0
for ritardo in ritardi:
if ritardo >= soglia:
conteggio = conteggio + 1
return conteggioIl disegno.
Va bene anche return len([ritardo for ritardo in ritardi if ritardo >= soglia]): un setaccio, poi quanti ne sono passati.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return conteggio rientrato dentro il for | Esce al primo giro. Con [0, 7, 2, 5, 12] il primo ritardo è 0: risposta 0. Con la lista vuota il for non gira nemmeno una volta, e la funzione dà None | test_conta_quelli_con_almeno_la_soglia, test_la_soglia_esatta_conta, test_nessun_treno |
if ritardo > soglia: | «Almeno 5» comprende il 5: con > i treni con 5 minuti esatti non contano | test_conta_quelli_con_almeno_la_soglia, test_la_soglia_esatta_conta |
conteggio = conteggio + ritardo | Somma i minuti invece di contare i treni: 24 invece di 3 | gli stessi due |
Guarda la prima: test_nessuno_in_ritardo resta verde, perché lì la risposta giusta è proprio 0. Un test verde non vuol dire che la funzione è giusta: vuol dire che quel caso funziona.
3 · Il cantiere di Largo Lista
In italiano. Una trasformazione: parto da una lista nuova, vuota, e per ogni durata ci metto la durata più i minuti del cantiere.
def allunga_corse(durate: list[int], minuti: int) -> list[int]:
nuove = []
for durata in durate:
nuove.append(durata + minuti)
return nuoveCon la comprehension: return [durata + minuti for durata in durate].
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
durata = durata + minuti nel for, poi return durate | durata è il dito: gli attacchi un numero nuovo, ma la scatola nella lista resta com'era. La funzione restituisce [28, 30, 29], la tabella di prima | test_ogni_corsa_si_allunga |
for i in range(len(durate)): e durate[i] = durate[i] + minuti | Il risultato è giusto, ma è la tabella vecchia ad essere cambiata: quella appesa in bacheca adesso dice [32, 34, 33] | test_la_tabella_vecchia_non_cambia |
Le due trappole sono opposte. Nella prima cambi il dito e non la lista; nella seconda cambi la lista, ma quella sbagliata. La lista giusta da cambiare è una lista nuova.
4 · Le corse soppresse
In italiano.
- Parto da una lista nuova, vuota.
- Per ogni corsa: se non è tra le soppresse, la aggiungo.
- Restituisco la lista nuova. Quella di partenza non l'ho toccata.
def togli_soppresse(corse: list[str], soppresse: list[str]) -> list[str]:
restano = []
for corsa in corse:
if corsa not in soppresse:
restano.append(corsa)
return restanoCon la comprehension: return [corsa for corsa in corse if corsa not in soppresse].
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
for corsa in corse: e dentro corse.remove(corsa) | Il dito salta una scatola dopo ogni remove: con due soppresse vicine, la seconda resta (18:30 è ancora lì). E la lista di partenza è cambiata | test_toglie_le_soppresse_anche_vicine, test_la_lista_di_partenza_non_cambia |
for corsa in list(corse): e dentro corse.remove(corsa) | Scorre una copia, quindi non salta niente: il risultato è giusto. Ma toglie dall'originale: la lista di domani ha perso le corse di oggi | test_la_lista_di_partenza_non_cambia |
La seconda è una correzione a metà: risolve il dito che salta, ma non il problema vero. La lista non è tua.
5 · Tra una fermata e l'altra
In italiano.
- Parto da una lista vuota.
- Per ogni posizione dalla 1 all'ultima: il passaggio di questa fermata meno quello della fermata prima.
- Restituisco la lista: ha un numero in meno delle fermate.
def tempi_tra_fermate(passaggi: list[int]) -> list[int]:
tempi = []
for i in range(1, len(passaggi)):
tempi.append(passaggi[i] - passaggi[i - 1])
return tempiPasso per passo, con [0, 3, 7, 12, 14]. range(1, 5) dà 1, 2, 3, 4:
| Giro | i | passaggi[i] | passaggi[i - 1] | Differenza | tempi dopo il giro |
|---|---|---|---|---|---|
| 1 | 1 | 3 | 0 | 3 | [3] |
| 2 | 2 | 7 | 3 | 4 | [3, 4] |
| 3 | 3 | 12 | 7 | 5 | [3, 4, 5] |
| 4 | 4 | 14 | 12 | 2 | [3, 4, 5, 2] |
Con una fermata sola, range(1, 1) è vuoto: nessun giro, e il risultato è [].
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
range(len(passaggi)) con passaggi[i + 1] - passaggi[i] | All'ultimo giro i + 1 è una scatola che non c'è: IndexError: list index out of range | test_i_tempi_tra_una_fermata_e_l_altra, test_due_fermate_un_tempo_solo, test_una_fermata_sola_nessun_tempo |
range(len(passaggi)) con passaggi[i] - passaggi[i - 1] | Al primo giro i - 1 vale -1: la scatola ultima. Nessun errore, ma in testa compare un tempo assurdo: [-14, 3, 4, 5, 2] | gli stessi tre |
La seconda è un errore silenzioso tipico delle liste: -1 non è «nessuna scatola», è l'ultima.
6 · Che fermata è?
In italiano.
- Scorro le fermate con il loro numero, da 1.
- Appena trovo quella cercata, restituisco il suo numero: ho finito, il resto non serve.
- Se il ciclo finisce senza trovarla, non c'è:
None.
def numero_fermata(fermate: list[str], cercata: str) -> int | None:
for numero, fermata in enumerate(fermate, start=1):
if fermata == cercata:
return numero
return NoneIl disegno.
Qui il return dentro il for è giusto: esce quando ha trovato, ed è proprio quello che vuoi. Il return None invece sta fuori, dopo il ciclo: ci arrivi solo se hai guardato tutte le fermate.
Passo per passo, cercando "Largo Lista":
| Giro | numero | fermata | È quella? | Cosa succede |
|---|---|---|---|---|
| 1 | 1 | Porta Codice | no | avanti |
| 2 | 2 | Via Variabile | no | avanti |
| 3 | 3 | Largo Lista | sì | return 3: la funzione finisce qui |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
else: return None dentro il for | Al primo giro, se la prima fermata non è quella giusta, esce con None. Trova solo Porta Codice | test_una_fermata_in_mezzo, test_l_ultima |
enumerate(fermate) senza start=1 | I numeri partono da 0: Largo Lista diventa la fermata 2 | test_la_prima_e_la_numero_uno, test_una_fermata_in_mezzo, test_l_ultima |
La prima è il return dentro il for sbagliato: un if con il suo else, tutti e due con un return, quindi il ciclo non arriva mai al secondo giro. Prima di decidere che una cosa non c'è, devi averle guardate tutte.
7 · I tre ritardi peggiori
In italiano. Una lista nuova, ordinata dal più grande; poi una fetta con i primi tre.
def tre_peggiori(ritardi: list[int]) -> list[int]:
in_ordine = sorted(ritardi, reverse=True)
return in_ordine[:3]Se i ritardi sono meno di tre, [:3] ti dà quelli che ci sono, senza errori: le fette non escono mai dalla lista.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
ritardi.sort(reverse=True), poi return ritardi[:3] | Il risultato è giusto, ma il registro adesso è [12, 7, 4, 3, 0]: l'ufficio reclami domani non trova più l'ordine della giornata | test_il_registro_non_cambia |
in_ordine = ritardi.sort(reverse=True), poi return in_ordine[:3] | .sort() restituisce None, e una fetta di None non esiste: TypeError: 'NoneType' object is not subscriptable | test_i_tre_piu_grandi_dal_piu_grande, test_meno_di_tre_ritardi, test_il_registro_non_cambia |
return sorted(ritardi)[:3] | Senza reverse=True l'ordine è dal più piccolo: i tre ritardi migliori, [0, 3, 4] | test_i_tre_piu_grandi_dal_piu_grande, test_meno_di_tre_ritardi |
8 · Il treno più puntuale
In italiano.
- Nessun arrivo? Nessun premio:
None. - Il migliore, per ora, è il primo arrivo: lo spacchetto in treno e ritardo.
- Per ogni arrivo: se il suo ritardo è più piccolo del minimo visto finora, diventa lui il migliore.
- Alla fine restituisco il nome del migliore.
def piu_puntuale(arrivi: list[tuple[str, int]]) -> str | None:
if len(arrivi) == 0:
return None
migliore, minimo = arrivi[0]
for treno, ritardo in arrivi:
if ritardo < minimo:
migliore = treno
minimo = ritardo
return miglioreIl disegno.
Passo per passo, con [("M16", 3), ("M12", 3), ("M14", 8)]:
| Giro | treno, ritardo | Confronto | migliore, minimo dopo il giro |
|---|---|---|---|
| prima | — | — | "M16", 3 (il primo arrivo) |
| 1 | "M16", 3 | 3 minore di 3? No | "M16", 3 |
| 2 | "M12", 3 | 3 minore di 3? No | "M16", 3 |
| 3 | "M14", 8 | 8 minore di 3? No | "M16", 3 |
Il pari merito si risolve da solo: con < (e non <=) un treno con lo stesso ritardo non scavalca quello arrivato prima nella lista.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Partire da minimo = 0 e migliore = None | Funziona solo se qualcuno è in anticipo. Se sono tutti in ritardo, nessuno scende sotto lo zero: risposta None | test_anche_se_sono_tutti_in_ritardo, test_pari_merito_vince_il_primo |
if ritardo <= minimo: | A pari merito l'ultimo scavalca il primo: vince M12 invece di M16 | test_pari_merito_vince_il_primo |
return min(arrivi)[0] | min sulle coppie confronta prima il nome del treno, in ordine alfabetico: vince M12 perché viene prima di M14, non perché è puntuale. E con la lista vuota: ValueError: min() iterable argument is empty | test_il_ritardo_piu_piccolo, test_pari_merito_vince_il_primo, test_nessun_treno |
La prima è la trappola del punto di partenza inventato, la stessa dell'esempio E: si parte dal primo elemento, non da un numero che ti sembra comodo.
La storia
Livello 1 · Il foglio di marcia
In italiano. La prima scatola e l'ultima, restituite insieme.
def prima_e_ultima(orario: list[str]) -> tuple[str, str]:
return orario[0], orario[-1]return orario[0], orario[-1] restituisce una tupla di due valori. Con una corsa sola, la prima e l'ultima sono la stessa scatola.
Nei dati veri: la prima corsa è prevista alle 06:00, l'ultima alle 20:15. Venti corse.
La trappola. orario[len(orario)] per l'ultima: IndexError: list index out of range. Rossi: test_livello_1_la_prima_e_l_ultima, test_livello_1_una_corsa_sola.
Livello 2 · I minuti tra due colonne
In italiano. Scorro le due liste insieme, un orario per lista a ogni giro. Per ogni coppia, trasformo i due orari in minuti e faccio la differenza.
def differenze(prima: list[str], dopo: list[str]) -> list[int]:
minuti_tra = []
for da, a in zip(prima, dopo):
minuti_tra.append(minuti(a) - minuti(da))
return minuti_traNei dati veri, i ritardi (differenze(ORARIO, PARTENZE)) e le durate (differenze(PARTENZE, ARRIVI)):
ritardi [0, 1, 0, 12, 1, 0, 2, 0, 6, 0, 1, 3, 0, 2, 0, 0, 5, 3, 0, 1]
durate [28, 29, 28, 29, 30, 28, 32, 28, 29, 30, 28, 35, 29, 28, 30, 33, 29, 31, 28, 28]Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Due for, uno dentro l'altro: for da in prima: e dentro for a in dopo: | Accoppia ogni orario di prima con ogni orario di dopo: 16 differenze invece di 4, molte senza senso | test_livello_2_i_ritardi, test_livello_2_le_durate |
a - da senza minuti() | Gli orari sono testo, e il testo non si sottrae: TypeError: unsupported operand type(s) for -: 'str' and 'str' | gli stessi due |
Livello 3 · Il conto dei ritardi
In italiano. Due accumulatori che partono da zero. A ogni corsa, il primo somma il ritardo; il secondo conta uno, ma solo se il ritardo è sopra zero. Dopo il ciclo, li restituisco insieme.
def conto_ritardi(ritardi: list[int]) -> tuple[int, int]:
totale = 0
in_ritardo = 0
for ritardo in ritardi:
totale = totale + ritardo
if ritardo > 0:
in_ritardo = in_ritardo + 1
return totale, in_ritardoNei dati veri: 37 minuti di ritardo in tutto, 11 corse partite in ritardo su 20.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return totale, in_ritardo rientrato dentro il for | Esce dopo la prima corsa: (0, 0). Con la lista vuota: None | test_livello_3_minuti_e_corse_in_ritardo, test_livello_3_nessuna_corsa |
in_ritardo = in_ritardo + ritardo | Il secondo accumulatore somma anche lui: (10, 10) invece di (10, 2) | test_livello_3_minuti_e_corse_in_ritardo |
Livello 4 · Le corse da segnalare
In italiano. Un setaccio: scorro i ritardi con il loro numero di corsa, da 1. Se il ritardo è almeno la soglia, tengo il numero.
def da_segnalare(ritardi: list[int], soglia: int) -> list[int]:
numeri = []
for numero, ritardo in enumerate(ritardi, start=1):
if ritardo >= soglia:
numeri.append(numero)
return numeriNei dati veri: vanno segnalate le corse 4, 9 e 17. La 17 è partita con 5 minuti esatti: con > sarebbe sfuggita.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
enumerate(ritardi) senza start=1 | Tiene le posizioni, da 0: [2, 4] invece di [3, 5]. Nel rapporto, tutte le corse sbagliate di uno | test_livello_4_i_numeri_delle_corse_da_segnalare, test_livello_4_la_soglia_esatta_si_segnala |
if ritardo > soglia: | La corsa con 5 minuti esatti non viene segnalata | test_livello_4_la_soglia_esatta_si_segnala |
Livello 5 · La corsa più lunga
In italiano.
- Lista vuota:
None. - Il massimo, per ora, è la prima scatola: valore
valori[0], numero 1. - Per ogni valore, con il suo numero: se è più grande del massimo, diventa lui il massimo, e mi segno il numero.
- Restituisco il numero.
def numero_del_massimo(valori: list[int]) -> int | None:
if len(valori) == 0:
return None
massimo = valori[0]
numero_massimo = 1
for numero, valore in enumerate(valori, start=1):
if valore > massimo:
massimo = valore
numero_massimo = numero
return numero_massimoPasso per passo, con i valori di prova [30, 34, 31, 34]:
| Giro | numero | valore | Confronto | massimo dopo | numero_massimo dopo |
|---|---|---|---|---|---|
| prima | — | — | — | 30 | 1 |
| 1 | 1 | 30 | 30 > 30? no | 30 | 1 |
| 2 | 2 | 34 | 34 > 30? sì | 34 | 2 |
| 3 | 3 | 31 | 31 > 34? no | 34 | 2 |
| 4 | 4 | 34 | 34 > 34? no | 34 | 2 |
Nei dati veri, la funzione dà due risposte diverse:
- sui ritardi: la corsa 4, partita alle 08:27 invece che alle 08:15, 12 minuti dopo. È il guasto al segnale che Lucia ricordava. Poi ci ha messo 29 minuti, come sempre;
- sulle durate: la corsa 12, 35 minuti da un capolinea all'altro, 5 più del solito. Era partita quasi in orario, alle 14:18 invece che alle 14:15: non è nemmeno tra quelle da segnalare.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
if valore >= massimo: | A pari merito vince l'ultima: 4 invece di 2 | test_livello_5_pari_merito_vince_la_prima |
enumerate(valori) senza start=1, e numero_massimo = 0 | Restituisce la posizione, da 0: 3 invece di 4. Nel finale, la corsa sbagliata di uno | test_livello_5_il_numero_della_piu_lunga, test_livello_5_la_prima_puo_essere_la_piu_lunga, test_livello_5_pari_merito_vince_la_prima |
Livello 6 · Chi guidava
In italiano.
- Il conto delle corse parte da zero.
- Per ogni turno, con il nome e quante corse guida: aggiungo le sue corse al conto.
- Se adesso il conto arriva almeno al numero cercato, la corsa è di questo turno: mi segno il nome e mi fermo.
def chi_guidava(turni: list[tuple[str, int]], numero: int) -> str:
contate = 0
macchinista = None
for nome, quante in turni:
contate = contate + quante
if numero <= contate:
macchinista = nome
break
return macchinistaVa bene anche return nome al posto delle due righe macchinista = nome e break: il return esce dal ciclo e dalla funzione insieme.
Passo per passo, nei dati veri, per la corsa 12:
| Giro | nome, quante | contate dopo | 12 <= contate? |
|---|---|---|---|
| 1 | Sergio Colombo, 5 | 5 | no |
| 2 | Rita Galbiati, 6 | 11 | no |
| 3 | Tommaso Greco, 5 | 16 | sì: break |
| — | Anita Ferraro, 4 | — | mai guardata |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Senza break | Il ciclo va avanti, e per ogni turno dopo numero <= contate resta vero: il nome viene sovrascritto fino all'ultimo. La risposta è sempre l'ultimo macchinista | test_livello_6_una_corsa_in_mezzo, test_livello_6_la_prima_corsa, test_livello_6_l_ultima_corsa_di_un_turno |
if numero < contate: | L'ultima corsa di ogni turno passa al turno dopo: la corsa 2 diventa di Bruno. E l'ultima corsa della giornata non ha più nessuno: None | test_livello_6_l_ultima_corsa_di_un_turno, test_livello_6_l_ultima_corsa_della_giornata |
Il finale
- Livello 2: una sosta in galleria non cambia l'ora di partenza. Allunga la durata della corsa.
- Livello 5: le corse da record sono due. La 4 è la più in ritardo alla partenza, ma è il guasto al segnale che Lucia ricordava, e poi ha viaggiato in 29 minuti. La 12 è la più lunga: 35 minuti, cinque più del solito, anche se era partita quasi in orario. È lei.
- Livello 6: la corsa 12 è la prima del turno di Tommaso Greco. Sergio Colombo guida dalla 1 alla 5, Rita Galbiati dalla 6 alla 11, Tommaso dalla 12 alla 16.
Con corsa_con_la_sosta = 12 il rapporto stampa:
La corsa numero 12
prevista alle 14:15 · partita alle 14:18 · arrivata alle 14:53
la guidava: Tommaso Grecopython storia/verifica.py "Tommaso Greco"