Le entità, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per il più difficile, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: la stessa logica si scrive in molti modi. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano quasi tutti i test e si rompono su uno.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
1 · Il dopolavoro
In italiano. Meno di 3 sono poche. Se non sono poche e non sono più di 6, sono giuste. Il resto è troppe.
def giudizio_entita(entita: list[str]) -> str:
if len(entita) < 3:
return "poche"
if len(entita) <= 6:
return "giuste"
return "troppe"Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
len(entita) <= 3 per «poche» e len(entita) < 6 per «giuste» | I due limiti sono esclusi: 3 entità sono «poche» e 6 sono «troppe» | test_tre_sono_giuste, test_sei_sono_ancora_giuste |
len(entita) <= 7 per «giuste» | Il limite alto sposta tutto di uno: con 7 entità l'app sembra a posto | test_sette_sono_troppe |
I limiti «da 3 a 6» sono compresi: nell'italiano di tutti i giorni «da 3 a 6» include il 3 e il 6, ed è facile scrivere un < dove serviva un <=.
2 · La mensa del personale
In italiano. Quattro regole, nell'ordine in cui sono scritte:
- Se l'app non la usa, è fuori, qualunque altra risposta.
- Se
tante,distinteecose_suesono tutte vere, è un'entità. - Altrimenti, se è un gruppo fisso di parole, è un valore.
- Altrimenti è un attributo.
def classifica(scheda: dict[str, bool]) -> str:
if not scheda["serve"]:
return "fuori"
if scheda["tante"] and scheda["distinte"] and scheda["cose_sue"]:
return "entità"
if scheda["gruppo_fisso"]:
return "valore"
return "attributo"Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Controllare «fuori» per ultimo (prima l'entità, poi il valore, poi "attributo" if serve else "fuori") | Il fornitore del caffè passa le prime tre domande e diventa un'entità; i vassoi sono «un gruppo fisso» e diventano un valore: l'app non li usa, ma ci sono nel disegno | test_il_fornitore_del_caffe_e_fuori, test_fuori_batte_valore |
if scheda["tante"] and scheda["distinte"]: (due domande su tre) | Il giorno è tante e distinte, ma non ha cose sue: diventa una tabella giorni | test_il_giorno_e_un_attributo |
Non restituire mai "valore" | Il turno (pranzo o cena) viene trattato come un attributo qualunque, e il CHECK con le parole ammesse sparisce dal disegno | test_il_turno_e_un_valore |
return "entità" if scheda["serve"] else "fuori" | Tutto quello che l'app usa diventa una tabella: sei sul punto di avere trenta entità | test_il_costo_e_un_attributo, test_il_giorno_e_un_attributo, test_la_cucina_e_un_attributo, test_il_dipendente_che_non_torna_e_un_attributo, test_il_turno_e_un_valore |
L'ultima è l'errore più diffuso di chi comincia: trasformare in tabella tutto quello che ha un nome. La prova serve a questo: a togliere.
3 · I turni di pulizia
In italiano. Quattro combinazioni di «uno» e «molti», quattro risposte. La prima parola del nome si riferisce ad A: «uno a molti» vuol dire che A è dalla parte dell'uno, e quindi ha molti B.
def relazione(quanti_b_per_a: str, quanti_a_per_b: str) -> str:
if quanti_b_per_a == "uno" and quanti_a_per_b == "uno":
return "uno a uno"
if quanti_b_per_a == "molti" and quanti_a_per_b == "uno":
return "uno a molti"
if quanti_b_per_a == "uno" and quanti_a_per_b == "molti":
return "molti a uno"
return "molti a molti"Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
uno a molti e molti a uno scambiati | Si legge «uno a molti» come «A ha uno, B ha molti» invece che «A è l'uno, e ha molti B». Le due relazioni escono scambiate | test_uno_a_molti, test_molti_a_uno |
return "molti a molti" appena uno dei due è «molti» | Ogni relazione che ha un «molti» diventa un molti a molti: avresti un ponte che non serve | test_uno_a_molti, test_molti_a_uno |
Il modo sicuro di non sbagliare: leggi il nome con una frase intera, «un condomino ha molti turni, e un turno ha un condomino». Dove c'è «molti» c'è il lato del molti, e la chiave esterna andrà lì.
4 · La navetta del deposito
In italiano. Nell'uno a molti la chiave sta dalla parte del molti, cioè in b. Nel molti a uno il molti è a. Nell'uno a uno sta nella tabella che nasce dopo: me lo dice nasce_dopo. Nel molti a molti nessuna delle due: serve un ponte.
def dove_va_la_chiave(a: str, b: str, tipo: str, nasce_dopo: str | None = None) -> str:
if tipo == "uno a molti":
return b
if tipo == "molti a uno":
return a
if tipo == "uno a uno":
return nasce_dopo
return "ponte"Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nell'uno a molti return a, nel molti a uno return b | La chiave va dalla parte dell'uno: una casella dovrebbe contenere molte righe | test_uno_a_molti_la_chiave_sta_dal_lato_del_molti, test_molti_a_uno_la_chiave_sta_dal_lato_del_molti |
return b per tutto, tranne il ponte | Funziona per l'uno a molti e basta: nel molti a uno la chiave finisce nella tabella sbagliata, e nell'uno a uno non guarda nasce_dopo | test_molti_a_uno_la_chiave_sta_dal_lato_del_molti, test_uno_a_uno_la_chiave_sta_in_quella_che_nasce_dopo |
Non gestire "molti a molti" e restituire b | Il molti a molti sembra un uno a molti: la chiave sta dalla parte di b, e nel database ti serve invece un ponte | test_molti_a_molti_serve_un_ponte |
5 · La lavanderia a gettoni
In italiano.
- Parto da una lista vuota,
mancano. - Per ogni azione, scorro le cose che legge e poi quelle che scrive.
- Se la cosa non è tra le entità e non l'ho già messa in
mancano, la aggiungo. - Restituisco
mancano, nell'ordine in cui l'ho riempita.
def cose_senza_tabella(entita: list[str], azioni: list[dict]) -> list[str]:
mancano = []
for azione in azioni:
for cosa in azione["legge"] + azione["scrive"]:
if cosa not in entita and cosa not in mancano:
mancano.append(cosa)
return mancanoLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Guardare solo azione["scrive"] | Una cosa che un'azione solo legge, e che non ha una tabella, passa inosservata. Ma se la leggi, deve esistere da qualche parte | test_manca_anche_la_cosa_che_si_legge, test_l_ordine_e_quello_in_cui_le_incontri |
Non controllare cosa not in mancano | La stessa cosa compare ogni volta che un'azione la nomina | test_ogni_cosa_compare_una_volta_sola |
Un set e poi sorted(...) | L'elenco esce in ordine alfabetico invece che nell'ordine in cui le trovi | test_l_ordine_e_quello_in_cui_le_incontri |
6 · Il nido aziendale
In italiano. Parto dal numero delle entità, perché ognuna è una tabella. Poi conto le relazioni «molti a molti», e ognuna aggiunge una tabella. Le altre relazioni (uno a molti, uno a uno) sono solo una colonna in più dentro tabelle che già ci sono.
def quante_tabelle(entita: list[str], relazioni: list[tuple[str, str, str]]) -> int:
ponti = 0
for a, b, tipo in relazioni:
if tipo == "molti a molti":
ponti = ponti + 1
return len(entita) + pontiLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
len(entita) + len(relazioni) | Ogni relazione sembra una tabella: ma una chiave esterna è una colonna, non una tabella | test_uno_a_molti_non_aggiunge_tabelle, test_uno_a_uno_e_molti_a_uno_non_aggiungono_tabelle, test_un_molti_a_molti_aggiunge_un_ponte, test_ogni_molti_a_molti_ha_il_suo_ponte |
return len(entita) | Il ponte non viene contato: le tabelle in realtà sono di più | test_un_molti_a_molti_aggiunge_un_ponte, test_ogni_molti_a_molti_ha_il_suo_ponte |
Un solo ponte, anche se i molti a molti sono due (any(...)) | Ogni molti a molti ha il suo ponte | test_ogni_molti_a_molti_ha_il_suo_ponte |
7 · La scuola di musica
In italiano.
- Parto da un dizionario con ogni entità e una lista vuota: per ora nessuna punta a niente.
- Per ogni relazione, decido quale tabella porta la chiave (come nell'esercizio 4) e aggiungo l'altra alla sua lista.
- Nel molti a molti creo la tabella nuova
a_b, che punta a tutte e due. - Alla fine ordino ogni lista.
def le_tabelle(entita: list[str], relazioni: list[dict]) -> dict[str, list[str]]:
punta_a = {nome: [] for nome in entita}
for r in relazioni:
a, b, tipo = r["a"], r["b"], r["tipo"]
if tipo == "uno a molti":
punta_a[b].append(a)
elif tipo == "molti a uno":
punta_a[a].append(b)
elif tipo == "uno a uno":
altra = a if r["nasce_dopo"] == b else b
punta_a[r["nasce_dopo"]].append(altra)
else:
punta_a[f"{a}_{b}"] = [a, b]
return {nome: sorted(altre) for nome, altre in punta_a.items()}Passo per passo, con la scuola di musica del test: insegnanti, corsi, allievi, tessere.
| Relazione | Chi porta la chiave | punta_a dopo |
|---|---|---|
| (partenza) | insegnanti: [] · corsi: [] · allievi: [] · tessere: [] | |
| insegnanti → corsi, uno a molti | corsi | corsi: ["insegnanti"] |
| allievi ↔ corsi, molti a molti | un ponte nuovo | allievi_corsi: ["allievi", "corsi"] |
allievi → tessere, uno a uno, nasce dopo tessere | tessere | tessere: ["allievi"] |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nell'uno a molti punta_a[a].append(b), nel molti a uno punta_a[b].append(a) | Le frecce vanno dalla parte dell'uno: lo schema è al contrario | test_uno_a_molti_la_freccia_parte_dal_molti, test_molti_a_uno_la_freccia_parte_da_a, test_la_scuola_intera, test_una_tabella_che_punta_a_due_le_elenca_in_ordine_alfabetico |
Il ponte c'è, ma con la lista [] | Una tabella che non punta a niente non è un ponte: manca proprio il suo lavoro | test_molti_a_molti_nasce_un_ponte_con_due_frecce, test_il_ponte_ha_il_nome_nell_ordine_della_relazione, test_la_scuola_intera |
Restituire punta_a senza ordinare le liste | Le frecce sono quelle giuste, ma in un ordine che dipende da come hai scritto le relazioni | test_una_tabella_che_punta_a_due_le_elenca_in_ordine_alfabetico |