├── 2005 └── territoriali │ └── sunny │ ├── sol │ └── soluzione.c │ ├── testo │ └── example0.in │ ├── gen │ └── valida.sh │ └── task.yaml ├── 2008 ├── nazionali │ ├── parole │ │ ├── testo │ │ │ ├── output0.txt │ │ │ └── input0.txt │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── task.yaml │ │ ├── gen │ │ │ └── valida.py │ │ └── altro │ │ │ └── genera_stringhe.cpp │ ├── triade │ │ ├── testo │ │ │ ├── output0.txt │ │ │ └── input0.txt │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── task.yaml │ │ └── gen │ │ │ ├── valida.py │ │ │ └── GEN │ └── cnn │ │ ├── sol │ │ ├── soluzione.cpp │ │ └── README.md │ │ ├── testo │ │ ├── output0.txt │ │ └── input0.txt │ │ ├── task.yaml │ │ └── gen │ │ ├── valida.py │ │ └── GEN └── territoriali │ ├── pizzini │ ├── gen │ │ ├── limiti.py │ │ └── GEN │ └── task.yaml │ ├── mappa │ ├── task.yaml │ └── gen │ │ ├── valida.py │ │ └── GEN │ └── missioni │ ├── task.yaml │ └── gen │ ├── GEN │ └── valida.py ├── 2009 ├── territoriali │ ├── depura │ │ ├── gen │ │ │ ├── generatore.py │ │ │ └── valida.py │ │ ├── sol │ │ │ └── soluzione.cpp │ │ └── task.yaml │ ├── treno │ │ ├── gen │ │ │ ├── generatore.sh │ │ │ ├── GEN │ │ │ └── valida.py │ │ ├── sol │ │ │ └── soluzione.cpp │ │ └── task.yaml │ └── essenza │ │ ├── sol │ │ └── soluzione.cpp │ │ ├── task.yaml │ │ └── gen │ │ └── valida.py └── nazionali │ └── README.md ├── 2010 ├── nazionali │ ├── amici │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── task.yaml │ │ └── gen │ │ │ └── valida.py │ ├── numeri │ │ ├── gen │ │ │ ├── generatore.cpp │ │ │ ├── limiti.py │ │ │ └── valida.py │ │ ├── sol │ │ │ ├── soluzione.cpp │ │ │ └── sol.py │ │ └── task.yaml │ ├── pesca │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ ├── limiti.py │ │ │ └── valida.py │ │ ├── testo │ │ │ └── mare.png │ │ └── task.yaml │ └── contest.yaml └── territoriali │ └── README.md ├── 2011 ├── nazionali │ ├── baht │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ ├── fuga │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ ├── salti │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ ├── limiti.py │ │ │ └── GEN │ │ └── task.yaml │ ├── scuola │ │ ├── gen │ │ │ ├── limiti.py │ │ │ └── GEN │ │ ├── sol │ │ │ └── soluzione.cpp │ │ └── task.yaml │ └── contest.yaml └── territoriali │ ├── quasipal │ ├── sol │ │ └── soluzione.cpp │ ├── task.yaml │ └── gen │ │ └── GEN │ ├── sbarramento │ ├── gen │ │ ├── limiti.py │ │ └── GEN │ ├── sol │ │ └── soluzione.c │ └── task.yaml │ └── tamburello │ ├── sol │ └── soluzione.c │ └── task.yaml ├── 2012 ├── nazionali │ ├── salta │ │ ├── gen │ │ │ ├── generatore.py │ │ │ └── limiti.py │ │ ├── sol │ │ │ └── soluzione.cpp │ │ └── task.yaml │ ├── eso │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ ├── fibstr │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ ├── matita │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ ├── testo │ │ │ └── casetta.png │ │ └── task.yaml │ └── contest.yaml └── territoriali │ ├── domino │ ├── gen │ │ ├── limiti.py │ │ └── GEN │ ├── sol │ │ └── soluzione.cpp │ └── task.yaml │ ├── nanga │ ├── sol │ │ └── soluzione.cpp │ ├── gen │ │ ├── limiti.py │ │ └── GEN │ └── task.yaml │ └── galattici │ ├── sol │ └── soluzione.cpp │ ├── gen │ ├── limiti.py │ └── GEN │ └── task.yaml ├── 2013 ├── nazionali │ ├── convoglio │ │ ├── sol │ │ │ ├── soluzione.cpp │ │ │ └── matteo_wrong_always_no.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ ├── testo │ │ │ └── figura.png │ │ └── task.yaml │ ├── fermata │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ ├── testo │ │ │ └── figura.png │ │ └── task.yaml │ ├── fontane │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ ├── testo │ │ │ └── figura.png │ │ └── task.yaml │ └── contest.yaml └── territoriali │ ├── turni │ ├── sol │ │ └── soluzione.cpp │ ├── gen │ │ ├── limiti.py │ │ └── GEN │ └── task.yaml │ ├── barbablu │ ├── sol │ │ └── soluzione.cpp │ ├── gen │ │ ├── graph.py │ │ └── limiti.py │ ├── task.yaml │ └── testo │ │ └── mappa.png │ └── grandprix │ ├── sol │ └── soluzione.cpp │ ├── gen │ ├── limiti.py │ └── GEN │ └── task.yaml ├── 2014 ├── nazionali │ ├── maree │ │ ├── att │ │ │ ├── grader.cpp │ │ │ ├── maree.cpp │ │ │ ├── maree.c │ │ │ ├── maree.pas │ │ │ └── grader.pas │ │ ├── sol │ │ │ ├── grader.c │ │ │ ├── grader.cpp │ │ │ ├── grader.pas │ │ │ ├── template_c.c │ │ │ ├── template_cpp.cpp │ │ │ └── template_pas.pas │ │ ├── gen │ │ │ └── graph.h │ │ ├── testo │ │ │ └── maree.jpg │ │ └── task.yaml │ ├── bufale │ │ ├── att │ │ │ ├── bufale.cpp │ │ │ ├── grader.cpp │ │ │ ├── bufale.c │ │ │ ├── bufale.pas │ │ │ └── grader.pas │ │ ├── sol │ │ │ ├── grader.c │ │ │ ├── grader.cpp │ │ │ ├── grader.pas │ │ │ ├── template_c.c │ │ │ ├── template_cpp.cpp │ │ │ ├── template_pas.pas │ │ │ ├── nlogn.cpp │ │ │ └── soluzione.cpp │ │ └── task.yaml │ ├── spiedini │ │ ├── att │ │ │ ├── grader.cpp │ │ │ ├── spiedini.cpp │ │ │ ├── spiedini.c │ │ │ ├── spiedini.pas │ │ │ └── grader.pas │ │ ├── sol │ │ │ ├── grader.c │ │ │ ├── grader.cpp │ │ │ ├── grader.pas │ │ │ ├── template_c.c │ │ │ ├── template_cpp.cpp │ │ │ └── template_pas.pas │ │ ├── task.yaml │ │ └── testo │ │ │ └── spiedino.png │ └── contest.yaml └── territoriali │ ├── trovaparola │ ├── gen │ │ ├── limiti.py │ │ ├── valida.sh │ │ └── GEN │ ├── task.yaml │ └── testo │ │ ├── image00.png │ │ ├── image02.png │ │ └── esempio.txt │ ├── brisbane │ ├── gen │ │ ├── graph.py │ │ ├── valida.sh │ │ ├── limiti.py │ │ └── GEN │ ├── testo │ │ ├── esempio.txt │ │ └── image01.jpg │ └── task.yaml │ └── gardaland │ ├── gen │ ├── valida.sh │ ├── limiti.py │ └── GEN │ ├── testo │ └── esempio.txt │ └── task.yaml ├── 2015 ├── nazionali │ ├── accensione │ │ ├── att │ │ │ ├── grader.cpp │ │ │ ├── accensione.cpp │ │ │ ├── accensione.c │ │ │ └── accensione.pas │ │ ├── sol │ │ │ ├── grader.c │ │ │ ├── grader.cpp │ │ │ ├── grader.pas │ │ │ ├── soluzione.cpp │ │ │ ├── template_c.c │ │ │ ├── template_cpp.cpp │ │ │ └── template_pas.pas │ │ ├── gen │ │ │ └── limiti.py │ │ ├── task.yaml │ │ └── testo │ │ │ └── sol_accensione_NlogN_lista.cpp │ ├── bottleneck │ │ ├── att │ │ │ ├── grader.cpp │ │ │ ├── bottleneck.cpp │ │ │ ├── bottleneck.c │ │ │ └── bottleneck.pas │ │ ├── sol │ │ │ ├── grader.c │ │ │ ├── grader.cpp │ │ │ ├── grader.pas │ │ │ ├── soluzione.cpp │ │ │ ├── template_c.c │ │ │ ├── template_cpp.cpp │ │ │ ├── template_pas.pas │ │ │ └── euristica_alice2.cpp │ │ ├── gen │ │ │ ├── graph.py │ │ │ ├── varie.py │ │ │ └── limiti.py │ │ └── task.yaml │ ├── taglialegna │ │ ├── att │ │ │ ├── grader.cpp │ │ │ ├── taglialegna.cpp │ │ │ ├── taglialegna.c │ │ │ ├── taglialegna.pas │ │ │ ├── grader.pas │ │ │ └── taglialegnalib.pas │ │ ├── sol │ │ │ ├── grader.c │ │ │ ├── grader.cpp │ │ │ ├── grader.pas │ │ │ ├── soluzione.cpp │ │ │ ├── template_c.c │ │ │ ├── template_cpp.cpp │ │ │ ├── template_pas.pas │ │ │ └── taglialegnalib.pas │ │ ├── cor │ │ │ └── correttore.cpp │ │ ├── gen │ │ │ ├── varie.py │ │ │ └── limiti.py │ │ ├── task.yaml │ │ └── testo │ │ │ └── aux │ │ │ ├── sol_taglialegna_quadratica_lep.cpp │ │ │ ├── sol_taglialegna_quadratica_rep.cpp │ │ │ ├── sol_taglialegna_lineare_rep.cpp │ │ │ └── sol_taglialegna_lineare_lep.cpp │ └── contest.yaml └── territoriali │ ├── collatz │ ├── gen │ │ ├── varie.py │ │ ├── limiti.py │ │ └── GEN │ └── task.yaml │ ├── mojito │ ├── gen │ │ ├── varie.py │ │ ├── limiti.py │ │ └── GEN │ ├── testo │ │ ├── mojito.png │ │ └── image00.jpg │ └── task.yaml │ └── sommelier │ ├── gen │ ├── varie.py │ ├── limiti.py │ └── GEN │ ├── testo │ └── image01.jpg │ └── task.yaml ├── 2016 ├── nazionali │ ├── nemesi │ │ ├── att │ │ │ ├── nemesi.c │ │ │ ├── input.txt │ │ │ ├── output.txt │ │ │ ├── nemesi.cpp │ │ │ └── nemesi.pas │ │ ├── sol │ │ │ ├── template_cpp.cpp │ │ │ ├── template_c.c │ │ │ └── template_pas.pas │ │ ├── testo │ │ │ ├── nemesi.input0.txt │ │ │ ├── nemesi.input1.txt │ │ │ ├── nemesi.output0.txt │ │ │ └── nemesi.output1.txt │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ ├── aeroporto │ │ ├── att │ │ │ ├── input.txt │ │ │ ├── aeroporto.c │ │ │ ├── output.txt │ │ │ ├── aeroporto.cpp │ │ │ └── aeroporto.pas │ │ ├── sol │ │ │ ├── template_cpp.cpp │ │ │ ├── template_c.c │ │ │ ├── fini.cpp │ │ │ ├── inizi.cpp │ │ │ ├── template_pas.pas │ │ │ └── matteo_nt.cpp │ │ ├── testo │ │ │ ├── aeroporto.output0.txt │ │ │ ├── aeroporto.output1.txt │ │ │ ├── aeroporto.input0.txt │ │ │ ├── aeroporto.input1.txt │ │ │ └── extra_aeroporto │ │ │ │ └── asy │ │ │ │ ├── plane.svg │ │ │ │ ├── fig1.asy │ │ │ │ └── fig2.asy │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ ├── paletta │ │ ├── att │ │ │ ├── input.txt │ │ │ ├── output.txt │ │ │ ├── paletta.c │ │ │ ├── paletta.cpp │ │ │ └── paletta.pas │ │ ├── sol │ │ │ ├── template_cpp.cpp │ │ │ ├── template_c.c │ │ │ ├── feasibility.cpp │ │ │ ├── template_pas.pas │ │ │ └── paletta.pas │ │ ├── testo │ │ │ ├── paletta.output0.txt │ │ │ ├── paletta.output1.txt │ │ │ ├── paletta.input0.txt │ │ │ └── paletta.input1.txt │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ └── contest.yaml └── territoriali │ ├── footing │ ├── gen │ │ ├── graph.py │ │ ├── limiti.py │ │ └── GEN │ ├── testo │ │ └── footing0.txt │ └── task.yaml │ ├── semiprimo │ ├── gen │ │ ├── generatore.sh │ │ ├── limiti.py │ │ ├── valida.sh │ │ └── GEN │ ├── testo │ │ └── semiprimo0.txt │ └── task.yaml │ └── disuguaglianze │ ├── gen │ ├── limiti.py │ └── GEN │ ├── testo │ └── disuguaglianze0.txt │ └── task.yaml ├── 2017 ├── nazionali │ ├── classifica │ │ ├── att │ │ │ ├── input.txt │ │ │ ├── output.txt │ │ │ ├── classifica.c │ │ │ └── classifica.cpp │ │ ├── gen │ │ │ ├── graph.py │ │ │ ├── varie.py │ │ │ └── limiti.py │ │ ├── testo │ │ │ ├── classifica.output0.txt │ │ │ ├── classifica.output_sol.txt │ │ │ ├── classifica.output1.txt │ │ │ ├── logo.png │ │ │ ├── classifica.input_sol.txt │ │ │ ├── classifica.input0.txt │ │ │ ├── classifica.input1.txt │ │ │ └── immagini_classifica │ │ │ │ └── albero.ggb │ │ ├── task.yaml │ │ ├── sol │ │ │ ├── template_c.c │ │ │ └── template_cpp.cpp │ │ └── gradergen │ │ │ ├── include_grader.c │ │ │ └── include_grader.cpp │ ├── hogwarts │ │ ├── att │ │ │ ├── input.txt │ │ │ ├── output.txt │ │ │ ├── hogwarts.c │ │ │ ├── hogwarts.cpp │ │ │ └── hogwarts.pas │ │ ├── gen │ │ │ ├── graph.py │ │ │ ├── varie.py │ │ │ └── limiti.py │ │ ├── testo │ │ │ ├── hogwarts.output0.txt │ │ │ ├── hogwarts.output1.txt │ │ │ ├── logo.png │ │ │ ├── hogwarts.input1.txt │ │ │ ├── hogwarts.input0.txt │ │ │ └── asy_hogwarts │ │ │ │ └── harry.png │ │ ├── sol │ │ │ ├── template_c.c │ │ │ ├── template_cpp.cpp │ │ │ └── template_pascal.pas │ │ └── task.yaml │ ├── lungomare │ │ ├── sol │ │ │ ├── soluzione.cpp │ │ │ ├── nessuna_spiaggia.cpp │ │ │ ├── template_c.c │ │ │ ├── template_cpp.cpp │ │ │ └── template_pascal.pas │ │ ├── testo │ │ │ ├── lungomare.output0.txt │ │ │ ├── lungomare.output1.txt │ │ │ ├── logo.png │ │ │ ├── lungomare.input0.txt │ │ │ ├── lungomare.input1.txt │ │ │ └── asy_lungomare │ │ │ │ ├── ring.png │ │ │ │ └── hotel.png │ │ ├── gen │ │ │ └── limiti.py │ │ ├── task.yaml │ │ └── att │ │ │ ├── lungomare.c │ │ │ ├── lungomare.cpp │ │ │ └── lungomare.pas │ └── contest.yaml └── territoriali │ ├── discesa │ ├── testo │ │ ├── discesa.output0.txt │ │ ├── discesa.output1.txt │ │ ├── discesa.input0.txt │ │ └── discesa.input1.txt │ ├── task.yaml │ └── gen │ │ ├── GEN │ │ ├── generatore.py │ │ └── valida.py │ ├── spartizione │ ├── gen │ │ ├── generatore.sh │ │ ├── limiti.py │ │ └── GEN │ ├── testo │ │ ├── spartizione.input0.txt │ │ ├── spartizione.input1.txt │ │ ├── spartizione.output0.txt │ │ └── spartizione.output1.txt │ └── task.yaml │ └── sentieri │ ├── testo │ ├── sentieri.output0.txt │ ├── sentieri.output1.txt │ ├── sentieri.input0.txt │ ├── sentieri.input1.txt │ └── extra │ │ └── fig-sentieri.graffle │ │ └── image1.png │ ├── gen │ ├── limiti.py │ └── GEN │ └── task.yaml ├── 2018 ├── territoriali │ ├── lwf │ │ ├── testo │ │ │ ├── lwf.input1.txt │ │ │ ├── lwf.input0.txt │ │ │ ├── lwf.output1.txt │ │ │ ├── lwf.output0.txt │ │ │ └── logo.png │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ ├── limiti.py │ │ │ └── GEN │ │ └── task.yaml │ ├── scommessa │ │ ├── sol │ │ │ └── soluzione.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ ├── testo │ │ │ ├── scommessa.input0.txt │ │ │ ├── scommessa.output0.txt │ │ │ ├── logo.png │ │ │ ├── scommessa.output1.txt │ │ │ └── scommessa.input1.txt │ │ └── task.yaml │ └── tecla │ │ ├── gen │ │ ├── graph.py │ │ ├── limiti.py │ │ └── GEN │ │ ├── testo │ │ ├── logo.png │ │ ├── oddcycle.output0.txt │ │ ├── oddcycle.output1.txt │ │ ├── oddcycle.input0.txt │ │ └── oddcycle.input1.txt │ │ └── task.yaml ├── nazionali │ ├── caduta │ │ ├── att │ │ │ ├── grader.cpp │ │ │ ├── caduta.c │ │ │ ├── input.txt │ │ │ ├── output.txt │ │ │ └── caduta.cpp │ │ ├── sol │ │ │ ├── grader.cpp │ │ │ ├── luca_ottima.cpp │ │ │ ├── soluzione.cpp │ │ │ ├── template_cpp.cpp │ │ │ ├── bogus_scambia_0_0.cpp │ │ │ ├── bogus_scambia_0_1.cpp │ │ │ └── bogus_scambia_0_N.cpp │ │ ├── testo │ │ │ ├── testo.pdf │ │ │ ├── caduta.output1.txt │ │ │ ├── caduta.output0.txt │ │ │ ├── caduta.output2.txt │ │ │ ├── caduta.input0.txt │ │ │ ├── caduta.input1.txt │ │ │ ├── caduta.input2.txt │ │ │ ├── domino.png │ │ │ └── asy_caduta │ │ │ │ ├── fig1.asy │ │ │ │ ├── fig2.asy │ │ │ │ └── fig3.asy │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ ├── corteo │ │ ├── att │ │ │ ├── grader.cpp │ │ │ ├── corteo.c │ │ │ ├── input.txt │ │ │ ├── output.txt │ │ │ └── corteo.cpp │ │ ├── sol │ │ │ ├── grader.cpp │ │ │ ├── soluzione.cpp │ │ │ ├── template_cpp.cpp │ │ │ ├── mangiapunti_triste.cpp │ │ │ └── template_c.c │ │ ├── testo │ │ │ ├── testo.pdf │ │ │ ├── corteo.output0.txt │ │ │ ├── corteo.input1.txt │ │ │ ├── corteo.output1.txt │ │ │ ├── asy_corteo │ │ │ │ ├── tab.png │ │ │ │ ├── spazi.png │ │ │ │ ├── fig1.asy │ │ │ │ ├── fig2.asy │ │ │ │ ├── fig3.asy │ │ │ │ ├── fig4.asy │ │ │ │ ├── fig5.asy │ │ │ │ └── fig6.asy │ │ │ └── corteo.input0.txt │ │ ├── cor │ │ │ └── correttore.cpp │ │ ├── gen │ │ │ ├── graph.py │ │ │ └── limiti.py │ │ └── task.yaml │ └── specchi │ │ ├── att │ │ ├── grader.cpp │ │ ├── specchi.c │ │ ├── input.txt │ │ ├── specchi.cpp │ │ └── output.txt │ │ ├── sol │ │ ├── grader.cpp │ │ ├── soluzione.cpp │ │ ├── template_cpp.cpp │ │ ├── smart_vector_fast.hpp │ │ ├── smart_vector_slow.hpp │ │ └── smart_vector_very_slow.hpp │ │ ├── testo │ │ ├── testo.pdf │ │ ├── specchi.output0.txt │ │ ├── specchi.output1.txt │ │ ├── specchi.input0.txt │ │ ├── specchi.input1.txt │ │ └── asy_specchi │ │ │ ├── fig6.asy │ │ │ ├── fig7.asy │ │ │ ├── fig8.asy │ │ │ ├── fig1.asy │ │ │ ├── fig3.asy │ │ │ ├── fig4.asy │ │ │ ├── fig5.asy │ │ │ └── fig2.asy │ │ ├── task.yaml │ │ ├── gen │ │ └── limiti.py │ │ └── visualizzatore │ │ └── css │ │ └── app.css └── territoriali-remastered │ ├── lwf │ ├── managers │ │ ├── limits.py │ │ └── validator.py │ ├── solutions │ │ ├── crash.c │ │ └── gibberish.c │ └── task.yaml │ ├── scommessa │ ├── managers │ │ ├── limits.py │ │ └── validator.py │ ├── solutions │ │ ├── crash.c │ │ └── gibberish.c │ └── task.yaml │ └── tecla │ ├── managers │ └── limits.py │ ├── solutions │ ├── crash.c │ └── gibberish.c │ ├── task.yaml │ └── statement │ ├── fig1.png │ └── fig2.png ├── 2019 ├── nazionali │ ├── cena │ │ ├── .gitignore │ │ ├── sol │ │ │ ├── soluzione.cpp │ │ │ ├── template.cpp │ │ │ ├── zero.cpp │ │ │ ├── quadratica.cpp │ │ │ └── tutti_uguali.cpp │ │ ├── testo │ │ │ ├── cena.output0.txt │ │ │ ├── cena.output1.txt │ │ │ ├── logo2018.png │ │ │ ├── cena.input0.txt │ │ │ └── cena.input1.txt │ │ ├── att │ │ │ ├── cena.cpp │ │ │ ├── grader.cpp │ │ │ ├── cena.input0.txt │ │ │ ├── cena.input1.txt │ │ │ ├── cena.output0.txt │ │ │ └── cena.output1.txt │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ ├── circuiti │ │ ├── gen │ │ │ ├── valida.sh │ │ │ └── generatore.sh │ │ ├── testo │ │ │ ├── logo2018.png │ │ │ ├── circuiti.input0.txt │ │ │ ├── circuiti.input1.txt │ │ │ ├── circuiti.input2.txt │ │ │ ├── circuiti.output0.txt │ │ │ ├── circuiti.output1.txt │ │ │ ├── asy_circuiti │ │ │ │ └── visualizzatore.png │ │ │ ├── circuiti.statement.txt │ │ │ └── circuiti.output2.txt │ │ ├── att │ │ │ ├── input.txt │ │ │ └── output.txt │ │ ├── task.yaml │ │ └── cor │ │ │ └── sparsepp │ │ │ └── spp_stdint.h │ ├── incendio │ │ ├── att │ │ │ ├── grader.c │ │ │ ├── grader.cpp │ │ │ ├── incendio.c │ │ │ ├── template.c │ │ │ ├── incendio.cpp │ │ │ ├── template.cpp │ │ │ ├── incendio.input0.txt │ │ │ ├── incendio.input1.txt │ │ │ ├── incendio.output0.txt │ │ │ └── incendio.output1.txt │ │ ├── sol │ │ │ ├── soluzione.cpp │ │ │ ├── template.cpp │ │ │ ├── template.c │ │ │ ├── uno.cpp │ │ │ ├── grader.c │ │ │ └── grader.cpp │ │ ├── testo │ │ │ ├── incendio.output0.txt │ │ │ ├── incendio.output1.txt │ │ │ ├── logo2018.png │ │ │ ├── incendio.input0.txt │ │ │ ├── incendio.input1.txt │ │ │ └── asy_incendio │ │ │ │ ├── fire.png │ │ │ │ ├── fire2.png │ │ │ │ ├── hotel.png │ │ │ │ └── school.png │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ └── logo.png └── territoriali │ ├── party │ ├── solutions │ │ ├── party.c │ │ ├── party.cpp │ │ ├── party.pas │ │ ├── somma_tutto.cpp │ │ ├── solo_zero.cpp │ │ └── solution.cpp │ ├── statement │ │ ├── party_output_example.txt │ │ ├── party_input_example.txt │ │ └── party.jpg │ ├── managers │ │ ├── limits.py │ │ └── validator.py │ └── task.yaml │ ├── antivirus │ ├── solutions │ │ ├── antivirus.c │ │ ├── antivirus.cpp │ │ ├── antivirus.pas │ │ └── invalid_pos.cpp │ ├── statement │ │ ├── antivirus_output_example.txt │ │ ├── virus.jpg │ │ └── antivirus_input_example.txt │ ├── managers │ │ └── limits.py │ └── task.yaml │ ├── xray │ ├── managers │ │ └── limits.py │ ├── statement │ │ ├── xray_output_example.txt │ │ ├── xray_input_example.txt │ │ └── xray.png │ └── task.yaml │ └── escursione │ ├── managers │ └── limits.py │ ├── solutions │ ├── crash.c │ └── gibberish.c │ ├── statement │ ├── escursione_output_example.txt │ ├── map.jpg │ └── escursione_input_example.txt │ └── task.yaml ├── 2020 ├── nazionali │ ├── pangramma │ │ ├── testo │ │ │ ├── pangramma.output0.txt │ │ │ ├── pangramma.output1.txt │ │ │ ├── pangramma.output2.txt │ │ │ ├── logo2019.png │ │ │ ├── pangramma.output3.txt │ │ │ ├── pangramma.input0.txt │ │ │ ├── pangramma.input1.txt │ │ │ ├── pangramma.input2.txt │ │ │ ├── pangramma.input3.txt │ │ │ └── pangram.pdf │ │ ├── att │ │ │ ├── pangramma.c │ │ │ ├── pangramma.cpp │ │ │ ├── pangramma.input0.txt │ │ │ ├── pangramma.input1.txt │ │ │ ├── pangramma.input2.txt │ │ │ ├── pangramma.input3.txt │ │ │ ├── pangramma.output0.txt │ │ │ ├── pangramma.output1.txt │ │ │ ├── pangramma.output2.txt │ │ │ └── pangramma.output3.txt │ │ ├── sol │ │ │ ├── soluzione.cpp │ │ │ ├── template_c.c │ │ │ ├── template_cpp.cpp │ │ │ └── ostuni_01.cpp │ │ └── task.yaml │ ├── grattacieli │ │ ├── att │ │ │ ├── grader.c │ │ │ ├── grader.cpp │ │ │ ├── grattacieli.c │ │ │ ├── grattacieli.cpp │ │ │ ├── grattacieli.input0.txt │ │ │ ├── grattacieli.input1.txt │ │ │ ├── grattacieli.input2.txt │ │ │ ├── grattacieli.output0.txt │ │ │ ├── grattacieli.output1.txt │ │ │ └── grattacieli.output2.txt │ │ ├── testo │ │ │ ├── grattacieli.output0.txt │ │ │ ├── grattacieli.output1.txt │ │ │ ├── grattacieli.output2.txt │ │ │ ├── logo2019.png │ │ │ ├── asy_grattacieli │ │ │ │ ├── fig1a.asy │ │ │ │ ├── fig1b.asy │ │ │ │ ├── fig1c.asy │ │ │ │ ├── fig2.asy │ │ │ │ └── fig3.asy │ │ │ ├── grattacieli.input0.txt │ │ │ ├── grattacieli.input1.txt │ │ │ └── grattacieli.input2.txt │ │ ├── sol │ │ │ ├── soluzione.cpp │ │ │ ├── template_c.c │ │ │ └── template_cpp.cpp │ │ ├── gen │ │ │ ├── graph.py │ │ │ └── limiti.py │ │ └── task.yaml │ ├── orticoltura │ │ ├── att │ │ │ ├── grader.c │ │ │ ├── grader.cpp │ │ │ ├── orticoltura.c │ │ │ ├── orticoltura.cpp │ │ │ ├── orticoltura.input0.txt │ │ │ ├── orticoltura.input1.txt │ │ │ ├── orticoltura.output0.txt │ │ │ └── orticoltura.output1.txt │ │ ├── testo │ │ │ ├── logo2019.png │ │ │ ├── orticoltura.input1.txt │ │ │ ├── orticoltura.output1.txt │ │ │ ├── orticoltura.output0.txt │ │ │ ├── orticoltura.input0.txt │ │ │ └── asy_orticoltura │ │ │ │ ├── irr.png │ │ │ │ ├── cash.png │ │ │ │ ├── dirt.jpg │ │ │ │ ├── grass.jpg │ │ │ │ ├── seed.jpg │ │ │ │ ├── seed2.png │ │ │ │ ├── fig2.asy │ │ │ │ ├── fig0.asy │ │ │ │ └── fig1.asy │ │ ├── sol │ │ │ ├── soluzione.cpp │ │ │ ├── template_c.c │ │ │ └── template_cpp.cpp │ │ ├── gen │ │ │ └── limiti.py │ │ └── task.yaml │ └── logo.png └── territoriali │ ├── download │ ├── managers │ │ ├── limits.py │ │ └── validator.py │ ├── solutions │ │ ├── template.c │ │ ├── template.cpp │ │ ├── template.pas │ │ ├── sbagliata_donadoni.cpp │ │ ├── ottima_petrillo.cpp │ │ └── ottima_ostuni.cpp │ ├── statement │ │ ├── download_output_example.txt │ │ ├── download_input_example.txt │ │ └── download.jpg │ └── task.yaml │ ├── gerarchie │ ├── managers │ │ ├── limits.py │ │ └── graph.py │ ├── solutions │ │ ├── template.c │ │ ├── template.cpp │ │ ├── template.pas │ │ ├── ottima_donadoni │ │ └── write_zero.py │ ├── statement │ │ ├── gerarchie_output_example.txt │ │ ├── hierarchy.png │ │ ├── asy_gerarchie │ │ │ ├── fig1.png │ │ │ └── fig2.png │ │ └── gerarchie_input_example.txt │ └── task.yaml │ ├── multicore │ ├── solutions │ │ ├── template.c │ │ ├── template.cpp │ │ └── template.pas │ ├── managers │ │ ├── solution.cpp │ │ └── limits.py │ ├── statement │ │ ├── multicore_output_example.txt │ │ ├── multicore.jpg │ │ └── multicore_input_example.txt │ └── task.yaml │ └── tornello │ ├── managers │ ├── limits.py │ └── validator.py │ ├── solutions │ ├── template.c │ └── template.pas │ ├── statement │ ├── tornello_output_example.txt │ ├── tornello.jpg │ └── tornello_input_example.txt │ └── task.yaml ├── util └── smart_vector │ └── .syntastic_cpp_config ├── .gitignore └── .travis.yml /2019/nazionali/cena/.gitignore: -------------------------------------------------------------------------------- 1 | GEN 2 | -------------------------------------------------------------------------------- /2014/nazionali/maree/att/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2014/nazionali/maree/att/maree.cpp: -------------------------------------------------------------------------------- 1 | maree.c -------------------------------------------------------------------------------- /2018/territoriali/lwf/testo/lwf.input1.txt: -------------------------------------------------------------------------------- 1 | 9 -------------------------------------------------------------------------------- /2019/nazionali/cena/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | SA.cpp -------------------------------------------------------------------------------- /2005/territoriali/sunny/sol/soluzione.c: -------------------------------------------------------------------------------- 1 | sunny.c -------------------------------------------------------------------------------- /2008/nazionali/parole/testo/output0.txt: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /2008/nazionali/triade/testo/output0.txt: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /2009/territoriali/depura/gen/generatore.py: -------------------------------------------------------------------------------- 1 | gen.py -------------------------------------------------------------------------------- /2010/nazionali/amici/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol.cpp -------------------------------------------------------------------------------- /2010/nazionali/numeri/gen/generatore.cpp: -------------------------------------------------------------------------------- 1 | gen.cpp -------------------------------------------------------------------------------- /2011/nazionali/baht/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_ste.cpp -------------------------------------------------------------------------------- /2011/nazionali/fuga/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_gio.cpp -------------------------------------------------------------------------------- /2011/nazionali/salti/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol.cpp -------------------------------------------------------------------------------- /2012/nazionali/salta/gen/generatore.py: -------------------------------------------------------------------------------- 1 | gen.py -------------------------------------------------------------------------------- /2014/nazionali/bufale/att/bufale.cpp: -------------------------------------------------------------------------------- 1 | bufale.c -------------------------------------------------------------------------------- /2014/nazionali/bufale/att/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2014/nazionali/maree/sol/grader.c: -------------------------------------------------------------------------------- 1 | ../att/grader.c -------------------------------------------------------------------------------- /2014/nazionali/spiedini/att/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2015/nazionali/accensione/att/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/att/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2018/nazionali/caduta/att/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2018/nazionali/caduta/sol/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/testo.pdf: -------------------------------------------------------------------------------- 1 | italian.pdf -------------------------------------------------------------------------------- /2018/nazionali/corteo/att/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2018/nazionali/corteo/sol/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/testo.pdf: -------------------------------------------------------------------------------- 1 | italian.pdf -------------------------------------------------------------------------------- /2018/nazionali/specchi/att/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2018/nazionali/specchi/sol/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2018/territoriali/lwf/testo/lwf.input0.txt: -------------------------------------------------------------------------------- 1 | 19 -------------------------------------------------------------------------------- /2018/territoriali/lwf/testo/lwf.output1.txt: -------------------------------------------------------------------------------- 1 | 11101 -------------------------------------------------------------------------------- /2019/nazionali/cena/testo/cena.output0.txt: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /2019/nazionali/cena/testo/cena.output1.txt: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /2019/nazionali/circuiti/gen/valida.sh: -------------------------------------------------------------------------------- 1 | /bin/true -------------------------------------------------------------------------------- /2008/nazionali/cnn/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | solve-quad.cpp -------------------------------------------------------------------------------- /2008/nazionali/parole/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_veloce.cpp -------------------------------------------------------------------------------- /2008/nazionali/parole/testo/input0.txt: -------------------------------------------------------------------------------- 1 | 2 4 2 | 01 3 | -------------------------------------------------------------------------------- /2008/nazionali/triade/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | triade.cpp -------------------------------------------------------------------------------- /2009/territoriali/depura/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_ste.cpp -------------------------------------------------------------------------------- /2009/territoriali/treno/gen/generatore.sh: -------------------------------------------------------------------------------- 1 | /bin/echo -------------------------------------------------------------------------------- /2009/territoriali/treno/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | treno.cpp -------------------------------------------------------------------------------- /2010/nazionali/numeri/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol-gio.cpp -------------------------------------------------------------------------------- /2010/nazionali/pesca/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_mau.cpp -------------------------------------------------------------------------------- /2011/nazionali/salti/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 2**30 2 | -------------------------------------------------------------------------------- /2011/nazionali/scuola/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 2100 2 | -------------------------------------------------------------------------------- /2011/nazionali/scuola/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_gio.cpp -------------------------------------------------------------------------------- /2012/nazionali/eso/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_giovanni.cpp -------------------------------------------------------------------------------- /2012/nazionali/fibstr/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_nlogn.cpp -------------------------------------------------------------------------------- /2012/nazionali/salta/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_giove.cpp -------------------------------------------------------------------------------- /2012/territoriali/domino/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 10 2 | -------------------------------------------------------------------------------- /2012/territoriali/domino/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_ste.cpp -------------------------------------------------------------------------------- /2012/territoriali/nanga/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_ste.cpp -------------------------------------------------------------------------------- /2013/nazionali/convoglio/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | versari.cpp -------------------------------------------------------------------------------- /2013/nazionali/fermata/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | versari.cpp -------------------------------------------------------------------------------- /2013/nazionali/fontane/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | wehrstedt.cpp -------------------------------------------------------------------------------- /2013/territoriali/turni/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_ste.cpp -------------------------------------------------------------------------------- /2014/nazionali/bufale/sol/grader.c: -------------------------------------------------------------------------------- 1 | ../att/grader.c -------------------------------------------------------------------------------- /2014/nazionali/bufale/sol/grader.cpp: -------------------------------------------------------------------------------- 1 | ../att/grader.cpp -------------------------------------------------------------------------------- /2014/nazionali/bufale/sol/grader.pas: -------------------------------------------------------------------------------- 1 | ../att/grader.pas -------------------------------------------------------------------------------- /2014/nazionali/bufale/sol/template_c.c: -------------------------------------------------------------------------------- 1 | ../att/bufale.c -------------------------------------------------------------------------------- /2014/nazionali/maree/gen/graph.h: -------------------------------------------------------------------------------- 1 | ../../../../graph.h -------------------------------------------------------------------------------- /2014/nazionali/maree/sol/grader.cpp: -------------------------------------------------------------------------------- 1 | ../att/grader.cpp -------------------------------------------------------------------------------- /2014/nazionali/maree/sol/grader.pas: -------------------------------------------------------------------------------- 1 | ../att/grader.pas -------------------------------------------------------------------------------- /2014/nazionali/maree/sol/template_c.c: -------------------------------------------------------------------------------- 1 | ../att/maree.c -------------------------------------------------------------------------------- /2014/nazionali/spiedini/att/spiedini.cpp: -------------------------------------------------------------------------------- 1 | spiedini.c -------------------------------------------------------------------------------- /2014/nazionali/spiedini/sol/grader.c: -------------------------------------------------------------------------------- 1 | ../att/grader.c -------------------------------------------------------------------------------- /2015/nazionali/accensione/sol/grader.c: -------------------------------------------------------------------------------- 1 | ../att/grader.c -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/sol/grader.c: -------------------------------------------------------------------------------- 1 | ../att/grader.c -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/att/grader.cpp: -------------------------------------------------------------------------------- 1 | grader.c -------------------------------------------------------------------------------- /2016/nazionali/nemesi/att/nemesi.c: -------------------------------------------------------------------------------- 1 | ../sol/template_c.c -------------------------------------------------------------------------------- /2018/nazionali/caduta/att/caduta.c: -------------------------------------------------------------------------------- 1 | ../sol/template_c.c -------------------------------------------------------------------------------- /2018/nazionali/caduta/sol/luca_ottima.cpp: -------------------------------------------------------------------------------- 1 | ottima.cpp -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/caduta.output1.txt: -------------------------------------------------------------------------------- 1 | OK 2 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/att/corteo.c: -------------------------------------------------------------------------------- 1 | ../sol/template_c.c -------------------------------------------------------------------------------- /2018/nazionali/corteo/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | ottima.cpp -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/corteo.output0.txt: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/testo.pdf: -------------------------------------------------------------------------------- 1 | italian.pdf -------------------------------------------------------------------------------- /2018/territoriali/lwf/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | edoardo.cpp -------------------------------------------------------------------------------- /2018/territoriali/lwf/testo/lwf.output0.txt: -------------------------------------------------------------------------------- 1 | 1011001 -------------------------------------------------------------------------------- /2019/nazionali/cena/att/cena.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template.cpp -------------------------------------------------------------------------------- /2019/nazionali/cena/att/grader.cpp: -------------------------------------------------------------------------------- 1 | ../sol/grader.cpp -------------------------------------------------------------------------------- /2019/nazionali/cena/testo/logo2018.png: -------------------------------------------------------------------------------- 1 | ../../logo.png -------------------------------------------------------------------------------- /2019/nazionali/circuiti/gen/generatore.sh: -------------------------------------------------------------------------------- 1 | /bin/echo -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/grader.c: -------------------------------------------------------------------------------- 1 | ../sol/grader.c -------------------------------------------------------------------------------- /2019/nazionali/incendio/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | M2_M.cpp -------------------------------------------------------------------------------- /2019/nazionali/incendio/sol/template.cpp: -------------------------------------------------------------------------------- 1 | template.c -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/pangramma.output0.txt: -------------------------------------------------------------------------------- 1 | 2 -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/pangramma.output1.txt: -------------------------------------------------------------------------------- 1 | 4 -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/pangramma.output2.txt: -------------------------------------------------------------------------------- 1 | 1 -------------------------------------------------------------------------------- /2008/nazionali/cnn/testo/output0.txt: -------------------------------------------------------------------------------- 1 | R 2 | R 3 | C 4 | -------------------------------------------------------------------------------- /2009/territoriali/essenza/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | essenza.cpp -------------------------------------------------------------------------------- /2011/territoriali/quasipal/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_matteo.cpp -------------------------------------------------------------------------------- /2011/territoriali/sbarramento/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 500 2 | -------------------------------------------------------------------------------- /2011/territoriali/sbarramento/sol/soluzione.c: -------------------------------------------------------------------------------- 1 | sol_gio.c -------------------------------------------------------------------------------- /2012/nazionali/fibstr/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000000 2 | -------------------------------------------------------------------------------- /2012/nazionali/matita/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_alessio.cpp -------------------------------------------------------------------------------- /2012/territoriali/galattici/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | sol_ste.cpp -------------------------------------------------------------------------------- /2013/territoriali/barbablu/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | audrito.cpp -------------------------------------------------------------------------------- /2013/territoriali/grandprix/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | audrito.cpp -------------------------------------------------------------------------------- /2014/nazionali/maree/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | ../att/maree.cpp -------------------------------------------------------------------------------- /2014/nazionali/maree/sol/template_pas.pas: -------------------------------------------------------------------------------- 1 | ../att/maree.pas -------------------------------------------------------------------------------- /2014/nazionali/spiedini/sol/grader.cpp: -------------------------------------------------------------------------------- 1 | ../att/grader.cpp -------------------------------------------------------------------------------- /2014/nazionali/spiedini/sol/grader.pas: -------------------------------------------------------------------------------- 1 | ../att/grader.pas -------------------------------------------------------------------------------- /2014/nazionali/spiedini/sol/template_c.c: -------------------------------------------------------------------------------- 1 | ../att/spiedini.c -------------------------------------------------------------------------------- /2014/territoriali/trovaparola/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAX = 100 2 | -------------------------------------------------------------------------------- /2015/nazionali/accensione/att/accensione.cpp: -------------------------------------------------------------------------------- 1 | accensione.c -------------------------------------------------------------------------------- /2015/nazionali/accensione/sol/grader.cpp: -------------------------------------------------------------------------------- 1 | ../att/grader.cpp -------------------------------------------------------------------------------- /2015/nazionali/accensione/sol/grader.pas: -------------------------------------------------------------------------------- 1 | ../att/grader.pas -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/att/bottleneck.cpp: -------------------------------------------------------------------------------- 1 | bottleneck.c -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/gen/graph.py: -------------------------------------------------------------------------------- 1 | ../../../../graph.py -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/gen/varie.py: -------------------------------------------------------------------------------- 1 | ../../../../varie.py -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/sol/grader.cpp: -------------------------------------------------------------------------------- 1 | ../att/grader.cpp -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/sol/grader.pas: -------------------------------------------------------------------------------- 1 | ../att/grader.pas -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | doppia_bfs.cpp -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/sol/grader.c: -------------------------------------------------------------------------------- 1 | ../att/grader.c -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/sol/grader.cpp: -------------------------------------------------------------------------------- 1 | ../att/grader.cpp -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/sol/grader.pas: -------------------------------------------------------------------------------- 1 | ../att/grader.pas -------------------------------------------------------------------------------- /2015/territoriali/collatz/gen/varie.py: -------------------------------------------------------------------------------- 1 | ../../../../varie.py -------------------------------------------------------------------------------- /2015/territoriali/mojito/gen/varie.py: -------------------------------------------------------------------------------- 1 | ../../../../varie.py -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/att/input.txt: -------------------------------------------------------------------------------- 1 | ../input/input0.txt -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | template_c.c -------------------------------------------------------------------------------- /2016/nazionali/nemesi/att/input.txt: -------------------------------------------------------------------------------- 1 | ../input/input0.txt -------------------------------------------------------------------------------- /2016/nazionali/nemesi/att/output.txt: -------------------------------------------------------------------------------- 1 | ../output/output0.txt -------------------------------------------------------------------------------- /2016/nazionali/nemesi/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | template_c.c -------------------------------------------------------------------------------- /2016/nazionali/paletta/att/input.txt: -------------------------------------------------------------------------------- 1 | ../input/input0.txt -------------------------------------------------------------------------------- /2016/nazionali/paletta/att/output.txt: -------------------------------------------------------------------------------- 1 | ../output/output0.txt -------------------------------------------------------------------------------- /2016/nazionali/paletta/att/paletta.c: -------------------------------------------------------------------------------- 1 | ../sol/template_c.c -------------------------------------------------------------------------------- /2016/nazionali/paletta/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | template_c.c -------------------------------------------------------------------------------- /2016/nazionali/paletta/testo/paletta.output0.txt: -------------------------------------------------------------------------------- 1 | -1 2 | -------------------------------------------------------------------------------- /2016/nazionali/paletta/testo/paletta.output1.txt: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /2016/territoriali/footing/gen/graph.py: -------------------------------------------------------------------------------- 1 | ../../../../graph.py -------------------------------------------------------------------------------- /2016/territoriali/semiprimo/gen/generatore.sh: -------------------------------------------------------------------------------- 1 | /bin/echo -------------------------------------------------------------------------------- /2016/territoriali/semiprimo/testo/semiprimo0.txt: -------------------------------------------------------------------------------- 1 | 961 2 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/att/input.txt: -------------------------------------------------------------------------------- 1 | ../input/input0.txt -------------------------------------------------------------------------------- /2017/nazionali/classifica/gen/graph.py: -------------------------------------------------------------------------------- 1 | ../../../../graph.py -------------------------------------------------------------------------------- /2017/nazionali/classifica/gen/varie.py: -------------------------------------------------------------------------------- 1 | ../../../../varie.py -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/att/input.txt: -------------------------------------------------------------------------------- 1 | ../input/input0.txt -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/gen/graph.py: -------------------------------------------------------------------------------- 1 | ../../../../graph.py -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/gen/varie.py: -------------------------------------------------------------------------------- 1 | ../../../../varie.py -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/testo/hogwarts.output0.txt: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/testo/hogwarts.output1.txt: -------------------------------------------------------------------------------- 1 | -1 2 | -------------------------------------------------------------------------------- /2017/territoriali/discesa/testo/discesa.output0.txt: -------------------------------------------------------------------------------- 1 | 28 2 | -------------------------------------------------------------------------------- /2017/territoriali/spartizione/gen/generatore.sh: -------------------------------------------------------------------------------- 1 | /bin/echo -------------------------------------------------------------------------------- /2018/nazionali/caduta/att/input.txt: -------------------------------------------------------------------------------- 1 | ../input/input0.txt -------------------------------------------------------------------------------- /2018/nazionali/caduta/att/output.txt: -------------------------------------------------------------------------------- 1 | ../output/output0.txt -------------------------------------------------------------------------------- /2018/nazionali/caduta/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | ottima_giorgio.cpp -------------------------------------------------------------------------------- /2018/nazionali/caduta/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | template_c.c -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/caduta.output0.txt: -------------------------------------------------------------------------------- 1 | 2 3 2 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/att/input.txt: -------------------------------------------------------------------------------- 1 | ../input/input0.txt -------------------------------------------------------------------------------- /2018/nazionali/corteo/att/output.txt: -------------------------------------------------------------------------------- 1 | ../output/output0.txt -------------------------------------------------------------------------------- /2018/nazionali/corteo/cor/correttore.cpp: -------------------------------------------------------------------------------- 1 | correttore_ita.cpp -------------------------------------------------------------------------------- /2018/nazionali/corteo/gen/graph.py: -------------------------------------------------------------------------------- 1 | ../../../../graph.py -------------------------------------------------------------------------------- /2018/nazionali/corteo/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | template_c.c -------------------------------------------------------------------------------- /2018/nazionali/specchi/att/specchi.c: -------------------------------------------------------------------------------- 1 | ../sol/template_c.c -------------------------------------------------------------------------------- /2018/nazionali/specchi/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | smart_fast.cpp -------------------------------------------------------------------------------- /2018/nazionali/specchi/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | template_c.c -------------------------------------------------------------------------------- /2018/territoriali/lwf/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 10**6 2 | 3 | -------------------------------------------------------------------------------- /2018/territoriali/scommessa/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | edoardo.cpp -------------------------------------------------------------------------------- /2018/territoriali/tecla/gen/graph.py: -------------------------------------------------------------------------------- 1 | ../../../../graph.py -------------------------------------------------------------------------------- /2019/nazionali/circuiti/testo/logo2018.png: -------------------------------------------------------------------------------- 1 | ../../logo.png -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/grader.cpp: -------------------------------------------------------------------------------- 1 | ../sol/grader.cpp -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/incendio.c: -------------------------------------------------------------------------------- 1 | ../sol/template.c -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/template.c: -------------------------------------------------------------------------------- 1 | ../sol/template.c -------------------------------------------------------------------------------- /2019/nazionali/incendio/testo/incendio.output0.txt: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/testo/incendio.output1.txt: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/testo/logo2018.png: -------------------------------------------------------------------------------- 1 | ../../logo.png -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grader.c: -------------------------------------------------------------------------------- 1 | ../sol/grader.c -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grader.cpp: -------------------------------------------------------------------------------- 1 | ../sol/grader.cpp -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/att/grader.c: -------------------------------------------------------------------------------- 1 | ../sol/grader.c -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/att/grader.cpp: -------------------------------------------------------------------------------- 1 | ../sol/grader.cpp -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/logo2019.png: -------------------------------------------------------------------------------- 1 | ../../logo.png -------------------------------------------------------------------------------- /2011/territoriali/tamburello/sol/soluzione.c: -------------------------------------------------------------------------------- 1 | sol_gio_nlogd.c -------------------------------------------------------------------------------- /2013/territoriali/barbablu/gen/graph.py: -------------------------------------------------------------------------------- 1 | ../../../../graph.py -------------------------------------------------------------------------------- /2014/nazionali/bufale/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | ../att/bufale.cpp -------------------------------------------------------------------------------- /2014/nazionali/bufale/sol/template_pas.pas: -------------------------------------------------------------------------------- 1 | ../att/bufale.pas -------------------------------------------------------------------------------- /2014/nazionali/spiedini/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | ../att/spiedini.cpp -------------------------------------------------------------------------------- /2014/nazionali/spiedini/sol/template_pas.pas: -------------------------------------------------------------------------------- 1 | ../att/spiedini.pas -------------------------------------------------------------------------------- /2014/territoriali/brisbane/gen/graph.py: -------------------------------------------------------------------------------- 1 | ../../../../graph.py -------------------------------------------------------------------------------- /2015/nazionali/accensione/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | nlogn_implicita.cpp -------------------------------------------------------------------------------- /2015/nazionali/accensione/sol/template_c.c: -------------------------------------------------------------------------------- 1 | ../att/accensione.c -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/sol/template_c.c: -------------------------------------------------------------------------------- 1 | ../att/bottleneck.c -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/att/taglialegna.cpp: -------------------------------------------------------------------------------- 1 | taglialegna.c -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/cor/correttore.cpp: -------------------------------------------------------------------------------- 1 | corr_lineare.cpp -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/gen/varie.py: -------------------------------------------------------------------------------- 1 | ../../../../varie.py -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | lineare_nostack.cpp -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/sol/template_c.c: -------------------------------------------------------------------------------- 1 | ../att/taglialegna.c -------------------------------------------------------------------------------- /2015/territoriali/sommelier/gen/varie.py: -------------------------------------------------------------------------------- 1 | ../../../../varie.py -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/att/aeroporto.c: -------------------------------------------------------------------------------- 1 | ../sol/template_c.c -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/att/output.txt: -------------------------------------------------------------------------------- 1 | ../output/output0.txt -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/testo/aeroporto.output0.txt: -------------------------------------------------------------------------------- 1 | 3 6 8 2 | -------------------------------------------------------------------------------- /2016/nazionali/nemesi/att/nemesi.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template_cpp.cpp -------------------------------------------------------------------------------- /2016/nazionali/nemesi/att/nemesi.pas: -------------------------------------------------------------------------------- 1 | ../sol/template_pas.pas -------------------------------------------------------------------------------- /2016/nazionali/paletta/att/paletta.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template_cpp.cpp -------------------------------------------------------------------------------- /2016/nazionali/paletta/att/paletta.pas: -------------------------------------------------------------------------------- 1 | ../sol/template_pas.pas -------------------------------------------------------------------------------- /2016/territoriali/semiprimo/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXP = 1000000 2 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/att/output.txt: -------------------------------------------------------------------------------- 1 | ../output/output0.txt -------------------------------------------------------------------------------- /2017/nazionali/classifica/testo/classifica.output0.txt: -------------------------------------------------------------------------------- 1 | 1 0 2 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/testo/classifica.output_sol.txt: -------------------------------------------------------------------------------- 1 | 6 2 | -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/att/output.txt: -------------------------------------------------------------------------------- 1 | ../output/output0.txt -------------------------------------------------------------------------------- /2017/nazionali/lungomare/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | soluzione_giada.cpp -------------------------------------------------------------------------------- /2017/nazionali/lungomare/testo/lungomare.output0.txt: -------------------------------------------------------------------------------- 1 | 60 2 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/testo/lungomare.output1.txt: -------------------------------------------------------------------------------- 1 | 67 2 | -------------------------------------------------------------------------------- /2017/territoriali/discesa/testo/discesa.output1.txt: -------------------------------------------------------------------------------- 1 | 145 2 | -------------------------------------------------------------------------------- /2017/territoriali/sentieri/testo/sentieri.output0.txt: -------------------------------------------------------------------------------- 1 | 2 2 | -------------------------------------------------------------------------------- /2017/territoriali/sentieri/testo/sentieri.output1.txt: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/att/caduta.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template_cpp.cpp -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/caduta.output2.txt: -------------------------------------------------------------------------------- 1 | IMPOSSIBILE 2 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/att/corteo.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template_cpp.cpp -------------------------------------------------------------------------------- /2018/nazionali/specchi/att/input.txt: -------------------------------------------------------------------------------- 1 | ../testo/specchi.input0.txt -------------------------------------------------------------------------------- /2018/nazionali/specchi/att/specchi.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template_cpp.cpp -------------------------------------------------------------------------------- /2018/territoriali/scommessa/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100 2 | 3 | -------------------------------------------------------------------------------- /2019/nazionali/cena/att/cena.input0.txt: -------------------------------------------------------------------------------- 1 | ../testo/cena.input0.txt -------------------------------------------------------------------------------- /2019/nazionali/cena/att/cena.input1.txt: -------------------------------------------------------------------------------- 1 | ../testo/cena.input1.txt -------------------------------------------------------------------------------- /2019/nazionali/circuiti/testo/circuiti.input0.txt: -------------------------------------------------------------------------------- 1 | 1 3 2 2 | -------------------------------------------------------------------------------- /2019/nazionali/circuiti/testo/circuiti.input1.txt: -------------------------------------------------------------------------------- 1 | 2 3 4 2 | -------------------------------------------------------------------------------- /2019/nazionali/circuiti/testo/circuiti.input2.txt: -------------------------------------------------------------------------------- 1 | 3 3 7 2 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/incendio.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template.cpp -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/template.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template.cpp -------------------------------------------------------------------------------- /2019/territoriali/party/solutions/party.c: -------------------------------------------------------------------------------- 1 | ../statement/party.c -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grattacieli.c: -------------------------------------------------------------------------------- 1 | ../sol/template_c.c -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/grattacieli.output0.txt: -------------------------------------------------------------------------------- 1 | 11 2 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/grattacieli.output1.txt: -------------------------------------------------------------------------------- 1 | 16 2 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/grattacieli.output2.txt: -------------------------------------------------------------------------------- 1 | 54 2 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/logo2019.png: -------------------------------------------------------------------------------- 1 | ../../logo.png -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/att/orticoltura.c: -------------------------------------------------------------------------------- 1 | ../sol/template_c.c -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/logo2019.png: -------------------------------------------------------------------------------- 1 | ../../logo.png -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.c: -------------------------------------------------------------------------------- 1 | ../sol/template_c.c -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/pangramma.output3.txt: -------------------------------------------------------------------------------- 1 | 10 2 | -------------------------------------------------------------------------------- /2008/nazionali/cnn/testo/input0.txt: -------------------------------------------------------------------------------- 1 | 3 5 2 | 4 5 3 | 3 3 4 | 2 2 5 | -------------------------------------------------------------------------------- /2012/nazionali/eso/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000 2 | MAXM = 1000 3 | -------------------------------------------------------------------------------- /2012/territoriali/nanga/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000 2 | MAXP = 100 3 | -------------------------------------------------------------------------------- /2013/territoriali/turni/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXK = 50 2 | MAXN = 50 3 | -------------------------------------------------------------------------------- /2014/territoriali/brisbane/gen/valida.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | exit 0 3 | -------------------------------------------------------------------------------- /2014/territoriali/gardaland/gen/valida.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | exit 0 3 | -------------------------------------------------------------------------------- /2014/territoriali/trovaparola/gen/valida.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | exit 0 3 | -------------------------------------------------------------------------------- /2015/nazionali/accensione/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | ../att/accensione.cpp -------------------------------------------------------------------------------- /2015/nazionali/accensione/sol/template_pas.pas: -------------------------------------------------------------------------------- 1 | ../att/accensione.pas -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | ../att/bottleneck.cpp -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/sol/template_pas.pas: -------------------------------------------------------------------------------- 1 | ../att/bottleneck.pas -------------------------------------------------------------------------------- /2015/territoriali/collatz/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MINN = 2 2 | MAXN = 1000 3 | -------------------------------------------------------------------------------- /2015/territoriali/mojito/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MINN = 1 2 | MAXN = 100 3 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/att/aeroporto.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template_cpp.cpp -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/att/aeroporto.pas: -------------------------------------------------------------------------------- 1 | ../sol/template_pas.pas -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/testo/aeroporto.output1.txt: -------------------------------------------------------------------------------- 1 | 2 5 8 13 2 | -------------------------------------------------------------------------------- /2016/nazionali/nemesi/testo/nemesi.input0.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 1 0 1 0 3 3 | -------------------------------------------------------------------------------- /2016/nazionali/nemesi/testo/nemesi.input1.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 1 2 3 4 0 3 | -------------------------------------------------------------------------------- /2016/nazionali/nemesi/testo/nemesi.output0.txt: -------------------------------------------------------------------------------- 1 | 0 4 2 2 | 3 1 3 | -------------------------------------------------------------------------------- /2016/nazionali/nemesi/testo/nemesi.output1.txt: -------------------------------------------------------------------------------- 1 | 1 4 2 | 3 3 | 2 0 4 | -------------------------------------------------------------------------------- /2016/nazionali/paletta/testo/paletta.input0.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 2 0 4 3 1 3 | -------------------------------------------------------------------------------- /2016/territoriali/disuguaglianze/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100000 2 | -------------------------------------------------------------------------------- /2016/territoriali/semiprimo/gen/valida.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | exit 0 3 | -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/testo/logo.png: -------------------------------------------------------------------------------- 1 | ../../../util/static/logo.png -------------------------------------------------------------------------------- /2017/nazionali/lungomare/testo/logo.png: -------------------------------------------------------------------------------- 1 | ../../../util/static/logo.png -------------------------------------------------------------------------------- /2017/territoriali/spartizione/testo/spartizione.input0.txt: -------------------------------------------------------------------------------- 1 | 11 2 2 | -------------------------------------------------------------------------------- /2017/territoriali/spartizione/testo/spartizione.input1.txt: -------------------------------------------------------------------------------- 1 | 18 4 2 | -------------------------------------------------------------------------------- /2017/territoriali/spartizione/testo/spartizione.output0.txt: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /2017/territoriali/spartizione/testo/spartizione.output1.txt: -------------------------------------------------------------------------------- 1 | 9 2 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/caduta.input0.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 3 2 1 4 1 3 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/caduta.input1.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 3 2 2 4 1 3 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/caduta.input2.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 1 1 1 1 1 3 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000 2 | MAXM = 5000 3 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/att/output.txt: -------------------------------------------------------------------------------- 1 | ../testo/specchi.output0.txt -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/specchi.output0.txt: -------------------------------------------------------------------------------- 1 | 0 4 2 | 3 3 3 | -------------------------------------------------------------------------------- /2018/territoriali/lwf/testo/logo.png: -------------------------------------------------------------------------------- 1 | ../../../util/static/logo.png -------------------------------------------------------------------------------- /2018/territoriali/scommessa/testo/scommessa.input0.txt: -------------------------------------------------------------------------------- 1 | 3 2 | 1 2 0 -------------------------------------------------------------------------------- /2018/territoriali/scommessa/testo/scommessa.output0.txt: -------------------------------------------------------------------------------- 1 | 1 2 | 0 3 | -------------------------------------------------------------------------------- /2018/territoriali/tecla/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 30 2 | MAXM = 30 3 | -------------------------------------------------------------------------------- /2018/territoriali/tecla/testo/logo.png: -------------------------------------------------------------------------------- 1 | ../../../util/static/logo.png -------------------------------------------------------------------------------- /2018/territoriali/tecla/testo/oddcycle.output0.txt: -------------------------------------------------------------------------------- 1 | 3 2 | 0 2 1 0 3 | -------------------------------------------------------------------------------- /2019/nazionali/cena/att/cena.output0.txt: -------------------------------------------------------------------------------- 1 | ../testo/cena.output0.txt -------------------------------------------------------------------------------- /2019/nazionali/cena/att/cena.output1.txt: -------------------------------------------------------------------------------- 1 | ../testo/cena.output1.txt -------------------------------------------------------------------------------- /2019/nazionali/circuiti/att/input.txt: -------------------------------------------------------------------------------- 1 | ../testo/circuiti.input0.txt -------------------------------------------------------------------------------- /2019/nazionali/circuiti/att/output.txt: -------------------------------------------------------------------------------- 1 | ../testo/circuiti.output0.txt -------------------------------------------------------------------------------- /2019/territoriali/party/solutions/party.cpp: -------------------------------------------------------------------------------- 1 | ../statement/party.cpp -------------------------------------------------------------------------------- /2019/territoriali/party/solutions/party.pas: -------------------------------------------------------------------------------- 1 | ../statement/party.pas -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | ostuni_superottima.cpp -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | federico_by_federico.cpp -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template_cpp.cpp -------------------------------------------------------------------------------- /2020/nazionali/pangramma/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | ostuni_superottima2.cpp -------------------------------------------------------------------------------- /2008/nazionali/triade/testo/input0.txt: -------------------------------------------------------------------------------- 1 | 3 4 2 | 4 2 3 | 1 3 4 | 3 4 5 | -------------------------------------------------------------------------------- /2011/nazionali/fuga/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MaxN = 100000 2 | MaxM = 200000 3 | -------------------------------------------------------------------------------- /2012/nazionali/matita/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100000 2 | MAXM = 1000000 3 | -------------------------------------------------------------------------------- /2012/nazionali/salta/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000000 2 | MAXVI = 1000000 3 | -------------------------------------------------------------------------------- /2013/territoriali/barbablu/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 30 2 | MAXM = 100 3 | -------------------------------------------------------------------------------- /2013/territoriali/grandprix/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 30 2 | MAXM = 100 3 | -------------------------------------------------------------------------------- /2014/territoriali/brisbane/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000 2 | MAXM = 10000 3 | -------------------------------------------------------------------------------- /2015/nazionali/accensione/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000000 2 | MINN = 1 3 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | ../att/taglialegna.cpp -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/sol/template_pas.pas: -------------------------------------------------------------------------------- 1 | ../att/taglialegna.pas -------------------------------------------------------------------------------- /2016/nazionali/paletta/testo/paletta.input1.txt: -------------------------------------------------------------------------------- 1 | 6 2 | 2 3 0 5 4 1 3 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/testo/classifica.output1.txt: -------------------------------------------------------------------------------- 1 | 2 6 3 3 1 1 2 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/testo/logo.png: -------------------------------------------------------------------------------- 1 | ../../../util/static/logo.png -------------------------------------------------------------------------------- /2017/territoriali/sentieri/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100 2 | MAXM = 1000 3 | -------------------------------------------------------------------------------- /2017/territoriali/spartizione/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXG = 1000 2 | MAXP = 10 3 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 5000000 2 | MAXA = 1000 3 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/lwf/managers/limits.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000000 2 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/scommessa/managers/limits.py: -------------------------------------------------------------------------------- 1 | MAXN = 100 2 | -------------------------------------------------------------------------------- /2018/territoriali/scommessa/testo/logo.png: -------------------------------------------------------------------------------- 1 | ../../../util/static/logo.png -------------------------------------------------------------------------------- /2018/territoriali/scommessa/testo/scommessa.output1.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 2 8 3 | -------------------------------------------------------------------------------- /2018/territoriali/tecla/testo/oddcycle.output1.txt: -------------------------------------------------------------------------------- 1 | 7 2 | 0 5 6 3 4 2 3 0 -------------------------------------------------------------------------------- /2019/territoriali/antivirus/solutions/antivirus.c: -------------------------------------------------------------------------------- 1 | ../statement/antivirus.c -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grattacieli.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template_cpp.cpp -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/gen/graph.py: -------------------------------------------------------------------------------- 1 | ../../../util/gen_lib/graph.py -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/att/orticoltura.cpp: -------------------------------------------------------------------------------- 1 | ../sol/template_cpp.cpp -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/pangramma.input0.txt: -------------------------------------------------------------------------------- 1 | 6 3 2 | 2 0 1 1 2 0 -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/pangramma.input1.txt: -------------------------------------------------------------------------------- 1 | 7 3 2 | 0 1 1 2 1 1 0 -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/pangramma.input2.txt: -------------------------------------------------------------------------------- 1 | 7 3 2 | 0 1 1 2 0 0 1 -------------------------------------------------------------------------------- /2020/territoriali/download/managers/limits.py: -------------------------------------------------------------------------------- 1 | T = 6 2 | MAXN = 10000 3 | -------------------------------------------------------------------------------- /2020/territoriali/download/solutions/template.c: -------------------------------------------------------------------------------- 1 | ../statement/download.c -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/managers/limits.py: -------------------------------------------------------------------------------- 1 | T = 19 2 | MAXN = 1000 3 | -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/solutions/template.c: -------------------------------------------------------------------------------- 1 | ../statement/gerarchie.c -------------------------------------------------------------------------------- /2020/territoriali/multicore/solutions/template.c: -------------------------------------------------------------------------------- 1 | ../statement/multicore.c -------------------------------------------------------------------------------- /2020/territoriali/tornello/managers/limits.py: -------------------------------------------------------------------------------- 1 | T = 12 2 | MAXN = 10000 3 | -------------------------------------------------------------------------------- /2020/territoriali/tornello/solutions/template.c: -------------------------------------------------------------------------------- 1 | ../statement/tornello.c -------------------------------------------------------------------------------- /2010/nazionali/numeri/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100000000 2 | MAXM = 1000000 3 | -------------------------------------------------------------------------------- /2013/nazionali/convoglio/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100000 2 | MAXM = 150000 3 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/sol/taglialegnalib.pas: -------------------------------------------------------------------------------- 1 | ../att/taglialegnalib.pas -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXR = 100000 2 | MAXT = 1000000000 3 | -------------------------------------------------------------------------------- /2016/territoriali/disuguaglianze/testo/disuguaglianze0.txt: -------------------------------------------------------------------------------- 1 | 6 2 | <><<> 3 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/specchi.output1.txt: -------------------------------------------------------------------------------- 1 | 3 1 2 | 1 1 3 | 0 1 4 | 5 | -------------------------------------------------------------------------------- /2018/territoriali/tecla/testo/oddcycle.input0.txt: -------------------------------------------------------------------------------- 1 | 3 3 2 | 0 1 3 | 1 2 4 | 2 0 -------------------------------------------------------------------------------- /2019/nazionali/cena/testo/cena.input0.txt: -------------------------------------------------------------------------------- 1 | 6 3 2 | 0 0 1 2 0 1 3 | 0 2 0 4 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/incendio.input0.txt: -------------------------------------------------------------------------------- 1 | ../testo/incendio.input0.txt -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/incendio.input1.txt: -------------------------------------------------------------------------------- 1 | ../testo/incendio.input1.txt -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/incendio.output0.txt: -------------------------------------------------------------------------------- 1 | ../testo/incendio.output0.txt -------------------------------------------------------------------------------- /2019/nazionali/incendio/att/incendio.output1.txt: -------------------------------------------------------------------------------- 1 | ../testo/incendio.output1.txt -------------------------------------------------------------------------------- /2019/territoriali/antivirus/solutions/antivirus.cpp: -------------------------------------------------------------------------------- 1 | ../statement/antivirus.cpp -------------------------------------------------------------------------------- /2019/territoriali/antivirus/solutions/antivirus.pas: -------------------------------------------------------------------------------- 1 | ../statement/antivirus.pas -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/asy_grattacieli/fig1a.asy: -------------------------------------------------------------------------------- 1 | include fig1; 2 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/asy_grattacieli/fig1b.asy: -------------------------------------------------------------------------------- 1 | include fig1; 2 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/asy_grattacieli/fig1c.asy: -------------------------------------------------------------------------------- 1 | include fig1; 2 | -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.input0.txt: -------------------------------------------------------------------------------- 1 | ../testo/pangramma.input0.txt -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.input1.txt: -------------------------------------------------------------------------------- 1 | ../testo/pangramma.input1.txt -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.input2.txt: -------------------------------------------------------------------------------- 1 | ../testo/pangramma.input2.txt -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.input3.txt: -------------------------------------------------------------------------------- 1 | ../testo/pangramma.input3.txt -------------------------------------------------------------------------------- /2020/territoriali/download/solutions/template.cpp: -------------------------------------------------------------------------------- 1 | ../statement/download.cpp -------------------------------------------------------------------------------- /2020/territoriali/download/solutions/template.pas: -------------------------------------------------------------------------------- 1 | ../statement/download.pas -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/managers/graph.py: -------------------------------------------------------------------------------- 1 | ../../../util/gen_lib/graph.py -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/solutions/template.cpp: -------------------------------------------------------------------------------- 1 | ../statement/gerarchie.cpp -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/solutions/template.pas: -------------------------------------------------------------------------------- 1 | ../statement/gerarchie.pas -------------------------------------------------------------------------------- /2020/territoriali/multicore/solutions/template.cpp: -------------------------------------------------------------------------------- 1 | ../statement/multicore.cpp -------------------------------------------------------------------------------- /2020/territoriali/multicore/solutions/template.pas: -------------------------------------------------------------------------------- 1 | ../statement/multicore.pas -------------------------------------------------------------------------------- /2020/territoriali/tornello/solutions/template.pas: -------------------------------------------------------------------------------- 1 | ../statement/tornello.pas -------------------------------------------------------------------------------- /2008/territoriali/pizzini/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MINN, MAXN = 1, 100 2 | MAXLEN = 80 3 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/testo/aeroporto.input0.txt: -------------------------------------------------------------------------------- 1 | 3 2 | 3 5 3 | 1 7 4 | 4 8 5 | -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/testo/hogwarts.input1.txt: -------------------------------------------------------------------------------- 1 | 3 2 2 | 0 1 3 5 3 | 1 2 2 4 4 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/tecla/managers/limits.py: -------------------------------------------------------------------------------- 1 | MAXN = 30 2 | MAXM = 100 3 | -------------------------------------------------------------------------------- /2019/nazionali/cena/testo/cena.input1.txt: -------------------------------------------------------------------------------- 1 | 9 3 2 | 0 1 0 1 1 0 1 0 1 3 | 0 0 0 4 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000000000 2 | MAXM = 20000 3 | 4 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/testo/incendio.input0.txt: -------------------------------------------------------------------------------- 1 | 8 3 2 | 1 7 3 | 5 1 4 | 7 2 5 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/testo/incendio.input1.txt: -------------------------------------------------------------------------------- 1 | 7 3 2 | 3 4 3 | 0 2 4 | 6 3 5 | -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.output0.txt: -------------------------------------------------------------------------------- 1 | ../testo/pangramma.output0.txt -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.output1.txt: -------------------------------------------------------------------------------- 1 | ../testo/pangramma.output1.txt -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.output2.txt: -------------------------------------------------------------------------------- 1 | ../testo/pangramma.output2.txt -------------------------------------------------------------------------------- /2020/nazionali/pangramma/att/pangramma.output3.txt: -------------------------------------------------------------------------------- 1 | ../testo/pangramma.output3.txt -------------------------------------------------------------------------------- /2020/territoriali/multicore/managers/solution.cpp: -------------------------------------------------------------------------------- 1 | ../solutions/ottima_ostuni.cpp -------------------------------------------------------------------------------- /2012/territoriali/galattici/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXM = 100 2 | MAXN = 100 3 | MAXK = 10 4 | -------------------------------------------------------------------------------- /2014/territoriali/gardaland/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100 2 | MAXL = 1000 3 | MAXR = 100 4 | -------------------------------------------------------------------------------- /2018/territoriali/scommessa/testo/scommessa.input1.txt: -------------------------------------------------------------------------------- 1 | 11 2 | 1 0 2 6 4 5 3 9 8 10 7 3 | -------------------------------------------------------------------------------- /2019/territoriali/xray/managers/limits.py: -------------------------------------------------------------------------------- 1 | T = 19 2 | MAXN = 1000 3 | MAXV = 1000 4 | -------------------------------------------------------------------------------- /2019/territoriali/xray/statement/xray_output_example.txt: -------------------------------------------------------------------------------- 1 | Case #1: 3 2 | Case #2: 101 3 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grattacieli.input0.txt: -------------------------------------------------------------------------------- 1 | ../testo/grattacieli.input0.txt -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grattacieli.input1.txt: -------------------------------------------------------------------------------- 1 | ../testo/grattacieli.input1.txt -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grattacieli.input2.txt: -------------------------------------------------------------------------------- 1 | ../testo/grattacieli.input2.txt -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grattacieli.output0.txt: -------------------------------------------------------------------------------- 1 | ../testo/grattacieli.output0.txt -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grattacieli.output1.txt: -------------------------------------------------------------------------------- 1 | ../testo/grattacieli.output1.txt -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/att/grattacieli.output2.txt: -------------------------------------------------------------------------------- 1 | ../testo/grattacieli.output2.txt -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/att/orticoltura.input0.txt: -------------------------------------------------------------------------------- 1 | ../testo/orticoltura.input0.txt -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/att/orticoltura.input1.txt: -------------------------------------------------------------------------------- 1 | ../testo/orticoltura.input1.txt -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/att/orticoltura.output0.txt: -------------------------------------------------------------------------------- 1 | ../testo/orticoltura.output0.txt -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/att/orticoltura.output1.txt: -------------------------------------------------------------------------------- 1 | ../testo/orticoltura.output1.txt -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/orticoltura.input1.txt: -------------------------------------------------------------------------------- 1 | 50 2 | 2 3 | 20 10 4 | 70 10 5 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/orticoltura.output1.txt: -------------------------------------------------------------------------------- 1 | 85 2 | 1 3 | 45 35 4 | 5 | -------------------------------------------------------------------------------- /util/smart_vector/.syntastic_cpp_config: -------------------------------------------------------------------------------- 1 | -DCHECK_INTERFACE 2 | -DVERSION_TO_TEST=1 3 | -------------------------------------------------------------------------------- /2013/nazionali/fermata/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100000 2 | MAXS = 100000 3 | MAXC = 100000 4 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/testo/aeroporto.input1.txt: -------------------------------------------------------------------------------- 1 | 4 2 | 1 5 3 | 1 9 4 | 6 8 5 | 8 13 6 | -------------------------------------------------------------------------------- /2016/territoriali/footing/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000 2 | MAXM = 10000 3 | MAXW = 10000 4 | -------------------------------------------------------------------------------- /2017/territoriali/discesa/testo/discesa.input0.txt: -------------------------------------------------------------------------------- 1 | 4 2 | 1 3 | 2 9 4 | 3 7 5 5 | 8 4 11 6 6 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/corteo.input1.txt: -------------------------------------------------------------------------------- 1 | 4 3 2 | 2 1 3 2 3 | 0 1 4 | 1 2 5 | 1 3 6 | -------------------------------------------------------------------------------- /2019/territoriali/escursione/managers/limits.py: -------------------------------------------------------------------------------- 1 | T = 27 2 | MAXL = 100 3 | MAXA = 10**6 4 | -------------------------------------------------------------------------------- /2019/territoriali/party/statement/party_output_example.txt: -------------------------------------------------------------------------------- 1 | Case #1: 15 2 | Case #2: 0 3 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/orticoltura.output0.txt: -------------------------------------------------------------------------------- 1 | 80 2 | 2 3 | 100 40 4 | 20 20 5 | -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/pangramma.input3.txt: -------------------------------------------------------------------------------- 1 | 13 5 2 | 2 3 0 0 3 1 3 4 3 3 0 3 2 3 | -------------------------------------------------------------------------------- /2020/territoriali/multicore/statement/multicore_output_example.txt: -------------------------------------------------------------------------------- 1 | Case #1: 2 2 | Case #2: 12 -------------------------------------------------------------------------------- /2015/territoriali/sommelier/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MINN = 2 2 | MAXN = 99 3 | MING = 1 4 | MAXG = 99 5 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/corteo.output1.txt: -------------------------------------------------------------------------------- 1 | 1 1 2 | 1 0 3 | 2 1 4 | 2 2 5 | 1 1 6 | 99999 7 | -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/statement/gerarchie_output_example.txt: -------------------------------------------------------------------------------- 1 | Case #1: 6 2 | Case #2: 2 3 | -------------------------------------------------------------------------------- /2014/nazionali/bufale/att/bufale.c: -------------------------------------------------------------------------------- 1 | long long solve(int N, int* M, int* P) { 2 | return 0; 3 | } 4 | -------------------------------------------------------------------------------- /2014/nazionali/spiedini/att/spiedini.c: -------------------------------------------------------------------------------- 1 | int solve(int N, int K, int* S) { 2 | return 0; 3 | } 4 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/testo/lungomare.input0.txt: -------------------------------------------------------------------------------- 1 | 5 100 2 | 10 30 40 50 70 3 | 50 40 20 30 10 4 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/sol/smart_vector_fast.hpp: -------------------------------------------------------------------------------- 1 | ../../../../util/smart_vector/smart_vector_fast.hpp -------------------------------------------------------------------------------- /2018/nazionali/specchi/sol/smart_vector_slow.hpp: -------------------------------------------------------------------------------- 1 | ../../../../util/smart_vector/smart_vector_slow.hpp -------------------------------------------------------------------------------- /2019/nazionali/cena/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXS = 100000 2 | MAXP = 100000 3 | MAXrep = 1000 4 | MAXT = 100 5 | -------------------------------------------------------------------------------- /2019/territoriali/escursione/solutions/crash.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { abort(); } 4 | -------------------------------------------------------------------------------- /2019/territoriali/party/managers/limits.py: -------------------------------------------------------------------------------- 1 | T = 6 2 | MAXN = 10000 3 | MINA = -100 4 | MAXA = 100 5 | -------------------------------------------------------------------------------- /2020/territoriali/download/statement/download_output_example.txt: -------------------------------------------------------------------------------- 1 | Case #1: 3 10 2 | Case #2: 33 0 3 | -------------------------------------------------------------------------------- /2016/nazionali/nemesi/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100000 2 | 3 | MAXN_ST = [ MAXN, MAXN, MAXN, 2000, MAXN ] 4 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/testo/classifica.input_sol.txt: -------------------------------------------------------------------------------- 1 | 7 3 2 | 5 2 6 3 4 1 0 3 | x 5 4 | p 2 5 | s 0 6 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/specchi.input0.txt: -------------------------------------------------------------------------------- 1 | 4 5 5 2 | / 1 2 3 | \ 1 4 4 | ? 1 1 5 | / 3 4 6 | ? 2 2 7 | -------------------------------------------------------------------------------- /2019/nazionali/circuiti/testo/circuiti.output0.txt: -------------------------------------------------------------------------------- 1 | temp[0] = in[0] + in[1] 2 | out[0] = temp[0] + in[2] 3 | -------------------------------------------------------------------------------- /2019/nazionali/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/nazionali/logo.png -------------------------------------------------------------------------------- /2019/territoriali/antivirus/statement/antivirus_output_example.txt: -------------------------------------------------------------------------------- 1 | Case #1: 4 0 1 1 2 | Case #2: 3 1 4 4 3 | -------------------------------------------------------------------------------- /2020/nazionali/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/nazionali/logo.png -------------------------------------------------------------------------------- /2020/territoriali/multicore/managers/limits.py: -------------------------------------------------------------------------------- 1 | T = 27 2 | MAXN = 300 3 | MAXC = 200 4 | MAXP = 10**9 5 | -------------------------------------------------------------------------------- /2005/territoriali/sunny/testo/example0.in: -------------------------------------------------------------------------------- 1 | 5 6 1 5 2 | 1 2 5 3 | 2 3 1 4 | 3 4 3 5 | 4 5 2 6 | 5 1 6 7 | 1 4 4 8 | -------------------------------------------------------------------------------- /2014/nazionali/maree/att/maree.c: -------------------------------------------------------------------------------- 1 | int solve(int N, int M, int T, int* S, int* E) { 2 | return 0; 3 | } 4 | -------------------------------------------------------------------------------- /2016/nazionali/paletta/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1500000 2 | 3 | MAXN_ST = [10, 100, 5000, 100000, 100000, MAXN] 4 | -------------------------------------------------------------------------------- /2016/nazionali/paletta/sol/template_c.c: -------------------------------------------------------------------------------- 1 | long long paletta_sort(int N, int V[]) { 2 | return N; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/sol/smart_vector_very_slow.hpp: -------------------------------------------------------------------------------- 1 | ../../../../util/smart_vector/smart_vector_very_slow.hpp -------------------------------------------------------------------------------- /2019/territoriali/xray/statement/xray_input_example.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 3 | 4 4 | 1 2 3 1 5 | 6 | 4 7 | 100 0 1 1 8 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/orticoltura.input0.txt: -------------------------------------------------------------------------------- 1 | 10 2 | 4 3 | 10 10 4 | 20 20 5 | 80 20 6 | 110 30 7 | -------------------------------------------------------------------------------- /2020/territoriali/download/statement/download_input_example.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 3 | 1000 300 10 4 | 5 | 1000 30 50 6 | -------------------------------------------------------------------------------- /2010/nazionali/pesca/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MinN, MaxN = 2, 2**31 - 1 2 | MinP, MaxP = 1, 10**6 3 | MinM, MaxM = 1, 10**8 4 | -------------------------------------------------------------------------------- /2013/nazionali/fontane/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100000 2 | MAXM = 100000 3 | MAXX = 1000000000 4 | MAXT = 1000000000 5 | -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/testo/hogwarts.input0.txt: -------------------------------------------------------------------------------- 1 | 4 5 2 | 0 2 0 5 3 | 0 1 1 3 4 | 0 3 3 6 5 | 3 2 3 8 6 | 3 1 0 10 7 | -------------------------------------------------------------------------------- /2019/nazionali/cena/sol/template.cpp: -------------------------------------------------------------------------------- 1 | long long conta(int S, int s[], int P, int p[]) { 2 | return S-P; 3 | } 4 | -------------------------------------------------------------------------------- /2019/territoriali/antivirus/managers/limits.py: -------------------------------------------------------------------------------- 1 | import string 2 | 3 | T = 12 4 | CHARS = string.ascii_lowercase 5 | -------------------------------------------------------------------------------- /2019/territoriali/escursione/statement/escursione_output_example.txt: -------------------------------------------------------------------------------- 1 | Case #1: 20 2 | Case #2: 1 3 | Case #3: 2 4 | -------------------------------------------------------------------------------- /2019/territoriali/party/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: party 4 | description: Festa canina 5 | max_score: 6 6 | -------------------------------------------------------------------------------- /2005/territoriali/sunny/gen/valida.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | exit 0 # non serve perche' l'input e' validato dalla soluzione 3 | -------------------------------------------------------------------------------- /2014/territoriali/gardaland/testo/esempio.txt: -------------------------------------------------------------------------------- 1 | 3 5 2 | 4 3 | 4 4 | 3 5 | 0 2 6 | 1 3 7 | 0 1 8 | 2 2 9 | 1 1 10 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/testo/classifica.input0.txt: -------------------------------------------------------------------------------- 1 | 5 6 2 | 4 0 3 2 1 3 | s 3 4 | s 1 5 | s 1 6 | p 3 7 | x 2 8 | p 4 9 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/lwf/solutions/crash.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | abort(); 6 | } 7 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/sol/template.c: -------------------------------------------------------------------------------- 1 | 2 | int alzati(int N, int M, int X[], int Y[]) { 3 | return N; 4 | } 5 | 6 | -------------------------------------------------------------------------------- /2019/territoriali/party/statement/party_input_example.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 3 | 8 4 | 1 -4 5 -2 -1 8 0 1 5 | 6 | 3 7 | -1 -2 -4 8 | -------------------------------------------------------------------------------- /2011/nazionali/baht/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MaxIter = 1000 2 | MaxSum = 2**31 - 1 3 | MaxVal = 2**20 - 1 4 | MaxN = MaxNum = 10000 5 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/sol/template_c.c: -------------------------------------------------------------------------------- 1 | void pianifica(int R, int A[], int B[], int T[]) { 2 | T[0] = 42; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/specchi.input1.txt: -------------------------------------------------------------------------------- 1 | 6 2 7 2 | ? 1 1 3 | / 1 1 4 | \ 4 0 5 | / 4 1 6 | / 1 0 7 | ? 0 1 8 | ? 1 1 9 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/tecla/solutions/crash.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | abort(); 6 | } 7 | -------------------------------------------------------------------------------- /2019/nazionali/cena/sol/zero.cpp: -------------------------------------------------------------------------------- 1 | // zero 2 | 3 | long long conta(int S, int s[], int P, int p[]) { 4 | return 0; 5 | } 6 | -------------------------------------------------------------------------------- /2019/nazionali/circuiti/testo/circuiti.output1.txt: -------------------------------------------------------------------------------- 1 | out[0] = in[0] + 0 2 | out[1] = in[0] + in[1] 3 | out[2] = in[2] + out[1] 4 | -------------------------------------------------------------------------------- /2019/territoriali/antivirus/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: antivirus 4 | description: Antivirus 5 | max_score: 12 6 | -------------------------------------------------------------------------------- /2019/territoriali/escursione/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: escursione 4 | description: Escursione 5 | max_score: 27 6 | -------------------------------------------------------------------------------- /2019/territoriali/xray/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: xray 4 | description: Radioanalisi fossile 5 | max_score: 19 6 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/grattacieli.input0.txt: -------------------------------------------------------------------------------- 1 | 4 5 2 | 2 3 6 3 3 | 0 1 4 4 | 1 2 1 5 | 2 0 1 6 | 0 3 0 7 | 3 2 2 8 | -------------------------------------------------------------------------------- /2020/territoriali/tornello/statement/tornello_output_example.txt: -------------------------------------------------------------------------------- 1 | Case #1: 3 2 | Case #2: 3 3 | Case #3: 1 4 | Case #4: 5 5 | -------------------------------------------------------------------------------- /2005/territoriali/sunny/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: sunny 2 | nome: Sunnydale 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2010/nazionali/pesca/testo/mare.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2010/nazionali/pesca/testo/mare.png -------------------------------------------------------------------------------- /2013/territoriali/turni/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: turni 2 | nome: Turni 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2014/nazionali/maree/testo/maree.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2014/nazionali/maree/testo/maree.jpg -------------------------------------------------------------------------------- /2015/nazionali/accensione/att/accensione.c: -------------------------------------------------------------------------------- 1 | void Accendi(int N, int acceso[], int pulsante[]) { 2 | pulsante[1] = 1; 3 | } 4 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/lwf/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: lwf 4 | description: Crittografia LWF 5 | max_score: 10 6 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/scommessa/solutions/crash.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | abort(); 6 | } 7 | -------------------------------------------------------------------------------- /2020/territoriali/download/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: download 4 | description: Filmati e canzoni 5 | max_score: 6 6 | -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: gerarchie 4 | description: Gerarchie di tutor 5 | max_score: 19 6 | -------------------------------------------------------------------------------- /2020/territoriali/tornello/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: tornello 4 | description: Tornello olimpico 5 | max_score: 12 6 | -------------------------------------------------------------------------------- /2008/nazionali/cnn/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: cnn 2 | nome: Troupe televisive 3 | timeout: 2 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2008/territoriali/mappa/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: mappa 2 | nome: Mappa antica 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2010/nazionali/amici/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: amici 2 | nome: Tè con gli amici 3 | timeout: 2 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2010/nazionali/pesca/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: pesca 2 | nome: Pesca bizzarra 3 | timeout: 2 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2012/territoriali/nanga/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: nanga 2 | nome: Nanga Parbat 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2013/territoriali/barbablu/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: barbablu 2 | nome: Barbablu 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2014/nazionali/maree/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: maree 2 | nome: Maree a Venezia 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/testo/lungomare.input1.txt: -------------------------------------------------------------------------------- 1 | 10 200 2 | 5 20 50 70 95 100 125 150 155 160 3 | 10 20 15 25 12 20 25 15 30 30 4 | -------------------------------------------------------------------------------- /2017/territoriali/discesa/testo/discesa.input1.txt: -------------------------------------------------------------------------------- 1 | 6 2 | 42 3 | 11 13 4 | 41 37 38 5 | 5 8 11 9 6 | 22 27 31 18 32 7 | 12 8 9 8 10 11 8 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/domino.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2018/nazionali/caduta/testo/domino.png -------------------------------------------------------------------------------- /2018/territoriali-remastered/tecla/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: tecla 4 | description: Appetito aracnide 5 | max_score: 20 6 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/grattacieli.input1.txt: -------------------------------------------------------------------------------- 1 | 4 6 2 | 2 4 10 7 3 | 0 1 1 4 | 1 2 3 5 | 1 3 2 6 | 3 2 2 7 | 3 0 0 8 | 0 3 4 9 | -------------------------------------------------------------------------------- /2020/territoriali/multicore/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: multicore 4 | description: Processori multicore 5 | max_score: 27 6 | -------------------------------------------------------------------------------- /2008/nazionali/parole/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: parole 2 | nome: Parole saturnine 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2009/territoriali/treno/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: treno 2 | nome: Treno di container 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2010/nazionali/numeri/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: numeri 2 | nome: Numeri antipatici 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2011/nazionali/baht/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: baht 2 | nome: Per un pugno di baht 3 | timeout: 10 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2011/nazionali/fuga/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: fuga 2 | nome: Fuga dagli inseguitori 3 | timeout: 3 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2011/nazionali/salti/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: salti 2 | nome: Salti spettacolari 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2011/nazionali/scuola/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: scuola 2 | nome: Scuola di supereroi 3 | timeout: 3 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2012/nazionali/matita/testo/casetta.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2012/nazionali/matita/testo/casetta.png -------------------------------------------------------------------------------- /2012/nazionali/salta/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: salta 2 | nome: Salta il coniglietto 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2012/territoriali/domino/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: domino 2 | nome: Domino massimale 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2013/nazionali/convoglio/testo/figura.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2013/nazionali/convoglio/testo/figura.png -------------------------------------------------------------------------------- /2013/nazionali/fermata/testo/figura.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2013/nazionali/fermata/testo/figura.png -------------------------------------------------------------------------------- /2013/nazionali/fontane/testo/figura.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2013/nazionali/fontane/testo/figura.png -------------------------------------------------------------------------------- /2013/territoriali/grandprix/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: grandprix 2 | nome: Grandprix 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2014/nazionali/bufale/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: bufale 2 | nome: Mozzarelle di bufala 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2015/territoriali/mojito/testo/mojito.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2015/territoriali/mojito/testo/mojito.png -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/att/hogwarts.c: -------------------------------------------------------------------------------- 1 | int raggiungi(int N, int M, int A[], int B[], int inizio[], int fine[]) { 2 | return 1; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /2019/territoriali/xray/statement/xray.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/territoriali/xray/statement/xray.png -------------------------------------------------------------------------------- /2008/nazionali/triade/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: triade 2 | nome: Giornalismo d'inchiesta 3 | timeout: 2 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2008/territoriali/missioni/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: missioni 2 | nome: Missioni segrete 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2008/territoriali/pizzini/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: pizzini 2 | nome: Codici e pizzini 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2009/territoriali/depura/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: depura 2 | nome: Depurazione dell'acqua 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2009/territoriali/essenza/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: essenza 2 | nome: Essenza per profumi 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2011/territoriali/quasipal/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: quasipal 2 | nome: Quasi-palindromi 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2012/nazionali/eso/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: eso 2 | nome: Espressioni senza operatori 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2012/nazionali/fibstr/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: fibstr 2 | nome: Stringhe di Fibonacci 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2013/nazionali/fermata/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: fermata 2 | nome: Entscheidungsproblem 3 | timeout: 2 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2013/territoriali/barbablu/testo/mappa.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2013/territoriali/barbablu/testo/mappa.png -------------------------------------------------------------------------------- /2014/nazionali/spiedini/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: spiedini 2 | nome: Spiedini di frutta 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2014/nazionali/spiedini/testo/spiedino.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2014/nazionali/spiedini/testo/spiedino.png -------------------------------------------------------------------------------- /2014/territoriali/brisbane/testo/esempio.txt: -------------------------------------------------------------------------------- 1 | 6 2 2 4 2 2 | 1 3 | 5 4 | 0 1 5 | 2 5 6 | 0 3 7 | 1 3 8 | 2 4 9 | 4 5 10 | 1 2 11 | 3 4 12 | -------------------------------------------------------------------------------- /2014/territoriali/gardaland/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: gardaland 2 | nome: Gita a Gardaland 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/task.yaml: -------------------------------------------------------------------------------- 1 | name: taglialegna 2 | title: Taglialegna 3 | time_limit: 1.0 4 | memory_limit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2015/territoriali/mojito/testo/image00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2015/territoriali/mojito/testo/image00.jpg -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/att/hogwarts.cpp: -------------------------------------------------------------------------------- 1 | int raggiungi(int N, int M, int A[], int B[], int inizio[], int fine[]) { 2 | return 1; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/sol/template_c.c: -------------------------------------------------------------------------------- 1 | int raggiungi(int N, int M, int A[], int B[], int inizio[], int fine[]) { 2 | return 1; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/scommessa/task.yaml: -------------------------------------------------------------------------------- 1 | %YAML 1.2 2 | --- 3 | name: scommessa 4 | description: Sport intellettuali 5 | max_score: 20 6 | -------------------------------------------------------------------------------- /2019/territoriali/party/statement/party.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/territoriali/party/statement/party.jpg -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/sol/template_c.c: -------------------------------------------------------------------------------- 1 | long long costruisci(int N, int M, long long* H, int* A, int* B, int* C) { 2 | return 42; 3 | } 4 | -------------------------------------------------------------------------------- /2020/nazionali/pangramma/sol/template_c.c: -------------------------------------------------------------------------------- 1 | const int MOD = 46337; 2 | 3 | int conta(int N, int K, int* V) { 4 | return 4263046 % MOD; 5 | } 6 | -------------------------------------------------------------------------------- /2020/nazionali/pangramma/testo/pangram.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/nazionali/pangramma/testo/pangram.pdf -------------------------------------------------------------------------------- /2012/territoriali/galattici/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: galattici 2 | nome: Eserciti galattici 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2013/nazionali/fontane/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: fontane 2 | nome: Allenamento per la maratona 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2014/territoriali/brisbane/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: brisbane 2 | nome: A spasso per Brisbane 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2014/territoriali/brisbane/testo/image01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2014/territoriali/brisbane/testo/image01.jpg -------------------------------------------------------------------------------- /2014/territoriali/trovaparola/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: trovaparola 2 | nome: Trova la parola 3 | timeout: 1 4 | memlimit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2015/nazionali/accensione/task.yaml: -------------------------------------------------------------------------------- 1 | name: accensione 2 | title: Accensione dei PC 3 | time_limit: 1.0 4 | memory_limit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/task.yaml: -------------------------------------------------------------------------------- 1 | name: bottleneck 2 | title: Collo di bottiglia 3 | time_limit: 2.0 4 | memory_limit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/att/taglialegna.c: -------------------------------------------------------------------------------- 1 | void Abbatti(int, int); 2 | 3 | void Pianifica(int N, int altezza[]) { 4 | Abbatti(0, 1); 5 | } 6 | -------------------------------------------------------------------------------- /2015/territoriali/mojito/task.yaml: -------------------------------------------------------------------------------- 1 | name: mojito 2 | title: Giochiamo con Mojito 3 | time_limit: 1.0 4 | memory_limit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2015/territoriali/sommelier/testo/image01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2015/territoriali/sommelier/testo/image01.jpg -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | int raggiungi(int N, int M, int A[], int B[], int inizio[], int fine[]) { 2 | return -1; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/sol/nessuna_spiaggia.cpp: -------------------------------------------------------------------------------- 1 | long long percorri(int N, long long L, long long D[], long long P[]) { 2 | return L; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /2017/territoriali/discesa/task.yaml: -------------------------------------------------------------------------------- 1 | name: discesa 2 | title: Discesa massima 3 | token_mode: infinite 4 | infile: input.txt 5 | outfile: output.txt 6 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/asy_corteo/tab.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2018/nazionali/corteo/testo/asy_corteo/tab.png -------------------------------------------------------------------------------- /2018/territoriali/lwf/task.yaml: -------------------------------------------------------------------------------- 1 | name: lwf 2 | title: Crittografia LWF 3 | infile: input.txt 4 | outfile: output.txt 5 | memlimit: 64 6 | timeout: 1 7 | -------------------------------------------------------------------------------- /2019/territoriali/escursione/statement/map.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/territoriali/escursione/statement/map.jpg -------------------------------------------------------------------------------- /2011/territoriali/sbarramento/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: sbarramento 2 | nome: Sbarramento tattico 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2011/territoriali/tamburello/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: tamburello 2 | nome: Sequenza per tamburello 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2012/nazionali/matita/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: matita 2 | nome: Disegna senza sollevare la matita 3 | timeout: 4 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2013/nazionali/convoglio/task.yaml: -------------------------------------------------------------------------------- 1 | nome_breve: convoglio 2 | nome: La battaglia del convoglio 3 | timeout: 1 4 | memlimit: 512 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2014/territoriali/trovaparola/testo/image00.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2014/territoriali/trovaparola/testo/image00.png -------------------------------------------------------------------------------- /2014/territoriali/trovaparola/testo/image02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2014/territoriali/trovaparola/testo/image02.png -------------------------------------------------------------------------------- /2015/territoriali/collatz/task.yaml: -------------------------------------------------------------------------------- 1 | name: collatz 2 | title: La congettura di Collatz 3 | time_limit: 1.0 4 | memory_limit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2015/territoriali/sommelier/task.yaml: -------------------------------------------------------------------------------- 1 | name: sommelier 2 | title: Corso per sommelier 3 | time_limit: 1.0 4 | memory_limit: 256 5 | token_mode: infinite 6 | -------------------------------------------------------------------------------- /2017/territoriali/sentieri/task.yaml: -------------------------------------------------------------------------------- 1 | name: sentieri 2 | title: Sentieri bollenti 3 | token_mode: infinite 4 | infile: input.txt 5 | outfile: output.txt 6 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/asy_corteo/spazi.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2018/nazionali/corteo/testo/asy_corteo/spazi.png -------------------------------------------------------------------------------- /2018/territoriali/tecla/task.yaml: -------------------------------------------------------------------------------- 1 | name: tecla 2 | title: Appetito aracnide 3 | infile: input.txt 4 | outfile: output.txt 5 | memlimit: 64 6 | timeout: 1 7 | -------------------------------------------------------------------------------- /2019/territoriali/antivirus/statement/virus.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/territoriali/antivirus/statement/virus.jpg -------------------------------------------------------------------------------- /2019/territoriali/escursione/solutions/gibberish.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | printf("wibble monster\n"); 5 | return 0; 6 | } 7 | -------------------------------------------------------------------------------- /2016/territoriali/footing/testo/footing0.txt: -------------------------------------------------------------------------------- 1 | 6 10 2 | 1 2 1 3 | 3 2 2 4 | 5 2 6 5 | 4 5 2 6 | 1 4 2 7 | 3 5 1 8 | 3 4 7 9 | 5 1 5 10 | 2 6 4 11 | 3 6 3 -------------------------------------------------------------------------------- /2018/territoriali-remastered/lwf/solutions/gibberish.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | printf("wibble monster\n"); 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /2018/territoriali/tecla/testo/oddcycle.input1.txt: -------------------------------------------------------------------------------- 1 | 8 12 2 | 0 1 3 | 1 2 4 | 2 3 5 | 3 0 6 | 2 4 7 | 3 4 8 | 4 5 9 | 5 6 10 | 6 7 11 | 7 0 12 | 0 5 13 | 6 3 -------------------------------------------------------------------------------- /2019/nazionali/incendio/testo/asy_incendio/fire.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/nazionali/incendio/testo/asy_incendio/fire.png -------------------------------------------------------------------------------- /2020/territoriali/download/statement/download.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/territoriali/download/statement/download.jpg -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/statement/hierarchy.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/territoriali/gerarchie/statement/hierarchy.png -------------------------------------------------------------------------------- /2020/territoriali/multicore/statement/multicore.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/territoriali/multicore/statement/multicore.jpg -------------------------------------------------------------------------------- /2020/territoriali/multicore/statement/multicore_input_example.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 3 | 1 100 4 | 2 10 5 | 6 | 4 10000 7 | 4 5000 8 | 6 7000 9 | 8 4000 10 | 10 8000 -------------------------------------------------------------------------------- /2020/territoriali/tornello/statement/tornello.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/territoriali/tornello/statement/tornello.jpg -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/testo/asy_hogwarts/harry.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2017/nazionali/hogwarts/testo/asy_hogwarts/harry.png -------------------------------------------------------------------------------- /2017/nazionali/lungomare/testo/asy_lungomare/ring.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2017/nazionali/lungomare/testo/asy_lungomare/ring.png -------------------------------------------------------------------------------- /2017/territoriali/spartizione/task.yaml: -------------------------------------------------------------------------------- 1 | name: spartizione 2 | title: La spartizione di Totò 3 | token_mode: infinite 4 | infile: input.txt 5 | outfile: output.txt 6 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/tecla/solutions/gibberish.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | printf("wibble monster\n"); 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/tecla/statement/fig1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2018/territoriali-remastered/tecla/statement/fig1.png -------------------------------------------------------------------------------- /2018/territoriali-remastered/tecla/statement/fig2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2018/territoriali-remastered/tecla/statement/fig2.png -------------------------------------------------------------------------------- /2018/territoriali/scommessa/task.yaml: -------------------------------------------------------------------------------- 1 | name: scommessa 2 | title: Sport intellettuali 3 | infile: input.txt 4 | outfile: output.txt 5 | memlimit: 64 6 | timeout: 1 7 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/testo/asy_incendio/fire2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/nazionali/incendio/testo/asy_incendio/fire2.png -------------------------------------------------------------------------------- /2019/nazionali/incendio/testo/asy_incendio/hotel.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/nazionali/incendio/testo/asy_incendio/hotel.png -------------------------------------------------------------------------------- /2019/nazionali/incendio/testo/asy_incendio/school.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/nazionali/incendio/testo/asy_incendio/school.png -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/solutions/ottima_donadoni: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/territoriali/gerarchie/solutions/ottima_donadoni -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/att/bottleneck.c: -------------------------------------------------------------------------------- 1 | int Analizza(int N, int M, int W, int L, int arco_da[], int arco_a[], int capacita[], int R, int C) { 2 | return 42; 3 | } 4 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/testo/asy_lungomare/hotel.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2017/nazionali/lungomare/testo/asy_lungomare/hotel.png -------------------------------------------------------------------------------- /2017/territoriali/discesa/gen/GEN: -------------------------------------------------------------------------------- 1 | # N S 2 | 1 0 3 | 2 1 4 | 3 2 5 | 4 3 6 | 5 40 7 | 6 5 8 | 7 600 9 | 8 7 10 | 9 80 11 | 10 9 12 | -------------------------------------------------------------------------------- /2017/territoriali/sentieri/testo/sentieri.input0.txt: -------------------------------------------------------------------------------- 1 | 7 1 11 2 | 1 5 3 | 3 5 4 | 4 3 5 | 4 6 6 | 1 2 7 | 2 3 8 | 3 1 9 | 1 6 10 | 5 6 11 | 5 4 12 | 4 7 13 | 6 7 14 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/corteo.input0.txt: -------------------------------------------------------------------------------- 1 | 10 11 2 | 2 5 3 7 3 | 0 1 4 | 1 2 5 | 2 6 6 | 4 6 7 | 4 5 8 | 3 5 9 | 3 0 10 | 6 7 11 | 5 8 12 | 7 9 13 | 9 8 14 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/scommessa/solutions/gibberish.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | printf("wibble monster\n"); 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/asy_orticoltura/irr.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/nazionali/orticoltura/testo/asy_orticoltura/irr.png -------------------------------------------------------------------------------- /2009/nazionali/README.md: -------------------------------------------------------------------------------- 1 | Nel 2009 è stato fatto un passaggio ad un nuovo meccanismo di selezione, per cui non ci sono state selezioni nazionali per partecipare alle IOI2009. 2 | -------------------------------------------------------------------------------- /2014/territoriali/trovaparola/testo/esempio.txt: -------------------------------------------------------------------------------- 1 | 8 7 2 | OLIMPIADI 3 | OLIVENT 4 | GQMPWER 5 | GTRIAYE 6 | IUICDPE 7 | AFCOIGH 8 | JKXCVRS 9 | ROMITAA 10 | STANLEE 11 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/asy_orticoltura/cash.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/nazionali/orticoltura/testo/asy_orticoltura/cash.png -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/asy_orticoltura/dirt.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/nazionali/orticoltura/testo/asy_orticoltura/dirt.jpg -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/asy_orticoltura/grass.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/nazionali/orticoltura/testo/asy_orticoltura/grass.jpg -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/asy_orticoltura/seed.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/nazionali/orticoltura/testo/asy_orticoltura/seed.jpg -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/asy_orticoltura/seed2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/nazionali/orticoltura/testo/asy_orticoltura/seed2.png -------------------------------------------------------------------------------- /2010/territoriali/README.md: -------------------------------------------------------------------------------- 1 | Nel 2009 è stato fatto un passaggio ad un nuovo meccanismo di selezione, per cui non ci sono state selezioni territoriali per partecipare alle IOI2010. 2 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/testo/classifica.input1.txt: -------------------------------------------------------------------------------- 1 | 7 11 2 | 5 2 6 3 4 1 0 3 | x 5 4 | p 1 5 | x 2 6 | p 1 7 | p 2 8 | s 3 9 | p 1 10 | p 4 11 | x 0 12 | s 1 13 | p 3 14 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 10000000 2 | MAXL = 10**18 3 | 4 | MAXN_st3 = 100 5 | MAXN_st4 = 10000 6 | MAXN_st5 = 15 7 | MAXN_st6 = 10000 8 | MAXN_st7 = 1000000 9 | -------------------------------------------------------------------------------- /2017/territoriali/spartizione/gen/GEN: -------------------------------------------------------------------------------- 1 | # G P 2 | 17 2 3 | 112 2 4 | 215 2 5 | 517 2 6 | 910 2 7 | 575 5 8 | 929 7 9 | 717 8 10 | 999 9 11 | 1000 10 12 | -------------------------------------------------------------------------------- /2019/nazionali/circuiti/testo/asy_circuiti/visualizzatore.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2019/nazionali/circuiti/testo/asy_circuiti/visualizzatore.png -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/statement/asy_gerarchie/fig1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/territoriali/gerarchie/statement/asy_gerarchie/fig1.png -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/statement/asy_gerarchie/fig2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2020/territoriali/gerarchie/statement/asy_gerarchie/fig2.png -------------------------------------------------------------------------------- /2017/nazionali/classifica/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000000 2 | MAXQ = 1000000 3 | MAXN_st2 = 10000 4 | MAXQ_st2 = 10000 5 | MAXQ_st3 = 100000 6 | MAXQ_st4 = 100000 7 | MAXQ_st6 = 100000 8 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/testo/immagini_classifica/albero.ggb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2017/nazionali/classifica/testo/immagini_classifica/albero.ggb -------------------------------------------------------------------------------- /2017/territoriali/sentieri/testo/sentieri.input1.txt: -------------------------------------------------------------------------------- 1 | 8 5 9 2 | 1 5 3 | 3 5 4 | 4 3 5 | 4 6 6 | 7 8 7 | 1 2 8 | 2 3 9 | 3 1 10 | 1 6 11 | 5 6 12 | 5 4 13 | 4 8 14 | 6 8 15 | 6 7 16 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/grattacieli.input2.txt: -------------------------------------------------------------------------------- 1 | 10 9 2 | 3 8 9 6 9 1 6 7 7 9 3 | 3 4 1 4 | 0 1 2 5 | 4 0 4 6 | 5 0 1 7 | 8 0 0 8 | 8 2 1 9 | 1 8 2 10 | 7 9 1 11 | 6 7 2 12 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 2000000 2 | MAXH = 1000000 3 | 4 | MAXN_ST = [ 10, MAXN, 50, 400, 5000, 100000, MAXN ] 5 | MAXH_ST = [ MAXH, 2, MAXH, MAXH, MAXH, MAXH, MAXH ] 6 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/task.yaml: -------------------------------------------------------------------------------- 1 | infile: input.txt 2 | memory_limit: 256 3 | name: aeroporto 4 | outfile: output.txt 5 | time_limit: 0.2 6 | title: Torre di controllo 7 | token_mode: infinite 8 | -------------------------------------------------------------------------------- /2016/nazionali/paletta/task.yaml: -------------------------------------------------------------------------------- 1 | infile: input.txt 2 | memory_limit: 256 3 | name: paletta 4 | outfile: output.txt 5 | time_limit: 0.2 6 | title: Ordinamento a paletta 7 | token_mode: infinite 8 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/sol/uno.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int alzati(int N, int M, int X[], int Y[]) { 4 | return std::max(std::min(X[0], N-1-Y[0]), std::min(Y[0], N-1-X[0]))-1; 5 | } 6 | -------------------------------------------------------------------------------- /2016/territoriali/footing/task.yaml: -------------------------------------------------------------------------------- 1 | memory_limit: 256 2 | name: footing 3 | time_limit: 1.0 4 | title: Corsa mattutina 5 | token_mode: infinite 6 | diff: 1 7 | infile: input.txt 8 | outfile: output.txt -------------------------------------------------------------------------------- /2017/territoriali/sentieri/testo/extra/fig-sentieri.graffle/image1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/olimpiadi-informatica/oii/HEAD/2017/territoriali/sentieri/testo/extra/fig-sentieri.graffle/image1.png -------------------------------------------------------------------------------- /2020/territoriali/tornello/statement/tornello_input_example.txt: -------------------------------------------------------------------------------- 1 | 4 2 | 3 | 3 4 | -1 -1 -1 5 | 6 | 3 7 | +1 +1 +1 8 | 9 | 3 10 | +1 -1 +1 11 | 12 | 10 13 | -1 +1 +1 +1 -1 +1 +1 +1 -1 +1 14 | -------------------------------------------------------------------------------- /2015/territoriali/collatz/gen/GEN: -------------------------------------------------------------------------------- 1 | # N S 2 | 3 | 6 -0 4 | 24 -1 5 | 30 2 6 | 55 3 7 | 73 4 8 | 111 5 9 | 327 6 10 | 530 7 11 | 703 8 12 | 871 9 13 | -------------------------------------------------------------------------------- /2016/territoriali/semiprimo/task.yaml: -------------------------------------------------------------------------------- 1 | memory_limit: 256 2 | name: semiprimo 3 | time_limit: 1.0 4 | title: Numero semiprimo 5 | token_mode: infinite 6 | diff: 1 7 | infile: input.txt 8 | outfile: output.txt -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/task.yaml: -------------------------------------------------------------------------------- 1 | infile: '' 2 | memory_limit: 256 3 | name: hogwarts 4 | outfile: '' 5 | time_limit: 1.0 6 | title: Scale di Hogwarts 7 | token_mode: disabled 8 | public_testcases: all 9 | -------------------------------------------------------------------------------- /2015/territoriali/sommelier/gen/GEN: -------------------------------------------------------------------------------- 1 | # N S 2 | 3 | 5 -0 4 | 5 -1 5 | 10 2 6 | 20 3 7 | 30 4 8 | 40 5 9 | 50 6 10 | 60 7 11 | 80 8 12 | 99 9 13 | -------------------------------------------------------------------------------- /2016/nazionali/nemesi/task.yaml: -------------------------------------------------------------------------------- 1 | infile: input.txt 2 | memory_limit: 256 3 | name: nemesi 4 | outfile: output.txt 5 | time_limit: 0.5 6 | title: Nemico mortale 7 | token_mode: infinite 8 | viz_testcases: [0, 1] 9 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/task.yaml: -------------------------------------------------------------------------------- 1 | infile: '' 2 | memory_limit: 256 3 | name: classifica 4 | outfile: '' 5 | public_testcases: all 6 | time_limit: 0.8 7 | title: Classifica senza fili 8 | token_mode: disabled 9 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/task.yaml: -------------------------------------------------------------------------------- 1 | infile: '' 2 | memory_limit: 512 3 | name: lungomare 4 | outfile: '' 5 | time_limit: 0.3 6 | title: Solleone sul lungomare 7 | token_mode: disabled 8 | public_testcases: all 9 | -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/solutions/write_zero.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import sys 4 | 5 | T = int(sys.stdin.readline().strip()) 6 | 7 | for t in range(1, T+1): 8 | print("Case #%d: 0" % t) 9 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/asy_caduta/fig1.asy: -------------------------------------------------------------------------------- 1 | import util; 2 | 3 | int[] altezze = {3, 2, 1, 4, 1}; 4 | int[] colors = {1, 4, 5, 3, 8}; 5 | int D = 1; 6 | int seed = 42; 7 | 8 | main(altezze, colors, D, seed); 9 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/asy_caduta/fig2.asy: -------------------------------------------------------------------------------- 1 | import util; 2 | 3 | int[] altezze = {3, 2, 2, 4, 1}; 4 | int[] colors = {1, 4, 4, 3, 8}; 5 | int D = 1; 6 | int seed = 42; 7 | 8 | main(altezze, colors, D, seed); 9 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/testo/asy_caduta/fig3.asy: -------------------------------------------------------------------------------- 1 | import util; 2 | 3 | int[] altezze = {1, 1, 1, 1, 1}; 4 | int[] colors = {1, 1, 1, 1, 1}; 5 | int D = 1; 6 | int seed = 42; 7 | 8 | main(altezze, colors, D, seed); 9 | -------------------------------------------------------------------------------- /2016/territoriali/disuguaglianze/task.yaml: -------------------------------------------------------------------------------- 1 | memory_limit: 256 2 | name: disuguaglianze 3 | time_limit: 1.0 4 | title: Rispetta i versi 5 | token_mode: infinite 6 | diff: 1 7 | infile: input.txt 8 | outfile: output.txt 9 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/att/lungomare.c: -------------------------------------------------------------------------------- 1 | long long int percorri(int N, long long int L, long long int D[], long long int P[]) { 2 | D[0] = 123456789123ll; 3 | P[0] = 123456789123ll; 4 | return 123456789123ll; 5 | } 6 | 7 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/att/lungomare.cpp: -------------------------------------------------------------------------------- 1 | long long int percorri(int N, long long int L, long long int D[], long long int P[]) { 2 | D[0] = 123456789123ll; 3 | P[0] = 123456789123ll; 4 | return 123456789123ll; 5 | } 6 | 7 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/sol/template_c.c: -------------------------------------------------------------------------------- 1 | long long int percorri(int N, long long int L, long long int D[], long long int P[]) { 2 | D[0] = 123456789123ll; 3 | P[0] = 123456789123ll; 4 | return 123456789123ll; 5 | } 6 | 7 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/task.yaml: -------------------------------------------------------------------------------- 1 | infile: '' 2 | memory_limit: 256 3 | name: caduta 4 | outfile: '' 5 | public_testcases: all 6 | score_mode: max 7 | time_limit: 1.0 8 | title: Pazza gioia 9 | token_mode: disabled 10 | -------------------------------------------------------------------------------- /2020/nazionali/pangramma/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | const int MOD = 46337; 6 | 7 | int conta(int N, int K, vector& V) { 8 | return 4263046 % MOD; 9 | } 10 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | \#*# 3 | __pycache__ 4 | .itime 5 | .import_error 6 | input/ 7 | output/ 8 | *.aux 9 | *.log 10 | *.out 11 | *.synctex.gz 12 | *.pdf 13 | *.pyg 14 | *.pyc 15 | *.o 16 | *.ppu 17 | *.plist 18 | *DWARF* 19 | -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100000 2 | MAXM = 1000000 3 | MAXW = 1000000000 4 | MAXC = 300 5 | 6 | MAXN_ST = [MAXN, MAXN, MAXN, MAXN, MAXN, 1000, MAXN] 7 | MAXM_ST = [MAXM, MAXM, MAXM, MAXM, MAXM, 1000, MAXM] 8 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | long long int percorri(int N, long long int L, long long int D[], long long int P[]) { 2 | D[0] = 123456789123ll; 3 | P[0] = 123456789123ll; 4 | return 123456789123ll; 5 | } 6 | 7 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/task.yaml: -------------------------------------------------------------------------------- 1 | infile: '' 2 | memory_limit: 256 3 | name: corteo 4 | outfile: '' 5 | public_testcases: all 6 | score_mode: max 7 | time_limit: 1.0 8 | title: Ordine pubblico 9 | token_mode: disabled 10 | -------------------------------------------------------------------------------- /2019/territoriali/escursione/statement/escursione_input_example.txt: -------------------------------------------------------------------------------- 1 | 3 2 | 3 | 2 2 4 | 100 150 5 | 110 130 6 | 7 | 4 4 8 | 1 5 6 7 9 | 2 4 3 8 10 | 2 9 2 8 11 | 3 3 2 9 12 | 13 | 1 10 14 | 2 4 6 8 10 12 14 16 18 20 15 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/sol/template_c.c: -------------------------------------------------------------------------------- 1 | void posiziona(int D, int T); 2 | 3 | void budget(int B); 4 | 5 | void irriga(int C, int N, int* X, int* P) 6 | { 7 | posiziona(X[0], P[0]); 8 | budget(42); 9 | } 10 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/asy_orticoltura/fig2.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int larg = 11; 4 | int alt = 4; 5 | int C = 5; 6 | pair[] irr = {(4.5, 3.5)}; 7 | pair[] semi = {(2,1), (7,1)}; 8 | main(larg, alt, C, semi, irr); 9 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/testo/aux/sol_taglialegna_quadratica_lep.cpp: -------------------------------------------------------------------------------- 1 | // Costruzione di lep 2 | for (int i = 0; i < N; i++) { 3 | lep[i] = i; 4 | for (int j = i; j > i - H[i] && j >= 0; j--) 5 | lep[i] = min(lep[i], lep[j]); 6 | } -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 500000 2 | MAXM = 1000000 3 | MAXT = 2000000 4 | 5 | MAXN_st2 = 10 6 | MAXM_st2 = 15 7 | MAXT_st2 = 20 8 | 9 | MAXN_st5 = 1000 10 | MAXM_st5 = 2000 11 | MAXT_st5 = 5000 12 | 13 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/task.yaml: -------------------------------------------------------------------------------- 1 | infile: '' 2 | memory_limit: 1024 3 | name: specchi 4 | outfile: '' 5 | public_testcases: all 6 | score_mode: max 7 | time_limit: 3.0 8 | title: Stanza degli specchi 9 | token_mode: disabled 10 | -------------------------------------------------------------------------------- /2020/territoriali/gerarchie/statement/gerarchie_input_example.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 3 | 7 4 | 6 6 5 | -1 0 6 | 4 4 7 | 1 2 8 | 1 1 9 | 4 3 10 | 4 5 11 | 12 | 8 13 | 3 6 14 | 2 4 15 | -1 7 16 | 2 5 17 | 5 1 18 | 2 0 19 | 3 2 20 | 5 3 21 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/testo/aux/sol_taglialegna_quadratica_rep.cpp: -------------------------------------------------------------------------------- 1 | // Costruzione di rep 2 | for (int i = N - 1; i >= 0; i--) { 3 | rep[i] = i; 4 | for (int j = i; j < i + H[i] && j < N; j++) 5 | rep[i] = max(rep[i], rep[j]); 6 | } -------------------------------------------------------------------------------- /2019/nazionali/circuiti/testo/circuiti.statement.txt: -------------------------------------------------------------------------------- 1 | add[0] = in[0] + in[1] 2 | add[1] = 5 + in[3] 3 | add[2] = in[3] + in[4] 4 | add[3] = add[0] + add[1] 5 | add[4] = add[1] - add[2] 6 | m[7] = add[3] max add[4] 7 | out[0] = m[7] + in[5] 8 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | long long costruisci(int N, int M, vector& H, vector& A, vector& B, vector& C) { 6 | return 42; 7 | } 8 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/asy_orticoltura/fig0.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int larg = 9; 4 | int alt = 3; 5 | int C = 1; 6 | pair[] irr = {(3.8, 2.6), (7,2)}; 7 | pair[] semi = {(5, 1), (2, 2), (7,2)}; 8 | main(larg, alt, C, semi, irr); 9 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/testo/aux/sol_taglialegna_lineare_rep.cpp: -------------------------------------------------------------------------------- 1 | // Costruiamo rep in tempo lineare 2 | for (int i = N - 1; i >= 0; i--) { 3 | rep[i] = i; 4 | while (rep[i] + 1 < N && rep[i] + 1 < i + H[i]) 5 | rep[i] = rep[rep[i] + 1]; 6 | } -------------------------------------------------------------------------------- /2019/territoriali/antivirus/statement/antivirus_input_example.txt: -------------------------------------------------------------------------------- 1 | 2 2 | 3 | 8 12 10 7 4 | 4 5 | ananasso 6 | associazione 7 | tassonomia 8 | massone 9 | 10 | 6 9 11 10 11 | 3 12 | simone 13 | ponessimo 14 | milionesimo 15 | cassonetto 16 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/testo/asy_orticoltura/fig1.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int larg = 11; 4 | int alt = 5; 5 | int C = 1; 6 | pair[] irr = {(10, 4), (2,2)}; 7 | pair[] semi = {(1,1), (2,2), (8,2), (11,3)}; 8 | main(larg, alt, C, semi, irr); 9 | -------------------------------------------------------------------------------- /2009/territoriali/treno/gen/GEN: -------------------------------------------------------------------------------- 1 | # Num di vagoni 2 | 3 | 10 # TODO: dovrebbe essere l'esempio? 4 | 20 5 | 31 6 | 44 7 | 161 8 | 354 9 | 567 10 | 768 11 | 999 12 | 7 13 | 25 14 | 47 15 | 58 16 | 101 17 | 54 18 | 38 19 | 5 20 | 48 21 | 33 22 | 97 23 | -------------------------------------------------------------------------------- /2008/territoriali/missioni/gen/GEN: -------------------------------------------------------------------------------- 1 | # N seed 2 | 3 | 10 0 # TODO: dovrebbe essere l'input di esempio? 4 | 20 1 5 | 30 2 6 | 35 3 7 | 80 4 8 | 90 5 9 | 100 6 10 | 100 7 11 | 100 8 12 | 100 9 13 | 14 | # TODO: aggiungere altri testcase 15 | -------------------------------------------------------------------------------- /2011/territoriali/sbarramento/gen/GEN: -------------------------------------------------------------------------------- 1 | # Parametri: 2 | # * N (dimensione del campo di battaglia) 3 | # * S (seed) 4 | 5 | ## TODO input di esempio 6 | 50 1 7 | 42 2 8 | 131 3 9 | 67 4 10 | 195 5 11 | 79 6 12 | 320 7 13 | 71 8 14 | 452 9 15 | -------------------------------------------------------------------------------- /2016/nazionali/nemesi/sol/template_c.c: -------------------------------------------------------------------------------- 1 | void nuovo_gruppo(); 2 | 3 | void aggiungi(int bambino); 4 | 5 | void smista(int N, int nemico[]) { 6 | int i; 7 | for (i = 0; i < N; i++) { 8 | nuovo_gruppo(); 9 | aggiungi(i); 10 | } 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/sol/mangiapunti_triste.cpp: -------------------------------------------------------------------------------- 1 | // chiama questa funzione per spostare un corteo (non la devi implementare!) 2 | // chi = 1..2 3 | // dove = 0..N-1 4 | int pianifica(int N, int M, int P1, int D1, int P2, int D2, int A[], int B[]) { 5 | return 1; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/lwf/managers/validator.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | from limits import MAXN 3 | import sys 4 | 5 | f = sys.stdin.readlines() 6 | T = int(f[0].strip()) 7 | for i in range(T): 8 | N = int(f[i + 1].strip()) 9 | assert 1 <= N <= MAXN 10 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/att/classifica.c: -------------------------------------------------------------------------------- 1 | void inizia(int N, int ids[]) { 2 | return ; 3 | } 4 | 5 | void supera(int id) { 6 | return ; 7 | } 8 | 9 | void squalifica(int id) { 10 | return ; 11 | } 12 | 13 | int partecipante(int pos) { 14 | return 1; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/att/classifica.cpp: -------------------------------------------------------------------------------- 1 | void inizia(int N, int ids[]) { 2 | return ; 3 | } 4 | 5 | void supera(int id) { 6 | return ; 7 | } 8 | 9 | void squalifica(int id) { 10 | return ; 11 | } 12 | 13 | int partecipante(int pos) { 14 | return 1; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/sol/template_c.c: -------------------------------------------------------------------------------- 1 | void inizia(int N, int ids[]) { 2 | return ; 3 | } 4 | 5 | void supera(int id) { 6 | return ; 7 | } 8 | 9 | void squalifica(int id) { 10 | return ; 11 | } 12 | 13 | int partecipante(int pos) { 14 | return 1; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | void inizia(int N, int ids[]) { 2 | return ; 3 | } 4 | 5 | void supera(int id) { 6 | return ; 7 | } 8 | 9 | void squalifica(int id) { 10 | return ; 11 | } 12 | 13 | int partecipante(int pos) { 14 | return 1; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /2019/nazionali/cena/task.yaml: -------------------------------------------------------------------------------- 1 | # General info 2 | name: cena 3 | title: Cena di gala 4 | 5 | # Technical info 6 | memory_limit: 512 7 | time_limit: 1 8 | infile: '' 9 | outfile: '' 10 | 11 | # Other stuff 12 | score_mode: max 13 | token_mode: disabled 14 | public_testcases: all 15 | -------------------------------------------------------------------------------- /2011/nazionali/contest.yaml: -------------------------------------------------------------------------------- 1 | name: oii 2 | description: OII 2011 3 | start: 1317366000 4 | stop: 1317384000 5 | tasks: 6 | - eso 7 | - fibstr 8 | - matita 9 | - salta 10 | users: 11 | - first_name: Name 12 | last_name: Surname 13 | username: user 14 | password: password 15 | ip: 10.0.0.1 16 | -------------------------------------------------------------------------------- /2014/territoriali/gardaland/gen/GEN: -------------------------------------------------------------------------------- 1 | # N (numero di nazioni) 2 | # L (numero di informazioni) 3 | # S (seed) 4 | 5 | #COPY: testo/esempio.txt 6 | 20 100 1 7 | 30 50 2 8 | 40 41 3 9 | 50 1000 4 10 | 60 60 5 11 | 70 400 6 12 | 80 1000 7 13 | 90 500 8 14 | 100 1000 9 15 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/task.yaml: -------------------------------------------------------------------------------- 1 | # General info 2 | name: incendio 3 | title: Attenti all'incendio 4 | 5 | # Technical info 6 | memory_limit: 512 7 | time_limit: 1 8 | infile: '' 9 | outfile: '' 10 | 11 | # Other stuff 12 | score_mode: max 13 | token_mode: disabled 14 | public_testcases: all 15 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/sol/template_cpp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | void posiziona(int D, int T); 6 | 7 | void budget(int B); 8 | 9 | void irriga(int C, int N, vector& X, vector& P) 10 | { 11 | posiziona(X[0], P[0]); 12 | budget(42); 13 | } 14 | -------------------------------------------------------------------------------- /2014/nazionali/maree/att/maree.pas: -------------------------------------------------------------------------------- 1 | unit maree; 2 | 3 | interface 4 | 5 | function solve(N, M, T: longint; var S, E: array of longint): longint; 6 | 7 | implementation 8 | 9 | function solve(N, M, T: longint; var S, E: array of longint): longint; 10 | begin 11 | solve := 0; 12 | end; 13 | 14 | end. 15 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/sol/fini.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Soluzione stupida 3 | * 4 | * Autore: Federico 5 | * 6 | * Descrizione: Si pone T[i] = B[i]. 7 | * La complessità è R. 8 | */ 9 | 10 | void pianifica(int R, int A[], int B[], int T[]) { 11 | for (int i = 0; i < R; i++) T[i] = B[i]; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/sol/inizi.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Soluzione stupida 3 | * 4 | * Autore: Federico 5 | * 6 | * Descrizione: Si pone T[i] = A[i]. 7 | * La complessità è R. 8 | */ 9 | 10 | void pianifica(int R, int A[], int B[], int T[]) { 11 | for (int i = 0; i < R; i++) T[i] = A[i]; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /2011/nazionali/salti/gen/GEN: -------------------------------------------------------------------------------- 1 | # N 2 | 3 | # TODO: manca l'input di esempio 4 | 15 5 | 26 6 | 59 7 | 1023 8 | 7247 9 | 52355 10 | 94344 11 | 395439 12 | 6343922 13 | 23433953 14 | 332421988 15 | 533494325 16 | 734823833 17 | 629702655 18 | 831349394 19 | 938343822 20 | 1003493847 21 | 1059833424 22 | 1073741824 23 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/testo/aux/sol_taglialegna_lineare_lep.cpp: -------------------------------------------------------------------------------- 1 | // Costruiamo lep e abbattitore in tempo lineare 2 | for (int i = 0; i < N; i++) { 3 | lep[i] = i, abbattitore[i] = INF; 4 | while (lep[i] - 1 >= 0 && lep[i] - 1 > i - H[i]) { 5 | abbattitore[lep[i] - 1] = i; 6 | lep[i] = lep[lep[i] - 1]; 7 | } 8 | } -------------------------------------------------------------------------------- /2010/nazionali/contest.yaml: -------------------------------------------------------------------------------- 1 | name: oii 2 | description: Olimpiadi Italiane di Informatica 3 | start: 1287126000 4 | stop: 1287144000 5 | tasks: 6 | - baht 7 | - fuga 8 | - salti 9 | - scuola 10 | users: 11 | - first_name: Name 12 | last_name: Surname 13 | username: user 14 | password: password 15 | ip: 10.0.0.1 16 | -------------------------------------------------------------------------------- /2011/territoriali/quasipal/gen/GEN: -------------------------------------------------------------------------------- 1 | # Parametri: 2 | # * M (numero di righe) 3 | # * N (numero di cifre decimali) 4 | # * P (percentuale di zeri) 5 | # * S (seed) 6 | 7 | ## TODO input di esempio 8 | 3 8 50 1 9 | 4 8 40 2 10 | 5 7 30 3 11 | 6 8 60 4 12 | 7 8 50 5 13 | 8 8 40 6 14 | 7 8 30 7 15 | 6 8 40 8 16 | 5 8 30 9 17 | -------------------------------------------------------------------------------- /2012/nazionali/contest.yaml: -------------------------------------------------------------------------------- 1 | name: oii 2 | description: OII 2012 3 | start: 1350025200 4 | stop: 1350043200 5 | token_mode: infinite 6 | tasks: 7 | - fermata 8 | - convoglio 9 | - fontane 10 | users: 11 | - first_name: Name 12 | last_name: Surname 13 | username: user 14 | password: password 15 | ip: 10.0.0.1 16 | -------------------------------------------------------------------------------- /2019/nazionali/circuiti/task.yaml: -------------------------------------------------------------------------------- 1 | # General info 2 | name: circuiti 3 | title: Circuiti bruciati 4 | 5 | # Technical info 6 | memory_limit: 1024 7 | time_limit: 10 8 | infile: '' 9 | outfile: '' 10 | 11 | # Other stuff 12 | score_mode: max 13 | token_mode: disabled 14 | public_testcases: all 15 | output_only: True 16 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: "python" 2 | python: 3 | - "2.7" 4 | before_install: 5 | - sudo apt-get install -qq python-pip gettext build-essential fpc 6 | - git clone https://github.com/cms-dev/cms.git 7 | - cd cms 8 | - pip install -r REQUIREMENTS.txt 9 | - python setup.py build 10 | - sudo python setup.py install 11 | -------------------------------------------------------------------------------- /2014/nazionali/spiedini/att/spiedini.pas: -------------------------------------------------------------------------------- 1 | unit spiedini; 2 | 3 | interface 4 | 5 | function solve(N: longint; K: longint; var S: array of longint): longint; 6 | 7 | implementation 8 | 9 | function solve(N: longint; K: longint; var S: array of longint): longint; 10 | begin 11 | solve := 0; 12 | end; 13 | 14 | end. 15 | -------------------------------------------------------------------------------- /2015/territoriali/mojito/gen/GEN: -------------------------------------------------------------------------------- 1 | # X Y N S 2 | 3 | 5 3 2 -0 4 | 8 3 3 -1 5 | 10 10 10 2 6 | 30 20 5 3 7 | 20 30 50 4 8 | 50 10 5 5 9 | 10 50 70 6 10 | 100 10 80 7 11 | 20 10 90 8 12 | 100 100 100 9 13 | -------------------------------------------------------------------------------- /2019/territoriali/antivirus/solutions/invalid_pos.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | int T; 9 | cin >> T; 10 | for (int t = 1; t <= T; t++) { 11 | cout << "Case #" << t << ": -1 -1 -1 -1" << endl; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /2017/territoriali/sentieri/gen/GEN: -------------------------------------------------------------------------------- 1 | # N M T S 2 | 16 15 1 3 3 | 80 162 2 1 4 | 11 10 1 2 5 | 20 19 1 1 6 | 20 37 2 1 7 | 50 49 1 1 8 | 50 99 2 1 9 | 99 218 2 1 10 | 100 99 1 1 11 | 100 203 2 1 12 | -------------------------------------------------------------------------------- /2010/nazionali/amici/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python2 2 | 3 | import sys 4 | import os 5 | 6 | def usage(): 7 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 8 | os.path.basename(sys.argv[0]) 9 | sys.exit(1) 10 | 11 | if __name__ == "__main__": 12 | if len(sys.argv) < 2: 13 | usage() 14 | 15 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 1000000 2 | MAXX = 10**9 3 | MAXP = 10**9 4 | MAXC = 10**9 5 | 6 | subtasks = [ 7 | dict(), 8 | dict(), 9 | dict(MAXN=4, MAXX=100, MAXP=10), 10 | dict(MAXN=1000, MAXP=10), 11 | dict(MAXP=10), 12 | dict(MAXN=1000), 13 | dict(MAXC=0), 14 | dict(), 15 | ] 16 | -------------------------------------------------------------------------------- /2020/nazionali/orticoltura/task.yaml: -------------------------------------------------------------------------------- 1 | # General info 2 | name: orticoltura 3 | title: Cecilia e l'orticoltura 4 | 5 | # Technical info 6 | memory_limit: 256 7 | time_limit: 1.0 8 | infile: "" 9 | outfile: "" 10 | 11 | # Other stuff 12 | score_mode: max_subtask 13 | token_mode: disabled 14 | public_testcases: all 15 | feedback_level: full -------------------------------------------------------------------------------- /2014/nazionali/bufale/att/bufale.pas: -------------------------------------------------------------------------------- 1 | unit bufale; 2 | 3 | interface 4 | 5 | function solve(N: longint; var M: array of longint; var P: array of longint): int64; 6 | 7 | implementation 8 | 9 | function solve(N: longint; var M: array of longint; var P: array of longint): int64; 10 | begin 11 | solve := 0; 12 | end; 13 | 14 | end. 15 | -------------------------------------------------------------------------------- /2016/territoriali/footing/gen/GEN: -------------------------------------------------------------------------------- 1 | # nodi, archi, max peso, seed 2 | 3 | #COPY: testo/footing0.txt 4 | 5 6 1 1 5 | 10 20 1 2 6 | 50 100 10000 3 7 | 100 150 1 4 8 | 200 500 10000 5 9 | 500 500 1 6 10 | 700 1000 10000 7 11 | 850 5000 1 8 12 | 1000 10000 10000 9 13 | -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/att/hogwarts.pas: -------------------------------------------------------------------------------- 1 | unit hogwarts; 2 | 3 | interface 4 | 5 | function raggiungi(N, M: longint; A, B, inizio, fine: array of longint): longint; 6 | 7 | implementation 8 | 9 | function raggiungi(N, M: longint; A, B, inizio, fine: array of longint): longint; 10 | begin 11 | raggiungi := 1; 12 | end; 13 | 14 | end. 15 | -------------------------------------------------------------------------------- /2020/nazionali/pangramma/task.yaml: -------------------------------------------------------------------------------- 1 | # General info 2 | name: pangramma 3 | title: Sfida all'ultimo pangramma 4 | 5 | # Technical info 6 | memory_limit: 512 7 | time_limit: 0.5 8 | infile: "" 9 | outfile: "" 10 | 11 | # Other stuff 12 | score_mode: max_subtask 13 | token_mode: disabled 14 | public_testcases: all 15 | feedback_level: full 16 | -------------------------------------------------------------------------------- /2008/nazionali/cnn/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | import sys 4 | import os 5 | 6 | def usage(): 7 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 8 | os.path.basename(sys.argv[0]) 9 | sys.exit(1) 10 | 11 | if __name__ == "__main__": 12 | if len(sys.argv) < 2: 13 | usage() 14 | 15 | -------------------------------------------------------------------------------- /2013/nazionali/contest.yaml: -------------------------------------------------------------------------------- 1 | name: oii 2 | description: Olimpiadi Italiane di Informatica 2013 3 | start: 1379054700 4 | stop: 1379072700 5 | token_mode: disabled 6 | tasks: 7 | - bufale 8 | - spiedini 9 | - maree 10 | users: 11 | - first_name: Name 12 | last_name: Surname 13 | username: user 14 | password: password 15 | ip: 10.0.0.1 16 | -------------------------------------------------------------------------------- /2014/territoriali/trovaparola/gen/GEN: -------------------------------------------------------------------------------- 1 | # R (numero di righe) 2 | # C (numero di colonne) 3 | # T (risolvibile = 0/1) 4 | # S (seed) 5 | 6 | #COPY: testo/esempio.txt 7 | 20 20 1 1 8 | 30 30 1 2 9 | 40 40 0 3 10 | 50 10 1 4 11 | 10 60 1 5 12 | 70 100 1 6 13 | 100 80 1 7 14 | 90 90 0 8 15 | 100 100 1 9 16 | -------------------------------------------------------------------------------- /2016/nazionali/paletta/sol/feasibility.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Soluzione parziale di paletta 3 | * 4 | * Autore: Giorgio 5 | * 6 | * Descrizione: controlla solo se e' fattibile ordinare. 7 | */ 8 | 9 | 10 | long long paletta_sort(int N, int V[]) { 11 | for (int i=0; i 0) return -1; 12 | return 42; 13 | } 14 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/task.yaml: -------------------------------------------------------------------------------- 1 | # General info 2 | name: grattacieli 3 | title: Grattacieli commemorativi 4 | 5 | # Technical info 6 | memory_limit: 256 7 | time_limit: 0.5 8 | infile: "" 9 | outfile: "" 10 | 11 | # Other stuff 12 | score_mode: max_subtask 13 | token_mode: disabled 14 | public_testcases: all 15 | feedback_level: full 16 | -------------------------------------------------------------------------------- /2008/nazionali/cnn/gen/GEN: -------------------------------------------------------------------------------- 1 | # N M seed 2 | 3 | #COPY: testo/input0.txt 4 | 10 10 1 5 | 5 10 2 6 | 5 10 4 7 | 40 30 4 8 | 30 40 5 9 | 40 40 6 10 | 700 300 7 11 | 800 300 8 12 | 900 300 9 13 | 1000 300 10 14 | 300 400 11 15 | 300 500 12 16 | 500 600 13 17 | 900 700 14 18 | 700 800 15 19 | 800 900 16 20 | 850 1000 17 21 | 900 900 18 22 | 1000 1000 19 23 | -------------------------------------------------------------------------------- /2008/nazionali/parole/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | import sys 4 | import os 5 | 6 | def usage(): 7 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 8 | os.path.basename(sys.argv[0]) 9 | sys.exit(1) 10 | 11 | if __name__ == "__main__": 12 | if len(sys.argv) < 2: 13 | usage() 14 | 15 | -------------------------------------------------------------------------------- /2008/nazionali/triade/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | import sys 4 | import os 5 | 6 | def usage(): 7 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 8 | os.path.basename(sys.argv[0]) 9 | sys.exit(1) 10 | 11 | if __name__ == "__main__": 12 | if len(sys.argv) < 2: 13 | usage() 14 | 15 | -------------------------------------------------------------------------------- /2017/nazionali/hogwarts/sol/template_pascal.pas: -------------------------------------------------------------------------------- 1 | unit hogwarts; 2 | 3 | interface 4 | 5 | function raggiungi(N, M: longint; A, B, inizio, fine: array of longint): longint; 6 | 7 | implementation 8 | 9 | function raggiungi(N, M: longint; A, B, inizio, fine: array of longint): longint; 10 | begin 11 | raggiungi := 1; 12 | end; 13 | 14 | end. 15 | -------------------------------------------------------------------------------- /2019/nazionali/circuiti/testo/circuiti.output2.txt: -------------------------------------------------------------------------------- 1 | somma[0] = 0 + 0 2 | somma[12] = in[0] + in[1] 3 | somma[23] = in[1] + in[2] 4 | mx[0] = somma[0] max in[0] 5 | somma[123] = somma[12] + in[2] 6 | mx[1] = mx[0] max in[1] 7 | mx[2] = mx[1] max in[2] 8 | mx[3] = somma[12] max mx[2] 9 | mx[4] = mx[3] max somma[23] 10 | out[0] = mx[4] max somma[123] 11 | -------------------------------------------------------------------------------- /2016/territoriali/semiprimo/gen/GEN: -------------------------------------------------------------------------------- 1 | # valore da stampare 2 | 3 | #COPY: testo/semiprimo0.txt 4 | 87 # 3 29 5 | 36 # 2 2 3 3 6 | 1000000 # 2 2 2 2 2 2 5 5 5 5 5 5 7 | 799 # 17 47 8 | 61517 # 227 271 9 | 153583 # 383 401 10 | 25957 # 101 257 11 | 159151 # 167 953 12 | 121879 # 307 397 13 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/sol/bogus_scambia_0_0.cpp: -------------------------------------------------------------------------------- 1 | typedef enum { 2 | OK, 3 | RISOLTO, 4 | IMPOSSIBILE 5 | } stato_t; 6 | 7 | typedef struct { 8 | int domino1; 9 | int domino2; 10 | } coppia_t; 11 | 12 | stato_t correggi(int N, int altezze[], coppia_t* scambio) { 13 | scambio->domino1 = 0; 14 | scambio->domino2 = 0; 15 | return RISOLTO; 16 | } 17 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/sol/bogus_scambia_0_1.cpp: -------------------------------------------------------------------------------- 1 | typedef enum { 2 | OK, 3 | RISOLTO, 4 | IMPOSSIBILE 5 | } stato_t; 6 | 7 | typedef struct { 8 | int domino1; 9 | int domino2; 10 | } coppia_t; 11 | 12 | stato_t correggi(int N, int altezze[], coppia_t* scambio) { 13 | scambio->domino1 = 0; 14 | scambio->domino2 = 1; 15 | return RISOLTO; 16 | } 17 | -------------------------------------------------------------------------------- /2018/nazionali/caduta/sol/bogus_scambia_0_N.cpp: -------------------------------------------------------------------------------- 1 | typedef enum { 2 | OK, 3 | RISOLTO, 4 | IMPOSSIBILE 5 | } stato_t; 6 | 7 | typedef struct { 8 | int domino1; 9 | int domino2; 10 | } coppia_t; 11 | 12 | stato_t correggi(int N, int altezze[], coppia_t* scambio) { 13 | scambio->domino1 = 0; 14 | scambio->domino2 = N; 15 | return RISOLTO; 16 | } 17 | -------------------------------------------------------------------------------- /2020/territoriali/download/solutions/sbagliata_donadoni.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int T; 6 | cin >> T; 7 | for (int t = 1; t <= T; ++t) { 8 | int N, F, C; 9 | cin >> N >> C >> F; 10 | cout << "Case # " << t << ": " << N/F << " " << (N%F)/C << endl; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /2008/territoriali/mappa/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python2 2 | 3 | import sys 4 | import os 5 | 6 | def usage(): 7 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 8 | os.path.basename(sys.argv[0]) 9 | sys.exit(1) 10 | 11 | if __name__ == "__main__": 12 | if len(sys.argv) < 2: 13 | usage() 14 | # TODO: valida l'input 15 | -------------------------------------------------------------------------------- /2008/territoriali/missioni/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python2 2 | 3 | import sys 4 | import os 5 | 6 | def usage(): 7 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 8 | os.path.basename(sys.argv[0]) 9 | sys.exit(1) 10 | 11 | if __name__ == "__main__": 12 | if len(sys.argv) < 2: 13 | usage() 14 | # TODO: valida l'input 15 | -------------------------------------------------------------------------------- /2009/territoriali/depura/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python2 2 | 3 | import sys 4 | import os 5 | 6 | def usage(): 7 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 8 | os.path.basename(sys.argv[0]) 9 | sys.exit(1) 10 | 11 | if __name__ == "__main__": 12 | if len(sys.argv) < 2: 13 | usage() 14 | # TODO: valida l'input 15 | -------------------------------------------------------------------------------- /2009/territoriali/essenza/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python2 2 | 3 | import sys 4 | import os 5 | 6 | def usage(): 7 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 8 | os.path.basename(sys.argv[0]) 9 | sys.exit(1) 10 | 11 | if __name__ == "__main__": 12 | if len(sys.argv) < 2: 13 | usage() 14 | # TODO: valida l'input 15 | -------------------------------------------------------------------------------- /2009/territoriali/treno/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python2 2 | 3 | import sys 4 | import os 5 | 6 | def usage(): 7 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 8 | os.path.basename(sys.argv[0]) 9 | sys.exit(1) 10 | 11 | if __name__ == "__main__": 12 | if len(sys.argv) < 2: 13 | usage() 14 | # TODO: valida l'input 15 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/sol/template_pas.pas: -------------------------------------------------------------------------------- 1 | unit aeroporto; 2 | 3 | interface 4 | procedure pianifica(R: longint; var A, B, T: array of longint); 5 | 6 | implementation 7 | 8 | (* qui vanno dichiarate eventuali variabili globali *) 9 | 10 | procedure pianifica(R: longint; var A, B, T: array of longint); 11 | begin 12 | T[0] := 42; 13 | end; 14 | 15 | end. 16 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/testo/extra_aeroporto/asy/plane.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/asy_specchi/fig6.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int N = 1; 4 | int M = 1; 5 | string[] grid = { 6 | '\\' 7 | }; 8 | pair inizio = (1,1); 9 | int[] percorso = {dx, dw}; 10 | 11 | 12 | luce(N, M, inizio, percorso, penna_luce); 13 | luce(N, M, inizio, percorso, penna_luce_2); 14 | griglia(N, M); 15 | //numeri(N, M); 16 | specchi(N, M, grid); 17 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/asy_specchi/fig7.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int N = 1; 4 | int M = 1; 5 | string[] grid = { 6 | '/' 7 | }; 8 | pair inizio = (1,1); 9 | int[] percorso = {dx, up}; 10 | 11 | 12 | luce(N, M, inizio, percorso, penna_luce); 13 | luce(N, M, inizio, percorso, penna_luce_2); 14 | griglia(N, M); 15 | //numeri(N, M); 16 | specchi(N, M, grid); 17 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/asy_specchi/fig8.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int N = 1; 4 | int M = 1; 5 | string[] grid = { 6 | '/' 7 | }; 8 | pair inizio = (1,1); 9 | int[] percorso = {up, dx}; 10 | 11 | 12 | luce(N, M, inizio, percorso, penna_luce); 13 | luce(N, M, inizio, percorso, penna_luce_2); 14 | griglia(N, M); 15 | //numeri(N, M); 16 | specchi(N, M, grid); 17 | -------------------------------------------------------------------------------- /2013/territoriali/grandprix/gen/GEN: -------------------------------------------------------------------------------- 1 | # N M S 2 | 2 1 1 3 | 4 99 2 4 | 6 34 3 5 | 7 11 4 6 | 9 5 5 7 | 10 21 6 8 | 12 54 7 9 | 13 92 8 10 | 15 83 9 11 | 16 77 10 12 | 18 61 11 13 | 19 54 12 14 | 21 49 13 15 | 22 32 14 16 | 24 26 15 17 | 25 44 16 18 | 27 69 17 19 | 28 87 18 20 | 30 100 19 21 | -------------------------------------------------------------------------------- /2016/nazionali/paletta/sol/template_pas.pas: -------------------------------------------------------------------------------- 1 | unit paletta; 2 | 3 | interface 4 | function paletta_sort(N: longint; V: array of longint): int64; 5 | 6 | implementation 7 | 8 | (* qui vanno dichiarate eventuali variabili globali *) 9 | 10 | function paletta_sort(N: longint; V: array of longint): int64; 11 | begin 12 | paletta_sort := 42; 13 | end; 14 | 15 | end. 16 | -------------------------------------------------------------------------------- /2017/territoriali/discesa/gen/generatore.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import sys 4 | import random 5 | 6 | def run(N): 7 | print(N) 8 | for i in range(N): 9 | print(" ".join([str(random.randint(1, 100)) for j in range(i + 1)])) 10 | 11 | if __name__ == "__main__": 12 | N, S = map(int, sys.argv[1:]) 13 | 14 | random.seed(S) 15 | run(N) 16 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/asy_grattacieli/fig2.asy: -------------------------------------------------------------------------------- 1 | include grattacieli; 2 | 3 | srand(42); 4 | 5 | int[] H = {2, 4, 10, 7}; // massime altezze 6 | int[] S = {2, 3, 6, 5}; // altezze finali 7 | 8 | // vincoli 9 | int[] A = {0, 1, 1, 3, 3, 0}; 10 | int[] B = {1, 2, 3, 2, 0, 3}; 11 | int[] C = {1, 3, 2, 2, 0, 4}; 12 | 13 | shipout("fig2", main(H, S, A, B, C)); 14 | -------------------------------------------------------------------------------- /2011/nazionali/scuola/gen/GEN: -------------------------------------------------------------------------------- 1 | # Parametri: 2 | # * N (numero di eroi) 3 | # * P (tipo di prova) 4 | 5 | # TODO: manca l'input di esempio 6 | 8 1 7 | 53 1 8 | 153 1 9 | 467 1 10 | 824 1 11 | 291 1 12 | 548 1 13 | 745 1 14 | 1000 1 15 | 4 2 16 | 8 2 17 | 16 2 18 | 32 2 19 | 64 2 20 | 128 2 21 | 256 2 22 | 512 2 23 | 1024 2 24 | 2048 2 25 | -------------------------------------------------------------------------------- /2013/nazionali/convoglio/sol/matteo_wrong_always_no.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | #ifdef EVAL 8 | ifstream in("input.txt"); 9 | ofstream out("output.txt"); 10 | #else 11 | istream &in(cin); 12 | ostream &out(cout); 13 | #endif 14 | 15 | int main() { 16 | out << -1 << endl; 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /2013/territoriali/turni/gen/GEN: -------------------------------------------------------------------------------- 1 | # K N C S ; 1 <= K <= N <= 50, C <= N 2 | 10 10 8 1 3 | 20 20 16 2 4 | 30 30 24 3 5 | 40 40 32 4 6 | 50 50 40 5 7 | 20 10 3 6 8 | 30 20 6 7 9 | 40 30 9 8 10 | 50 40 12 9 11 | 50 50 15 10 12 | 50 50 2 11 13 | 50 50 20 12 14 | 50 50 40 13 15 | 50 50 50 14 16 | 50 10 8 15 17 | 50 20 20 16 18 | 50 30 24 17 19 | 50 40 32 18 20 | 50 50 12 19 21 | -------------------------------------------------------------------------------- /2015/nazionali/accensione/att/accensione.pas: -------------------------------------------------------------------------------- 1 | unit accensione; 2 | 3 | interface 4 | procedure Accendi(N: longint; var acceso, pulsante: array of longint); 5 | 6 | implementation 7 | 8 | (* qui vanno dichiarate eventuali variabili globali *) 9 | 10 | procedure Accendi(N: longint; var acceso, pulsante: array of longint); 11 | begin 12 | pulsante[1] := 1; 13 | end; 14 | 15 | end. 16 | -------------------------------------------------------------------------------- /2016/territoriali/disuguaglianze/gen/GEN: -------------------------------------------------------------------------------- 1 | ## N, seed 2 | 3 | ## Nel 30% dei casi il valore di N non supera 10 4 | 5 | #COPY: testo/disuguaglianze0.txt 6 | 9 1 7 | 10 2 8 | 9 | ## Nel 60% dei casi il valore di N non supera 20 10 | 11 | 18 3 12 | 19 4 13 | 20 5 14 | 15 | ## Casi piu' grandi... 16 | 17 | 100 6 18 | 1000 7 19 | 10000 8 20 | 100000 9 21 | -------------------------------------------------------------------------------- /2010/nazionali/numeri/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | import sys 4 | import os 5 | 6 | from limiti import * 7 | 8 | def usage(): 9 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 10 | os.path.basename(sys.argv[0]) 11 | sys.exit(1) 12 | 13 | if __name__ == "__main__": 14 | if len(sys.argv) < 2: 15 | usage() 16 | # TODO: validare l'input 17 | -------------------------------------------------------------------------------- /2010/nazionali/pesca/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python2 2 | 3 | import sys 4 | import os 5 | 6 | from limiti import * 7 | 8 | def usage(): 9 | print >> sys.stderr, "Usage: %s file_input.txt" % \ 10 | os.path.basename(sys.argv[0]) 11 | sys.exit(1) 12 | 13 | if __name__ == "__main__": 14 | if len(sys.argv) < 2: 15 | usage() 16 | # TODO: verificare l'input 17 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/att/lungomare.pas: -------------------------------------------------------------------------------- 1 | unit lungomare; 2 | 3 | interface 4 | 5 | function percorri(N: longint; L: int64; var D, P: array of int64): int64; 6 | 7 | implementation 8 | 9 | function percorri(N: longint; L: int64; var D, P: array of int64): int64; 10 | begin 11 | D[0] := 123456789123; 12 | P[0] := 123456789123; 13 | percorri := 123456789123; 14 | end; 15 | 16 | end. 17 | -------------------------------------------------------------------------------- /2012/territoriali/domino/gen/GEN: -------------------------------------------------------------------------------- 1 | # Parametri: 2 | # * N (numero di tessere) 3 | # * R (lower bound della risposta) 4 | # * S (seed) 5 | 6 | 2 0 1 7 | 2 2 2 8 | 3 0 3 9 | 3 3 4 10 | 4 0 5 11 | 4 4 6 12 | 5 0 7 13 | 5 2 8 14 | 5 5 9 15 | 6 0 10 16 | 6 4 11 17 | 7 3 12 18 | 7 7 13 19 | 8 2 14 20 | 8 6 15 21 | 9 0 16 22 | 9 6 17 23 | 10 0 18 24 | 10 10 19 25 | -------------------------------------------------------------------------------- /2017/nazionali/lungomare/sol/template_pascal.pas: -------------------------------------------------------------------------------- 1 | unit lungomare; 2 | 3 | interface 4 | 5 | function percorri(N: longint; L: int64; var D, P: array of int64): int64; 6 | 7 | implementation 8 | 9 | function percorri(N: longint; L: int64; var D, P: array of int64): int64; 10 | begin 11 | D[0] := 123456789123; 12 | P[0] := 123456789123; 13 | percorri := 123456789123; 14 | end; 15 | 16 | end. 17 | -------------------------------------------------------------------------------- /2020/nazionali/pangramma/sol/ostuni_01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define MOD 46337ULL 6 | 7 | int conta(int n, int k, std::vector& v) { 8 | int s = 0; 9 | int last = v[0]; 10 | for(size_t i = 1; i < v.size(); i++) { 11 | s += (last != v[i]); 12 | last = v[i]; 13 | } 14 | return (s ? s : v.size()) % MOD; 15 | } 16 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/att/taglialegna.pas: -------------------------------------------------------------------------------- 1 | unit taglialegna; 2 | 3 | interface 4 | procedure Pianifica(N: longint; var altezza: array of longint); 5 | 6 | implementation 7 | uses taglialegnalib; 8 | 9 | (* qui vanno dichiarate eventuali variabili globali *) 10 | 11 | procedure Pianifica(N: longint; var altezza: array of longint); 12 | begin 13 | Abbatti(0, 1); 14 | end; 15 | 16 | end. 17 | -------------------------------------------------------------------------------- /2017/territoriali/discesa/gen/valida.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python2 2 | 3 | import sys 4 | 5 | lines = open(sys.argv[1]).readlines() 6 | A = int(lines[0]) 7 | assert(A <= 10 and len(lines) == A + 1) 8 | 9 | lines = map(lambda x: map(int, x.strip().split()), lines[1:]) 10 | for i in xrange(A): 11 | assert len(lines[i]) == i + 1 12 | for j in xrange(i + 1): 13 | assert lines[i][j] in range(1, 101) 14 | -------------------------------------------------------------------------------- /2008/nazionali/triade/gen/GEN: -------------------------------------------------------------------------------- 1 | # N T S 2 | # T = (U: uniform, W: small worlds, C: chain, H: hub) 3 | 4 | #COPY: testo/input0.txt 5 | 8 U 1 6 | 20 C 2 7 | 100 U 3 8 | 500 U 4 9 | 1000 H 5 10 | 5000 U 6 11 | 5000 W 7 12 | 10000 U 8 13 | 10000 H 9 14 | 20000 H 10 15 | 20000 W 11 16 | 30000 H 12 17 | 30000 W 13 18 | 50000 W 14 19 | 55000 W 15 20 | 60000 W 16 21 | 70000 W 17 22 | 80000 W 18 23 | 100000 W 19 24 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/att/grader.pas: -------------------------------------------------------------------------------- 1 | uses taglialegna; 2 | 3 | const MAXN = 2000000; 4 | var N, i : longint; 5 | altezza : array[0..MAXN-1] of longint; 6 | fr : text; 7 | 8 | begin 9 | assign(fr, 'input.txt'); 10 | reset(fr); 11 | 12 | readln(fr, N); 13 | for i:=0 to N-1 do read(fr, altezza[i]); 14 | 15 | Pianifica(N, altezza); 16 | 17 | close(fr); 18 | end. 19 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/testo/extra_aeroporto/asy/fig1.asy: -------------------------------------------------------------------------------- 1 | unitsize(.8cm); 2 | import plane_lib; 3 | 4 | setup_grid(3, 8); 5 | 6 | // 3 5 7 | // 1 7 8 | // 4 8 9 | 10 | draw_plane(1, "$1$"); 11 | draw_interval(1, 3, 5); 12 | select_tick(1, 3); 13 | 14 | draw_plane(2, "$2$"); 15 | draw_interval(2, 1, 7); 16 | select_tick(2, 6); 17 | 18 | draw_plane(3, "$3$"); 19 | draw_interval(3, 4, 8); 20 | select_tick(3, 8); -------------------------------------------------------------------------------- /2018/nazionali/specchi/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MAXN = 100000 2 | MAXQ = 500000 3 | 4 | # (MAXN, MAXQ, query alla fine) 5 | ST = [ 6 | (), # 1-based 7 | (100, 100, False), # casi d'esempio 8 | (10, 100, False), 9 | (1000, 5000, False), 10 | (5000, 200000, True), 11 | (100000, 5000, False), 12 | (100000, 250000, True), 13 | (100000, 100000, False), 14 | (100000, 250000, False) 15 | ] 16 | -------------------------------------------------------------------------------- /2012/territoriali/galattici/gen/GEN: -------------------------------------------------------------------------------- 1 | # Parametri: 2 | # * N (numero di configurazioni) 3 | # * K (numero di lettere) 4 | # * S (seed) 5 | 6 | 45 2 1 7 | 20 3 2 8 | 100 4 3 9 | 2 5 4 10 | 80 5 5 11 | 41 6 6 12 | 95 6 7 13 | 100 7 8 14 | 99 7 9 15 | 82 7 10 16 | 49 8 11 17 | 100 8 12 18 | 93 8 13 19 | 98 9 14 20 | 100 9 15 21 | 3 9 16 22 | 99 10 17 23 | 100 10 18 24 | 100 10 19 25 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/asy_specchi/fig1.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int N = 4; 4 | int M = 5; 5 | string[] grid = { 6 | '.....', 7 | '../.\\', 8 | '.....', 9 | '.....' 10 | }; 11 | pair inizio = (2,5); 12 | int[] percorso = {sx, up, up}; 13 | 14 | 15 | luce(N, M, inizio, percorso, penna_luce); 16 | luce(N, M, inizio, percorso, penna_luce_2); 17 | griglia(N, M); 18 | numeri(N, M); 19 | specchi(N, M, grid); 20 | -------------------------------------------------------------------------------- /2014/nazionali/contest.yaml: -------------------------------------------------------------------------------- 1 | name: oii 2 | description: OII 2014 -- Finale nazionale 3 | start: 1411110000.0 4 | stop: 1411128000.0 5 | token_mode: infinite 6 | logo: logo.png 7 | location: Fisciano 8 | date: 19 settembre 2014 9 | tasks: 10 | - accensione 11 | - bottleneck 12 | - taglialegna 13 | users: 14 | - first_name: Name 15 | last_name: Surname 16 | username: user 17 | password: password 18 | ip: 10.0.0.1 19 | -------------------------------------------------------------------------------- /2017/nazionali/contest.yaml: -------------------------------------------------------------------------------- 1 | name: oii-2017 2 | description: Olimpiadi Italiane di Informatica 2017 3 | start: 1505458800.0 4 | stop: 1505476800.0 5 | token_mode: disabled 6 | logo: logo.png 7 | date: "14 – 16 settembre 2017" 8 | location: "Trento" 9 | tasks: 10 | - caduta 11 | - corteo 12 | - specchi 13 | users: 14 | - first_name: Name 15 | last_name: Surname 16 | username: user 17 | password: password 18 | ip: 10.0.0.1 19 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/testo/asy_grattacieli/fig3.asy: -------------------------------------------------------------------------------- 1 | include grattacieli; 2 | 3 | srand(42); 4 | 5 | int[] H = {3, 8, 9, 6, 9, 1, 6, 7, 7, 9}; // massime altezze 6 | int[] S = {2, 4, 7, 6, 7, 1, 6, 7, 6, 8}; // altezze finali 7 | 8 | // vincoli 9 | int[] A = {3, 0, 4, 5, 8, 8, 1, 7, 6}; 10 | int[] B = {4, 1, 0, 0, 0, 2, 8, 9, 7}; 11 | int[] C = {1, 2, 4, 1, 0, 1, 2, 1, 2}; 12 | 13 | shipout("fig3", main(H, S, A, B, C)); 14 | -------------------------------------------------------------------------------- /2008/territoriali/pizzini/gen/GEN: -------------------------------------------------------------------------------- 1 | # N minK maxK minR seed 2 | 3 | 4 3 3 1 1234613 # TODO: dovrebbe essere l'input di esempio? 4 | 10 19 21 1 1362980 5 | 51 12 68 9 16942 6 | 21 3 8 2 123719 7 | 8 50 80 1 123719 8 | 69 3 24 2 67406 9 | 89 3 24 1 67412 10 | 40 1 50 1 67419 11 | 72 60 80 1 8723 12 | 100 4 4 1 1247 13 | 14 | # TODO: aggiungere altri testcase 15 | -------------------------------------------------------------------------------- /2008/territoriali/mappa/gen/GEN: -------------------------------------------------------------------------------- 1 | # N = dimension (1 - 100) 2 | # M = number of paths (1 -) 3 | # Fill = random fill percentage (1 - 100) 4 | # Seed = random seed 5 | 6 | 1 0 0 0 # TODO: dovrebbe essere l'input di esempio? 7 | 10 1 0 1 8 | 20 1 0 2 9 | 60 1 0 3 10 | 100 6 0 4 11 | 30 2 20 5 12 | 50 1 20 6 13 | 60 2 10 7 14 | 90 1 30 8 15 | 100 1 90 9 16 | 17 | # TODO: aggiungere altri testcase 18 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/gradergen/include_grader.c: -------------------------------------------------------------------------------- 1 | void make_calls(int* Q, char types[], int params[], int answers[]) { 2 | int cnt = 0; 3 | for (int i = 0; i < *Q; i++) { 4 | if (types[i] == 's') { 5 | supera(params[i]); 6 | } 7 | else if (types[i] == 'x') { 8 | squalifica(params[i]); 9 | } 10 | else if (types[i] == 'p') { 11 | answers[cnt++] = partecipante(params[i]); 12 | } 13 | } 14 | *Q = cnt; 15 | } 16 | -------------------------------------------------------------------------------- /2017/nazionali/classifica/gradergen/include_grader.cpp: -------------------------------------------------------------------------------- 1 | void make_calls(int& Q, char types[], int params[], int answers[]) { 2 | int cnt = 0; 3 | for (int i = 0; i < Q; i++) { 4 | if (types[i] == 's') { 5 | supera(params[i]); 6 | } 7 | else if (types[i] == 'x') { 8 | squalifica(params[i]); 9 | } 10 | else if (types[i] == 'p') { 11 | answers[cnt++] = partecipante(params[i]); 12 | } 13 | } 14 | Q = cnt; 15 | } 16 | -------------------------------------------------------------------------------- /2020/nazionali/grattacieli/gen/limiti.py: -------------------------------------------------------------------------------- 1 | MIN_N = 1 2 | MAX_N = 100000 3 | 4 | MIN_M = 1 5 | MAX_M = 100000 6 | 7 | MIN_H = 1 8 | MAX_H = 10**12 9 | 10 | MIN_C = 0 11 | MAX_C = 10**9 12 | 13 | subtasks = [ 14 | dict(), 15 | dict(), 16 | dict(MAX_N=5, MAX_H=5), 17 | dict(line=True), 18 | dict(dag=True), 19 | dict(MAX_N=300), 20 | dict(MAX_C=1), 21 | dict(MAX_N=2000, MAX_M=10000), 22 | dict(), 23 | ] 24 | -------------------------------------------------------------------------------- /2015/nazionali/contest.yaml: -------------------------------------------------------------------------------- 1 | name: oii 2 | description: Olimpiadi Italiane di Informatica 2015 3 | location: Castiglione de' Pepoli (BO) 4 | date: 17 -- 19 settembre 2015 5 | start: 1442559600.0 6 | stop: 1442577600.0 7 | token_mode: infinite 8 | logo: logo.png 9 | tasks: 10 | - aeroporto 11 | - nemesi 12 | - paletta 13 | users: 14 | - first_name: Name 15 | last_name: Surname 16 | username: user 17 | password: password 18 | ip: 10.0.0.1 19 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/asy_specchi/fig3.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int N = 6; 4 | int M = 2; 5 | string[] grid = { 6 | '..', 7 | '..', 8 | '..', 9 | '..', 10 | '..', 11 | '..' 12 | }; 13 | pair inizio = (2,2); 14 | int[] percorso = {sx, sx, sx}; 15 | 16 | 17 | luce(N, M, inizio, percorso, penna_luce); 18 | luce(N, M, inizio, percorso, penna_luce_2); 19 | griglia(N, M); 20 | numeri(N, M); 21 | specchi(N, M, grid); 22 | -------------------------------------------------------------------------------- /2018/territoriali-remastered/scommessa/managers/validator.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | from limits import MAXN 3 | import sys 4 | 5 | f = sys.stdin.readlines() 6 | T = int(f[0].strip()) 7 | for i in range(T): 8 | N = int(f[2 * i + 1].strip()) 9 | assert 1 <= N <= MAXN 10 | assert N % 2 == 1 11 | nums = list(map(int, f[2 * i + 2].strip().split(' '))) 12 | nums.sort() 13 | ok = list(range(0, N)) 14 | assert nums == ok 15 | -------------------------------------------------------------------------------- /2012/territoriali/nanga/gen/GEN: -------------------------------------------------------------------------------- 1 | # Parametri: 2 | # * N (lunghezza della sequenza) 3 | # * P (massimo dislivello) 4 | # * S (seed) 5 | 6 | 2 1 1 7 | 6 2 20 8 | 10 1 13 9 | 15 5 4 10 | 20 7 15 11 | 30 10 16 12 | 40 8 7 13 | 50 20 8 14 | 60 10 9 15 | 80 40 10 16 | 100 50 11 17 | 150 20 12 18 | 200 60 13 19 | 300 40 14 20 | 400 80 15 21 | 500 30 16 22 | 600 90 17 23 | 800 20 18 24 | 999 99 19 25 | -------------------------------------------------------------------------------- /2014/nazionali/bufale/sol/nlogn.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAXN 10000000 3 | using namespace std; 4 | 5 | int D[MAXN]; 6 | long long solve(int N, int M[], int P[]){ 7 | long long tot = 0; 8 | for(int i=0; i 3 | long long conta(int S, int s[], int P, int p[]) 4 | { 5 | long long out = 0; 6 | for(int i=0; i(S-k); 12 | else break; 13 | } 14 | return out; 15 | } 16 | -------------------------------------------------------------------------------- /2019/territoriali/party/managers/validator.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import limits 3 | import sys 4 | 5 | f = sys.stdin.readlines() 6 | T = int(f[0]) 7 | 8 | assert T == limits.T 9 | assert len(f) == 1 + 3*T 10 | 11 | for t in range(T): 12 | assert f[1+3*t] == "\n" 13 | N = int(f[1+3*t+1]) 14 | A = map(int, f[1+3*t+2].split()) 15 | 16 | assert 2 <= N <= limits.MAXN 17 | assert all(limits.MINA <= a <= limits.MAXA for a in A) 18 | -------------------------------------------------------------------------------- /2016/nazionali/contest.yaml: -------------------------------------------------------------------------------- 1 | name: oii2016 2 | description: Olimpiadi Italiane di Informatica 2016 3 | 4 | start: 1442559600.0 5 | stop: 1442577600.0 6 | token_mode: infinite 7 | 8 | location: Catania 9 | date: 15 -- 17 settembre 2016 10 | logo: logo.png 11 | 12 | tasks: 13 | - classifica 14 | - hogwarts 15 | - lungomare 16 | 17 | users: 18 | - first_name: Name 19 | last_name: Surname 20 | username: user 21 | password: password 22 | ip: 10.0.0.1 23 | -------------------------------------------------------------------------------- /2019/territoriali/party/solutions/somma_tutto.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int T; 7 | cin >> T; 8 | for (int t = 1; t <= T; t++) { 9 | int N; cin >> N; 10 | int sum = 0; 11 | for (int i = 0; i < N; i++) { 12 | int x; 13 | cin >> x; 14 | sum += x; 15 | } 16 | cout << "Case #" << t << ": " << sum << endl; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /2020/territoriali/download/managers/validator.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | from limits import MAXN 4 | import sys 5 | 6 | f = sys.stdin.readlines() 7 | T = int(f[0]) 8 | row = 0 9 | for i in range(T): 10 | row += 1 11 | assert len(f[row].strip()) == 0 12 | 13 | row += 1 14 | N, F, C = map(int, f[row].split()) 15 | assert 1 <= N <= MAXN 16 | assert 1 <= F <= MAXN 17 | assert 1 <= C <= MAXN 18 | 19 | assert len(f) == row + 1 20 | -------------------------------------------------------------------------------- /2014/nazionali/bufale/att/grader.pas: -------------------------------------------------------------------------------- 1 | uses bufale; 2 | 3 | const MAXN = 10000000; 4 | var N, i : longint; 5 | M, P : array[0..MAXN-1] of longint; 6 | fin, fout : text; 7 | 8 | begin 9 | assign(fin, 'input.txt'); reset(fin); 10 | assign(fout, 'output.txt'); rewrite(fout); 11 | read(fin, N); 12 | for i:=0 to N-1 do read(fin, M[i], P[i]); 13 | writeln(fout, solve(N, M, P)); 14 | close(fin); 15 | close(fout); 16 | end. 17 | -------------------------------------------------------------------------------- /2014/nazionali/spiedini/att/grader.pas: -------------------------------------------------------------------------------- 1 | uses spiedini; 2 | 3 | const MAXN = 20000000; 4 | var N, K, i : longint; 5 | s : array[0..MAXN-1] of longint; 6 | fin, fout : text; 7 | 8 | begin 9 | assign(fin, 'input.txt'); reset(fin); 10 | assign(fout, 'output.txt'); rewrite(fout); 11 | read(fin, N, K); 12 | for i:=0 to N-1 do read(fin, s[i]); 13 | writeln(fout, solve(N, K, s)); 14 | close(fin); 15 | close(fout); 16 | end. 17 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/asy_corteo/fig1.asy: -------------------------------------------------------------------------------- 1 | unitsize(1cm); 2 | settings.tex = "pdflatex"; 3 | import grafi; 4 | 5 | pair[] posizioni = { (0,2), (2,2), (4,2), (2,0) }; 6 | int[][] E = { 7 | {0, 1}, 8 | {1, 2}, 9 | {1, 3} 10 | }; 11 | int[] colE = {0,1,1}; 12 | pair spazi = (4,2); 13 | pair tab = (2,0); 14 | main(posizioni, E, colE); 15 | label(scale(0.05) * graphic("spazi.png"), spazi+(0.0,0.8)); 16 | label(scale(0.05) * graphic("tab.png"), tab+(0.0,-0.8)); 17 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/asy_corteo/fig2.asy: -------------------------------------------------------------------------------- 1 | unitsize(1cm); 2 | settings.tex = "pdflatex"; 3 | import grafi; 4 | 5 | pair[] posizioni = { (0,2), (2,2), (4,2), (2,0) }; 6 | int[][] E = { 7 | {0, 1}, 8 | {1, 2}, 9 | {1, 3} 10 | }; 11 | int[] colE = {0,0,2}; 12 | pair spazi = (2,2); 13 | pair tab = (2,0); 14 | main(posizioni, E, colE); 15 | label(scale(0.05) * graphic("spazi.png"), spazi+(0.0,0.8)); 16 | label(scale(0.05) * graphic("tab.png"), tab+(0.0,-0.8)); 17 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/asy_corteo/fig3.asy: -------------------------------------------------------------------------------- 1 | unitsize(1cm); 2 | settings.tex = "pdflatex"; 3 | import grafi; 4 | 5 | pair[] posizioni = { (0,2), (2,2), (4,2), (2,0) }; 6 | int[][] E = { 7 | {0, 1}, 8 | {1, 2}, 9 | {1, 3} 10 | }; 11 | int[] colE = {1,0,1}; 12 | pair spazi = (0,2); 13 | pair tab = (2,0); 14 | main(posizioni, E, colE); 15 | label(scale(0.05) * graphic("spazi.png"), spazi+(0.0,0.8)); 16 | label(scale(0.05) * graphic("tab.png"), tab+(0.0,-0.8)); 17 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/asy_corteo/fig4.asy: -------------------------------------------------------------------------------- 1 | unitsize(1cm); 2 | settings.tex = "pdflatex"; 3 | import grafi; 4 | 5 | pair[] posizioni = { (0,2), (2,2), (4,2), (2,0) }; 6 | int[][] E = { 7 | {0, 1}, 8 | {1, 2}, 9 | {1, 3} 10 | }; 11 | int[] colE = {2,0,0}; 12 | pair spazi = (0,2); 13 | pair tab = (2,2); 14 | main(posizioni, E, colE); 15 | label(scale(0.05) * graphic("spazi.png"), spazi+(0.0,0.8)); 16 | label(scale(0.05) * graphic("tab.png"), tab+(0.0,0.8)); 17 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/asy_corteo/fig5.asy: -------------------------------------------------------------------------------- 1 | unitsize(1cm); 2 | settings.tex = "pdflatex"; 3 | import grafi; 4 | 5 | pair[] posizioni = { (0,2), (2,2), (4,2), (2,0) }; 6 | int[][] E = { 7 | {0, 1}, 8 | {1, 2}, 9 | {1, 3} 10 | }; 11 | int[] colE = {1,1,0}; 12 | pair spazi = (0,2); 13 | pair tab = (4,2); 14 | main(posizioni, E, colE); 15 | label(scale(0.05) * graphic("spazi.png"), spazi+(0.0,0.8)); 16 | label(scale(0.05) * graphic("tab.png"), tab+(0.0,0.8)); 17 | -------------------------------------------------------------------------------- /2018/nazionali/corteo/testo/asy_corteo/fig6.asy: -------------------------------------------------------------------------------- 1 | unitsize(1cm); 2 | settings.tex = "pdflatex"; 3 | import grafi; 4 | 5 | pair[] posizioni = { (0,2), (2,2), (4,2), (2,0) }; 6 | int[][] E = { 7 | {0, 1}, 8 | {1, 2}, 9 | {1, 3} 10 | }; 11 | int[] colE = {0,2,0}; 12 | pair spazi = (2,2); 13 | pair tab = (4,2); 14 | main(posizioni, E, colE); 15 | label(scale(0.05) * graphic("spazi.png"), spazi+(0.0,0.8)); 16 | label(scale(0.05) * graphic("tab.png"), tab+(0.0,0.8)); 17 | -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/att/bottleneck.pas: -------------------------------------------------------------------------------- 1 | unit bottleneck; 2 | 3 | interface 4 | function Analizza(N, M, W, L: longint; var arco_da, arco_a, capacita: array of longint; R, C: longint): longint; 5 | 6 | implementation 7 | 8 | (* qui vanno dichiarate eventuali variabili globali *) 9 | 10 | function Analizza(N, M, W, L: longint; var arco_da, arco_a, capacita: array of longint; R, C: longint): longint; 11 | begin 12 | Analizza := 42; 13 | end; 14 | 15 | end. 16 | -------------------------------------------------------------------------------- /2015/nazionali/taglialegna/att/taglialegnalib.pas: -------------------------------------------------------------------------------- 1 | unit taglialegnalib; 2 | 3 | interface 4 | 5 | procedure Abbatti(indice: longint; direzione: longint); 6 | 7 | implementation 8 | var fw: text; 9 | 10 | procedure Abbatti(indice: longint; direzione: longint); 11 | begin 12 | writeln(fw, indice, ' ', direzione); 13 | end; 14 | 15 | initialization 16 | 17 | assign(fw, 'output.txt'); 18 | rewrite(fw); 19 | 20 | finalization 21 | 22 | close(fw); 23 | 24 | end. 25 | -------------------------------------------------------------------------------- /2019/nazionali/circuiti/cor/sparsepp/spp_stdint.h: -------------------------------------------------------------------------------- 1 | #if !defined(spp_stdint_h_guard) 2 | #define spp_stdint_h_guard 3 | 4 | #include "spp_config.h" 5 | 6 | #if defined(SPP_HAS_CSTDINT) && (__cplusplus >= 201103) 7 | #include 8 | #else 9 | #if defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX) 10 | #include 11 | #else 12 | #include 13 | #endif 14 | #endif 15 | 16 | #endif // spp_stdint_h_guard 17 | -------------------------------------------------------------------------------- /2014/nazionali/bufale/sol/soluzione.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAXN 10000000 3 | using namespace std; 4 | 5 | int D[MAXN]; 6 | long long solve(int N, int M[], int P[]){ 7 | long long tot = 0; 8 | for(int i=0; i 2 | using namespace std; 3 | 4 | void pianifica(int R, int A[], int B[], int T[]) { 5 | T[0] = A[0]; 6 | int d= ( B[1]-A[0] )+1; 7 | bool invalid = true; 8 | while(invalid) { 9 | d--; 10 | invalid=false; 11 | for(int i=1;i B[i]) { 16 | invalid=true; 17 | break; 18 | } 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /2020/territoriali/tornello/managers/validator.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import limits 3 | import sys 4 | 5 | f = sys.stdin.readlines() 6 | T = int(f[0]) 7 | 8 | assert T == limits.T 9 | assert len(f) == 1 + 3*T 10 | 11 | for t in range(T): 12 | assert f[1+3*t] == "\n" 13 | 14 | N = int(f[2+3*t]) 15 | assert 1 <= N <= limits.MAXN 16 | 17 | V = f[3+3*t].split() 18 | assert len(V) == N 19 | for v in V: 20 | assert v in ("-1", "+1") 21 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/asy_specchi/fig4.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int N = 6; 4 | int M = 2; 5 | string[] grid = { 6 | '..', 7 | '//', 8 | '..', 9 | '..', 10 | '\\/', 11 | '..' 12 | }; 13 | pair inizio = (1,2); 14 | int[] percorso = {dw, dw, sx, dw, dw, dw, dx, up, up, up, dx}; 15 | 16 | 17 | luce(N, M, inizio, percorso, penna_luce); 18 | luce(N, M, inizio, percorso, penna_luce_2); 19 | griglia(N, M); 20 | numeri(N, M); 21 | specchi(N, M, grid); 22 | -------------------------------------------------------------------------------- /2018/nazionali/specchi/testo/asy_specchi/fig5.asy: -------------------------------------------------------------------------------- 1 | include util; 2 | 3 | int N = 6; 4 | int M = 2; 5 | string[] grid = { 6 | '..', 7 | '//', 8 | '..', 9 | '..', 10 | '\\/', 11 | '..' 12 | }; 13 | pair inizio = (2,2); 14 | int[] percorso = {sx, dw, dw, dw, sx, up, up, up, dx, up, up}; 15 | 16 | 17 | luce(N, M, inizio, percorso, penna_luce); 18 | luce(N, M, inizio, percorso, penna_luce_2); 19 | griglia(N, M); 20 | numeri(N, M); 21 | specchi(N, M, grid); 22 | -------------------------------------------------------------------------------- /2019/nazionali/cena/sol/tutti_uguali.cpp: -------------------------------------------------------------------------------- 1 | long long conta(int S, int s[], int P, int p[]) { 2 | long long sol = 0; 3 | int right = -1; 4 | int c = p[0]; 5 | int count = 0; 6 | for (int left = 0; left < S; count -= s[left] == c, left++) { 7 | while (right < S && count < P) { 8 | right++; 9 | count += s[right] == c; 10 | } 11 | if (count == P) 12 | sol += S-right; 13 | } 14 | return sol; 15 | } 16 | -------------------------------------------------------------------------------- /2019/territoriali/party/solutions/solo_zero.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | // le seguenti due righe possono essere utili per leggere e scrivere da file 8 | 9 | //freopen("input.txt", "r", stdin); 10 | //freopen("output.txt", "w", stdout); 11 | 12 | int T; 13 | cin >> T; 14 | 15 | for (int t = 1; t <= T; t++) { 16 | cout << "Case #" << t << ": 0" << endl; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /2016/nazionali/nemesi/sol/template_pas.pas: -------------------------------------------------------------------------------- 1 | unit nemesi; 2 | 3 | interface 4 | procedure smista(N: longint; var nemico: array of longint); 5 | 6 | implementation 7 | uses nemesilib; 8 | 9 | (* qui vanno dichiarate eventuali variabili globali *) 10 | 11 | procedure smista(N: longint; var nemico: array of longint); 12 | var 13 | i: longint; 14 | begin 15 | for i:=0 to N-1 do 16 | begin 17 | nuovo_gruppo(); 18 | aggiungi(i); 19 | end; 20 | end; 21 | 22 | end. 23 | -------------------------------------------------------------------------------- /2019/territoriali/party/solutions/solution.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int T; 7 | cin >> T; 8 | for (int t = 1; t <= T; t++) { 9 | int N; cin >> N; 10 | int sum = 0; 11 | for (int i = 0; i < N; i++) { 12 | int x; 13 | cin >> x; 14 | if (x > 0) 15 | sum += x; 16 | } 17 | cout << "Case #" << t << ": " << sum << endl; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /2018/territoriali/lwf/gen/GEN: -------------------------------------------------------------------------------- 1 | # Task lwf 2 | # Scrivere N come somma di numeri di fibonacci usando al più una volta 3 | # F_i 4 | # Limiti: 1 <= N <= 1.000.000 5 | # Parametri: N 6 | 7 | # 10 casi nascosti 8 | 1 9 | 63547 10 | 2938 11 | 109893 12 | 229402 13 | # F(29)+1 14 | 832041 15 | # F(21) 16 | 17711 17 | 948594 18 | 837593 19 | 123 20 | 21 | # 5 casi per il desktop 22 | #### #COPY: testo/lwf.input0.txt 23 | #### #COPY: testo/lwf.input1.txt 24 | #### 42 25 | #### 6872 26 | #### 502983 27 | -------------------------------------------------------------------------------- /2015/nazionali/accensione/testo/sol_accensione_NlogN_lista.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | const int MAXN = 1000000; 4 | std::list divisori[MAXN + 1]; 5 | 6 | void Accendi(int N, int acceso[], int pulsante[]) { 7 | for (int i = 1; i <= N; i++) 8 | for (int j = i; j <= N; j += i) 9 | divisori[j].push_back(i); 10 | 11 | for (int i = N; i >= 1; i--) { 12 | if (!acceso[i]) { 13 | pulsante[i] = true; 14 | 15 | for (const auto& j: divisori[i]) 16 | acceso[j] ^= 1; 17 | } 18 | } 19 | } -------------------------------------------------------------------------------- /2016/nazionali/paletta/sol/paletta.pas: -------------------------------------------------------------------------------- 1 | (* soluzione.cpp riscritta in pascal *) 2 | 3 | unit paletta; 4 | 5 | interface 6 | 7 | function paletta_sort(N: longint; V: array of longint) : int64; 8 | 9 | implementation 10 | 11 | function paletta_sort(N: longint; V: array of longint) : int64; 12 | var 13 | i : longint; 14 | begin 15 | paletta_sort := 666; 16 | for i := 0 to N-1 do begin 17 | if (V[i]+i) mod 2 > 0 then paletta_sort := -1; 18 | end; 19 | end; 20 | 21 | end. 22 | -------------------------------------------------------------------------------- /2019/nazionali/incendio/sol/grader.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int alzati(int N, int M, int X[], int Y[]); 6 | 7 | int main() { 8 | 9 | int N, M; 10 | 11 | assert(2==scanf("%d %d", &N, &M)); 12 | 13 | int *X = (int*) malloc(M * sizeof(int)); 14 | int *Y = (int*) malloc(M * sizeof(int)); 15 | 16 | for(int i=0; i 2 | #include 3 | #include 4 | 5 | int alzati(int N, int M, int X[], int Y[]); 6 | 7 | int main() { 8 | 9 | int N, M; 10 | 11 | assert(2==scanf("%d %d", &N, &M)); 12 | 13 | int *X = (int*) malloc(M * sizeof(int)); 14 | int *Y = (int*) malloc(M * sizeof(int)); 15 | 16 | for(int i=0; i 2 | #include 3 | 4 | #define MAXN 64 5 | char A[MAXN]; 6 | int N; 7 | 8 | void bgen( int b ){ 9 | int i; 10 | if (b == 0){ 11 | for (i=0; i< N; i++) 12 | printf("%c", A[i]); 13 | printf("\n"); 14 | } else { 15 | A[b-1] = '0'; 16 | bgen( b-1 ); 17 | A[b-1] = '1'; 18 | bgen( b-1 ); 19 | } 20 | } 21 | 22 | int main(int argc, char *argv[]){ 23 | 24 | 25 | N = atoi(argv[1]); 26 | bgen( N ); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /2016/nazionali/aeroporto/testo/extra_aeroporto/asy/fig2.asy: -------------------------------------------------------------------------------- 1 | unitsize(.8cm); 2 | import plane_lib; 3 | 4 | setup_grid(4, 13); 5 | 6 | // 1 5 7 | // 1 9 8 | // 6 8 9 | // 8 13 10 | 11 | draw_plane(1, "$1$"); 12 | draw_interval(1, 1, 5); 13 | select_tick(1, 2); 14 | 15 | draw_plane(2, "$2$"); 16 | draw_interval(2, 1, 9); 17 | select_tick(2, 5); 18 | 19 | draw_plane(3, "$3$"); 20 | draw_interval(3, 6, 8); 21 | select_tick(3, 8); 22 | 23 | draw_plane(4, "$4$"); 24 | draw_interval(4, 8, 13); 25 | select_tick(4, 13); -------------------------------------------------------------------------------- /2010/nazionali/numeri/sol/sol.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python2 2 | 3 | import sys 4 | 5 | 6 | linea = sys.stdin.readline() 7 | N, M = [int(x) for x in linea.split()] 8 | linea = sys.stdin.readline() 9 | s = [int(x) for x in linea.split()] 10 | 11 | indietro = 0 12 | avanti = 0 13 | somma = 0 14 | while True: 15 | somma += s[avanti] 16 | avanti += 1 17 | while somma > N: 18 | somma -= s[indietro] 19 | indietro += 1 20 | if somma == N: 21 | print indietro+1 22 | sys.exit(0) 23 | -------------------------------------------------------------------------------- /2015/nazionali/bottleneck/sol/euristica_alice2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | const int MAXM = 1000000; 9 | const int MAXN = 100000; 10 | const int INF = 1000000001; 11 | 12 | int Analizza(int N, int M, int W, int L, int arco_da[], int arco_a[], int capacita[], int R, int C) { 13 | int m = capacita[0]; 14 | 15 | for (int i=1; i 2 | 3 | using namespace std; 4 | 5 | typedef int64_t i64; 6 | 7 | int main() { 8 | i64 T; 9 | cin >> T; 10 | for(i64 caso = 1; caso <= T; caso++) 11 | { 12 | i64 C, G, B; 13 | cin >> B >> G >> C; 14 | i64 c = 0, g = 0; 15 | for(; B >= G; g++) B -= G; 16 | for(; B >= C; c++) B -= C; 17 | cout << "Case #" << caso << ": " << g << " " << c << endl; 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /2008/nazionali/cnn/sol/README.md: -------------------------------------------------------------------------------- 1 | Soluzioni implementate: 2 | 3 | * greedy 4 | * backtrackingn con branch&bound classico, bound iniziale greedy. 5 | * nm^2 6 | * n^3 (cub) 7 | * n^2 (due versioni: quad e quad2 -- usare quad) 8 | 9 | Greedy, b&b e la "solve-quad" (migliore) scrivono solitamente la soluzione, gli altri soltanto il peso. Per fargli scrivere soltanto il peso, lanciare con -q. 10 | 11 | Regression e regression2 servono per fare controlli incrociati tra i solutori: il primo contro il btrack il secondo contro la cubica. 12 | -------------------------------------------------------------------------------- /2020/territoriali/download/solutions/ottima_ostuni.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | typedef int64_t i64; 6 | 7 | int main() { 8 | i64 T; 9 | cin >> T; 10 | for(i64 caso = 1; caso <= T; caso++) { 11 | i64 cane, gatto, budget; 12 | cin >> budget >> gatto >> cane; 13 | i64 n_gatto = budget / gatto; 14 | i64 n_cane = (budget % gatto) / cane; 15 | cout << "Case #" << caso << ": " << n_gatto << " " << n_cane << endl; 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /2014/territoriali/brisbane/gen/GEN: -------------------------------------------------------------------------------- 1 | # N (nodi) 2 | # A (attrazioni) 3 | # Mg (collegamenti gratuiti) 4 | # Mb (collegamenti col bus) 5 | # Mt (collegamenti col traghetto) 6 | # S (seed) 7 | 8 | #COPY: testo/esempio.txt 9 | 10 5 5 4 3 1 10 | 20 10 8 6 7 2 11 | 50 40 15 40 25 3 12 | 100 50 100 50 20 4 13 | 300 150 120 100 100 5 14 | 500 480 1000 10 1000 6 15 | 700 500 500 500 8000 7 16 | 1000 100 500 500 500 8 17 | 1000 900 1000 4000 5000 9 18 | --------------------------------------------------------------------------------