Vai al contenuto
code-to-code

Apro l'indice…

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

Python1. Valori, tipi, etichettep. 18

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.

python-valori-tipi-etichette-soluzioni.zip16 KB

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.

Python
def pin_possibili(cifre: int) -> int:
    return 10 ** cifre

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return 10 * cifre10 per 4 fa 40, non 10000. Con una cifra torna per casotest_quattro_cifre, test_sei_cifre
return cifre ** 10Base ed esponente scambiati: 4 alla decima fa 1048576test_quattro_cifre, test_una_cifra, test_sei_cifre

2 · Il display del credito

In italiano.

  1. Trasformo le tacche piene in un numero.
  2. Ripeto # tante volte quante sono le piene, e - tante volte quante ne mancano a 10.
  3. Attacco i due pezzi.
Python
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 sbagliatoCosa succedeIl 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 - quanteSenza 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) + "-" * 10Le vuote sono sempre dieci: "###----------", tredici tacche. Con zero piene torna per casotest_tre_tacche, test_barra_piena

3 · Quanto dura il viaggio

In italiano.

  1. Le ore sono quante volte 60 ci sta nei minuti: //.
  2. I minuti sono quelli che avanzano: %.
  3. Attacco tutto in un testo, con str() per i due numeri.
Python
def durata_viaggio(minuti: int) -> str:
    ore = minuti // 60
    resto = minuti % 60
    return str(ore) + " h " + str(resto) + " min"

Passo per passo, con 135:

RigaIl contoIl valore
ore = …135 // 602
resto = …135 % 6015
return …"2" + " h " + "15" + " min""2 h 15 min"

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
ore = minuti / 60La 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.

  1. Trasformo i chilometri in un numero con i decimali.
  2. 1 euro, più 20 centesimi per ogni chilometro.
  3. Arrotondo a due decimali.
Python
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 sbagliatoCosa succedeIl 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 notest_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.

Python
def ha_credito(saldo: str) -> bool:
    return float(saldo) > 0

Le trappole.

Il codice sbagliatoCosa succedeIl 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 rossotest_credito_in_rosso
return float(saldo) >= 0Con >= lo zero passa: la tessera vuota apre il tornellotest_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.

  1. Porto il resto in centesimi interi, con round.
  2. Per ogni moneta, dalla più grande: quante ne escono (//) e quanto resta da dare (%).
  3. Ogni volta sposto l'etichetta centesimi su quello che resta.
  4. Alla fine sommo le monete.
Python
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_dieci

Passo per passo, con "3.80": round(float("3.80") * 100) fa 380.

MonetaQuante ne esconoQuanto resta da dare
2 euro380 // 200 = 1380 % 200 = 180
1 euro180 // 100 = 1180 % 100 = 80
50 centesimi80 // 50 = 180 % 50 = 30
10 centesimi30 // 10 = 3non 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 sbagliatoCosa succedeIl test rosso
centesimi = int(float(resto) * 100)float("2.30") * 100 fa 229.99999999999997, e int taglia: 229 centesimi. Escono 3 monete invece di 4test_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 monetetest_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.0test_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.

Python
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 sbagliatoCosa succedeIl test rosso
return interi + ridottiÈ il programma vecchio: "205", un testotest_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 0test_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.

Python
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 sbagliatoCosa succedeIl test rosso
return int(float(euro) * 100)"0.29" diventa 28. E il ridotto vero, "1.15", diventa 114: un centesimo in meno a bigliettotest_livello_2_i_float_non_sono_esatti, test_livello_3_prezzi_con_i_centesimi
return float(euro) * 100Non è un intero: 110.00000000000001, 28.999999999999996, 300.0test_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) * 100int("1.10") dà ValueError. Con "3" invece funziona, e così non te ne accorgi subitotest_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.

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

PezzoIl contoCentesimi
Interi37 * 2208140
Ridotti12 * 1151380
Prezzo pieno8140 + 13809520
Tutti al ridotto37 * 115 + 12 * 1155635

Le trappole.

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

Python
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 sbagliatoCosa succedeIl test rosso
return bool(risposta)È il programma vecchio: "no" non è vuoto, quindi Truetest_livello_4_no_vuol_dire_falso
return rispostaRestituisce il testo "sì", non True: il test chiede proprio un booltest_livello_4_si_vuol_dire_vero, test_livello_4_no_vuol_dire_falso

Livello 5 · Lo scontrino

In italiano.

  1. Gli euro sono quante volte 100 ci sta nei centesimi: //.
  2. I centesimi da scrivere sono quelli che avanzano: %.
  3. Scrivo gli euro, la virgola, poi i centesimi con due cifre: prima le decine, poi le unità.
Python
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:

PezzoIl contoIl valore
euro805 // 1008
resto805 % 1005
le decine5 // 100
le unità5 % 105
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 sbagliatoCosa succedeIl 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 cinquetest_livello_5_lo_zero_davanti_ai_centesimi, test_livello_5_cifra_tonda, test_livello_5_meno_di_un_euro

Il finale

  1. Livello 1: i biglietti sono 49, non 3712. Il display attaccava due testi.
  2. Livello 4: la promozione non c'era. Il distributore però ha letto "no" come True, e ha fatto pagare il ridotto a tutti.
  3. Livello 5: ha fatto pagare 56,35 euro, proprio quelli nella cassetta. Nessuno ha rubato niente: i soldi non sono mai entrati.
  4. 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.

Terminale
python storia/verifica.py "38,85"

Ivo Brambati è innocente. Il colpevole è bool("no").