aggiunte scolastiche 2024

src/fibonacci-primarie/2024-prima-fase/contest/A11-connetti-stati/question.md

@@ -21,7 +21,7 @@ Qual è il minimo numero di carote che Tip-Tap deve spendere affinché da ogni f
 - [ ] $\js{wrong1[2]}$
 - [ ] $\js{wrong1[3]}$
 
-> Dato che le strade all'interno dello stesso paese costano poco, conviene intanto collegare le fattorie all'interno dello stesso paese. Per ogni paese servono $\js{s-1}$ fattorie. Ad esempio, colleghiamo la fattoria $1$ con la fattoria $2$, la fattoria $2$ con la fattoria $3$, ..., la fattoria $\js{s-1}$ con la fattoria $\js{s}$). Quindi il costo parziale è di $\js{n*(s-1)}$ carote.
+> Dato che le strade all'interno dello stesso paese costano poco, conviene intanto collegare le fattorie all'interno dello stesso paese. Per ogni paese servono $\js{s-1}$ fattorie. Ad esempio, colleghiamo la fattoria $1$ con la fattoria $2$, la fattoria $2$ con la fattoria $3$, ..., la fattoria $\js{s-1}$ con la fattoria $\js{s}$. Quindi il costo parziale è di $\js{n*(s-1)}$ carote.
 > Adesso dobbiamo anche connettere i paesi tra di loro, e servono altre $\js{n-1}$ strade di costo $2$ carote. Ad esempio, colleghiamo l'ultima fattoria di ogni paese (tranne l'ultimo) con la prima di quello successivo. Il costo totale è $\js{2*(n-1) + n*(s-1)}$ carote.
 >
 > ![4.1 secondarie](4-1-secondarie.asy)
@@ -46,6 +46,6 @@ Qual è il minimo numero di carote che Tip-Tap deve spendere affinché da ogni f
 - [ ] $\js{wrong2[2]}$
 - [ ] $\js{wrong2[3]}$
 
-> Nel problema precedente, abbiamo formato una linea composta da tutte le $\js{n*s}$ città. Assegniamo lo stesso verso a tutte le strade della linea, in modo che dalla prima città si possa raggiungere l'ultima. Ma in questo modo dall'ultima città non se ne può raggiungere nessun'altra. Per rimediare, creiamo una nuova strada che collega l'ultima città alla prima, pagando un costo aggiuntivo di $2$ carote.
+> Nel problema precedente, abbiamo formato una linea composta da tutte le $\js{n*s}$ città. Assegniamo lo stesso verso a tutte le strade della linea, in modo che dalla prima città si possa raggiungere l'ultima. Ma in questo modo dall'ultima città non se ne può raggiungere nessun'altra. Per rimediare, basta creare una nuova strada che collega l'ultima città alla prima, pagando un costo aggiuntivo di $2$ carote.
 >
 > ![4.2 secondarie](4-2-secondarie.asy)

src/scolastiche/2022/header.md

@@ -12,7 +12,7 @@ Ti è permesso:
 
 Non ti è permesso:
 
-- navigare su internet, se non all'indirizzo del sito della prova https://gara.scolastiche.olinfo.it;
+- navigare su internet, se non all'indirizzo del sito della prova;
 - comunicare con i tuoi compagni;
 - comunicare con il docente sorvegliante sul contenuto della prova;
 - diffondere il testo della prova, o parte di esso, prima delle 20:00 del giorno della prova (16 dicembre).

src/scolastiche/2023/header.md

@@ -12,7 +12,7 @@ Ti è permesso:
 
 Non ti è permesso:
 
-- navigare su internet, se non all'indirizzo del sito della prova [https://scolastiche23.olinfo.it](https://scolastiche23.olinfo.it);
+- navigare su internet, se non all'indirizzo del sito della prova;
 - comunicare con i tuoi compagni;
 - comunicare con il docente sorvegliante sul contenuto della prova;
 - diffondere il testo della prova, o parte di esso, prima delle 20:00 del giorno della prova (14 dicembre).

src/scolastiche/2024/contest/A11-connetti-stati/5-1.asy

@@ -0,0 +1,3 @@
+access "../../../../asy_library/structures/histogram.asy" as histogram;
+unitsize(1cm);
+add(histogram.drawing(scale(1.5)*"scolastiche", new Label[]{"corretta", "non corretta"}, new real[]{2978, 10874}));

src/scolastiche/2024/contest/A11-connetti-stati/5-2.asy

@@ -0,0 +1,3 @@
+access "../../../../asy_library/structures/histogram.asy" as histogram;
+unitsize(1cm);
+add(histogram.drawing(scale(1.5)*"scolastiche", new Label[]{"corretta", "non corretta"}, new real[]{671, 13181}));

src/scolastiche/2024/contest/A11-connetti-stati/question.md

@@ -0,0 +1,37 @@
+import variants from "./variants.py";
+
+
+A _Olinfolandia_ ci sono $\js{n}$ Stati e ognuno di essi ha al suo interno $10$ città.
+Valerio è stato incaricato di costruire delle strade **bidirezionali** per connettere le città: può costruire una strada che connette due città dello stesso Stato con costo $1$ e città di Stati diversi con costo $2$.
+Per esempio, se ci fossero $3$ Stati con $2$ città ciascuno, si potrebbero collegare come in figura. Questo piano costa $2 \times 4 + 1 \times 2 = 10$:
+
+![esempio1](ex1.svg)
+
+In questo esempio, ci sono anche altri piani validi, ciascuno con un costo di $7$ o più.
+
+Ricordando che a _Olinfolandia_ ci sono $\js{n}$ Stati con $10$ città, se Valerio costruisce strade **bidirezionali**, quanto deve spendere al minimo per fare in modo che da ogni città si possa raggiungere ogni altra città?
+
+?> {ans1}
+
+> Dato che le strade all'interno dello stesso Stato costano poco, conviene intanto collegare le città all'interno dello stesso Stato. Per ogni Stato servono $9$ strade. Ad esempio, colleghiamo la città $1$ con la città $2$, la città $2$ con la città $3$, ..., la città $9$ con la città $10$. Il costo parziale fino a questo punto è quindi $\js{n} \times 9 = \js{n*9}$.
+> Adesso dobbiamo anche connettere gli Stati tra di loro, e servono altre $\js{n-1}$ strade di costo $2$: ad esempio, se colleghiamo l'ultima città di ogni Stato (tranne l'ultimo) con la prima di quello successivo. Il costo totale è quindi $\js{2*(n-1)} + \js{n*9} = \js{2*(n-1) + n*9}$.
+>
+> ![5.1](5-1.asy)
+
+
+---
+
+Mettiamo ora che le strade che Valerio costruisce siano **unidirezionali**, come in questo esempio:
+
+![esempio2](ex2.svg)
+
+Questo piano costa $3 \times 2 + 2 \times 1 = 8$, e consente di poter andare da ogni città ad ogni altra rispettando i versi delle strade.
+Come prima, ci sono anche altri piani validi, ciascuno con un costo di $6$ o più.
+
+Ricordando che a _Olinfolandia_ ci sono $\js{n}$ Stati con $10$ città, se Valerio costruisce strade **unidirezionali**, quanto deve spendere al minimo per fare in modo che da ogni città si possa raggiungere ogni altra città?
+
+?> {ans2}
+
+> Nella versione precedente del problema, abbiamo formato una linea composta da tutte le $\js{n*10}$ città. Assegniamo lo stesso verso a tutte le strade della linea, in modo che dalla prima città si possa raggiungere l'ultima. Ma in questo modo dall'ultima città non se ne può raggiungere nessun'altra! Per rimediare, basta creare una nuova strada che collega l'ultima città alla prima, pagando un costo aggiuntivo di $2$, per un totale di $\js{2*n + n*9}$.
+>
+> ![5.2](5-2.asy)

src/scolastiche/2024/contest/A11-connetti-stati/variants.py

@@ -0,0 +1,25 @@
+import json
+
+variants_input = [
+    dict(n=90),
+    dict(n=95),
+    dict(n=100),
+    dict(n=105),
+    dict(n=110),
+    dict(n=115),
+    dict(n=120)
+]
+
+
+def build_variant(n):
+    ans1 = n*10 - 1 + (n-1)
+    ans2 = ans1 + 2
+
+    return dict(
+        n=n,
+        ans1=ans1,
+        ans2=ans2,
+    )
+
+
+print(json.dumps([build_variant(**data) for i, data in enumerate(variants_input)]))

src/scolastiche/2024/contest/A13-flippa-griglia/6-1.asy

@@ -0,0 +1,3 @@
+access "../../../../asy_library/structures/histogram.asy" as histogram;
+unitsize(1cm);
+add(histogram.drawing(scale(1.5)*"scolastiche", new Label[]{"corretta", "non corretta"}, new real[]{7263, 6589}));

src/scolastiche/2024/contest/A13-flippa-griglia/6-2.asy

@@ -0,0 +1,3 @@
+access "../../../../asy_library/structures/histogram.asy" as histogram;
+unitsize(1cm);
+add(histogram.drawing(scale(1.5)*"scolastiche", new Label[]{"corretta", "non corretta"}, new real[]{800, 13052}));

src/scolastiche/2024/contest/A13-flippa-griglia/grid.asy

@@ -0,0 +1,18 @@
+void drawGrid(int[][] grid, real x_offset, string label) {
+    for (int i = 0; i < 4; ++i) {
+        for (int j = 0; j < 4; ++j) {
+            real x = x_offset + j;
+            real y = -i;
+
+            // Draw the cell background
+            if (grid[i][j] == 1) {
+                filldraw(box((x, y), (x + 1, y - 1)), black);
+            } else {
+                filldraw(box((x, y), (x + 1, y - 1)), white, black);
+            }
+        }
+    }
+    if(label!=""){
+        label(scale(4.5)*label, (x_offset + 2, -4.5), S);
+    }
+}

src/scolastiche/2024/contest/A13-flippa-griglia/griglia1.asy

@@ -0,0 +1,3 @@
+import "grid.asy" as grid;
+unitsize(1cm);
+drawGrid(initial_grid, 0, "");

src/scolastiche/2024/contest/A13-flippa-griglia/griglie2.asy

@@ -0,0 +1,6 @@
+import "grid.asy" as grid;
+unitsize(1cm);
+
+for (int k = 0; k < options.length; ++k) {
+    drawGrid(options[k], k * 5, string(k+1));
+}

src/scolastiche/2024/contest/A13-flippa-griglia/immagine1_fliprow2.asy

@@ -0,0 +1,7 @@
+import "grid.asy" as grid;
+unitsize(1cm);
+int [][] initial_grid1 = initial_grid;
+for (int i = 0; i < 4; ++i) {
+    initial_grid1[2][i] = 1 - initial_grid1[2][i];
+}
+drawGrid(initial_grid1, 0, "");

src/scolastiche/2024/contest/A13-flippa-griglia/question.md

@@ -0,0 +1,45 @@
+import variants from "./variants.py";
+
+Mentre andava a scuola, Francesco è inciampato su una griglia magica 4x4 formata da caselle bianche e nere, rappresentata in figura.
+
+![Immagine](griglia1.asy?v=variants.py)
+
+Provando a giocarci si è accorto che può invertire tutte le celle in una riga, facendo sì che le caselle nere diventino bianche e viceversa. Ad esempio, se applica l'operazione alla terza riga ottiene la griglia seguente.
+
+![Immagine](immagine1_fliprow2.asy?v=variants.py)
+
+Quali delle seguenti griglie può ottenere se applica questa operazione in modo opportuno? Inserire la lista di griglie che può ottenere, in ordine e non separate da spazi. Per esempio se può ottenere le griglie $2$, $4$ e $5$, inserire $245$.
+
+![Immagine](griglie2.asy?v=variants.py)
+
+?> {ans1}
+
+> Le righe non interagiscono tra loro, quindi posso controllare ogni riga singolarmente.
+> Notiamo che effettuare due operazioni sulla stessa riga è inutile. Quindi, su una riga, posso scegliere se effettuare l'operazione una sola volta o zero volte.
+> Dunque ogni riga può avere due stati possibili (quello iniziale, e quello in cui tutte le caselle sono state invertite).
+> Per ogni possibile griglia che vorrei ottenere, verifico se ogni riga è in uno di quei due stati: se sì la includo nella risposta, altrimenti non la includo.
+> Le griglie ottenibili sono $\js{String(ans1).split('').join(', ')}$ e quindi la risposta è $\js{ans1}$.
+>
+> ![6.1](6-1.asy)
+
+---
+
+Il giorno dopo Francesco si accorge che può anche invertire una colonna della griglia. Sapendo quindi che può invertire sia righe che colonne, quali delle seguenti griglie può ottenere? Inserire la risposta nello stesso formato della domanda precedente.
+
+![Immagine](griglie2.asy?v=variants.py)
+
+?> {ans2}
+
+> Le uniche mosse che possono modificare la prima riga sono:
+> - invertire la prima riga;
+> - invertire le colonne.
+> 
+> Ad esempio, suppongo di non invertire la prima riga. Allora, guardando la griglia finale, posso capire quali colonne vanno invertite (quelle che non corrispondono nella casella della prima riga).
+> A questo punto ho determinato tutte le mosse sulle colonne, e rimangono solo le mosse sulle altre righe, quindi mi sono ricondotto alla versione facile del problema.
+> Quindi una possibile soluzione è: provo a invertire o non invertire la prima riga, quindi determino le mosse sulle colonne, e infine determino le mosse sulle righe.
+> 
+> In realtà, non è necessario controllare entrambi i casi per la mossa sulla prima riga. Se esiste una soluzione che non inverte la prima riga, esiste anche una soluzione che la inverte (e viceversa): basta fare una mossa in più su ogni riga e una su ogni colonna, e queste mosse si annullano tra loro, lasciando la griglia invariata. Possiamo qunidi assumere di non invertire la prima riga.
+>
+> Seguendo questo procedimento, possiamo capire che le griglie ottenibili sono $\js{String(ans2).split('').join(', ')}$ e quindi la risposta è $\js{ans2}$.
+>
+> ![6.2](6-2.asy)

src/scolastiche/2024/contest/A13-flippa-griglia/variants.py

@@ -0,0 +1,77 @@
+import json
+import sys
+import random
+
+
+def gen_random_grid(n):
+    return [[random.randint(0, 1) for i in range(n)] for j in range(n)]
+
+
+def apply_random_moves(grid, cols):
+    grid1 = [[grid[i][j] for j in range(4)] for i in range(4)]
+    for i in range(100):
+        if random.randint(0, 1):
+            row = random.randint(0, 3)
+            for j in range(4):
+                grid1[row][j] = 1 - grid1[row][j]
+
+        elif cols:
+            col = random.randint(0, 3)
+            for j in range(4):
+                grid1[j][col] = 1 - grid1[j][col]
+    return grid1
+
+
+def is_reachable(grid, grid1, cols):
+    for row_mask in range(16):
+        for col_mask in range(16):
+            grid2 = [[grid[i][j] for j in range(4)] for i in range(4)]
+            for row in range(4):
+                if row_mask & (1 << row):
+                    for j in range(4):
+                        grid2[row][j] = 1 - grid2[row][j]
+            if cols:
+                for col in range(4):
+                    if col_mask & (1 << col):
+                        for i in range(4):
+                            grid2[i][col] = 1 - grid2[i][col]
+            if grid2 == grid1:
+                return True
+    return False
+
+
+def build_variant(seed):
+    random.seed(seed)
+    initial_grid = gen_random_grid(4)
+    options = []
+    for i in range(2):
+        options.append(apply_random_moves(initial_grid, False))
+        assert (is_reachable(initial_grid, options[-1], False))
+
+    for i in range(random.randint(2, 3)):
+        options.append(apply_random_moves(initial_grid, True))
+    while len(options) < 7:
+        options.append(gen_random_grid(4))
+    random.shuffle(options)
+
+    ans1 = ""
+    for i in range(len(options)):
+        if is_reachable(initial_grid, options[i], False):
+            ans1 += str(i + 1)
+    ans2 = ""
+    for i in range(len(options)):
+        if is_reachable(initial_grid, options[i], True):
+            ans2 += str(i + 1)
+    return dict(
+        initial_grid=initial_grid,
+        options=options,
+        ans1=ans1,
+        ans2=ans2
+    )
+
+
+def build_variants():
+    return [build_variant(i) for i in range(20)]
+
+
+print(json.dumps(build_variants()))

src/scolastiche/2024/contest/A19-max-sum/7-1.asy

@@ -0,0 +1,3 @@
+access "../../../../asy_library/structures/histogram.asy" as histogram;
+unitsize(1cm);
+add(histogram.drawing(scale(1.5)*"scolastiche", new Label[]{"corretta", "non corretta"}, new real[]{7491, 6361}));

src/scolastiche/2024/contest/A19-max-sum/7-2.asy

@@ -0,0 +1,3 @@
+access "../../../../asy_library/structures/histogram.asy" as histogram;
+unitsize(1cm);
+add(histogram.drawing(scale(1.5)*"scolastiche", new Label[]{"corretta", "non corretta"}, new real[]{4680, 9172}));

src/scolastiche/2024/contest/A19-max-sum/array1.asy

@@ -0,0 +1,10 @@
+access "../../../../asy_library/structures/layout.asy" as layout;
+unravel layout;
+unitsize(1cm);
+
+element[][] elements = {{}};
+for (int i=0; i<test1.length; ++i) {
+    elements[0][i] = element(string(test1[i]));
+}
+
+add(grid(0.3, true, true, black+1, elements).drawing());

src/scolastiche/2024/contest/A19-max-sum/array2.asy

@@ -0,0 +1,10 @@
+access "../../../../asy_library/structures/layout.asy" as layout;
+unravel layout;
+unitsize(1cm);
+
+element[][] elements = {{}};
+for (int i=0; i<test2.length; ++i) {
+    elements[0][i] = element(string(test2[i]));
+}
+
+add(grid(0.3, true, true, black+1, elements).drawing());

src/scolastiche/2024/contest/A19-max-sum/array3.asy

@@ -0,0 +1,11 @@
+access "../../../../asy_library/structures/layout.asy" as layout;
+unravel layout;
+unitsize(1cm);
+
+element[][] elements = {{}, {}};
+for (int i=0; i<test2.length; ++i) {
+    elements[0][i] = element(string(test2[i]));
+    elements[1][i] = element(string(arr[i]));
+}
+
+add(grid(0.3, true, true, black+1, elements).drawing());

src/scolastiche/2024/contest/A19-max-sum/esempio.asy

@@ -0,0 +1,12 @@
+access "../../../../asy_library/structures/layout.asy" as layout;
+unravel layout;
+unitsize(1cm);
+
+int[] esempio = {5, 10, 0, 2, 6};
+
+element[][] elements = {{}};
+for (int i=0; i<esempio.length; ++i) {
+    elements[0][i] = element(string(esempio[i]));
+}
+
+add(grid(0.3, true, true, black+1, elements).drawing());

src/scolastiche/2024/contest/A19-max-sum/question.md

@@ -0,0 +1,57 @@
+import variants from "./variants.py";
+
+Elia è nel suo negozio di quaderni preferito. Davanti a sé ha una fila di quaderni, e ha assegnato ad ognuno di essi un valore in base a quanto gli piace. Vuole comprare alcuni di essi, ma ha deciso di non comprare $2$ quaderni che si trovano vicini.
+Qual è la massima somma dei valori dei quaderni che può comprare?
+Per esempio se i valori fossero questi:
+
+![Immagine](esempio.asy?v=variants.py)
+
+la somma massima ottenibile sarebbe $16$.
+
+Rispondi considerando che questa è la lista dei valori dei quaderni, in ordine da sinistra a destra.
+
+![Immagine](array1.asy?v=variants.py)
+
+?> {ans1}
+
+> Non ha senso comprare quaderni di valore $0$ (se non li compro, ottengo una soluzione con la stessa somma).
+> Quindi guardo gli intervalli massimali contenenti solo quaderni di valore $1$, e da ogni intervallo mi conviene prendere il primo quaderno, il terzo, il quinto, e così via.
+> Se ho un intervallo lungo $x$, posso prendere metà dei quaderni, arrotondata per eccesso. Adesso basta sommare il numero di quaderni che posso prendere su tutti gli intervalli.
+> 
+> In alternativa, anche la strategia "guardo i quaderni da sinistra a destra, e se ne trovo uno di valore $1$ che posso prendere lo prendo" funziona.
+> In entrambi i modi si può calcolare la risposta corretta che è quindi $\js{ans1}$.
+>
+> ![7.1](7-1.asy)
+
+---
+
+Quale sarebbe invece la massima somma se i valori fossero questi?
+
+![Immagine](array2.asy?v=variants.py)
+
+?> {ans2}
+
+> Qui non sembra esserci una strategia semplice (senza memoria) per prendere i quaderni. Ad esempio, "guardo da sinistra a destra e prendo un quaderno se posso e ha valore positivo" non funziona.
+> Neanche "guardo i quaderni partendo da quello di valore massimo e se posso prenderne uno lo prendo" funziona!
+> Ad esempio, se ho quaderni di valore $[2, 1, 1, 2]$, conviene saltare il terzo quaderno e prendere il primo e il quarto. Se i valori sono $[1, 3, 1]$, conviene prendere solo il secondo quaderno. Se i valori sono $[2, 3, 2]$, conviene prendere il primo e il terzo quaderno.
+> Le possibilità diverse sembrano troppe!
+> 
+> Per gestirle, possiamo provare a creare un algoritmo che in qualche modo considera tutti i modi possibili di prendere i quaderni. Ad esempio, posso calcolare $f(i) = $ _massima somma dei valori se guardo solo $i$ quaderni, dal primo fino all'$i$-esimo da sinistra_.
+> In questo modo, ho due casi:
+> - non prendo il quaderno in posizione $i$, quindi la risposta è $f(i-1)$ perché mi riconduco a guardare i quaderni fino alla posizione $i-1$;
+> - prendo il quaderno in posizione $i$, e a quel punto non posso più prendere quello in posizione $i-1$ ma mi riconduco a guardare quelli fino alla posizione $i-2$. Se i quaderni hanno valori $a_1, a_2, \ldots, a_n$, la risposta sarebbe quindi $f(i - 2) + a_i$.
+> 
+> Quindi posso calcolare tutti i valori di $f(i)$ da sinistra a destra usando $f(i) = \max(f(i - 1), f(i - 2) + a_i)$, considerando che se $i \leq 0$, $f(i) = 0$.
+> i valori di $f(i)$ per $i=1 \ldots \js{test2.length}$ che ottengo in questo modo sono questi (riportati per comodità sotto alla lista dei valori corrispondenti):
+>
+> ![Immagine](array3.asy?v=variants.py)
+> 
+> e la risposta corretta è quindi $\js{ans2}$!
+> Questo problema è un classico esempio di _programmazione dinamica_. Se vuoi approfondire l'argomento, queste sono alcune guide che potresti leggere:
+> 
+> - [Guida per le selezioni territoriali - Capitolo 7 (italiano)](https://training.olinfo.it/bugatti.pdf#page=66)
+> - [Dispense di programmazione dinamica (italiano)](https://wiki.olinfo.it/extra/unimi/dinamica.pdf)
+> - [Competitve Programmer's Handbook - Capitolo 7 (inglese)](https://training.olinfo.it/cph.pdf#page=75)
+> - [USACO Guide - Introduction to DP (inglese)](https://usaco.guide/gold/intro-dp)
+>
+> ![7.2](7-2.asy)