Valori, tipi, etichette, 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 PIN della tessera
In italiano. Con una cifra i PIN sono 10. Ogni cifra in più moltiplica per 10. Con 4 cifre: 10 per 10 per 10 per 10, cioè 10 alla quarta.
def pin_possibili(cifre: int) -> int:
return 10 ** cifreLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return 10 * cifre | 10 per 4 fa 40, non 10000. Con una cifra torna per caso | test_quattro_cifre, test_sei_cifre |
return cifre ** 10 | Base ed esponente scambiati: 4 alla decima fa 1048576 | test_quattro_cifre, test_una_cifra, test_sei_cifre |
2 · Il display del credito
In italiano.
- Trasformo le tacche piene in un numero.
- Ripeto
#tante volte quante sono le piene, e-tante volte quante ne mancano a 10. - Attacco i due pezzi.
def barra_credito(piene: str) -> str:
quante = int(piene)
return "#" * quante + "-" * (10 - quante)quante è un'etichetta in più, per non scrivere int(piene) due volte. Le parentesi intorno a 10 - quante servono: senza, Python farebbe prima "-" * 10.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
"#" * piene + "-" * (10 - piene) | Testo per testo: TypeError: can't multiply sequence by non-int of type 'str' | test_tre_tacche, test_barra_piena, test_barra_vuota |
"#" * quante + "-" * 10 - quante | Senza parentesi * viene prima: "-" * 10 è un testo, e un testo meno un numero dà TypeError: unsupported operand type(s) for -: 'str' and 'int' | test_tre_tacche, test_barra_piena, test_barra_vuota |
"#" * int(piene) + "-" * 10 | Le vuote sono sempre dieci: "###----------", tredici tacche. Con zero piene torna per caso | test_tre_tacche, test_barra_piena |
3 · Quanto dura il viaggio
In italiano.
- Le ore sono quante volte 60 ci sta nei minuti:
//. - I minuti sono quelli che avanzano:
%. - Attacco tutto in un testo, con
str()per i due numeri.
def durata_viaggio(minuti: int) -> str:
ore = minuti // 60
resto = minuti % 60
return str(ore) + " h " + str(resto) + " min"Passo per passo, con 135:
| Riga | Il conto | Il valore |
|---|---|---|
ore = … | 135 // 60 | 2 |
resto = … | 135 % 60 | 15 |
return … | "2" + " h " + "15" + " min" | "2 h 15 min" |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
ore = minuti / 60 | La divisione vera: "2.25 h 15 min", e con 120 minuti "2.0 h 0 min" | test_ore_e_minuti, test_meno_di_un_ora, test_ore_tonde |
return ore + " h " + resto + " min" | Un numero più un testo: TypeError: unsupported operand type(s) for +: 'int' and 'str' | test_ore_e_minuti, test_meno_di_un_ora, test_ore_tonde |
4 · La bici di Ponte Ciclo
In italiano.
- Trasformo i chilometri in un numero con i decimali.
- 1 euro, più 20 centesimi per ogni chilometro.
- Arrotondo a due decimali.
def costo_noleggio(km: str) -> float:
chilometri = float(km)
return round(1 + 0.20 * chilometri, 2)In 1 + 0.20 * chilometri la moltiplicazione si fa prima della somma, che è proprio quello che serve.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return 1 + 0.20 * float(km) | Il conto è giusto, il float no: con 7 km 2.4000000000000004. Con 2,5 km invece torna 1.5 esatto: a volte va, a volte no | test_chilometri_interi, test_i_float_non_sono_esatti |
round(1 + 0.20 * int(km), 2) | int() non sa leggere il punto: ValueError: invalid literal for int() with base 10: '2.5' | test_chilometri_con_i_decimali, test_i_float_non_sono_esatti |
round(1 + 0.20 * km, 2) | Un float per un testo: TypeError: can't multiply sequence by non-int of type 'float' | test_chilometri_interi, test_chilometri_con_i_decimali, test_i_float_non_sono_esatti, test_zero_chilometri |
5 · Si apre il tornello?
In italiano. Trasformo il saldo in un numero e chiedo: è più di zero? La risposta di un confronto è già un bool: non serve altro.
def ha_credito(saldo: str) -> bool:
return float(saldo) > 0Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return bool(saldo) | Il testo "0.00" non è vuoto, quindi True. E anche "-1.20" | test_credito_a_zero, test_credito_in_rosso |
return bool(float(saldo)) | Lo zero diventa False, giusto. Ma -1.2 non è zero: True, e il tornello si apre a chi è in rosso | test_credito_in_rosso |
return float(saldo) >= 0 | Con >= lo zero passa: la tessera vuota apre il tornello | test_credito_a_zero |
La terza è la trappola del confine: «più di zero» e «almeno zero» differiscono per un solo valore, ed è proprio quello che il test controlla. Ne riparliamo nel capitolo Le condizioni.
6 · Il resto in monete
In italiano.
- Porto il resto in centesimi interi, con
round. - Per ogni moneta, dalla più grande: quante ne escono (
//) e quanto resta da dare (%). - Ogni volta sposto l'etichetta
centesimisu quello che resta. - Alla fine sommo le monete.
def monete_del_resto(resto: str) -> int:
centesimi = round(float(resto) * 100)
da_due = centesimi // 200
centesimi = centesimi % 200
da_uno = centesimi // 100
centesimi = centesimi % 100
da_cinquanta = centesimi // 50
centesimi = centesimi % 50
da_dieci = centesimi // 10
return da_due + da_uno + da_cinquanta + da_dieciPasso per passo, con "3.80": round(float("3.80") * 100) fa 380.
| Moneta | Quante ne escono | Quanto resta da dare |
|---|---|---|
| 2 euro | 380 // 200 = 1 | 380 % 200 = 180 |
| 1 euro | 180 // 100 = 1 | 180 % 100 = 80 |
| 50 centesimi | 80 // 50 = 1 | 80 % 50 = 30 |
| 10 centesimi | 30 // 10 = 3 | non serve più |
Totale: 1 + 1 + 1 + 3, sei monete.
centesimi = centesimi % 200 è il disegno del capitolo: Python calcola il resto, crea una scatola nuova con 180, e ci sposta l'etichetta centesimi. La scatola del 380 non serve più.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
centesimi = int(float(resto) * 100) | float("2.30") * 100 fa 229.99999999999997, e int taglia: 229 centesimi. Escono 3 monete invece di 4 | test_i_float_non_sono_esatti |
Senza le righe centesimi = centesimi % … | Ogni moneta si conta sul resto intero: con "3.80" escono 1 + 3 + 7 + 38 = 49 monete | test_un_po_di_tutto, test_solo_monete_da_due, test_i_float_non_sono_esatti |
/ al posto di // | Mezze monete: con "3.80" ne escono 8.3. Con "6.00" torna per caso: 3.0 | test_un_po_di_tutto, test_i_float_non_sono_esatti |
La storia
Livello 1 · Il contatore
In italiano. Converto ogni quantità in numero, poi sommo.
def biglietti_venduti(interi: str, ridotti: str) -> int:
return int(interi) + int(ridotti)Sulla mattina vera: 49 biglietti. Il 3712 del display è "37" + "12": due testi attaccati.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return interi + ridotti | È il programma vecchio: "205", un testo | test_livello_1_somma_i_biglietti, test_livello_1_il_risultato_e_un_numero, test_livello_1_nessun_biglietto |
return int(interi + ridotti) | Converte troppo tardi: 205, un numero sbagliato. Con "0" e "0" torna per caso, perché int("00") fa 0 | test_livello_1_somma_i_biglietti |
Livello 2 · Il listino
In italiano. Leggo il testo come float, lo porto in centesimi moltiplicando per 100, e arrotondo all'intero più vicino.
def in_centesimi(euro: str) -> int:
return round(float(euro) * 100)Sulla mattina vera: l'intero costa 220 centesimi, il ridotto 115.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return int(float(euro) * 100) | "0.29" diventa 28. E il ridotto vero, "1.15", diventa 114: un centesimo in meno a biglietto | test_livello_2_i_float_non_sono_esatti, test_livello_3_prezzi_con_i_centesimi |
return float(euro) * 100 | Non è un intero: 110.00000000000001, 28.999999999999996, 300.0 | test_livello_2_prezzo_con_i_centesimi, test_livello_2_i_float_non_sono_esatti, test_livello_2_il_risultato_e_un_intero, test_livello_3_prezzi_con_i_centesimi, test_livello_3_il_risultato_e_un_intero |
return int(euro) * 100 | int("1.10") dà ValueError. Con "3" invece funziona, e così non te ne accorgi subito | test_livello_2_prezzo_con_i_centesimi, test_livello_2_i_float_non_sono_esatti e tutti e quattro i test del livello 3 |
Il livello 3 usa in_centesimi: un errore qui si porta dietro anche i suoi test. Se il livello 3 è rosso senza un motivo, controlla prima il 2.
Livello 3 · L'incasso
In italiano. Le quantità con int(), i prezzi con in_centesimi(). Poi interi per il loro prezzo, più ridotti per il loro.
def incasso(interi: str, ridotti: str, prezzo_intero: str, prezzo_ridotto: str) -> int:
return int(interi) * in_centesimi(prezzo_intero) + int(ridotti) * in_centesimi(prezzo_ridotto)Le parentesi non servono: le due moltiplicazioni si fanno prima della somma.
Sulla mattina vera, passo per passo:
| Pezzo | Il conto | Centesimi |
|---|---|---|
| Interi | 37 * 220 | 8140 |
| Ridotti | 12 * 115 | 1380 |
| Prezzo pieno | 8140 + 1380 | 9520 |
| Tutti al ridotto | 37 * 115 + 12 * 115 | 5635 |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
interi * in_centesimi(prezzo_intero) + … senza int() | Un testo per un numero: "10" ripetuto 250 volte, attaccato a "4" ripetuto 125 volte. Un testo di 625 caratteri, e nessun errore | test_livello_3_interi_e_ridotti, test_livello_3_prezzi_con_i_centesimi, test_livello_3_nessun_ridotto, test_livello_3_il_risultato_e_un_intero |
(int(interi) + int(ridotti)) * in_centesimi(prezzo_intero) | Le parentesi sommano tutti i biglietti e li fanno pagare interi: 3500 invece di 3000. Senza ridotti torna per caso | test_livello_3_interi_e_ridotti, test_livello_3_prezzi_con_i_centesimi |
Livello 4 · La promozione
In italiano. La promozione c'è solo se la risposta è proprio "sì". Il confronto dà già True o False.
def promozione_attiva(risposta: str) -> bool:
return risposta == "sì"Sulla mattina vera: False. Marta aveva ragione. Il programma vecchio faceva bool("no"), e per bool un testo non vuoto è vero.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return bool(risposta) | È il programma vecchio: "no" non è vuoto, quindi True | test_livello_4_no_vuol_dire_falso |
return risposta | Restituisce il testo "sì", non True: il test chiede proprio un bool | test_livello_4_si_vuol_dire_vero, test_livello_4_no_vuol_dire_falso |
Livello 5 · Lo scontrino
In italiano.
- Gli euro sono quante volte 100 ci sta nei centesimi:
//. - I centesimi da scrivere sono quelli che avanzano:
%. - Scrivo gli euro, la virgola, poi i centesimi con due cifre: prima le decine, poi le unità.
def in_euro(centesimi: int) -> str:
euro = centesimi // 100
resto = centesimi % 100
return str(euro) + "," + str(resto // 10) + str(resto % 10)Passo per passo, con 805:
| Pezzo | Il conto | Il valore |
|---|---|---|
euro | 805 // 100 | 8 |
resto | 805 % 100 | 5 |
| le decine | 5 // 10 | 0 |
| le unità | 5 % 10 | 5 |
| il testo | "8" + "," + "0" + "5" | "8,05" |
Sulla mattina vera: doveva incassare 95,20 euro, ha fatto pagare 56,35 euro.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return str(centesimi / 100) | "12.34", con il punto invece della virgola. E 4000 diventa "40.0" | test_livello_5_euro_e_centesimi, test_livello_5_lo_zero_davanti_ai_centesimi, test_livello_5_cifra_tonda, test_livello_5_meno_di_un_euro |
str(centesimi // 100) + "," + str(centesimi % 100) | "12,34" va bene, ma 805 diventa "8,5": otto euro e cinquanta, non otto e cinque | test_livello_5_lo_zero_davanti_ai_centesimi, test_livello_5_cifra_tonda, test_livello_5_meno_di_un_euro |
Il finale
- Livello 1: i biglietti sono 49, non 3712. Il display attaccava due testi.
- Livello 4: la promozione non c'era. Il distributore però ha letto
"no"comeTrue, e ha fatto pagare il ridotto a tutti. - Livello 5: ha fatto pagare 56,35 euro, proprio quelli nella cassetta. Nessuno ha rubato niente: i soldi non sono mai entrati.
- Doveva incassarne 95,20. La Linea Menta ha perso 95,20 meno 56,35: 38,85 euro. In Python, con le tue funzioni:
in_euro(9520 - 5635).
È anche un conto che torna a mano: 37 interi pagati 1,05 euro in meno ciascuno.
python storia/verifica.py "38,85"Ivo Brambati è innocente. Il colpevole è bool("no").