Vai al contenuto
code-to-code

Apro l'indice…

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

Il progetto2. Le entitàp. 52

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.

progetto-le-entita-soluzioni.zip13 KB

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.

Python
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 sbagliatoCosa succedeIl 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 postotest_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:

  1. Se l'app non la usa, è fuori, qualunque altra risposta.
  2. Se tante, distinte e cose_sue sono tutte vere, è un'entità.
  3. Altrimenti, se è un gruppo fisso di parole, è un valore.
  4. Altrimenti è un attributo.
Python
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 sbagliatoCosa succedeIl 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 disegnotest_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 giornitest_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 disegnotest_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.

Python
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 sbagliatoCosa succedeIl test rosso
uno a molti e molti a uno scambiatiSi legge «uno a molti» come «A ha uno, B ha molti» invece che «A è l'uno, e ha molti B». Le due relazioni escono scambiatetest_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 servetest_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.

Python
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 sbagliatoCosa succedeIl test rosso
Nell'uno a molti return a, nel molti a uno return bLa chiave va dalla parte dell'uno: una casella dovrebbe contenere molte righetest_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 ponteFunziona 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_dopotest_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 bIl molti a molti sembra un uno a molti: la chiave sta dalla parte di b, e nel database ti serve invece un pontetest_molti_a_molti_serve_un_ponte

5 · La lavanderia a gettoni

In italiano.

  1. Parto da una lista vuota, mancano.
  2. Per ogni azione, scorro le cose che legge e poi quelle che scrive.
  3. Se la cosa non è tra le entità e non l'ho già messa in mancano, la aggiungo.
  4. Restituisco mancano, nell'ordine in cui l'ho riempita.
Python
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 mancano

Le trappole.

Il codice sbagliatoCosa succedeIl 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 partetest_manca_anche_la_cosa_che_si_legge, test_l_ordine_e_quello_in_cui_le_incontri
Non controllare cosa not in mancanoLa stessa cosa compare ogni volta che un'azione la nominatest_ogni_cosa_compare_una_volta_sola
Un set e poi sorted(...)L'elenco esce in ordine alfabetico invece che nell'ordine in cui le trovitest_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.

Python
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) + ponti

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
len(entita) + len(relazioni)Ogni relazione sembra una tabella: ma una chiave esterna è una colonna, non una tabellatest_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 pontetest_ogni_molti_a_molti_ha_il_suo_ponte

7 · La scuola di musica

In italiano.

  1. Parto da un dizionario con ogni entità e una lista vuota: per ora nessuna punta a niente.
  2. Per ogni relazione, decido quale tabella porta la chiave (come nell'esercizio 4) e aggiungo l'altra alla sua lista.
  3. Nel molti a molti creo la tabella nuova a_b, che punta a tutte e due.
  4. Alla fine ordino ogni lista.
Python
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.

RelazioneChi porta la chiavepunta_a dopo
(partenza)insegnanti: [] · corsi: [] · allievi: [] · tessere: []
insegnanti → corsi, uno a molticorsicorsi: ["insegnanti"]
allievi ↔ corsi, molti a moltiun ponte nuovoallievi_corsi: ["allievi", "corsi"]
allievi → tessere, uno a uno, nasce dopo tesseretesseretessere: ["allievi"]

Le trappole.

Il codice sbagliatoCosa succedeIl 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 contrariotest_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 lavorotest_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 listeLe frecce sono quelle giuste, ma in un ordine che dipende da come hai scritto le relazionitest_una_tabella_che_punta_a_due_le_elenca_in_ordine_alfabetico