Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Python4. Liste e ciclip. 114

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.

python-liste-e-cicli-soluzioni.zip19 KB

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.

Python
def cartello(fermate: list[str]) -> str:
    return f"Da {fermate[0]} a {fermate[-1]}, {len(fermate)} fermate"

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
fermate[1] per la primaSi 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'ultimaCon 5 fermate cerca la scatola 5, che non c'è: IndexError: list index out of rangegli stessi tre
fermate[4] per l'ultimaCon 5 fermate funziona, per caso. Con 2 o 3: IndexErrortest_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.

  1. Il conto parte da zero.
  2. Per ogni ritardo: se è almeno la soglia, il conto sale di uno.
  3. Dopo il ciclo, restituisco il conto.
Python
def quanti_in_ritardo(ritardi: list[int], soglia: int) -> int:
    conteggio = 0
    for ritardo in ritardi:
        if ritardo >= soglia:
            conteggio = conteggio + 1
    return conteggio

Il disegno.

inizio quanti_in_ritardo(ritardi, soglia) conteggio = 0 per ogni ritardo in ritardi se ritardo >= soglia sì: conteggio = conteggio + 1 restituisci conteggioquanti_in_ritardo(ritardi,soglia)conteggio = 0per ogni ritardo in ritardiritardo >= sogliaconteggio = conteggio + 1restituisci conteggionosìfiniti
Il conto dei treni in ritardo

Va bene anche return len([ritardo for ritardo in ritardi if ritardo >= soglia]): un setaccio, poi quanti ne sono passati.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return conteggio rientrato dentro il forEsce 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à Nonetest_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 contanotest_conta_quelli_con_almeno_la_soglia, test_la_soglia_esatta_conta
conteggio = conteggio + ritardoSomma i minuti invece di contare i treni: 24 invece di 3gli 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.

Python
def allunga_corse(durate: list[int], minuti: int) -> list[int]:
    nuove = []
    for durata in durate:
        nuove.append(durata + minuti)
    return nuove

Con la comprehension: return [durata + minuti for durata in durate].

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
durata = durata + minuti nel for, poi return duratedurata è il dito: gli attacchi un numero nuovo, ma la scatola nella lista resta com'era. La funzione restituisce [28, 30, 29], la tabella di primatest_ogni_corsa_si_allunga
for i in range(len(durate)): e durate[i] = durate[i] + minutiIl 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.

  1. Parto da una lista nuova, vuota.
  2. Per ogni corsa: se non è tra le soppresse, la aggiungo.
  3. Restituisco la lista nuova. Quella di partenza non l'ho toccata.
Python
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 restano

Con la comprehension: return [corsa for corsa in corse if corsa not in soppresse].

Le trappole.

Il codice sbagliatoCosa succedeIl 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 è cambiatatest_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 oggitest_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.

  1. Parto da una lista vuota.
  2. Per ogni posizione dalla 1 all'ultima: il passaggio di questa fermata meno quello della fermata prima.
  3. Restituisco la lista: ha un numero in meno delle fermate.
Python
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 tempi

Passo per passo, con [0, 3, 7, 12, 14]. range(1, 5) dà 1, 2, 3, 4:

Giroipassaggi[i]passaggi[i - 1]Differenzatempi dopo il giro
11303[3]
22734[3, 4]
331275[3, 4, 5]
4414122[3, 4, 5, 2]

Con una fermata sola, range(1, 1) è vuoto: nessun giro, e il risultato è [].

Le trappole.

Il codice sbagliatoCosa succedeIl 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 rangetest_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.

  1. Scorro le fermate con il loro numero, da 1.
  2. Appena trovo quella cercata, restituisco il suo numero: ho finito, il resto non serve.
  3. Se il ciclo finisce senza trovarla, non c'è: None.
Python
def numero_fermata(fermate: list[str], cercata: str) -> int | None:
    for numero, fermata in enumerate(fermate, start=1):
        if fermata == cercata:
            return numero
    return None

Il disegno.

inizio numero_fermata(fermate, cercata) per ogni numero, fermata in enumerate(fermate, start=1) se fermata == cercata sì: restituisci numero restituisci Nonenumero_fermata(fermate,cercata)per ogni numero, fermata inenumerate(fermate, start=1)fermata == cercatarestituisci numerorestituisci Nonenosìfiniti
Il giro che si ferma quando trova

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":

GironumerofermataÈ quella?Cosa succede
11Porta Codicenoavanti
22Via Variabilenoavanti
33Largo Listasìreturn 3: la funzione finisce qui

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
else: return None dentro il forAl primo giro, se la prima fermata non è quella giusta, esce con None. Trova solo Porta Codicetest_una_fermata_in_mezzo, test_l_ultima
enumerate(fermate) senza start=1I numeri partono da 0: Largo Lista diventa la fermata 2test_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.

Python
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 sbagliatoCosa succedeIl 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 giornatatest_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 subscriptabletest_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.

  1. Nessun arrivo? Nessun premio: None.
  2. Il migliore, per ora, è il primo arrivo: lo spacchetto in treno e ritardo.
  3. Per ogni arrivo: se il suo ritardo è più piccolo del minimo visto finora, diventa lui il migliore.
  4. Alla fine restituisco il nome del migliore.
Python
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 migliore

Il disegno.

inizio piu_puntuale(arrivi) se len(arrivi) == 0 sì: restituisci None migliore, minimo = arrivi[0] per ogni treno, ritardo in arrivi se ritardo < minimo sì: migliore = treno minimo = ritardo restituisci migliorepiu_puntuale(arrivi)len(arrivi) == 0restituisci Nonemigliore, minimo = arrivi[0]per ogni treno, ritardo inarriviritardo < minimomigliore = trenominimo = ritardorestituisci migliorenosìnosìfiniti
Il treno più puntuale

Passo per passo, con [("M16", 3), ("M12", 3), ("M14", 8)]:

Girotreno, ritardoConfrontomigliore, minimo dopo il giro
prima——"M16", 3 (il primo arrivo)
1"M16", 33 minore di 3? No"M16", 3
2"M12", 33 minore di 3? No"M16", 3
3"M14", 88 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 sbagliatoCosa succedeIl test rosso
Partire da minimo = 0 e migliore = NoneFunziona solo se qualcuno è in anticipo. Se sono tutti in ritardo, nessuno scende sotto lo zero: risposta Nonetest_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 M16test_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 emptytest_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.

Python
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.

Python
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_tra

Nei 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 sbagliatoCosa succedeIl 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 sensotest_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.

Python
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_ritardo

Nei dati veri: 37 minuti di ritardo in tutto, 11 corse partite in ritardo su 20.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return totale, in_ritardo rientrato dentro il forEsce dopo la prima corsa: (0, 0). Con la lista vuota: Nonetest_livello_3_minuti_e_corse_in_ritardo, test_livello_3_nessuna_corsa
in_ritardo = in_ritardo + ritardoIl 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.

Python
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 numeri

Nei dati veri: vanno segnalate le corse 4, 9 e 17. La 17 è partita con 5 minuti esatti: con > sarebbe sfuggita.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
enumerate(ritardi) senza start=1Tiene le posizioni, da 0: [2, 4] invece di [3, 5]. Nel rapporto, tutte le corse sbagliate di unotest_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 segnalatatest_livello_4_la_soglia_esatta_si_segnala

Livello 5 · La corsa più lunga

In italiano.

  1. Lista vuota: None.
  2. Il massimo, per ora, è la prima scatola: valore valori[0], numero 1.
  3. Per ogni valore, con il suo numero: se è più grande del massimo, diventa lui il massimo, e mi segno il numero.
  4. Restituisco il numero.
Python
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_massimo

Passo per passo, con i valori di prova [30, 34, 31, 34]:

GironumerovaloreConfrontomassimo doponumero_massimo dopo
prima———301
113030 > 30? no301
223434 > 30? sì342
333131 > 34? no342
443434 > 34? no342

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 sbagliatoCosa succedeIl test rosso
if valore >= massimo:A pari merito vince l'ultima: 4 invece di 2test_livello_5_pari_merito_vince_la_prima
enumerate(valori) senza start=1, e numero_massimo = 0Restituisce la posizione, da 0: 3 invece di 4. Nel finale, la corsa sbagliata di unotest_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.

  1. Il conto delle corse parte da zero.
  2. Per ogni turno, con il nome e quante corse guida: aggiungo le sue corse al conto.
  3. Se adesso il conto arriva almeno al numero cercato, la corsa è di questo turno: mi segno il nome e mi fermo.
Python
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 macchinista

Va 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:

Gironome, quantecontate dopo12 <= contate?
1Sergio Colombo, 55no
2Rita Galbiati, 611no
3Tommaso Greco, 516sì: break
—Anita Ferraro, 4—mai guardata

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Senza breakIl ciclo va avanti, e per ogni turno dopo numero <= contate resta vero: il nome viene sovrascritto fino all'ultimo. La risposta è sempre l'ultimo macchinistatest_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: Nonetest_livello_6_l_ultima_corsa_di_un_turno, test_livello_6_l_ultima_corsa_della_giornata

Il finale

  1. Livello 2: una sosta in galleria non cambia l'ora di partenza. Allunga la durata della corsa.
  2. 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.
  3. 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 Greco
Terminale
python storia/verifica.py "Tommaso Greco"