aggiunta seconda fase

src/fibonacci-primarie/2023-seconda-fase/contest/contest.mdx

@@ -0,0 +1,28 @@
+import { P1CicliCondizioni } from "problemset";
+import { P2BalleDiFieno } from "problemset";
+import { P3PileDiCarote } from "problemset";
+import { P4Contatore } from "problemset";
+import { S1OrdinaPalloni } from "problemset";
+import { S2GaraSalto } from "problemset";
+import { S3SquadreBasket } from "problemset";
+import { S4TorriGemelle } from "problemset";
+
+<Contest>
+
+## Sezione 1: procedimenti procedurali
+
+<Section>
+  <Problem points={[5, 1, 0]} statement={P1CicliCondizioni} />
+  <Problem points={[5, 1, 0]} statement={P2BalleDiFieno} />
+  <Problem points={[5, 1, 0]} statement={P3PileDiCarote} />
+</Section>
+
+## Sezione 2: programmazione
+
+<Section>
+  <Problem points={[5, 0, 0]} statement={S1OrdinaPalloni} />
+  <Problem points={[5, 0, 0]} statement={S2GaraSalto} />
+  <Problem points={[5, 0, 0]} statement={S3SquadreBasket} />
+</Section>
+
+</Contest>

src/fibonacci-primarie/2023-seconda-fase/contest/header.md

@@ -0,0 +1,24 @@
+Questa prova contiene _6 domande_ da risolvere in _100 minuti_.
+Le domande sono a **scelta multipla** o a **blocchi**, e sono divise in due parti:
+
+- domande di interpretazione di **procedimenti procedurali** come programmi a blocchi, e
+- domande di **programmazione** tramite blocchi.
+
+In entrambe le parti, le domande sono ordinate per difficoltà crescente.
+**Attento che la difficoltà è soggettiva!** Se stai passando tanto tempo cercando di risolvere una domanda, prova a passare ad altre domande e altre categorie!
+
+## Punteggio
+
+Tutte le domande a _scelta multipla_ hanno 5 opzioni, di cui **solo una** è corretta. Il punteggio che puoi ottenere è:
+
+- 5 punti per una risposta _corretta_;
+- 1 punto per una risposta _non data_;
+- 0 punti per una risposta _sbagliata_.
+
+Le domande a _blocchi_ richiedono di scrivere un singolo programma a blocchi, che viene valutato su tre diversi livelli.
+Per ciascuna domanda e per ciascun livello, Il punteggio che puoi ottenere è:
+
+- 5 punti se il programma produce la risposta _corretta_;
+- 0 punti se il programma produce una risposta _sbagliata_.
+
+Quindi ogni domanda a blocchi può valere fino a 15 punti in totale.

src/fibonacci-primarie/2023-seconda-fase/contest/p-1-cicli-condizioni/code.asy

@@ -0,0 +1,99 @@
+access "../../../../asy_library/structures/layout.asy" as layout;
+
+unravel layout; // per evitare di scrivere layout.cose tutto il tempo
+
+unitsize(1cm);
+
+TEXT_SIZE = 2;
+ALIGN = (0, 0.5);
+
+element P = row(
+    5*BLOCK_PADDING,
+    fill_space=0,
+    block_sequence(
+        start_block(element("Opzione 1:")),
+        for_block(
+            block_content(e("ripeti"), data_block(e("8")), e("volte:")),
+            block_sequence(
+                instr_block(element("mangia carota")),
+                instr_block(element("avanza"))
+            )
+        ),
+        instr_block(element("mangia carota"))
+    ),
+    block_sequence(
+        start_block(element("Opzione 2:")),
+        for_block(
+            block_content(e("ripeti"), data_block(e("8")), e("volte:")),
+            block_sequence(
+                if_block(
+                    block_content(e("se"), cond_block(e("roccia marrone"))),
+                    instr_block(element("mangia carota"))
+                ),
+                instr_block(element("avanza"))
+            )
+        ),
+        instr_block(element("mangia carota"))
+    ),
+    block_sequence(
+        start_block(element("Opzione 3:")),
+        for_block(
+            block_content(e("ripeti"), data_block(e("2")), e("volte:")),
+            block_sequence(
+                instr_block(element("mangia carota")),
+                for_block(
+                    block_content(e("ripeti"), data_block(e("4")), e("volte:")),
+                    block_sequence(
+                        instr_block(element("avanza")),
+                        if_block(
+                            block_content(e("se"), cond_block(e("roccia marrone"))),
+                            instr_block(element("mangia carota"))
+                        )
+                    )
+                )
+            )
+        )
+    ),
+    block_sequence(
+        start_block(element("Opzione 4:")),
+        instr_block(element("mangia carota")),
+        for_block(
+            block_content(e("ripeti"), data_block(e("4")), e("volte:")),
+            block_sequence(
+                instr_block(element("avanza")),
+                if_block(
+                    block_content(e("se"), cond_block(e("roccia marrone"))),
+                    instr_block(element("mangia carota"))
+                ),
+                instr_block(element("avanza"))
+            )
+        ),
+        instr_block(element("mangia carota"))
+    ),
+    block_sequence(
+        start_block(element("Opzione 5:")),
+        for_block(
+            block_content(e("ripeti"), data_block(e("4")), e("volte:")),
+            block_sequence(
+                if_block(
+                    block_content(e("se"), cond_block(e("roccia marrone"))),
+                    instr_block(element("mangia carota"))
+                ),
+                instr_block(element("avanza"))
+            )
+        ),
+        instr_block(element("mangia carota")),
+        for_block(
+            block_content(e("ripeti"), data_block(e("4")), e("volte:")),
+            block_sequence(
+                instr_block(element("avanza")),
+                if_block(
+                    block_content(e("se"), cond_block(e("roccia marrone"))),
+                    instr_block(element("mangia carota"))
+                )
+            )
+        )
+    )
+);
+
+add(P.drawing());

src/fibonacci-primarie/2023-seconda-fase/contest/p-1-cicli-condizioni/fig.asy

@@ -0,0 +1,18 @@
+unitsize(1cm);
+
+access "../../../../asy_library/pictures/carrot.asy" as carrot;
+access "../../../../asy_library/pictures/flat_rock.asy" as flat_rock;
+access "../../../../asy_library/pictures/bunny_polychrome.asy" as bunny_polychrome;
+access "../../../../asy_library/pictures/vertical_door.asy" as vertical_door;
+
+pen[]  cols = {brown, gray};
+int[]  rocks = {0, 0, 1, 0, 1, 0, 1, 0, 0};
+bool[] carts = {true, true, false, true, true, true, false, true, true};
+
+for (int i=0; i<rocks.length; ++i)
+    add(shift(4*i, -2.25)*scale(3.5)*flat_rock.drawing(0.15, cols[rocks[i]]));
+
+add(shift(-4, -0.25)*reflect((2, 1), (2, 0))*bunny_polychrome.drawing(0.85));
+
+for (int i=0; i<carts.length; ++i) if (carts[i])
+    add(shift(4*i+1.3, -2.1)*carrot.drawing(0.15));

src/fibonacci-primarie/2023-seconda-fase/contest/p-1-cicli-condizioni/question.md

@@ -0,0 +1,35 @@
+Tip-Tap ha proprio voglia di una bella scorpacciata di carote!
+Per farla, può usare le seguenti azioni:
++ `avanza`: salta alla roccia più vicina a destra. 
++ `mangia carota`: mangia una carota, ma se dov'è arrivato non ci sono carote si **mangia la lingua**!
++ `roccia marrone`: condizione vera se Tip-Tap si trova su una roccia di colore marrone.
+
+Quali di questi procedimenti consentono a Tip-Tap di mangiare tutte le carote, senza
+mangiarsi la lingua?
+
+![T_ | _ _ | _C](fig.asy)
+
+![code](code.asy)
+
+- [ ] $1$, $3$ e $5$
+- [ ] $2$ e $4$
+- [x] $3$ e $5$
+- [ ] solo $5$
+- [ ] tutti tranne l'$1$
+
+> Tip-Tap riesce a mangiare tutte le carote sia seguendo l'opzione 3 che l'opzione 5.
+> 
+> _Nell'opzione 3, inizia mangiando la prima carota, poi le carote sulle rocce marroni tra le 4 successive, poi un'altra carota
+> (quella sulla roccia grigia centrale), e ancora le carote sulle rocce marroni tra le 4 successive._
+>
+> _Nell'opzione 5, inizia mangiando le carote sulle rocce marroni tra le prime 4, poi un'altra carota
+> (quella sulla roccia grigia centrale), e ancora le carote sulle rocce marroni tra le 4 successive._
+>
+> In tutte le altre tre opzioni, Tip-Tap non riesce a fare quanto richiesto.
+>
+> _Nell'opzione 1, Tip-Tap tenta di mangiare carote anche dove non ce ne sono, mordendosi la lingua._
+>
+> _Nell'opzione 2, Tip-Tap mangia tutte le carote sulle rocce marroni, ma non mangia la carota sulla roccia grigia centrale._
+>
+> _Nell'opzione 4, Tip-Tap mangia la prima carota, poi una carota ogni due rocce, e infine mangia anche l'ultima carota.
+> Anche in questo caso non mangia la carota sulla roccia grigia centrale._

src/fibonacci-primarie/2023-seconda-fase/contest/p-2-balle-di-fieno/code.asy

@@ -0,0 +1,30 @@
+access "../../../../asy_library/structures/layout.asy" as layout;
+
+unravel layout; // per evitare di scrivere layout.cose tutto il tempo
+
+unitsize(1cm);
+
+TEXT_SIZE = 2;
+ALIGN = (0, 0.5);
+
+element P = row(
+    BLOCK_PADDING,
+    fill_space=0,
+    block_sequence(
+        instr_block(element("imposta"), choice_block(e("posizione")), element("a"), data_block(e("1"))),
+        for_block(
+            block_content(e("ripeti mentre"), cond_block(data_block(e("posizione")), e("minore di"), data_block(e("9"))), e(":")),
+            block_sequence(
+                else_block(
+                    block_content(e("se"), cond_block(data_block(e("altezza della pila"), data_block(data_block(e("posizione")), e("+"), data_block(e("1")))), e("minore di"), data_block(e("altezza della pila"), data_block(e("posizione"))))),
+                    instr_block(e("diminuisci"), choice_block(e("posizione")), element("di"), data_block(e("1"))),
+                    block_content(e("altrimenti: ")),
+                    instr_block(e("aumenta"), choice_block(e("posizione")), element("di"), data_block(e("2")))
+                )
+            )
+        ),
+        instr_block(element("esci dal fienile"))
+    )
+);
+
+add(P.drawing());

src/fibonacci-primarie/2023-seconda-fase/contest/p-2-balle-di-fieno/opzioni.asy

@@ -0,0 +1,30 @@
+unitsize(1cm);
+
+access "../../../../asy_library/pictures/bunny_polychrome.asy" as bunny;
+access "../../../../asy_library/pictures/hay_cube.asy" as hay_cube;
+access "../../../../asy_library/structures/layout.asy" as layout;
+
+unravel layout; // per evitare di scrivere layout.cose tutto il tempo
+
+element option(int num, int[] pile) {
+    picture pic;
+    unitsize(pic, 1cm);
+
+    label(pic, scale(2.5)*(string(num)+":"), (-3-0.4,2-1.6));
+    for (int i=0; i<pile.length; ++i) {
+	    label(pic, scale(1.8)*("pila " + string(i+1)), (3*i-0.4,-1.6));
+        for(int j=0; j<pile[i]; ++j)
+            add(pic, shift(3*i, 2*j)*scale(3.8)*hay_cube.drawing(0.2));
+    }
+    add(pic, shift(-4.3, 2.1)*reflect((2, 1), (2, 0))*bunny.drawing(0.7, bunny.bunny_col));
+    return e(pic);
+}
+
+element P = column(
+    padding = 1,
+    option(1, new int[]{1, 2, 2, 3, 4, 4, 4, 5, 5}),
+    option(2, new int[]{1, 2, 3, 2, 4, 5, 3, 4, 5}),
+    option(3, new int[]{1, 3, 3, 5, 4, 2, 3, 4, 5})
+);
+
+add(P.drawing());

src/fibonacci-primarie/2023-seconda-fase/contest/p-2-balle-di-fieno/question.md

@@ -0,0 +1,22 @@
+Bunny è all’ingresso del fienile della fattoria Fibonacci, e davanti a lui ci sono $9$ pile di balle di fieno numerate con i numeri da $1$ a $9$. Ogni pila è formata da un numero variabile di balle di fieno. Bunny vuole giocare spostandosi da una pila all'altra, partendo dalla pila $1$ e seguendo questo procedimento:
+
+![code](code.asy)
+
+In quali di queste situazioni Bunny riesce ad uscire dal fienile?
+
+![opzione1](opzioni.asy)
+
+Risposte:
+- [ ] nessuna
+- [ ] tutte
+- [ ] solo la 1
+- [x] la 1 e la 2
+- [ ] la 1 e la 3
+
+> Bunny riesce ad uscire dal fienile nell'opzione 1 e nella 2.
+> 
+> _Nell'opzione 1, inizia dalla pila 1, poi salta di due in due fino alla pila 9._
+>
+> _Nell'opzione 2, inizia dalla pila 1, salta sulla 3, indietreggia sulla due, salta sulla 4, salta sulla 6, indietreggia sulla 5, salta sulla 7 e finisce sulla 9._
+>
+> _Nell'opzione 3, Bunny non riesce ad uscire perchè rimane bloccato saltando in circolo tra le pile 3, 4, 5 senza mai smettere._

src/fibonacci-primarie/2023-seconda-fase/contest/p-3-pile-di-carote/code.asy

@@ -0,0 +1,38 @@
+access "../../../../asy_library/structures/layout.asy" as layout;
+
+unravel layout; // per evitare di scrivere layout.cose tutto il tempo
+
+unitsize(1cm);
+
+TEXT_SIZE = 2;
+ALIGN = (0, 0.5);
+
+element P = row(
+    BLOCK_PADDING,
+    fill_space=0,
+    block_sequence(
+        instr_block(element("imposta"), choice_block(e("mucchio sinistro")), element("a"), data_block(e("2024")), e("carote")),
+        instr_block(element("imposta"), choice_block(e("mucchio destro")), element("a"), data_block(e("3024")), e("carote")),
+        for_block(
+            block_content(e("ripeti fino a che"), cond_block(cond_block(data_block(e("mucchio sinistro")), e("ha meno carote di"), data_block(e("7"))), e("o"), cond_block(data_block(e("mucchio destro")), e("ha meno carote di"), data_block(e("7")))), e(":")),
+            block_sequence(
+                else_block(
+                    block_content(e("se"), cond_block(data_block(e("mucchio sinistro")), e("ha meno carote di"), data_block(e("mucchio destro")))),
+                    block_sequence(
+                        instr_block(choice_block(e("Bunny")), e("mangia"), data_block(e("3")), e("carote da"), choice_block(e("mucchio sinistro"))),
+                        instr_block(choice_block(e("Tip-Tap")), e("mangia"), data_block(e("7")), e("carote da"), choice_block(e("mucchio destro")))
+                    ),
+                    block_content(e("altrimenti:")),
+                    block_sequence(
+                        instr_block(choice_block(e("Tip-Tap")), e("mangia"), data_block(e("6")), e("carote da"), choice_block(e("mucchio sinistro"))),
+                        instr_block(choice_block(e("Bunny")), e("mangia"), data_block(e("4")), e("carote da"), choice_block(e("mucchio destro")))
+                    )
+                )
+            )
+        ),
+        instr_block(choice_block(e("Carol")), e("mangia"), data_block(e("mucchio sinistro")), e("carote da"), choice_block(e("mucchio sinistro"))),
+        instr_block(choice_block(e("Carol")), e("mangia"), data_block(e("mucchio destro")), e("carote da"), choice_block(e("mucchio destro")))
+    )
+);
+
+add(P.drawing());

src/fibonacci-primarie/2023-seconda-fase/contest/p-3-pile-di-carote/question.md

@@ -0,0 +1,29 @@
+I conigli della fattoria Fibonacci hanno preparato due enormi mucchi di carote.
+All'inizio il mucchio sinistro contiene 2024 carote, mentre il mucchio destro ne contiene 3024.
+Bunny, Tip-Tap e Carol le mangiano seguendo questo procedimento:
+
+![code](code.asy)
+
+Quante carote mangia Carol?
+- [ ] 0
+- [ ] 1
+- [ ] 2
+- [ ] 4
+- [x] 8
+
+> Si può notare che ad ogni passaggio della ripetizione, indipendentemente da quale mucchio
+> abbia più carote, Tip-Tap e Bunny in totale mangiano $10$ carote.
+> Visto che all'inizio ci sono $2024 + 3024 = 5048$ carote, i due conigli andranno avanti
+> a mangiare $10$ carote per volta fino a quando rimarranno $8$ carote tra i due mucchi.
+> A quel punto tutte le carote rimaste le mangerà Carol!
+>
+> **Approfondimento:** visto che la condizione che termina la ripetizione chiede solo che
+> una delle due pile contenga meno di $7$ carote, si potrebbe pensare che alla fine potrebbero
+> rimanere più carote per Carol, come $18$, $28$, $38$, eccetera. Questo però non è possibile!
+> 
+> Infatti, si può notare che ogni volta Tip-Tap e Bunny mangiano più carote dalla pila più grande
+> e meno dalla pila più piccola. Questo porta a ridurre la differenza tra le due pile, finché
+> la differenza non è **al massimo 3**. Da quel punto in poi la differenza tra le due pila rimarrà
+> sempre al massimo 3, e quindi quando una pila arriva ad avere meno di $7$ carote (quindi al massimo
+> $6$), l'altra pila non può avere più di $6 + 3 = 9$ carote, per un totale di al massimo $9 + 6 = 15$
+> carote, che è meno di $18$.

src/fibonacci-primarie/2023-seconda-fase/contest/p-4-contatore/code.asy

@@ -0,0 +1,32 @@
+access "../../../../asy_library/structures/layout.asy" as layout;
+
+unravel layout; // per evitare di scrivere layout.cose tutto il tempo
+
+unitsize(1cm);
+
+TEXT_SIZE = 2;
+ALIGN = (0, 0.5);
+
+element P = row(
+    BLOCK_PADDING,
+    fill_space=0,
+    block_sequence(
+        instr_block(element("imposta"), choice_block(e("contatore")), element("a"), data_block(e("0"))),
+        for_block(
+            block_content(e("conta con"), choice_block(e("i")), e("da"), data_block(e("1")), e("a"), data_block(e("42")), e(":")),
+            block_sequence(
+                if_block(
+                    block_content(e("se"), cond_block(e(""), choice_block(e("i")), e("è multiplo di"), data_block(e("7")), e("")), e(":")),
+                    instr_block(element("aumenta"), choice_block(e("contatore")), element("di"), data_block(e("1")))
+                ),
+                if_block(
+                    block_content(e("se"), cond_block(e(""), choice_block(e("i")), e("è multiplo di"), data_block(e("9")), e("")), e(":")),
+                    instr_block(element("diminuisci"), choice_block(e("contatore")), element("di"), data_block(e("1")))
+                )
+            )
+        ),
+        instr_block(element("stampa"), choice_block(e("contatore")))
+    )
+);
+
+add(P.drawing());