aggiunta finale di fibonacci

src/fibonacci-secondarie/2023-terza-fase/contest/contest.mdx

@@ -0,0 +1,15 @@
+import { S1Cioccolato } from "problemset";
+import { S2Montagna } from "problemset";
+import { S3Calcolatrice } from "problemset";
+import { S4Superbunny } from "problemset";
+
+<Contest>
+
+<Section>
+  <Problem points={[5, 0, 0]} statement={S1Cioccolato} />
+  <Problem points={[5, 0, 0]} statement={S2Montagna} />
+  <Problem points={[5, 0, 0]} statement={S3Calcolatrice} />
+  <Problem points={[5, 0, 0]} statement={S4Superbunny} />
+</Section>
+
+</Contest>

src/fibonacci-secondarie/2023-terza-fase/contest/header.md

@@ -0,0 +1,19 @@
+# Giochi di Fibonacci 2023/2024
+
+## Fase finale - Scuole secondarie
+
+Questa prova contiene _4 domande_ da risolvere in _3 ore_.
+Tutte le domande sono di **programmazione** tramite blocchi, e 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 sono a _blocchi_ e richiedono di scrivere un singolo programma a blocchi, che viene valutato su 10 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 50 punti in totale.
+
+In ogni domanda a blocchi, i primi 5 livelli vengono anche visualizzati graficamente, mentre gli ultimi 5 livelli non vengono visualizzati.

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/asy/bunnies0.asy

@@ -0,0 +1,5 @@
+unitsize(1cm);
+
+access "../../../../../asy_library/pictures/bunny_polychrome.asy" as bunny;
+
+add(bunny.drawing(0.85, bunny.allie_col));

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/asy/bunnies1.asy

@@ -0,0 +1,5 @@
+unitsize(1cm);
+
+access "../../../../../asy_library/pictures/bunny_polychrome.asy" as bunny;
+
+add(bunny.drawing(0.85, bunny.bunny_col));

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/asy/bunnies2.asy

@@ -0,0 +1,5 @@
+unitsize(1cm);
+
+access "../../../../../asy_library/pictures/bunny_polychrome.asy" as bunny;
+
+add(bunny.drawing(0.85, bunny.carol_col));

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/asy/bunnies3.asy

@@ -0,0 +1,5 @@
+unitsize(1cm);
+
+access "../../../../../asy_library/pictures/bunny_polychrome.asy" as bunny;
+
+add(bunny.drawing(0.85, bunny.tiptap_col));

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/asy/bunny.asy

@@ -0,0 +1,5 @@
+unitsize(1cm);
+
+access "../../../../../asy_library/pictures/bunny_polychrome.asy" as bunny;
+
+add(reflect((2, 1), (2, 0))*bunny.drawing(0.85, bunny.tiptap_col));

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/asy/chocolate.asy

@@ -0,0 +1,5 @@
+unitsize(1cm);
+
+access "../../../../../asy_library/pictures/chocolate.asy" as chocolate;
+
+add(chocolate.drawing());

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/customBlocks.yaml

@@ -0,0 +1,95 @@
+- type: start
+  message0: inizia qui
+  nextStatement: null
+  colour: 20
+  tooltip: L'esecuzione inizia da qui
+  helpUrl: ""
+  maxInstances: 1
+  js: ""
+
+- type: larghezza
+  message0: larghezza
+  output: Number
+  colour: 20
+  tooltip: larghezza della tavoletta rimasta
+  helpUrl: ""
+  js:
+    - hiddenState.N
+    - ORDER_MEMBER
+
+- type: altezza
+  message0: altezza
+  output: Number
+  colour: 20
+  tooltip: altezza della tavoletta rimasta
+  helpUrl: ""
+  js:
+    - hiddenState.M
+    - ORDER_MEMBER
+
+- type: compagni
+  message0: compagni
+  output: Number
+  colour: 20
+  tooltip: numero di compagni rimasti
+  helpUrl: ""
+  js:
+    - hiddenState.K
+    - ORDER_MEMBER
+
+- type: spezza in orizzontale
+  message0: spezza %1 quadratini in orizzontale
+  args0:
+    - type: input_value
+      name: LENGTH
+      value: 0
+      check: Number
+  previousStatement: null
+  nextStatement: null
+  colour: 20
+  tooltip: spezza x quadratini in orizzontale
+  helpUrl: ""
+  js: |-
+    (function(i) {
+      if (i === undefined) exit(false, "l'argomento del blocco non ha un valore");
+      if (i <= 0 || Math.floor(i) != i) exit(false, "numero di righe " + i + " non valido");
+      if (i > hiddenState.M) exit(false, "non ci sono " + i + " righe");
+      hiddenState.M -= i;
+      hiddenState.K -= 1;
+      hiddenState.cuts.push(i);
+    })(%0);
+
+- type: spezza in verticale
+  message0: spezza %1 quadratini in verticale
+  args0:
+    - type: input_value
+      name: LENGTH
+      value: 0
+      check: Number
+  previousStatement: null
+  nextStatement: null
+  colour: 20
+  tooltip: spezza x quadratini in verticale
+  helpUrl: ""
+  js: |-
+    (function(i) {
+      if (i === undefined) exit(false, "l'argomento del blocco non ha un valore");
+      if (i <= 0 || Math.floor(i) != i) exit(false, "numero di colonne " + i + " non valido");
+      if (i > hiddenState.N) exit(false, "non ci sono " + i + " colonne");
+      hiddenState.N -= i;
+      hiddenState.K -= 1;
+      hiddenState.cuts.push(-i);
+    })(%0);
+
+- type: termina
+  message0: termina
+  previousStatement: null
+  colour: 20
+  tooltip: termina il procedimento
+  helpUrl: ""
+  js: |
+    if (hiddenState.K > 0)
+      exit(false, "ci sono ancora compagni che vogliono cioccolato");
+    if (hiddenState.N*hiddenState.M < hiddenState.sol)
+      exit(false, "potevi tenerti più cioccolato");
+    exit(true, "hai distribuito bene il cioccolato, complimenti!");

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/initialBlocks.json

@@ -0,0 +1,14 @@
+{
+  "blocks": {
+    "languageVersion": 0,
+    "blocks": [
+      {
+        "type": "start",
+        "id": "y=zq)Uya2A/{vyOtN[i6",
+        "x": 61,
+        "y": 81
+      }
+    ]
+  },
+  "variables": []
+}

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/question.mdx

@@ -0,0 +1,42 @@
+import initialBlocks from "./initialBlocks.json";
+import customBlocks from "./customBlocks.yaml";
+import testcases from "./testcases.py";
+import Visualizer from "./visualizer.jsx";
+
+Tip-Tap adora il cioccolato, e allora si è comprato una tavoletta di cioccolato fatta di $N \times M$ quadratini.
+Anche i $K$ suoi compagni di fattoria vorrebbero mangiare il cioccolato, e Tip-Tap è troppo buono per non dargliene!
+Quindi per $K$ volte spezza la tavoletta in due parti rettangolari, non necessariamente uguali, e dà una delle due ad uno dei suoi $K$ compagni tenendo infine l'ultimo pezzo per sè.
+
+!["La tavoletta di Tip-Tap"](lorenzo.jpg "Il cioccolato non è mai troppo!")
+
+La tavoletta può essere spezzata solo lungo i bordi dei quadratini, in orizzontale o verticale, in modo tale da non dividere nessun quadratino in due.
+Inoltre una volta spezzata una parte, quella viene subito presa e mangiata da un amico senza dargli la possibilità di spezzarla ulteriormente.
+Tip-Tap vorrebbe sapere come spezzare la tavoletta $K$ volte in modo che gli rimangano il maggior numero possibile di quadratini. Puoi aiutarlo?
+
+Puoi usare questi blocchi:
+
+- `larghezza`: la larghezza attuale della tavoletta.
+- `altezza`: l'altezza attuale della tavoletta.
+- `compagni`: il numero di compagni che ancora chiedono del cioccolato.
+- `spezza x quadratini in orizzontale`: spezza la tavoletta in orizzontale, lasciando $x$ file ad un compagno.
+- `spezza x quadratini in verticale`: spezza la tavoletta in verticale, lasciando $x$ colonne ad un compagno.
+- `termina`: mangia il cioccolato rimasto.
+
+Aiuta Tip-Tap a spezzare la tavoletta $K$ volte, in modo gli rimanga il maggior numero possibile di quadratini!
+
+<Blockly
+  customBlocks={customBlocks}
+  initialBlocks={initialBlocks}
+  testcases={testcases}
+  debug={{ logBlocks: false, logJs: false, logVariables: false }}
+  Visualizer={Visualizer}
+/>
+
+> Un possibile programma corretto è il seguente:
+>
+> ![soluzione](sol.png)
+>
+> Secondo questo programma, per ognuno dei compagni di Tip-Tap, il protagonista
+> controlla se la tavoletta è più larga o  più alta, e gli passa una singola fila
+> o colonna a seconda di quale delle due è più piccola. In questo modo, si
+> assicura che alla fine gli rimanga più cioccolato possibile.

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/testcases.py

@@ -0,0 +1,57 @@
+from random import randint, seed
+import json
+import math
+
+seed(42)
+
+L = [2, 5, 10, 10, 10, 90, 900, 900, 900, 900]
+U = [3, 10, 20, 20, 20, 100, 1000, 1000, 1000, 1000]
+type = [0, 1, 2, 3, 0, 3, 0, 2, 0, 4]
+
+params = [L, U, type]
+
+def solve(n, m, k):
+    if n > m:
+        n, m = m, n
+    d = min(k, m - n)
+    k -= d
+    m -= d
+    n -= k // 2
+    m -= k // 2 + k % 2
+    return n*m
+
+def generate(L, U, type):
+    args = set(locals()) | set(['args'])
+
+    # base generator
+    if type == 1:
+        # M = 1
+        N = randint(L, U)
+        M = 1
+    elif type == 2:
+        #quadrato
+        N = M = randint(L, U)
+    elif type == 3:
+        #rettangolo stretto e allungato
+        M = randint(L, U)
+        N = randint(1, L)
+    else:
+        #generico
+        N = randint(L, U)
+        M = randint(L, U)
+
+    if type == 4:
+        K = randint(max(N+M-5, 1), N+M-2)
+    else:
+        K = randint(1, N+M-2)
+
+    # additional state for visualizer
+    sol = solve(N, M, K)
+    cuts = []
+
+    return {k:v for k,v in locals().items() if k not in args}
+
+testcases = []
+for args in zip(*params):
+    testcases.append(generate(*args))
+print(json.dumps(list(testcases)))

src/fibonacci-secondarie/2023-terza-fase/contest/s-1-cioccolato/visualizer.jsx

@@ -0,0 +1,62 @@
+import React from "react";
+import { range } from "lodash-es";
+
+import { Canvas, Sprite, Rectangle, Variables } from "~/utils/visualizer";
+
+import bunny from "./asy/bunny.asy?w=66";
+import chocolate from "./asy/chocolate.asy?w=25";
+
+const bunnies = import.meta.glob("./asy/bunnies*.asy", {
+  eager: true,
+  import: "default",
+  query: { w: 50 },
+});
+
+export default function Visualizer({ variables }) {
+  const { blocklyVariables, hiddenState } = variables;
+  if (!hiddenState) return;
+
+  var blocks = [];
+  var xoffs = 1.5;
+  var yoffs = 9;
+  var sep = 0.15;
+
+  function chocblock(N0, N, M0, M, name="cioc") {
+    for (var i=N0; i<N; ++i)
+      for (var j=M0; j<M; ++j)
+        blocks.push(<Sprite key={name+'-'+i+'-'+j} src={chocolate} alt={name+'-'+i+'-'+j} x={xoffs+i*0.5} y={yoffs-j*0.5} />)
+  }
+
+  var N = hiddenState.N;
+  var M = hiddenState.M;
+  if (N <= 20 && M <= 20) {
+    chocblock(0, N, 0, M);
+    for (var i=hiddenState.cuts.length-1; i>=0; --i) {
+      var c = hiddenState.cuts[i];
+      if (c > 0) {
+        yoffs -= sep;
+        chocblock(0, N, M, M+c);
+        M += c;
+      } else {
+        xoffs += sep;
+        chocblock(N, N-c, 0, M);
+        N -= c;
+      }
+    }
+  }
+
+  var len = Object.keys(bunnies).length;
+
+  return (
+    <>
+      <Canvas scale={50}>
+        <Sprite src={bunny} alt="Tip-Tap" x={0} y={yoffs-2} follow />
+        {range(N <= 20 && M <= 20 ? hiddenState.K : 0).map((i) => {
+          return <Sprite key={"bunny-"+i} src={bunnies[`./asy/bunnies${i%len}.asy`]} alt="Bunny" x={2+N*(0.5+sep)+((11*i)%19)*0.4} y={4+3*i/(hiddenState.K+hiddenState.cuts.length-1)} />
+        })}
+        {blocks}
+      </Canvas>
+      <Variables variables={{larghezza: hiddenState.N, altezza: hiddenState.M, compagni: hiddenState.K, ...blocklyVariables}} />
+    </>
+  );
+}

src/fibonacci-secondarie/2023-terza-fase/contest/s-2-montagna/asy/bunny.asy

@@ -0,0 +1,14 @@
+unitsize(1cm);
+
+access "../../../../../asy_library/pictures/bunny_polychrome.asy" as bunny;
+
+filldraw((2,-1) -- (2.5,0) -- (6,0) -- (5.5,-1) -- cycle, heavyblue*0.5 + lightgray*0.5, blue+3);
+add(shift(-0.7,0.3)*reflect((2, 1), (2, 0))*bunny.drawing(0.85, bunny.bunny_col));
+add(shift(1.2,0.6)*reflect((2, 1), (2, 0))*bunny.drawing(0.85, bunny.tiptap_col));
+add(shift(0.5,0)*reflect((2, 1), (2, 0))*bunny.drawing(0.85, bunny.carol_col));
+filldraw((2,-1) -- (5.5,-1) -- (6, -2) -- (2, -2) -- cycle, heavyblue, blue+3);
+filldraw((6,0) -- (5.5,-1) -- (6, -2) -- (6.5,-1) -- cycle, darkblue, blue+3);
+for (int i=0; i<2; ++i) {
+    filldraw(circle((3+2*i,-2), 0.7), gray, black+3);
+    filldraw(circle((3+2*i,-2), 0.2), mediumgray, black+2);
+}

src/fibonacci-secondarie/2023-terza-fase/contest/s-2-montagna/asy/leftri.asy

@@ -0,0 +1,9 @@
+unitsize(1cm);
+
+pen lightcol = rgb("9e6b5a");
+pen darkcol = brown+2;
+
+path bord = (0,0) {dir(10)}..{dir(30)} (1,1);
+
+fill(bord -- (1,0) -- cycle, lightcol);
+fill((0,0) {dir(0)}..{dir(35)} (1,1) -- reverse(bord) -- cycle, darkcol);

src/fibonacci-secondarie/2023-terza-fase/contest/s-2-montagna/asy/leftsnow.asy

@@ -0,0 +1,10 @@
+unitsize(1cm);
+
+pen lightcol = rgb("9e6b5a");
+pen darkcol = brown+2;
+
+path bord = (0,0) {dir(60)}..{E} (1,1);
+
+fill(bord -- (1,0) -- cycle, lightcol);
+fill(point(bord, 0.2) {E}..{dir(50)} (1,0.45) -- (1,1) -- subpath(bord, 1, 0.2) -- cycle, palegray);
+fill((0,0) {dir(55)}..{dir(5)} (1,1) -- reverse(bord) -- cycle, darkcol);

src/fibonacci-secondarie/2023-terza-fase/contest/s-2-montagna/asy/offcharge.asy

@@ -0,0 +1,5 @@
+unitsize(1cm);
+
+access "../../../../../asy_library/pictures/charger.asy" as charger;
+
+add(charger.drawing());

src/fibonacci-secondarie/2023-terza-fase/contest/s-2-montagna/asy/oncharge.asy

@@ -0,0 +1,5 @@
+unitsize(1cm);
+
+access "../../../../../asy_library/pictures/charger.asy" as charger;
+
+add(charger.drawing(1, lightyellow, green));