Le domande da farsi, 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 frase del torneo
In italiano.
- Tolgo gli spazi ai lati e divido la frase su « aiuta »: prima il nome dell'app, poi il separatore, poi il resto.
- Se il separatore non c'è, non è una frase «… aiuta … a …»:
False. - Divido il resto su « a »: prima «chi», poi il separatore, poi «la cosa».
- Il secondo separatore deve esserci, e i tre pezzi non devono essere vuoti.
partition restituisce sempre tre pezzi, anche quando non trova niente: in quel caso il separatore è la stringa vuota, che per if è falsa. Si divide dopo «aiuta», non su tutta la frase: così una «a» che viene prima non conta.
def frase_valida(frase: str) -> bool:
soggetto, aiuta, resto = frase.strip().partition(" aiuta ")
if not aiuta:
return False
chi, a, cosa = resto.partition(" a ")
return bool(a) and all(pezzo.strip() for pezzo in (soggetto, chi, cosa))Il trucco delle parole con lo spazio intorno (" aiuta ", " a ") evita di confondere «aiuta» con «aiutare», e la preposizione «a» con la lettera «a» dentro una parola.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
"aiuta" in frase | Basta che la parola ci sia: «TorneoMenta aiuta gli scacchisti» passa, senza nessuna «a …» | test_senza_la_a_dopo_aiuta e altri 4 |
" aiuta " in frase and " a " in frase | La «a» può stare ovunque, anche prima di «aiuta»: «Da casa a scuola aiuta gli scacchisti» passa | test_la_a_prima_di_aiuta_non_conta e altri 3 |
2 · Per chi gioca
In italiano.
- Se i tipi non sono uno o due,
False. - Per ogni tipo: tolgo gli spazi e le maiuscole. Se è vuoto, o uguale a «tutti», «per tutti» o «chiunque»,
False. - Se nessun tipo è stato bocciato,
True.
Il return False dentro il for è giusto: basta un tipo sbagliato. Il return True sta fuori: si arriva lì solo dopo aver guardato tutti.
def per_chi_valido(per_chi: list[str]) -> bool:
if not 1 <= len(per_chi) <= 2:
return False
for tipo in per_chi:
tipo = tipo.strip().lower()
if tipo == "" or tipo in ("tutti", "per tutti", "chiunque"):
return False
return TrueLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
"tutti" not in per_chi | Controlla la lista, non le voci: « Per Tutti » e la voce vuota passano | test_tutti_in_tutte_le_forme e test_una_voce_vuota |
"tutti" in tipo.lower() | Boccia anche «tutti i soci del circolo scacchi», che è un tipo di persone preciso | test_tutti_dentro_una_frase_va_bene |
3 · Le funzioni del torneo
In italiano. Conto le indispensabili e le «se avanza». Le prime devono essere da 1 a 3, le seconde al massimo 2. Il «NON» non c'entra: è la domanda 5.
def funzioni_ok(funzioni: dict) -> bool:
indispensabili = len(funzioni["indispensabili"])
se_avanza = len(funzioni["se_avanza"])
return 1 <= indispensabili <= 3 and se_avanza <= 2Un confronto con due estremi si scrive 1 <= n <= 3, come in matematica: Python lo capisce.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
1 <= len(…) < 3 | Con tre indispensabili il canvas viene bocciato: «da 1 a 3» comprende il 3 | test_tre_indispensabili_e_una_se_avanza |
conta anche non_fa (al massimo 5 voci in tutto) | Un «NON» lungo, che è un buon segno, fa bocciare il canvas | test_il_non_fa_non_si_conta e test_tre_se_avanza_sono_troppe |
4 · Cosa il torneo NON fa
In italiano. Scorro le voci del «NON». Alla prima che, senza spazi, non è vuota, rispondo True. Se finisco il giro senza trovarne, False.
def ha_un_non(funzioni: dict) -> bool:
for voce in funzioni["non_fa"]:
if voce.strip() != "":
return True
return FalseÈ lo schema «c'è almeno uno?»: il return True sta dentro il for, il return False fuori.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
len(funzioni["non_fa"]) > 0 | Una voce vuota o di soli spazi conta come un «NON»: il canvas sembra a posto e non lo è | test_solo_voci_vuote |
5 · Il coro conta le sue cose
In italiano. Due conti, uno per riquadro. len di un dizionario dà il numero delle chiavi, quindi qui il numero delle schermate. Il risultato è un dizionario nuovo con le due risposte.
def quantita_giuste(canvas: dict) -> dict[str, bool]:
return {
"schermate": 3 <= len(canvas["schermate"]) <= 5,
"dati": 3 <= len(canvas["dati"]) <= 6,
}Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
3 < len(…) < 5 | Gli estremi sono esclusi: il canvas del coro, che ha tre schermate e tre cose, viene bocciato | test_il_canvas_del_coro e altri 2 |
6 · Una funzione che non si vede
In italiano.
- Raccolgo, in una lista, tutte le funzioni che qualche schermata fa fare.
- Per ogni funzione indispensabile, se non è in quella lista la aggiungo al risultato.
- Le restituisco nell'ordine del canvas.
def funzioni_senza_schermata(canvas: dict) -> list[str]:
coperte = []
for schermata in canvas["schermate"].values():
coperte = coperte + schermata["funzioni"]
senza = []
for funzione in canvas["funzioni"]["indispensabili"]:
if funzione not in coperte:
senza.append(funzione)
return senzaPasso per passo, sul canvas del coro senza la schermata «una prova»:
| Dopo la schermata | coperte |
|---|---|
| «le prove» | ["vedo le prove"] |
| «nuova prova» | ["vedo le prove", "pubblico una prova"] |
funzione | In coperte? | senza dopo il giro |
|---|---|---|
"pubblico una prova" | sì | [] |
"vedo le prove" | sì | [] |
"dico se ci sono" | no | ["dico se ci sono"] |
Le funzioni «se avanza» non si controllano: non hanno ancora la loro schermata, ed è giusto così.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
| guarda solo la prima schermata | Le funzioni delle altre schermate risultano «senza schermata»: il canvas giusto viene bocciato | test_il_canvas_del_coro_e_a_posto e altri 3 |
| scorre anche le «se avanza» | Le funzioni «se avanza» non hanno ancora una schermata, e finiscono nel risultato | test_le_funzioni_se_avanza_non_contano e altri 5 |
7 · Una schermata vuota
In italiano.
- Per ogni schermata parto da «non usa nessun dato».
- Guardo i suoi dati: appena uno è anche nel riquadro 6, cambio idea.
- Se alla fine non ho cambiato idea, il nome della schermata va nel risultato.
def schermate_senza_dati(canvas: dict) -> list[str]:
segnalate = []
for nome, schermata in canvas["schermate"].items():
usa_un_dato = False
for dato in schermata["dati"]:
if dato in canvas["dati"]:
usa_un_dato = True
if not usa_un_dato:
segnalate.append(nome)
return segnalate.items() ti dà il nome e i dettagli insieme, come nei dizionari del capitolo di Python.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
not schermata["dati"] | Controlla solo la lista vuota: una schermata con dati che nel riquadro 6 non ci sono passa | test_un_nome_che_nel_riquadro_6_non_c_e |
8 · Il revisore del canvas
In italiano.
- Parto da una lista vuota,
non_passano. - Per ogni domanda che una macchina sa controllare, un
ifche la verifica. Se non passa, aggiungo il suo numero. - Alla fine restituisco la lista. I numeri escono in ordine perché i controlli sono scritti in ordine.
Ogni controllo è uno di quelli dei sei esercizi di prima, scritto in breve:
def revisore(canvas: dict) -> list[int]:
non_passano = []
soggetto, aiuta, resto = canvas["frase"].strip().partition(" aiuta ")
chi, a, cosa = resto.partition(" a ")
if not (aiuta and a and soggetto.strip() and chi.strip() and cosa.strip()):
non_passano.append(1)
per_chi = canvas["per_chi"]
ok = 1 <= len(per_chi) <= 2
for tipo in per_chi:
if tipo.strip().lower() in ("", "tutti", "per tutti", "chiunque"):
ok = False
if not ok:
non_passano.append(2)
if not 1 <= len(canvas["funzioni"]["indispensabili"]) <= 3:
non_passano.append(4)
if not any(voce.strip() for voce in canvas["funzioni"]["non_fa"]):
non_passano.append(5)
coperte = []
for schermata in canvas["schermate"].values():
coperte = coperte + schermata["funzioni"]
if any(f not in coperte for f in canvas["funzioni"]["indispensabili"]):
non_passano.append(6)
for schermata in canvas["schermate"].values():
if not any(dato in canvas["dati"] for dato in schermata["dati"]):
non_passano.append(7)
break
if not 3 <= len(canvas["dati"]) <= 6:
non_passano.append(8)
return non_passanoPasso per passo, su un canvas con «per tutti», senza il «NON» e con una schermata senza dati:
| Domanda | Il controllo | Passa? | non_passano dopo |
|---|---|---|---|
| 1 | la frase ha «aiuta» e «a» | sì | [] |
| 2 | "tutti" è tra i tipi | no | [2] |
| 4 | indispensabili da 1 a 3 | sì | [2] |
| 5 | non_fa ha una voce vera | no | [2, 5] |
| 6 | ogni indispensabile ha una schermata | sì | [2, 5] |
| 7 | ogni schermata usa un dato | no | [2, 5, 7] |
| 8 | dati da 3 a 6 | sì | [2, 5, 7] |
Il break nel controllo 7 non ferma il revisore: esce solo dal for sulle schermate, perché basta trovarne una per aggiungere il 7 una volta sola.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
una catena di if … elif … | Appena una domanda non passa, le altre non si guardano più: il canvas «tutto sbagliato» ne segnala una sola | test_un_canvas_tutto_sbagliato e test_piu_domande_insieme_in_ordine_crescente |
non_fa == [] | Una voce di soli spazi conta come un «NON»: la domanda 5 passa quando non dovrebbe | test_domanda_5_manca_il_non |
La prima è quella più facile da scrivere, perché ogni if sembra la continuazione del precedente. Ma le domande sono sette cose indipendenti: sette if separati, non una catena.
Il tuo CANVAS.md
Non ha una soluzione unica, ed è giusto così. Per vedere se sei sulla strada, leggilo con le dieci domande, a voce alta, e per ognuna rispondi sì o no senza esitare:
| Se rispondi no a… | Di solito vuol dire |
|---|---|
| 1 · la frase | che parla di tecnologia («piattaforma», «gestionale», «con database») invece che di chi è aiutato |
| 2 · per chi | che c'è scritto «tutti», o più di due tipi di persone |
| 3 · il problema | che descrive la tua soluzione («manca un'app») invece di qualcosa che una persona vive |
| 4 · le tre funzioni | che sono quattro, cinque o nove: scegli con la domanda «se manca, il problema resta?» |
| 5 · il «NON» | che non l'hai scritto, o che hai scritto qualità («veloce», «sicura») invece di funzioni |
| 6 · le schermate | che una funzione non ha la sua pagina, o che una pagina non serve a niente |
Se il compagno non sa spiegare la tua app in un minuto, il canvas non è finito: riscrivi la frase, e controlla quale riquadro lo ha confuso.