├── .gitignore ├── Readme.md ├── base ├── abb │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── lib.cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── testes.tio ├── alternando │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── altura │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── apagando │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ └── draft.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ ├── gen.py │ └── t.tio ├── arvore-path │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ └── t.tio ├── arvore │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── lib.cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── testes.tio ├── balanceada │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── testes.tio ├── banco │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── bettersearch │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── go │ │ │ │ └── main.go │ │ │ ├── java │ │ │ │ └── Main.java │ │ │ └── py │ │ │ │ └── main.py │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── binomiais │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── bitcoin │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── bufferring │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── extra.md │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── buscas │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ └── t.tio ├── caminhao │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── caminho │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ └── main.cpp │ │ │ └── go │ │ │ │ ├── main.go │ │ │ │ └── queue.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ └── t.tio ├── cauda │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── lib.cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── t.tio ├── chaves │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ ├── gen.py │ └── t.tio ├── concatenar │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── t.tio ├── controlz │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── capa.jpg │ └── cover.jpg ├── converte │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── t.tio ├── diagonal │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── distancia │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── dividido │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Makefile │ ├── Readme.md │ ├── cover.jpg │ ├── lib.cpp │ ├── lib.hpp │ ├── main.cpp │ └── student.cpp ├── duplamente │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── lib.cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── t.tio ├── editor │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── editorint │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── extra.md │ │ │ │ ├── lista.go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── eh_primo │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ └── main.cpp │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── enesimo │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── escada │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── fib1 │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── FibonacciRabbits1.jpg │ ├── Readme.md │ └── testes.tio ├── fib2 │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Fibonacci.png │ ├── FibonacciRabbits1.jpg │ ├── Readme.md │ └── testes.tio ├── fila │ └── cover.jpg ├── fila_enc │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── formatada │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── fracao │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── fn.hpp │ │ │ │ ├── fracao.cpp │ │ │ │ ├── fracao.hpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── fracaoGo │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── fn.hpp │ │ │ │ ├── fracao.cpp │ │ │ │ ├── fracao.hpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── fractais │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── draw.go │ │ │ │ ├── extra.md │ │ │ │ └── pen.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── desenho.svg │ └── desenhos │ │ ├── arvore.png │ │ ├── carpete.jpg │ │ ├── circulos.png │ │ ├── gelo.png │ │ ├── quadrados.png │ │ ├── rotacao.png │ │ ├── triangulos.png │ │ └── trigo.png ├── fractais_png │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── extra.md │ │ │ │ ├── main.go │ │ │ │ └── pen.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── desenho.svg │ └── desenhos │ │ ├── arvore.png │ │ ├── carpete.jpg │ │ ├── circulos.png │ │ ├── gelo.png │ │ ├── quadrados.png │ │ ├── rotacao.png │ │ ├── triangulos.png │ │ └── trigo.png ├── hex │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── main.go │ │ │ │ └── matrix.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── grid.svg ├── incompleta │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── lib.cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── testes.tio ├── indices │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── invertendo │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── testes.tio ├── invertendo2 │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── testes.tio ├── iterador │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── extra.md │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── labirinto │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ └── main.hpp │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ └── t.tio ├── list_basic │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── lista_d1 │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ ├── fn.hpp │ │ │ │ ├── list.cpp │ │ │ │ ├── list.hpp │ │ │ │ └── main.cpp │ │ │ └── go │ │ │ │ ├── extra.md │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── lista_d2 │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── extra.md │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── lista_d3 │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── lista_d4 │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── extra.md │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── lista_simples │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── lib.cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cases.vpl │ └── q.tio ├── magicsearch │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── mdc │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ └── main.cpp │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── mergevet │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── lib.hpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── multiset │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── extra.md │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.png ├── padroes1 │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── decomposition.jpeg │ ├── pattern.png │ └── testes.tio ├── padroes2 │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── seq1.png │ └── testes.tio ├── padroes3 │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Padroes.png │ ├── Readme.md │ ├── seq1.png │ └── testes.tio ├── pilha │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── extra.md │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── pilhado │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ ├── lib.cpp │ │ │ │ ├── lib.h │ │ │ │ └── main.cpp │ │ │ └── go │ │ │ │ ├── main.go │ │ │ │ └── stack.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ └── t.tio ├── polonesa │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── fn.hpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── ponto │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── fn.hpp │ │ │ │ ├── main.cpp │ │ │ │ ├── point.cpp │ │ │ │ └── point.hpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── pontoGo │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ ├── fn.hpp │ │ │ │ ├── main.cpp │ │ │ │ ├── point.cpp │ │ │ │ └── point.hpp │ │ │ └── go │ │ │ │ └── point.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── priminhos │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ └── Readme.md ├── prin_list1 │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── prin_list2 │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── princesa │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ ├── solv_marcacao.cpp │ ├── student.cpp │ └── t.tio ├── quadrado │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── queimada │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ └── main.cpp │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ └── t.tio ├── queimando │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── go │ │ │ │ ├── main.go │ │ │ │ └── pilha.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── resto │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ ├── lib.cpp │ │ │ │ ├── lib.h │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── rotacoes │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ ├── student.cpp │ └── t.tio ├── santo │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── serial │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── setbuild │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── go │ │ │ │ ├── extra.md │ │ │ │ └── main.go │ │ │ └── java │ │ │ │ ├── Main.java │ │ │ │ └── extra.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── soma │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── sudoku │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── argparse │ ├── cover.jpg │ └── main.py ├── sufixos │ ├── .cache │ │ ├── Readme.md │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── tapioca │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── treinando │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ └── main.cpp │ │ │ └── go │ │ │ │ └── main.go │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg ├── triangulo │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── cpp │ │ │ │ ├── main.cpp │ │ │ │ └── user.cpp │ │ │ ├── go │ │ │ │ └── main.go │ │ │ └── py │ │ │ │ └── main.py │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ ├── cover.jpg │ └── q.tio ├── vacina │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ └── cpp │ │ │ │ └── main.cpp │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── testes.tio ├── vetbuild │ ├── .cache │ │ ├── Readme.md │ │ ├── draft │ │ │ ├── c │ │ │ │ └── main.c │ │ │ ├── cpp │ │ │ │ ├── extra.md │ │ │ │ └── main.cpp │ │ │ ├── go │ │ │ │ ├── extra.md │ │ │ │ └── main.go │ │ │ ├── java │ │ │ │ ├── Shell.java │ │ │ │ └── extra.md │ │ │ └── py │ │ │ │ ├── extra.md │ │ │ │ └── main.py │ │ ├── mapi.json │ │ ├── q.html │ │ └── q.tio │ ├── Readme.md │ └── cover.jpg └── vetequals │ ├── .cache │ ├── Readme.md │ ├── draft │ │ └── go │ │ │ └── main.go │ ├── mapi.json │ ├── q.html │ └── q.tio │ └── Readme.md └── wiki ├── analise ├── analise.md └── grafico-comparacao.png ├── busca_ordenacao ├── assets │ ├── BubbleSort.gif │ ├── InsertionSort.gif │ ├── SelectionSort.gif │ ├── binarySearch.webp │ ├── cartasNaMão.png │ ├── linearSearch.webp │ └── vetorOrdenado.png ├── busca.md └── ordenacao.md ├── images └── play.png ├── objetivos_intro.md ├── ordenacao_recursiva ├── assets │ ├── merge.cpp │ ├── merge.gif │ ├── quick.cpp │ └── quick.gif └── ordenacao_rec.md ├── recursao ├── boneca.jpeg └── recursao.md ├── tad ├── imprimindo.cpp ├── sobrecarga.md ├── sobrecarga_operadores.md └── tad.cpp └── video_intro.md /.gitignore: -------------------------------------------------------------------------------- 1 | # common files for languages 2 | package.json 3 | package-lock.json 4 | node_modules 5 | # java 6 | *.class 7 | # python 8 | .mypy_cache 9 | __pycache__ 10 | # c e c++ 11 | *.out 12 | *.exe 13 | *.o 14 | # haskell 15 | *.hi 16 | # project files 17 | .idea 18 | .vscode 19 | *.pro 20 | *.pro.user 21 | .config.ini 22 | # tko local 23 | .tko 24 | .build 25 | follow.csv 26 | # public filter 27 | local.sh 28 | config.json 29 | src 30 | solver* 31 | Solver* 32 | __* 33 | .hide 34 | .exec 35 | -------------------------------------------------------------------------------- /base/alternando/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/alternando/cover.jpg -------------------------------------------------------------------------------- /base/altura/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 01 um 2 | 4 # # 3 | 4 4 | ======== EXPECT 5 | 1 1 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 02 dois 10 | 1 # 0 # # 11 | 0 1 12 | ======== EXPECT 13 | 1 2 14 | 2 1 15 | <<<<<<<< FINISH 16 | 17 | 18 | >>>>>>>> INSERT 03 tres 19 | 4 # 8 2 # # # 20 | 2 8 4 21 | ======== EXPECT 22 | 1 3 23 | 2 2 24 | 3 1 25 | <<<<<<<< FINISH 26 | 27 | 28 | >>>>>>>> INSERT 04 quatro 29 | 0 9 4 # # # 5 # # 30 | 5 4 3 0 9 31 | ======== EXPECT 32 | 1 2 33 | 1 3 34 | -1 35 | 3 1 36 | 2 2 37 | <<<<<<<< FINISH 38 | 39 | 40 | >>>>>>>> INSERT 05 cinco 41 | 8 4 # # 2 0 # # 3 # # 42 | 0 4 8 2 3 7 43 | ======== EXPECT 44 | 1 3 45 | 1 2 46 | 3 1 47 | 2 2 48 | 1 3 49 | -1 50 | <<<<<<<< FINISH 51 | 52 | 53 | >>>>>>>> INSERT 06 seis 54 | 2 1 0 # # # 3 # 7 # 9 # # 55 | 9 7 3 6 1 2 0 56 | ======== EXPECT 57 | 1 4 58 | 2 3 59 | 3 2 60 | -1 61 | 2 2 62 | 4 1 63 | 1 3 64 | <<<<<<<< FINISH 65 | 66 | 67 | >>>>>>>> INSERT 07 dez 68 | 1 8 7 # # 4 # 6 # # 5 0 # # 9 # 3 2 # # # 69 | 1 2 3 4 5 6 7 8 9 70 | ======== EXPECT 71 | 5 1 72 | 1 5 73 | 2 4 74 | 2 3 75 | 4 2 76 | 1 4 77 | 1 3 78 | 3 2 79 | 3 3 80 | <<<<<<<< FINISH 81 | 82 | -------------------------------------------------------------------------------- /base/altura/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/altura/cover.jpg -------------------------------------------------------------------------------- /base/apagando/.cache/draft/go/draft.go: -------------------------------------------------------------------------------- 1 | package main 2 | import "fmt" 3 | func main() { 4 | } 5 | -------------------------------------------------------------------------------- /base/apagando/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/apagando/cover.jpg -------------------------------------------------------------------------------- /base/apagando/gen.py: -------------------------------------------------------------------------------- 1 | import random 2 | vet = [] 3 | for x in range(10): 4 | print(">>>>>>>>") 5 | n = random.randint(2,10) 6 | print(n) 7 | for x in range(n): 8 | vet.append(random.randint(1,1000)) 9 | for x in range(n): 10 | print(vet[x-1], end = " ") 11 | print() 12 | m = random.randint(1,n-1) 13 | print(m) 14 | for x in range(m): 15 | print(vet[random.randint(0,n-1)], end = " ") 16 | print() 17 | print("========") 18 | print("<<<<<<<<") 19 | print() 20 | vet = [] -------------------------------------------------------------------------------- /base/apagando/t.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 01 2 | 10 3 | 817 364 524 565 132 499 412 563 297 638 4 | 7 5 | 364 817 412 132 499 524 297 6 | ======== 7 | 565 563 638 8 | <<<<<<<< 9 | 10 | 11 | >>>>>>>> 02 12 | 9 13 | 2 840 316 408 711 537 296 565 735 14 | 5 15 | 316 565 408 735 2 16 | ======== 17 | 840 711 537 296 18 | <<<<<<<< 19 | 20 | 21 | >>>>>>>> 03 22 | 7 23 | 831 565 110 581 726 770 990 24 | 3 25 | 770 581 565 26 | ======== 27 | 831 110 726 990 28 | <<<<<<<< 29 | 30 | 31 | >>>>>>>> 04 32 | 3 33 | 11 74 816 34 | 1 35 | 74 36 | ======== 37 | 11 816 38 | <<<<<<<< 39 | 40 | 41 | >>>>>>>> 05 42 | 8 43 | 992 854 103 984 485 949 283 672 44 | 5 45 | 283 103 485 984 949 46 | ======== 47 | 992 854 672 48 | <<<<<<<< 49 | 50 | 51 | >>>>>>>> 06 52 | 6 53 | 867 123 560 217 606 175 54 | 1 55 | 606 56 | ======== 57 | 867 123 560 217 175 58 | <<<<<<<< 59 | 60 | 61 | >>>>>>>> 07 62 | 5 63 | 436 984 930 101 946 64 | 1 65 | 101 66 | ======== 67 | 436 984 930 946 68 | <<<<<<<< 69 | 70 | 71 | >>>>>>>> 08 72 | 10 73 | 186 739 126 213 75 174 447 658 856 365 74 | 7 75 | 856 174 186 447 75 658 126 76 | ======== 77 | 739 213 365 78 | <<<<<<<< 79 | 80 | 81 | >>>>>>>> 09 82 | 3 83 | 229 402 828 84 | 1 85 | 828 86 | ======== 87 | 229 402 88 | <<<<<<<< 89 | 90 | 91 | >>>>>>>> 10 92 | 9 93 | 652 47 136 650 578 622 923 281 100 94 | 6 95 | 652 578 923 100 47 100 96 | ======== 97 | 136 650 622 281 98 | <<<<<<<< 99 | -------------------------------------------------------------------------------- /base/arvore-path/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 01 um 2 | 4 # # 3 | 4 4 | ======== EXPECT 5 | x 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 02 dois 10 | 1 # 0 # # 11 | 0 12 | ======== EXPECT 13 | rx 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 03 tres 18 | 4 # 8 2 # # # 19 | 2 20 | ======== EXPECT 21 | rlx 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT 04 not found 26 | 0 9 4 # # # 5 # # 27 | 7 28 | ======== EXPECT 29 | ! 30 | <<<<<<<< FINISH 31 | 32 | 33 | >>>>>>>> INSERT 34 | 1 8 7 # # 4 # 6 # # 5 0 # # 9 # 3 2 # # # 35 | 2 36 | ======== EXPECT 37 | rrrlx 38 | <<<<<<<< FINISH 39 | 40 | 41 | >>>>>>>> INSERT 05 quatro 42 | 0 9 4 # # # 5 # # 43 | 5 44 | ======== EXPECT 45 | rx 46 | <<<<<<<< FINISH 47 | 48 | 49 | >>>>>>>> INSERT 06 cinco 50 | 0 4 # # 2 0 # # 1 # # 51 | 4 52 | ======== EXPECT 53 | lx 54 | <<<<<<<< FINISH 55 | 56 | 57 | >>>>>>>> INSERT 07 seis 58 | 2 1 5 # # # 9 # 7 # 8 # # 59 | 9 60 | ======== EXPECT 61 | rx 62 | <<<<<<<< FINISH 63 | 64 | 65 | >>>>>>>> INSERT 08 dez 66 | 1 8 7 # # 5 # 6 # # 3 0 # # 9 # 4 2 # # # 67 | 2 68 | ======== EXPECT 69 | rrrlx 70 | <<<<<<<< FINISH 71 | 72 | -------------------------------------------------------------------------------- /base/arvore-path/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/arvore-path/cover.jpg -------------------------------------------------------------------------------- /base/arvore-path/t.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 01 um 2 | 4 # # 3 | 4 4 | ======== 5 | x 6 | <<<<<<<< 7 | 8 | >>>>>>>> 02 dois 9 | 1 # 0 # # 10 | 0 11 | ======== 12 | rx 13 | <<<<<<<< 14 | 15 | >>>>>>>> 03 tres 16 | 4 # 8 2 # # # 17 | 2 18 | ======== 19 | rlx 20 | <<<<<<<< 21 | 22 | >>>>>>>> 04 not found 23 | 0 9 4 # # # 5 # # 24 | 7 25 | ======== 26 | ! 27 | <<<<<<<< 28 | 29 | >>>>>>>> 05 quatro 30 | 0 9 4 # # # 5 # # 31 | 5 32 | ======== 33 | rx 34 | <<<<<<<< 35 | 36 | >>>>>>>> 06 cinco 37 | 0 4 # # 2 0 # # 1 # # 38 | 4 39 | ======== 40 | lx 41 | <<<<<<<< 42 | 43 | >>>>>>>> 07 seis 44 | 2 1 5 # # # 9 # 7 # 8 # # 45 | 9 46 | ======== 47 | rx 48 | <<<<<<<< 49 | 50 | >>>>>>>> 08 dez 51 | 1 8 7 # # 5 # 6 # # 3 0 # # 9 # 4 2 # # # 52 | 2 53 | ======== 54 | rrrlx 55 | <<<<<<<< 56 | -------------------------------------------------------------------------------- /base/arvore/cases.vpl: -------------------------------------------------------------------------------- 1 | Case=test_insert 2 | Input=test_insert 3 | Output=TESTE insert 4 | insert 32 5 | insert 45 6 | insert 12 7 | insert 10 8 | insert 37 9 | BinaryTree: Node-32{(Node-45{(Node-10{(, )}, Node-37{(, )})}, Node-12{(, )})} 10 | 11 | Case=test_search 12 | Input=test_search 13 | Output=TESTE search 14 | BinaryTree: Node-55{(Node-12{(Node-76{(Node-33{(, )}, )}, Node-4{(, )})}, Node-110{(Node-762{(Node-77{(, )}, Node--20{(, Node-19{(, )})})}, Node-1267{(Node--665{(, )}, Node--221{(, Node-9{(, )})})})})} 15 | search 55: Node(55) 16 | search 9: Node(9) 17 | search 77: Node(77) 18 | search -665: Node(-665) 19 | search 110: Node(110) 20 | search -29: Node(empty) 21 | search 1000: Node(empty) 22 | search 45: Node(empty) 23 | search 25: Node(empty) 24 | search 35: Node(empty) 25 | search 65: Node(empty) 26 | 27 | Case=test_size 28 | Input=test_size 29 | Output=TESTE size 30 | insert 32 31 | size 1 32 | insert 45 33 | size 2 34 | insert 12 35 | size 3 36 | insert 10 37 | size 3 38 | insert 37 39 | BinaryTree: Node-32{(Node-45{(, )}, Node-12{(, )})} 40 | size 3 41 | 42 | Case=test_min_max 43 | Input=test_min_max 44 | Output=TESTE min max 45 | min -1 46 | max -1 47 | insert 32 48 | insert 45 49 | insert 12 50 | insert 10 51 | insert 37 52 | BinaryTree: Node-32{(Node-45{(Node-10{(, )}, Node-37{(, )})}, Node-12{(, )})} 53 | min 10 54 | max 45 55 | -------------------------------------------------------------------------------- /base/arvore/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> Teste do insert 2 | test_insert 3 | ======== 4 | TESTE insert 5 | insert 32 6 | insert 45 7 | insert 12 8 | insert 10 9 | insert 37 10 | BinaryTree: Node-32{(Node-45{(Node-10{(, )}, Node-37{(, )})}, Node-12{(, )})} 11 | <<<<<<<< 12 | 13 | >>>>>>>> Teste do search 14 | test_search 15 | ======== 16 | TESTE search 17 | BinaryTree: Node-55{(Node-12{(Node-76{(Node-33{(, )}, )}, Node-4{(, )})}, Node-110{(Node-762{(Node-77{(, )}, Node--20{(, Node-19{(, )})})}, Node-1267{(Node--665{(, )}, Node--221{(, Node-9{(, )})})})})} 18 | search 55: Node(55) 19 | search 9: Node(9) 20 | search 77: Node(77) 21 | search -665: Node(-665) 22 | search 110: Node(110) 23 | search -29: Node(empty) 24 | search 1000: Node(empty) 25 | search 45: Node(empty) 26 | search 25: Node(empty) 27 | search 35: Node(empty) 28 | search 65: Node(empty) 29 | <<<<<<<< 30 | 31 | >>>>>>>> Teste do size 32 | test_size 33 | ======== 34 | TESTE size 35 | insert 32 36 | size 1 37 | insert 45 38 | size 2 39 | insert 12 40 | size 3 41 | insert 10 42 | size 3 43 | insert 37 44 | BinaryTree: Node-32{(Node-45{(, )}, Node-12{(, )})} 45 | size 3 46 | <<<<<<<< 47 | 48 | >>>>>>>> Teste do min_max 49 | test_min_max 50 | ======== 51 | TESTE min max 52 | min -1 53 | max -1 54 | insert 32 55 | insert 45 56 | insert 12 57 | insert 10 58 | insert 37 59 | BinaryTree: Node-32{(Node-45{(Node-10{(, )}, Node-37{(, )})}, Node-12{(, )})} 60 | min 10 61 | max 45 62 | <<<<<<<< -------------------------------------------------------------------------------- /base/balanceada/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Fórmula balanceada 2 | 3 | 4 | [Intro](#intro) | [Draft](#draft) | [Tests](#tests) 5 | -- | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Neste exercício, o objetivo é verificar se uma string composta apenas por parênteses `()` e colchetes `[]` está **balanceada**. 11 | 12 | Uma string é considerada balanceada quando: 13 | 14 | - Para cada símbolo de abertura, existe um símbolo de fechamento correspondente. 15 | - Os símbolos estão na ordem correta e corretamente aninhados. 16 | 17 | Exemplos de strings balanceadas: 18 | 19 | - `"()"`, `"(())"`, `"[()]"`, `"[()][](https://github.com/qxcodeed/arcade/blob/master/base/balanceada/)"` 20 | 21 | Exemplos de strings não balanceadas: 22 | 23 | - `")("`, `"(()"`, `"[(])"` 24 | 25 | ## Draft 26 | 27 | 28 | - cpp 29 | - [main.cpp](https://github.com/qxcodeed/arcade/blob/master/base/balanceada/.cache/draft/cpp/main.cpp) 30 | 31 | 32 | ### Observações 33 | 34 | - Certifique-se de verificar correspondência exata entre os parênteses e colchetes. 35 | - O algoritmo deve percorrer a string apenas uma vez, garantindo eficiência. 36 | 37 | ## Tests 38 | 39 | ### Entrada 40 | 41 | - A entrada será uma string contendo apenas parênteses `()` e colchetes `[]`. 42 | 43 | ### Saída 44 | 45 | - `balanceado` se a string estiver balanceada. 46 | - `nao balanceado` caso contrário. 47 | 48 | ```txt 49 | >>>>>>>> 50 | (()) 51 | ======== 52 | balanceado 53 | <<<<<<<< 54 | ``` 55 | -------------------------------------------------------------------------------- /base/balanceada/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | // Arquivo de execucao 2 | #include 3 | #include 4 | using std::stack; 5 | using std::string; 6 | 7 | // Altere essa funcao. 8 | // Receba uma string composta de parenteses e colchetes 9 | // e retorna 'true' se essa sequencia esta balanceada 10 | // e retorna 'false' caso contrario. 11 | 12 | // Uma sequencia e considerada balanceada se cada simbolo 13 | // de abertura tem um símbolo correspondente de fechamento na ordem correta, 14 | // e os simbolos estao corretamente aninhados. 15 | bool isBalanced(string word){ 16 | // TODO: complexidade O(n) 17 | (void) word; 18 | return false; 19 | } 20 | 21 | // Exemplos: 22 | // isBalanced("") == true 23 | // isBalanced("()") == true 24 | // isBalanced("(((())))") == true 25 | // isBalanced("()()()()") == true 26 | // isBalanced("[()]") == true 27 | // isBalanced("([])[()]") == true 28 | // isBalanced("((()") == false 29 | // isBalanced(")()") == false 30 | // isBalanced("[(])") == false 31 | // isBalanced("[(][)]") == false 32 | 33 | 34 | int main() { 35 | string s; 36 | std::cin >> s; 37 | 38 | if(isBalanced(s)) { 39 | std::cout << "balanceado" << std::endl; 40 | } else { 41 | std::cout << "nao balanceado" << std::endl; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /base/balanceada/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | (()) 3 | ======== EXPECT 4 | balanceado 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT Teste 1 9 | () 10 | ======== EXPECT 11 | balanceado 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT Teste 3 16 | ()()()()[][][][] 17 | ======== EXPECT 18 | balanceado 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT Teste 4 23 | ([])(([][])) 24 | ======== EXPECT 25 | balanceado 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT Teste 5 30 | (([[[(([([])][][][](([()]))))]]()(())()][][][()[](())]))()([])[()] 31 | ======== EXPECT 32 | balanceado 33 | <<<<<<<< FINISH 34 | 35 | 36 | >>>>>>>> INSERT Teste 6 37 | )( 38 | ======== EXPECT 39 | nao balanceado 40 | <<<<<<<< FINISH 41 | 42 | 43 | >>>>>>>> INSERT Teste 7 44 | [[] 45 | ======== EXPECT 46 | nao balanceado 47 | <<<<<<<< FINISH 48 | 49 | 50 | >>>>>>>> INSERT Teste 8 51 | [(][)] 52 | ======== EXPECT 53 | nao balanceado 54 | <<<<<<<< FINISH 55 | 56 | 57 | >>>>>>>> INSERT Teste 9 58 | [[[[)))) 59 | ======== EXPECT 60 | nao balanceado 61 | <<<<<<<< FINISH 62 | 63 | 64 | >>>>>>>> INSERT Teste 10 65 | (([[[(([([])][][][](([()]))))]]()(())()][][][()[](())])))()([])[()] 66 | ======== EXPECT 67 | nao balanceado 68 | <<<<<<<< FINISH 69 | 70 | -------------------------------------------------------------------------------- /base/balanceada/Readme.md: -------------------------------------------------------------------------------- 1 | # Fórmula balanceada 2 | 3 | 4 | [Intro](#intro) | [Draft](#draft) | [Tests](#tests) 5 | -- | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Neste exercício, o objetivo é verificar se uma string composta apenas por parênteses `()` e colchetes `[]` está **balanceada**. 11 | 12 | Uma string é considerada balanceada quando: 13 | 14 | - Para cada símbolo de abertura, existe um símbolo de fechamento correspondente. 15 | - Os símbolos estão na ordem correta e corretamente aninhados. 16 | 17 | Exemplos de strings balanceadas: 18 | 19 | - `"()"`, `"(())"`, `"[()]"`, `"[()][]()"` 20 | 21 | Exemplos de strings não balanceadas: 22 | 23 | - `")("`, `"(()"`, `"[(])"` 24 | 25 | ## Draft 26 | 27 | 28 | - cpp 29 | - [main.cpp](.cache/draft/cpp/main.cpp) 30 | 31 | 32 | ### Observações 33 | 34 | - Certifique-se de verificar correspondência exata entre os parênteses e colchetes. 35 | - O algoritmo deve percorrer a string apenas uma vez, garantindo eficiência. 36 | 37 | ## Tests 38 | 39 | ### Entrada 40 | 41 | - A entrada será uma string contendo apenas parênteses `()` e colchetes `[]`. 42 | 43 | ### Saída 44 | 45 | - `balanceado` se a string estiver balanceada. 46 | - `nao balanceado` caso contrário. 47 | 48 | ```txt 49 | >>>>>>>> 50 | (()) 51 | ======== 52 | balanceado 53 | <<<<<<<< 54 | ``` 55 | -------------------------------------------------------------------------------- /base/balanceada/cases.vpl: -------------------------------------------------------------------------------- 1 | Case = Teste 1 2 | Input =() 3 | Output =balanceado 4 | 5 | Case = Teste 2 6 | Input =(()) 7 | Output =balanceado 8 | 9 | Case = Teste 3 10 | Input =()()()()[][][][] 11 | Output =balanceado 12 | 13 | 14 | Case = Teste 4 15 | Input =([])(([][])) 16 | Output =balanceado 17 | 18 | 19 | Case = Teste 5 20 | Input =(([[[(([([])][][][](([()]))))]]()(())()][][][()[](())]))()([])[()] 21 | Output =balanceado 22 | 23 | 24 | Case = Teste 6 25 | Input =)( 26 | Output =nao balanceado 27 | 28 | 29 | Case = Teste 7 30 | Input =[[] 31 | Output =nao balanceado 32 | 33 | 34 | Case = Teste 8 35 | Input =[(][)] 36 | Output =nao balanceado 37 | 38 | 39 | Case = Teste 9 40 | Input =[[[[)))) 41 | Output =nao balanceado 42 | 43 | 44 | Case = Teste 10 45 | Input =(([[[(([([])][][][](([()]))))]]()(())()][][][()[](())])))()([])[()] 46 | Output =nao balanceado 47 | 48 | 49 | -------------------------------------------------------------------------------- /base/balanceada/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> Teste 1 2 | () 3 | ======== 4 | balanceado 5 | <<<<<<<< 6 | 7 | >>>>>>>> Teste 2 8 | (()) 9 | ======== 10 | balanceado 11 | <<<<<<<< 12 | 13 | >>>>>>>> Teste 3 14 | ()()()()[][][][] 15 | ======== 16 | balanceado 17 | <<<<<<<< 18 | 19 | >>>>>>>> Teste 4 20 | ([])(([][])) 21 | ======== 22 | balanceado 23 | <<<<<<<< 24 | 25 | >>>>>>>> Teste 5 26 | (([[[(([([])][][][](([()]))))]]()(())()][][][()[](())]))()([])[()] 27 | ======== 28 | balanceado 29 | <<<<<<<< 30 | 31 | >>>>>>>> Teste 6 32 | )( 33 | ======== 34 | nao balanceado 35 | <<<<<<<< 36 | 37 | >>>>>>>> Teste 7 38 | [[] 39 | ======== 40 | nao balanceado 41 | <<<<<<<< 42 | 43 | >>>>>>>> Teste 8 44 | [(][)] 45 | ======== 46 | nao balanceado 47 | <<<<<<<< 48 | 49 | >>>>>>>> Teste 9 50 | [[[[)))) 51 | ======== 52 | nao balanceado 53 | <<<<<<<< 54 | 55 | >>>>>>>> Teste 10 56 | (([[[(([([])][][][](([()]))))]]()(())()][][][()[](())])))()([])[()] 57 | ======== 58 | nao balanceado 59 | <<<<<<<< -------------------------------------------------------------------------------- /base/banco/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/banco/cover.jpg -------------------------------------------------------------------------------- /base/bettersearch/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strconv" 8 | "strings" 9 | ) 10 | 11 | func BetterSearch(slice []int, value int) (bool, int) { 12 | _, _ = slice, value 13 | return false, 0 14 | } 15 | 16 | func main() { 17 | scanner := bufio.NewScanner(os.Stdin) 18 | scanner.Scan() 19 | parts := strings.Split(scanner.Text(), " ") 20 | slice := []int{} 21 | for _, elem := range parts[1 : len(parts)-1] { 22 | value, _ := strconv.Atoi(elem) 23 | slice = append(slice, value) 24 | } 25 | scanner.Scan() 26 | value, _ := strconv.Atoi(scanner.Text()) 27 | found, result := BetterSearch(slice, value) 28 | if found { 29 | fmt.Println("V", result) 30 | } else { 31 | fmt.Println("F", result) 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /base/bettersearch/.cache/draft/java/Main.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Main { 4 | // Classe auxiliar para representar o retorno em formato (booleano, inteiro) 5 | static class Result { 6 | boolean found; 7 | int position; 8 | 9 | Result(boolean found, int position) { 10 | this.found = found; 11 | this.position = position; 12 | } 13 | } 14 | 15 | public static Result betterSearch(List arr, int value) { 16 | return new Result(false, 0); 17 | } 18 | 19 | public static void main(String[] args) { 20 | Scanner sc = new Scanner(System.in); 21 | String[] tokens = sc.nextLine().split(" "); 22 | List vet = new ArrayList<>(); 23 | for (int i = 1; i < tokens.length - 1; i++) { 24 | vet.add(Integer.parseInt(tokens[i])); 25 | } 26 | int value = Integer.parseInt(sc.nextLine()); 27 | Result result = betterSearch(vet, value); 28 | System.out.println((result.found ? "V" : "F") + " " + result.position); 29 | sc.close(); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /base/bettersearch/.cache/draft/py/main.py: -------------------------------------------------------------------------------- 1 | def better_search(arr: list[int], value: int) -> tuple[bool, int]: 2 | """ 3 | Retorna a posição do elemento x na lista arr ou onde ele deve ser inserido. 4 | """ 5 | return False, 0 6 | args = input().split()[1:-1] 7 | vet: list[int] = [] 8 | for i in range(len(args)): 9 | vet.append(int(args[i])) 10 | 11 | value = int(input()) 12 | result = better_search(vet, value) 13 | print("V" if result[0] else "F", result[1]) 14 | -------------------------------------------------------------------------------- /base/bettersearch/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | [ ] 3 | 4 4 | ======== EXPECT 5 | F 0 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 10 | [ 1 2 3 4 ] 11 | 1 12 | ======== EXPECT 13 | V 0 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 18 | [ 1 2 3 4 ] 19 | 2 20 | ======== EXPECT 21 | V 1 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT 26 | [ 1 2 3 4 ] 27 | 3 28 | ======== EXPECT 29 | V 2 30 | <<<<<<<< FINISH 31 | 32 | 33 | >>>>>>>> INSERT 34 | [ 1 2 3 4 ] 35 | 4 36 | ======== EXPECT 37 | V 3 38 | <<<<<<<< FINISH 39 | 40 | 41 | >>>>>>>> INSERT 42 | [ 1 3 4 ] 43 | 2 44 | ======== EXPECT 45 | F 1 46 | <<<<<<<< FINISH 47 | 48 | 49 | >>>>>>>> INSERT 50 | [ 1 2 3 5 6 7 8 ] 51 | 4 52 | ======== EXPECT 53 | F 3 54 | <<<<<<<< FINISH 55 | 56 | 57 | >>>>>>>> INSERT 58 | [ 1 2 3 7 8 9 ] 59 | 0 60 | ======== EXPECT 61 | F 0 62 | <<<<<<<< FINISH 63 | 64 | 65 | >>>>>>>> INSERT 66 | [ 1 3 5 6 7 9 10 ] 67 | 2 68 | ======== EXPECT 69 | F 1 70 | <<<<<<<< FINISH 71 | 72 | 73 | >>>>>>>> INSERT 74 | [ 1 2 3 6 7 9 ] 75 | 9 76 | ======== EXPECT 77 | V 5 78 | <<<<<<<< FINISH 79 | 80 | 81 | >>>>>>>> INSERT 82 | [ -2 1 2 4 5 6 7 ] 83 | 8 84 | ======== EXPECT 85 | F 7 86 | <<<<<<<< FINISH 87 | 88 | -------------------------------------------------------------------------------- /base/binomiais/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Calculando coeficientes 2 | 3 | Os coeficientes binomiais são muito importantes para a resolução de vários problemas de contagem. Por exemplo, 4 | 5 | `C(n,k)` representa o número de maneiras de escolher `k` elementos de um conjunto de n elementos. 6 | 7 | `C(n + k - 1,k)` representa o número de maneiras de escolher `k` elementos de um conjunto de n elementos se repetições são permitidas. 8 | 9 | Os coeficientes binomiais podem ser definidos usando a seguinte recursão: 10 | 11 | ```math 12 | C(n,k) = \begin{cases}1& ,k=0\\1 & ,k=n\\ C(n-1,k-1) + C(n-1, k)&, 1\leq k \leq n-1\end{cases} 13 | ``` 14 | 15 | Sua tarefa é dado dois inteiros n e k, calcula C(n,k). 16 | 17 | ## Entrada 18 | 19 | A primeira linha contendo dois inteiros n e k. 20 | 21 | ## Saída 22 | 23 | Imprima uma linha contendo C(n,k). 24 | 25 | ## Exemplo de Entrada 26 | 27 | ```txt 28 | 8 4 29 | ``` 30 | 31 | ## Exemplo de Saída 32 | 33 | ```txt 34 | 70 35 | ``` 36 | -------------------------------------------------------------------------------- /base/binomiais/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 8 1 3 | ======== EXPECT 4 | 8 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT 9 | 8 2 10 | ======== EXPECT 11 | 28 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT 16 | 8 3 17 | ======== EXPECT 18 | 56 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT 23 | 8 4 24 | ======== EXPECT 25 | 70 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT 30 | 8 5 31 | ======== EXPECT 32 | 56 33 | <<<<<<<< FINISH 34 | 35 | 36 | >>>>>>>> INSERT 37 | 8 6 38 | ======== EXPECT 39 | 28 40 | <<<<<<<< FINISH 41 | 42 | 43 | >>>>>>>> INSERT 44 | 8 7 45 | ======== EXPECT 46 | 8 47 | <<<<<<<< FINISH 48 | 49 | 50 | >>>>>>>> INSERT 51 | 7 2 52 | ======== EXPECT 53 | 21 54 | <<<<<<<< FINISH 55 | 56 | 57 | >>>>>>>> INSERT 58 | 7 3 59 | ======== EXPECT 60 | 35 61 | <<<<<<<< FINISH 62 | 63 | 64 | >>>>>>>> INSERT 65 | 7 4 66 | ======== EXPECT 67 | 35 68 | <<<<<<<< FINISH 69 | 70 | -------------------------------------------------------------------------------- /base/binomiais/Readme.md: -------------------------------------------------------------------------------- 1 | # Calculando coeficientes 2 | 3 | Os coeficientes binomiais são muito importantes para a resolução de vários problemas de contagem. Por exemplo, 4 | 5 | `C(n,k)` representa o número de maneiras de escolher `k` elementos de um conjunto de n elementos. 6 | 7 | `C(n + k - 1,k)` representa o número de maneiras de escolher `k` elementos de um conjunto de n elementos se repetições são permitidas. 8 | 9 | Os coeficientes binomiais podem ser definidos usando a seguinte recursão: 10 | 11 | ```math 12 | C(n,k) = \begin{cases}1& ,k=0\\1 & ,k=n\\ C(n-1,k-1) + C(n-1, k)&, 1\leq k \leq n-1\end{cases} 13 | ``` 14 | 15 | Sua tarefa é dado dois inteiros n e k, calcula C(n,k). 16 | 17 | ## Entrada 18 | 19 | A primeira linha contendo dois inteiros n e k. 20 | 21 | ## Saída 22 | 23 | Imprima uma linha contendo C(n,k). 24 | 25 | ## Exemplo de Entrada 26 | 27 | ```txt 28 | 8 4 29 | ``` 30 | 31 | ## Exemplo de Saída 32 | 33 | ```txt 34 | 70 35 | ``` 36 | -------------------------------------------------------------------------------- /base/binomiais/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 2 | 8 1 3 | ======== 4 | 8 5 | <<<<<<<< 6 | 7 | >>>>>>>> 8 | 8 2 9 | ======== 10 | 28 11 | <<<<<<<< 12 | 13 | >>>>>>>> 14 | 8 3 15 | ======== 16 | 56 17 | <<<<<<<< 18 | 19 | >>>>>>>> 20 | 8 4 21 | ======== 22 | 70 23 | <<<<<<<< 24 | 25 | >>>>>>>> 26 | 8 5 27 | ======== 28 | 56 29 | <<<<<<<< 30 | 31 | >>>>>>>> 32 | 8 6 33 | ======== 34 | 28 35 | <<<<<<<< 36 | 37 | 38 | >>>>>>>> 39 | 8 7 40 | ======== 41 | 8 42 | <<<<<<<< 43 | 44 | 45 | >>>>>>>> 46 | 7 2 47 | ======== 48 | 21 49 | <<<<<<<< 50 | 51 | 52 | >>>>>>>> 53 | 7 3 54 | ======== 55 | 35 56 | <<<<<<<< 57 | 58 | 59 | >>>>>>>> 60 | 7 4 61 | ======== 62 | 35 63 | <<<<<<<< 64 | 65 | 66 | 67 | -------------------------------------------------------------------------------- /base/bufferring/.cache/draft/go/extra.md: -------------------------------------------------------------------------------- 1 | # Go 2 | 3 | Nesta atividade, implementamos um **buffer circular com redimensionamento automático**. A estrutura se comporta como uma fila circular, permitindo inserções no início ou no fim e remoções em ambos os lados, mantendo os elementos em um vetor fixo que cresce conforme necessário. 4 | 5 | ## Diagrama de Implementação 6 | 7 | ```go 8 | class Deque { 9 | data []int // vetor que guarda os elementos 10 | front int // índice do início 11 | size, capacity int // tamanho atual e capacidade total 12 | resize(newCap int) // dobra o tamanho do caso ele chege no máximo de sua capacidade 13 | PushBack(v int) // insere valor no fim 14 | PushFront(v int) // insere valor no início 15 | PopBack() // remove valor do fim 16 | PopFront() // remove valor do início 17 | Front() (int, error) // retorna o valor do início 18 | Back() (int, error) // retorna o valor do fim 19 | Clear() // limpa todos os elementos 20 | Len() int // retorna o número de elementos 21 | String() string // representação no formato [1, 2, 3] 22 | } 23 | ``` 24 | -------------------------------------------------------------------------------- /base/bufferring/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/bufferring/cover.jpg -------------------------------------------------------------------------------- /base/buscas/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 00 2 | 4 3 | aba baba aba xzxb 4 | 3 5 | aba xzxb ab 6 | ======== EXPECT 7 | 2 1 0 8 | <<<<<<<< FINISH 9 | 10 | 11 | >>>>>>>> INSERT 01 12 | 3 13 | c c mpikv 14 | 8 15 | f c o uplbd o zl xoi mpikv 16 | ======== EXPECT 17 | 0 2 0 0 0 0 0 1 18 | <<<<<<<< FINISH 19 | 20 | 21 | >>>>>>>> INSERT 02 22 | 7 23 | qu qu pg qu qu cjyrx y 24 | 6 25 | o qu sxsse b pd yuv 26 | ======== EXPECT 27 | 0 4 0 0 0 0 28 | <<<<<<<< FINISH 29 | 30 | 31 | >>>>>>>> INSERT 00 32 | 2 33 | rw rw 34 | 3 35 | y rw iowz 36 | ======== EXPECT 37 | 0 2 0 38 | <<<<<<<< FINISH 39 | 40 | 41 | >>>>>>>> INSERT 03 42 | 4 43 | jphjf urx xs ijn 44 | 7 45 | fzsjg u hb daldh mgzd hgv jmqh 46 | ======== EXPECT 47 | 0 0 0 0 0 0 0 48 | <<<<<<<< FINISH 49 | 50 | 51 | >>>>>>>> INSERT 04 52 | 5 53 | sdurp tnl himf tnl tnl 54 | 6 55 | y sdurp tvaez tnl undx u 56 | ======== EXPECT 57 | 0 1 0 3 0 0 58 | <<<<<<<< FINISH 59 | 60 | 61 | >>>>>>>> INSERT 05 62 | 7 63 | axx svw xhac svw svw wfsy svw 64 | 5 65 | ms axx svw svw svw 66 | ======== EXPECT 67 | 0 1 4 4 4 68 | <<<<<<<< FINISH 69 | 70 | 71 | >>>>>>>> INSERT 06 72 | 3 73 | yakwy hkfx hkfx 74 | 10 75 | v uqojw hkfx mo o qzb yakwy fsl evhb b 76 | ======== EXPECT 77 | 0 0 2 0 0 0 1 0 0 0 78 | <<<<<<<< FINISH 79 | 80 | 81 | >>>>>>>> INSERT 07 82 | 5 83 | odbor aeoow dbpak hwsh pwkr 84 | 7 85 | wqtmc vpje ia vn kajln dwe zi 86 | ======== EXPECT 87 | 0 0 0 0 0 0 0 88 | <<<<<<<< FINISH 89 | 90 | -------------------------------------------------------------------------------- /base/buscas/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/buscas/cover.jpg -------------------------------------------------------------------------------- /base/buscas/t.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 00 2 | 2 3 | rw rw 4 | 3 5 | y rw iowz 6 | ======== 7 | 0 2 0 8 | <<<<<<<< 9 | 10 | >>>>>>>> 01 11 | 3 12 | c c mpikv 13 | 8 14 | f c o uplbd o zl xoi mpikv 15 | ======== 16 | 0 2 0 0 0 0 0 1 17 | <<<<<<<< 18 | 19 | >>>>>>>> 02 20 | 7 21 | qu qu pg qu qu cjyrx y 22 | 6 23 | o qu sxsse b pd yuv 24 | ======== 25 | 0 4 0 0 0 0 26 | <<<<<<<< 27 | 28 | >>>>>>>> 03 29 | 4 30 | jphjf urx xs ijn 31 | 7 32 | fzsjg u hb daldh mgzd hgv jmqh 33 | ======== 34 | 0 0 0 0 0 0 0 35 | <<<<<<<< 36 | 37 | >>>>>>>> 04 38 | 5 39 | sdurp tnl himf tnl tnl 40 | 6 41 | y sdurp tvaez tnl undx u 42 | ======== 43 | 0 1 0 3 0 0 44 | <<<<<<<< 45 | 46 | >>>>>>>> 05 47 | 7 48 | axx svw xhac svw svw wfsy svw 49 | 5 50 | ms axx svw svw svw 51 | ======== 52 | 0 1 4 4 4 53 | <<<<<<<< 54 | 55 | >>>>>>>> 06 56 | 3 57 | yakwy hkfx hkfx 58 | 10 59 | v uqojw hkfx mo o qzb yakwy fsl evhb b 60 | ======== 61 | 0 0 2 0 0 0 1 0 0 0 62 | <<<<<<<< 63 | 64 | >>>>>>>> 07 65 | 5 66 | odbor aeoow dbpak hwsh pwkr 67 | 7 68 | wqtmc vpje ia vn kajln dwe zi 69 | ======== 70 | 0 0 0 0 0 0 0 71 | <<<<<<<< 72 | -------------------------------------------------------------------------------- /base/caminhao/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/caminhao/cover.jpg -------------------------------------------------------------------------------- /base/caminho/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | ) 8 | 9 | type Pos struct { 10 | l, c int 11 | } 12 | 13 | func (p Pos) pegarVizinhos() []Pos { 14 | return nil 15 | } 16 | 17 | func procurarSaida(mat [][]rune, inicio Pos, fim Pos) { 18 | _, _, _ = mat, inicio, fim 19 | } 20 | 21 | func main() { 22 | scanner := bufio.NewScanner(os.Stdin) 23 | 24 | var nl, nc int 25 | scanner.Scan() 26 | line := scanner.Text() 27 | fmt.Sscanf(line, "%d %d", &nl, &nc) 28 | mat := make([][]rune, nl) // Inicializa a matriz de runes 29 | 30 | // Carregando matriz 31 | for i := range nl { 32 | scanner.Scan() 33 | line := scanner.Text() 34 | mat[i] = []rune(line) 35 | } 36 | 37 | var inicio, fim Pos 38 | 39 | // Procurando inicio e fim e colocando ' ' nas posições iniciais 40 | for l := range nl { 41 | for c := range nc { 42 | if mat[l][c] == 'I' { 43 | mat[l][c] = ' ' 44 | inicio = Pos{l, c} 45 | } 46 | if mat[l][c] == 'F' { 47 | mat[l][c] = ' ' 48 | fim = Pos{l, c} 49 | } 50 | } 51 | } 52 | 53 | procurarSaida(mat, inicio, fim) 54 | 55 | for _, line := range mat { 56 | fmt.Println(string(line)) // Converte o slice de runes de volta para string para imprimir 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /base/caminho/.cache/draft/go/queue.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "container/list" 5 | ) 6 | 7 | // Implmentação de uma fila genérica usando a lista duplamente encadeada do pacote container/list 8 | type Queue[T any] struct { 9 | queue list.List 10 | } 11 | 12 | func NewQueue[T any]() *Queue[T] { 13 | return &Queue[T]{ 14 | queue: *list.New(), 15 | } 16 | } 17 | func (q *Queue[T]) Enqueue(value T) { 18 | q.queue.PushBack(value) 19 | } 20 | func (q *Queue[T]) Dequeue() (T, bool) { 21 | element := q.queue.Front() 22 | if element == nil { 23 | var zero T 24 | return zero, false 25 | } 26 | q.queue.Remove(element) 27 | value := element.Value.(T) 28 | return value, true 29 | } 30 | func (q *Queue[T]) Peek() (T, bool) { 31 | element := q.queue.Front() 32 | if element == nil { 33 | var zero T 34 | return zero, false 35 | } 36 | value := element.Value.(T) 37 | return value, true 38 | } 39 | func (q *Queue[T]) IsEmpty() bool { 40 | return q.queue.Len() == 0 41 | } 42 | -------------------------------------------------------------------------------- /base/caminho/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/caminho/cover.jpg -------------------------------------------------------------------------------- /base/cauda/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Lista Simplesmente Encadeada com Cauda 2 | 3 | Nesse exercício, implementaremos lista simplesmente encadeada com uma pequena modificação: adição de um ponteiro para o nó cauda. 4 | A lista encadeada com cauda consiste utilizar um ponteiro adicional que aponta para o último nó da lista (tail), além de apenas o ponteiro para o início da lista (head). Após cada operação, você pode manter o ponteiro para a cauda atualizado. 5 | Por simplicidade, implementaremos as informações dos Nós apenas como um inteiro. 6 | No arquivo lib.cpp, se encontra a classe SLinkedList que possui os seguintes métodos: 7 | 8 | - ~~SLinkedList();~~ 9 | - ~~\~SLinkedList();~~ 10 | - bool hasInfo(int info); 11 | - void push_front(int info); 12 | - void push_back(int info); 13 | - void pop_front(int info); 14 | - void pop_back(int info); 15 | - ~~void clear();~~ 16 | - ~~bool length();~~ 17 | - ~~void empty();~~ 18 | - ~~void print();~~ 19 | 20 | Métodos riscados já estão implementados, você precisa implementar os demais. 21 | A funcionalidade de cada método está descrita em comentários no próprio arquivo lib.cpp. Sua tarefa é alterar o arquivo lib.cpp, implementando as funcionalidades faltantes citadas. Seu código deve passar no caso de teste para ser considerado correto. 22 | 23 | OBS.: Não altere os métodos já implementados. 24 | 25 | OBS.2: Não precisa escrever a main(). Ela já está implementada internamente no Moodle. 26 | -------------------------------------------------------------------------------- /base/cauda/Readme.md: -------------------------------------------------------------------------------- 1 | # Lista Simplesmente Encadeada com Cauda 2 | 3 | Nesse exercício, implementaremos lista simplesmente encadeada com uma pequena modificação: adição de um ponteiro para o nó cauda. 4 | A lista encadeada com cauda consiste utilizar um ponteiro adicional que aponta para o último nó da lista (tail), além de apenas o ponteiro para o início da lista (head). Após cada operação, você pode manter o ponteiro para a cauda atualizado. 5 | Por simplicidade, implementaremos as informações dos Nós apenas como um inteiro. 6 | No arquivo lib.cpp, se encontra a classe SLinkedList que possui os seguintes métodos: 7 | 8 | - ~~SLinkedList();~~ 9 | - ~~\~SLinkedList();~~ 10 | - bool hasInfo(int info); 11 | - void push_front(int info); 12 | - void push_back(int info); 13 | - void pop_front(int info); 14 | - void pop_back(int info); 15 | - ~~void clear();~~ 16 | - ~~bool length();~~ 17 | - ~~void empty();~~ 18 | - ~~void print();~~ 19 | 20 | Métodos riscados já estão implementados, você precisa implementar os demais. 21 | A funcionalidade de cada método está descrita em comentários no próprio arquivo lib.cpp. Sua tarefa é alterar o arquivo lib.cpp, implementando as funcionalidades faltantes citadas. Seu código deve passar no caso de teste para ser considerado correto. 22 | 23 | OBS.: Não altere os métodos já implementados. 24 | 25 | OBS.2: Não precisa escrever a main(). Ela já está implementada internamente no Moodle. 26 | -------------------------------------------------------------------------------- /base/chaves/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/chaves/cover.jpg -------------------------------------------------------------------------------- /base/chaves/gen.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | for x in range(10): 4 | print(">>>>>>>>") 5 | for x in range(15): 6 | a = random.randint(1,5) 7 | b = random.randint(1,5) 8 | while(a == b): 9 | a = random.randint(1,5) 10 | b = random.randint(1,5) 11 | print(a, b) 12 | print("========") 13 | print("<<<<<<<<") 14 | print() 15 | -------------------------------------------------------------------------------- /base/concatenar/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Concatenar duas listas duplamente encadeadas 2 | 3 | Dado duas listas duplamente encadeadas, sua função deve concaternar as duas. 4 | 5 | ## Entrada 6 | 7 | - Ponteiro para nó cabeça da primeira lista 'headA' 8 | - Ponteiro para nó cabeça da segunda lista 'headB' 9 | 10 | ## Saída 11 | 12 | - Não há retorno. a lista deve estar invertida no final da função. 13 | -------------------------------------------------------------------------------- /base/concatenar/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT Teste 1 2 | main 3 | ======== EXPECT 4 | Lista A: uno dos tres 5 | Lista B: cuatro cinco seis siete 6 | Concatena Lista A e Lista B 7 | Lista A (head): uno dos tres cuatro cinco seis siete 8 | Lista A (tail): uno dos tres cuatro cinco seis siete 9 | <<<<<<<< FINISH 10 | 11 | -------------------------------------------------------------------------------- /base/concatenar/Readme.md: -------------------------------------------------------------------------------- 1 | # Concatenar duas listas duplamente encadeadas 2 | 3 | Dado duas listas duplamente encadeadas, sua função deve concaternar as duas. 4 | 5 | ## Entrada 6 | 7 | - Ponteiro para nó cabeça da primeira lista 'headA' 8 | - Ponteiro para nó cabeça da segunda lista 'headB' 9 | 10 | ## Saída 11 | 12 | - Não há retorno. a lista deve estar invertida no final da função. 13 | -------------------------------------------------------------------------------- /base/concatenar/cases.vpl: -------------------------------------------------------------------------------- 1 | Case = Teste 1 2 | Input= main 3 | Output=Lista A: uno dos tres 4 | Lista B: cuatro cinco seis siete 5 | Concatena Lista A e Lista B 6 | Lista A (head): uno dos tres cuatro cinco seis siete 7 | Lista A (tail): uno dos tres cuatro cinco seis siete 8 | -------------------------------------------------------------------------------- /base/concatenar/t.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT Teste 1 2 | main 3 | ======== EXPECT 4 | Lista A: uno dos tres 5 | Lista B: cuatro cinco seis siete 6 | Concatena Lista A e Lista B 7 | Lista A (head): uno dos tres cuatro cinco seis siete 8 | Lista A (tail): uno dos tres cuatro cinco seis siete 9 | <<<<<<<< FINISH 10 | 11 | -------------------------------------------------------------------------------- /base/controlz/capa.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/controlz/capa.jpg -------------------------------------------------------------------------------- /base/controlz/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/controlz/cover.jpg -------------------------------------------------------------------------------- /base/converte/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Converte simples em dupla 2 | 3 | Dada uma lista simplesmente encadeada, sua tarefa é implementar uma função que faça uma cópia dessa lista, mas convertendo-a para uma lista duplamente encadeada. 4 | A struct SLinkedList::Node representa um nó de uma lista singular, que possui apenas a informação e um ponteiro para o próximo. A struct DLinkedList::Node representa um nó da lista duplamente encadeada, que possui ponteiros para o próximo e anterior. 5 | Você deve implementar a função DLinkedList::Node* convertToDouble(SLinkedList::Node *head) 6 | 7 | ## Entrada 8 | 9 | - Ponteiro para nó cabeça da lista simplesmente encadeada. 10 | 11 | ## Saída 12 | 13 | - Retorna um ponteiro para uma nova lista duplamente encadeada, que possui as mesmas informações da lista original. 14 | -------------------------------------------------------------------------------- /base/converte/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT Teste 1 2 | main 3 | ======== EXPECT 4 | Lista simplesmente ligada: A -> B -> C -> D 5 | Lista duplamente ligada: A <-> B <-> C <-> D 6 | <<<<<<<< FINISH 7 | 8 | -------------------------------------------------------------------------------- /base/converte/Readme.md: -------------------------------------------------------------------------------- 1 | # Converte simples em dupla 2 | 3 | Dada uma lista simplesmente encadeada, sua tarefa é implementar uma função que faça uma cópia dessa lista, mas convertendo-a para uma lista duplamente encadeada. 4 | A struct SLinkedList::Node representa um nó de uma lista singular, que possui apenas a informação e um ponteiro para o próximo. A struct DLinkedList::Node representa um nó da lista duplamente encadeada, que possui ponteiros para o próximo e anterior. 5 | Você deve implementar a função DLinkedList::Node* convertToDouble(SLinkedList::Node *head) 6 | 7 | ## Entrada 8 | 9 | - Ponteiro para nó cabeça da lista simplesmente encadeada. 10 | 11 | ## Saída 12 | 13 | - Retorna um ponteiro para uma nova lista duplamente encadeada, que possui as mesmas informações da lista original. 14 | -------------------------------------------------------------------------------- /base/converte/cases.vpl: -------------------------------------------------------------------------------- 1 | Case = Teste 1 2 | input= main 3 | Output=Lista simplesmente ligada: A -> B -> C -> D 4 | Lista duplamente ligada: A <-> B <-> C <-> D 5 | -------------------------------------------------------------------------------- /base/converte/t.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT Teste 1 2 | main 3 | ======== EXPECT 4 | Lista simplesmente ligada: A -> B -> C -> D 5 | Lista duplamente ligada: A <-> B <-> C <-> D 6 | <<<<<<<< FINISH 7 | 8 | -------------------------------------------------------------------------------- /base/diagonal/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Imprimindo um char por linha 2 | 3 | Faça um programa que recebe uma palavra com até 100 caracteres e imprime a palavra em diagonal. 4 | 5 | ## Entrada 6 | 7 | A entrada é composta por uma única linha contendo uma palavra com até 100 caracteres. 8 | 9 | ## Saída 10 | 11 | A saída é composta por `n` linhas sendo `n` o tamanho da palavra lida. 12 | 13 | ## Exemplo de Entrada 14 | 15 | ```txt 16 | wladimir 17 | ``` 18 | 19 | ## Exemplo de Saída 20 | 21 | ```txt 22 | w 23 | l 24 | a 25 | d 26 | i 27 | m 28 | i 29 | r 30 | ``` 31 | 32 | Dica: 33 | 34 | ```c 35 | void diagonal(char * s, int k) { 36 | if (*s == '\0') { 37 | return; 38 | } 39 | //imprima k caracteres 40 | //imprima o primeiro caractere de s e pule a linha 41 | //faça a chamada recursiva 42 | } 43 | } 44 | ``` 45 | 46 | ```go 47 | func diagonal(s string, k int) { 48 | if len(s) == 0 { 49 | return 50 | } 51 | // imprima k caracteres 52 | // imprima o primeiro caractere de s e pule a linha 53 | // faça a chamada recursiva 54 | } 55 | ``` 56 | -------------------------------------------------------------------------------- /base/diagonal/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | jefferson 3 | ======== EXPECT 4 | j 5 | e 6 | f 7 | f 8 | e 9 | r 10 | s 11 | o 12 | n 13 | <<<<<<<< FINISH 14 | 15 | 16 | >>>>>>>> INSERT 17 | lukeEuSouSeuPai 18 | ======== EXPECT 19 | l 20 | u 21 | k 22 | e 23 | E 24 | u 25 | S 26 | o 27 | u 28 | S 29 | e 30 | u 31 | P 32 | a 33 | i 34 | <<<<<<<< FINISH 35 | 36 | 37 | >>>>>>>> INSERT 38 | fabiocarlos 39 | ======== EXPECT 40 | f 41 | a 42 | b 43 | i 44 | o 45 | c 46 | a 47 | r 48 | l 49 | o 50 | s 51 | <<<<<<<< FINISH 52 | 53 | -------------------------------------------------------------------------------- /base/diagonal/Readme.md: -------------------------------------------------------------------------------- 1 | # Imprimindo um char por linha 2 | 3 | Faça um programa que recebe uma palavra com até 100 caracteres e imprime a palavra em diagonal. 4 | 5 | ## Entrada 6 | 7 | A entrada é composta por uma única linha contendo uma palavra com até 100 caracteres. 8 | 9 | ## Saída 10 | 11 | A saída é composta por `n` linhas sendo `n` o tamanho da palavra lida. 12 | 13 | ## Exemplo de Entrada 14 | 15 | ```txt 16 | wladimir 17 | ``` 18 | 19 | ## Exemplo de Saída 20 | 21 | ```txt 22 | w 23 | l 24 | a 25 | d 26 | i 27 | m 28 | i 29 | r 30 | ``` 31 | 32 | Dica: 33 | 34 | ```c 35 | void diagonal(char * s, int k) { 36 | if (*s == '\0') { 37 | return; 38 | } 39 | //imprima k caracteres 40 | //imprima o primeiro caractere de s e pule a linha 41 | //faça a chamada recursiva 42 | } 43 | } 44 | ``` 45 | 46 | ```go 47 | func diagonal(s string, k int) { 48 | if len(s) == 0 { 49 | return 50 | } 51 | // imprima k caracteres 52 | // imprima o primeiro caractere de s e pule a linha 53 | // faça a chamada recursiva 54 | } 55 | ``` 56 | -------------------------------------------------------------------------------- /base/diagonal/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 2 | jefferson 3 | ======== 4 | j 5 | e 6 | f 7 | f 8 | e 9 | r 10 | s 11 | o 12 | n 13 | <<<<<<<< 14 | 15 | >>>>>>>> 16 | lukeEuSouSeuPai 17 | ======== 18 | l 19 | u 20 | k 21 | e 22 | E 23 | u 24 | S 25 | o 26 | u 27 | S 28 | e 29 | u 30 | P 31 | a 32 | i 33 | <<<<<<<< 34 | 35 | 36 | 37 | >>>>>>>> 38 | fabiocarlos 39 | ======== 40 | f 41 | a 42 | b 43 | i 44 | o 45 | c 46 | a 47 | r 48 | l 49 | o 50 | s 51 | <<<<<<<< 52 | 53 | 54 | -------------------------------------------------------------------------------- /base/distancia/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 01.2. 3 | 3 4 | ======== EXPECT 5 | 01320 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 02 10 | .0..231..5 11 | 5 12 | ======== EXPECT 13 | 1045231045 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 01 18 | 2..0..............3........... 19 | 3 20 | ======== EXPECT 21 | 213021302130213021302130213021 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT 03 26 | 0..32..41. 27 | 5 28 | ======== EXPECT 29 | 0413250413 30 | <<<<<<<< FINISH 31 | 32 | 33 | >>>>>>>> INSERT 03 34 | 9....7.620.5318..... 35 | 9 36 | ======== EXPECT 37 | 95318746209531874620 38 | <<<<<<<< FINISH 39 | 40 | 41 | >>>>>>>> INSERT 42 | 12.3...0 43 | 4 44 | ======== EXPECT 45 | 12034120 46 | <<<<<<<< FINISH 47 | 48 | 49 | >>>>>>>> INSERT 50 | 0.76.14..2..5.. 51 | 7 52 | ======== EXPECT 53 | 027651430276514 54 | <<<<<<<< FINISH 55 | 56 | -------------------------------------------------------------------------------- /base/distancia/Readme.md: -------------------------------------------------------------------------------- 1 | # Colocando os números no lugar certo 2 | 3 | ![_](cover.jpg) 4 | 5 | - Seja uma string formada por dígitos e underlines `.`. 6 | - Seja um valor de limite L. 7 | 8 | Objetivos: 9 | 10 | - Você deve substituir todos os `.` por dígitos seguindo as seguintes regras. 11 | - Só pode utilizar dígitos de 0 até L, incluindo L. 12 | - Qualquer dígito precisa estar a uma distância mínima de L casas de outra ocorrência dele mesmo, tanto à esquerda como à direita. 13 | 14 | - Para cada problema, existe uma e somente uma solução. 15 | 16 | ## Entrada e Saída 17 | 18 | - Entrada 19 | - 1a linha: sequência. 20 | - 2a linha: valor de L. 21 | - Saída 22 | - A string solução do problema. 23 | 24 | ## Limites 25 | 26 | - sequência de tamanho t, 0 > t > 100 27 | - 0 > L > 100 28 | 29 | ___ 30 | 31 | ## Testes 32 | 33 | ```txt 34 | 35 | 36 | >>>>>>>> 37 | 01.2. 38 | 3 39 | ======== 40 | 01320 41 | <<<<<<<< 42 | 43 | 44 | 45 | >>>>>>>> 02 46 | .0..231..5 47 | 5 48 | ======== 49 | 1045231045 50 | <<<<<<<< 51 | 52 | >>>>>>>> 01 53 | 2..0..............3........... 54 | 3 55 | ======== 56 | 213021302130213021302130213021 57 | <<<<<<<< 58 | 59 | 60 | >>>>>>>> 03 61 | 0..32..41. 62 | 5 63 | ======== 64 | 0413250413 65 | <<<<<<<< 66 | 67 | 68 | >>>>>>>> 03 69 | 9....7.620.5318..... 70 | 9 71 | ======== 72 | 95318746209531874620 73 | <<<<<<<< 74 | 75 | >>>>>>>> 76 | 12.3...0 77 | 4 78 | ======== 79 | 12034120 80 | <<<<<<<< 81 | 82 | >>>>>>>> 83 | 0.76.14..2..5.. 84 | 7 85 | ======== 86 | 027651430276514 87 | <<<<<<<< 88 | 89 | ``` 90 | -------------------------------------------------------------------------------- /base/distancia/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/distancia/cover.jpg -------------------------------------------------------------------------------- /base/dividido/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT um 2 | 4 # # 3 | ======== EXPECT 4 | [ 4 ] 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT dois 9 | 1 # 0 # # 10 | ======== EXPECT 11 | [ 1 0 ] 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT tres 16 | 4 # 8 2 # # # 17 | ======== EXPECT 18 | [ 4 2 8 ] 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT quatro 23 | 0 9 4 # # # 5 # # 24 | ======== EXPECT 25 | [ 4 9 0 5 ] 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT cinco 30 | 0 4 # # 2 0 # # 3 # # 31 | ======== EXPECT 32 | [ 4 0 0 2 3 ] 33 | <<<<<<<< FINISH 34 | 35 | 36 | >>>>>>>> INSERT seis 37 | 2 0 0 # # # 3 # 7 # 9 # # 38 | ======== EXPECT 39 | [ 0 0 2 3 7 9 ] 40 | <<<<<<<< FINISH 41 | 42 | 43 | >>>>>>>> INSERT dez 44 | 1 8 7 # # 4 # 6 # # 5 0 # # 9 # 3 2 # # # 45 | ======== EXPECT 46 | [ 7 8 4 6 1 0 5 9 2 3 ] 47 | <<<<<<<< FINISH 48 | 49 | -------------------------------------------------------------------------------- /base/dividido/Makefile: -------------------------------------------------------------------------------- 1 | test: student 2 | 3 | extra = lib.cpp main.cpp 4 | 5 | % : %.cpp 6 | g++ -Wall $@.cpp $(extra) -o $@.out 7 | tk run $@.out Readme.md 8 | rm -f $@.out 9 | -------------------------------------------------------------------------------- /base/dividido/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/dividido/cover.jpg -------------------------------------------------------------------------------- /base/dividido/lib.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | using namespace std; 4 | 5 | struct Node { 6 | int value; 7 | Node * left; 8 | Node * right; 9 | Node(int value = 0, Node * left = nullptr, Node * right = nullptr){ 10 | this->value = value; 11 | this->left = left; 12 | this->right = right; 13 | } 14 | }; 15 | 16 | class BTree { 17 | public: 18 | Node * root {nullptr}; 19 | BTree(string serial); 20 | ~BTree(); 21 | std::string format(); 22 | std::string in_order(); 23 | }; -------------------------------------------------------------------------------- /base/dividido/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "lib.hpp" 4 | 5 | int main(){ 6 | std::string line; 7 | std::getline(cin, line); 8 | BTree bt(line); 9 | std::cout << bt.in_order() << '\n'; 10 | } 11 | -------------------------------------------------------------------------------- /base/dividido/student.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "lib.hpp" 4 | 5 | BTree::BTree(string serial) { 6 | (void) serial; 7 | //TODO 8 | } 9 | 10 | -------------------------------------------------------------------------------- /base/duplamente/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Lista Dupla - Algoritmos 2 | -------------------------------------------------------------------------------- /base/duplamente/Readme.md: -------------------------------------------------------------------------------- 1 | # Lista Dupla - Algoritmos 2 | -------------------------------------------------------------------------------- /base/editor/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Editor de texto 2 | 3 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/editor/cover.jpg) 4 | 5 | Implementar um editor de texto simplificado que receba os seguintes valores como 6 | entrada. 7 | 8 | - Os caracteres minúsculos "abc...z" e "-" são compreendidas como texto. 9 | - O cursor deve ser mostrado com o char | 10 | - Os seguintes caracteres serão comandos. 11 | - __Parte 1__ - Movimentação de Cursor 12 | - "R" return, insere o Enter. 13 | - "B" backspace, apaga o caractere atrás do cursor, se houver. 14 | - "D" delete, apaga o caractere na frente do cursor, se houver. 15 | - ">" move o cursor para direita, se for possível. 16 | - "<" move o cursor para esquerda, se for possível. 17 | 18 | ## Testes 19 | 20 | ```txt 21 | >>>>>>>> 22 | abc 23 | ======== 24 | abc| 25 | <<<<<<<< 26 | 27 | >>>>>>>> 28 | euRteRamo 29 | ======== 30 | eu 31 | te 32 | amo| 33 | <<<<<<<< 34 | 35 | >>>>>>>> 36 | euRamo<<< 37 | ======== 38 | eu 39 | |amo 40 | <<<<<<<< 41 | 42 | >>>>>>>> 43 | euRamo<<<<<<>>>>>>> 51 | euRemo<>>>>> 52 | ======== 53 | eu 54 | amo| 55 | <<<<<<<< 56 | 57 | >>>>>>>> 58 | voc-ae<>>Di> 59 | ======== 60 | voce-vai| 61 | <<<<<<<< 62 | ``` 63 | -------------------------------------------------------------------------------- /base/editor/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | abc 3 | ======== EXPECT 4 | abc| 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT 9 | euRteRamo 10 | ======== EXPECT 11 | eu 12 | te 13 | amo| 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 18 | euRamo<<< 19 | ======== EXPECT 20 | eu 21 | |amo 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT 26 | euRamo<<<<<<>>>>>>> INSERT 34 | euRemo<>>>>> 35 | ======== EXPECT 36 | eu 37 | amo| 38 | <<<<<<<< FINISH 39 | 40 | 41 | >>>>>>>> INSERT 42 | voc-ae<>>Di> 43 | ======== EXPECT 44 | voce-vai| 45 | <<<<<<<< FINISH 46 | 47 | -------------------------------------------------------------------------------- /base/editor/Readme.md: -------------------------------------------------------------------------------- 1 | # Editor de texto 2 | 3 | ![_](cover.jpg) 4 | 5 | Implementar um editor de texto simplificado que receba os seguintes valores como 6 | entrada. 7 | 8 | - Os caracteres minúsculos "abc...z" e "-" são compreendidas como texto. 9 | - O cursor deve ser mostrado com o char | 10 | - Os seguintes caracteres serão comandos. 11 | - __Parte 1__ - Movimentação de Cursor 12 | - "R" return, insere o Enter. 13 | - "B" backspace, apaga o caractere atrás do cursor, se houver. 14 | - "D" delete, apaga o caractere na frente do cursor, se houver. 15 | - ">" move o cursor para direita, se for possível. 16 | - "<" move o cursor para esquerda, se for possível. 17 | 18 | ## Testes 19 | 20 | ```txt 21 | >>>>>>>> 22 | abc 23 | ======== 24 | abc| 25 | <<<<<<<< 26 | 27 | >>>>>>>> 28 | euRteRamo 29 | ======== 30 | eu 31 | te 32 | amo| 33 | <<<<<<<< 34 | 35 | >>>>>>>> 36 | euRamo<<< 37 | ======== 38 | eu 39 | |amo 40 | <<<<<<<< 41 | 42 | >>>>>>>> 43 | euRamo<<<<<<>>>>>>> 51 | euRemo<>>>>> 52 | ======== 53 | eu 54 | amo| 55 | <<<<<<<< 56 | 57 | >>>>>>>> 58 | voc-ae<>>Di> 59 | ======== 60 | voce-vai| 61 | <<<<<<<< 62 | ``` 63 | -------------------------------------------------------------------------------- /base/editor/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/editor/cover.jpg -------------------------------------------------------------------------------- /base/editorint/.cache/draft/go/extra.md: -------------------------------------------------------------------------------- 1 | # Go 2 | 3 | - Navegue pelo terminal até a pasta do projeto. 4 | - Você encontrará os arquivos `lista.go`, `main.go`. 5 | 6 | ```bash 7 | # Você precisará criar um projeto Go com o comando: 8 | go mod init editor 9 | # Instale a biblioteca `tcell` com o comando 10 | go get github.com/gdamore/tcell/v2 11 | # Estando dentro da pasta do projeto, você pode rodar o projeto com o comando: 12 | tko run *.go 13 | ``` 14 | 15 | - Caso entre em loop infinito ou dê algum erro de execução, você pode interromper o programa com `Ctrl + C`. 16 | - Caso seu terminal fique estranho, você pode tentar restaurá-lo com o comando `reset` ou digitando `Ctrl + D` pra matar o terminal. 17 | -------------------------------------------------------------------------------- /base/editorint/.cache/q.tio: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/editorint/.cache/q.tio -------------------------------------------------------------------------------- /base/eh_primo/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Retorna se é ou não é 2 | 3 | Seja um número inteiro, retorne se ele é primo ou não. 4 | 5 | ## Draft 6 | 7 | 8 | - cpp 9 | - [main.cpp](https://github.com/qxcodeed/arcade/blob/master/base/eh_primo/.cache/draft/cpp/main.cpp) 10 | - go 11 | - [main.go](https://github.com/qxcodeed/arcade/blob/master/base/eh_primo/.cache/draft/go/main.go) 12 | 13 | 14 | ## Testes 15 | 16 | ```bash 17 | 18 | >>>>>>>> 19 | 1 20 | ======== 21 | false 22 | <<<<<<<< 23 | 24 | >>>>>>>> 25 | 2 26 | ======== 27 | true 28 | <<<<<<<< 29 | 30 | >>>>>>>> 31 | 3 32 | ======== 33 | true 34 | <<<<<<<< 35 | 36 | >>>>>>>> 37 | 4 38 | ======== 39 | false 40 | <<<<<<<< 41 | 42 | >>>>>>>> 43 | 5 44 | ======== 45 | true 46 | <<<<<<<< 47 | 48 | >>>>>>>> 49 | 6 50 | ======== 51 | false 52 | <<<<<<<< 53 | 54 | >>>>>>>> 55 | 7 56 | ======== 57 | true 58 | <<<<<<<< 59 | 60 | >>>>>>>> 61 | 18 62 | ======== 63 | false 64 | <<<<<<<< 65 | 66 | >>>>>>>> 67 | 19 68 | ======== 69 | true 70 | <<<<<<<< 71 | 72 | ``` 73 | -------------------------------------------------------------------------------- /base/eh_primo/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // x: número que está sendo testado 4 | // div: divisor que está sendo testado 5 | bool eh_primo(int x, int div = 2) { 6 | (void) x; 7 | (void) div; 8 | return false; 9 | } 10 | 11 | int main() { 12 | int x {}; 13 | std::cin >> x; 14 | std::cout << (eh_primo(x) ? "true" : "false") << '\n'; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /base/eh_primo/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // x: número que está sendo testado 6 | // div: divisor que está sendo testado 7 | func eh_primo(x int, div int) bool { 8 | _, _ = x, div 9 | return false; 10 | } 11 | 12 | func main() { 13 | var x int 14 | fmt.Scan(&x) 15 | if eh_primo(x, 2) { 16 | fmt.Println("true") 17 | } else { 18 | fmt.Println("false") 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /base/eh_primo/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 1 3 | ======== EXPECT 4 | false 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT 9 | 2 10 | ======== EXPECT 11 | true 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT 16 | 3 17 | ======== EXPECT 18 | true 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT 23 | 4 24 | ======== EXPECT 25 | false 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT 30 | 5 31 | ======== EXPECT 32 | true 33 | <<<<<<<< FINISH 34 | 35 | 36 | >>>>>>>> INSERT 37 | 6 38 | ======== EXPECT 39 | false 40 | <<<<<<<< FINISH 41 | 42 | 43 | >>>>>>>> INSERT 44 | 7 45 | ======== EXPECT 46 | true 47 | <<<<<<<< FINISH 48 | 49 | 50 | >>>>>>>> INSERT 51 | 18 52 | ======== EXPECT 53 | false 54 | <<<<<<<< FINISH 55 | 56 | 57 | >>>>>>>> INSERT 58 | 19 59 | ======== EXPECT 60 | true 61 | <<<<<<<< FINISH 62 | 63 | -------------------------------------------------------------------------------- /base/eh_primo/Readme.md: -------------------------------------------------------------------------------- 1 | # Retorna se é ou não é 2 | 3 | Seja um número inteiro, retorne se ele é primo ou não. 4 | 5 | ## Draft 6 | 7 | 8 | - cpp 9 | - [main.cpp](.cache/draft/cpp/main.cpp) 10 | - go 11 | - [main.go](.cache/draft/go/main.go) 12 | 13 | 14 | ## Testes 15 | 16 | ```bash 17 | 18 | >>>>>>>> 19 | 1 20 | ======== 21 | false 22 | <<<<<<<< 23 | 24 | >>>>>>>> 25 | 2 26 | ======== 27 | true 28 | <<<<<<<< 29 | 30 | >>>>>>>> 31 | 3 32 | ======== 33 | true 34 | <<<<<<<< 35 | 36 | >>>>>>>> 37 | 4 38 | ======== 39 | false 40 | <<<<<<<< 41 | 42 | >>>>>>>> 43 | 5 44 | ======== 45 | true 46 | <<<<<<<< 47 | 48 | >>>>>>>> 49 | 6 50 | ======== 51 | false 52 | <<<<<<<< 53 | 54 | >>>>>>>> 55 | 7 56 | ======== 57 | true 58 | <<<<<<<< 59 | 60 | >>>>>>>> 61 | 18 62 | ======== 63 | false 64 | <<<<<<<< 65 | 66 | >>>>>>>> 67 | 19 68 | ======== 69 | true 70 | <<<<<<<< 71 | 72 | ``` 73 | -------------------------------------------------------------------------------- /base/enesimo/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Gere o enesimo primo 2 | 3 | ## Intro 4 | 5 | Dado um número inteiro `n`, gere o `n`-ésimo número primo apenas utilizando recursão. 6 | 7 | Utilize o código eh_primo que você já implementou. 8 | 9 | O primeiro primo da lista é o número 2. 10 | 11 | ## Draft 12 | 13 | 14 | - cpp 15 | - [main.cpp](https://github.com/qxcodeed/arcade/blob/master/base/enesimo/.cache/draft/cpp/main.cpp) 16 | 17 | 18 | ## Teste 19 | 20 | ```txt 21 | >>>>>>>> 22 | 1 23 | ======== 24 | 2 25 | <<<<<<<< 26 | 27 | >>>>>>>> 28 | 2 29 | ======== 30 | 3 31 | <<<<<<<< 32 | 33 | >>>>>>>> 34 | 3 35 | ======== 36 | 5 37 | <<<<<<<< 38 | 39 | >>>>>>>> 40 | 4 41 | ======== 42 | 7 43 | <<<<<<<< 44 | 45 | >>>>>>>> 46 | 5 47 | ======== 48 | 11 49 | <<<<<<<< 50 | 51 | >>>>>>>> 52 | 6 53 | ======== 54 | 13 55 | <<<<<<<< 56 | 57 | >>>>>>>> 58 | 7 59 | ======== 60 | 17 61 | <<<<<<<< 62 | 63 | >>>>>>>> 64 | 8 65 | ======== 66 | 19 67 | <<<<<<<< 68 | 69 | ``` 70 | -------------------------------------------------------------------------------- /base/enesimo/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | // x: número que está sendo testado 3 | // div: divisor que está sendo testado 4 | bool eh_primo(int x, int div = 2) { 5 | (void) x; 6 | (void) div; 7 | return false; 8 | } 9 | 10 | // n: n-ésimo número primo 11 | // cont: contador de quantos números primos já foram encontrados 12 | // i: número que está sendo testado 13 | int n_esimo(int n, int cont = 0, int i = 2) { 14 | (void) n; 15 | (void) cont; 16 | (void) i; 17 | return 0; 18 | } 19 | 20 | int main() { 21 | int n {}; 22 | std::cin >> n; 23 | std::cout << n_esimo(n) << '\n'; 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /base/enesimo/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 1 3 | ======== EXPECT 4 | 2 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT 9 | 2 10 | ======== EXPECT 11 | 3 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT 16 | 3 17 | ======== EXPECT 18 | 5 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT 23 | 4 24 | ======== EXPECT 25 | 7 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT 30 | 5 31 | ======== EXPECT 32 | 11 33 | <<<<<<<< FINISH 34 | 35 | 36 | >>>>>>>> INSERT 37 | 6 38 | ======== EXPECT 39 | 13 40 | <<<<<<<< FINISH 41 | 42 | 43 | >>>>>>>> INSERT 44 | 7 45 | ======== EXPECT 46 | 17 47 | <<<<<<<< FINISH 48 | 49 | 50 | >>>>>>>> INSERT 51 | 8 52 | ======== EXPECT 53 | 19 54 | <<<<<<<< FINISH 55 | 56 | -------------------------------------------------------------------------------- /base/enesimo/Readme.md: -------------------------------------------------------------------------------- 1 | # Gere o enesimo primo 2 | 3 | ## Intro 4 | 5 | Dado um número inteiro `n`, gere o `n`-ésimo número primo apenas utilizando recursão. 6 | 7 | Utilize o código eh_primo que você já implementou. 8 | 9 | O primeiro primo da lista é o número 2. 10 | 11 | ## Draft 12 | 13 | 14 | - cpp 15 | - [main.cpp](.cache/draft/cpp/main.cpp) 16 | 17 | 18 | ## Teste 19 | 20 | ```txt 21 | >>>>>>>> 22 | 1 23 | ======== 24 | 2 25 | <<<<<<<< 26 | 27 | >>>>>>>> 28 | 2 29 | ======== 30 | 3 31 | <<<<<<<< 32 | 33 | >>>>>>>> 34 | 3 35 | ======== 36 | 5 37 | <<<<<<<< 38 | 39 | >>>>>>>> 40 | 4 41 | ======== 42 | 7 43 | <<<<<<<< 44 | 45 | >>>>>>>> 46 | 5 47 | ======== 48 | 11 49 | <<<<<<<< 50 | 51 | >>>>>>>> 52 | 6 53 | ======== 54 | 13 55 | <<<<<<<< 56 | 57 | >>>>>>>> 58 | 7 59 | ======== 60 | 17 61 | <<<<<<<< 62 | 63 | >>>>>>>> 64 | 8 65 | ======== 66 | 19 67 | <<<<<<<< 68 | 69 | ``` 70 | -------------------------------------------------------------------------------- /base/escada/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # De quantas maneiras podemos subir 2 | 3 | Ao subir a escada de seu prédio, José às vezes sobe três degraus de uma vez e às vezes sobe um de cada vez. Dado uma escada com n degraus de quantas maneiras diferentes José pode subir essa escada. Para resolver esse problema, vamos pensar nos casos menores: 4 | 5 | - Uma escada de 1 degrau, podemos subir as escadas de 1 maneira (1). 6 | - Uma escada de 2 degrau, podemos subir as escadas de 1 maneiras ((1,1)). 7 | - Uma escada de 3 degraus, podemos subir as escadas de 2 maneiras 8 | ((1,1,1),(3)). 9 | 10 | Seja $x_n$ número de maneira de subir uma escada de $n$ degraus. O primeiro passo para subir uma escada de n degraus pode ser dado de duas maneiras: 11 | 12 | - Se você subir apenas um degrau, então teremos $x_{n-1}$ maneiras de subir o restante da escada. 13 | - Se você subir três degraus, então teremos $x_{n-3}$ maneiras de subir o restante da escada. 14 | 15 | A recorrência para $x_n$ será: 16 | 17 | $$ 18 | x_n = \begin{cases} 19 | 1 & n = 1\\ 20 | 1 & n = 2\\ 21 | 2 & n = 3\\ 22 | x_{n-1} + x_{n-3} & n > 3\\ 23 | \end{cases} 24 | $$ 25 | 26 | ## Entrada 27 | 28 | A entrada é composta por uma única linha contendo um inteiro $n$ representando o número de degraus da escada 29 | 30 | ## Saída 31 | 32 | A saída é composta por uma única linha contendo o número de maneiras que uma escada com $n$ degraus pode ser subida saltando 1 ou 3 degraus por vez. 33 | 34 | ## Exemplo de Entrada 35 | 36 | ```txt 37 | 4 38 | ``` 39 | 40 | ## Exemplo de Saída 41 | 42 | ```txt 43 | 3 44 | ``` 45 | -------------------------------------------------------------------------------- /base/escada/Readme.md: -------------------------------------------------------------------------------- 1 | # De quantas maneiras podemos subir 2 | 3 | Ao subir a escada de seu prédio, José às vezes sobe três degraus de uma vez e às vezes sobe um de cada vez. Dado uma escada com n degraus de quantas maneiras diferentes José pode subir essa escada. Para resolver esse problema, vamos pensar nos casos menores: 4 | 5 | - Uma escada de 1 degrau, podemos subir as escadas de 1 maneira (1). 6 | - Uma escada de 2 degrau, podemos subir as escadas de 1 maneiras ((1,1)). 7 | - Uma escada de 3 degraus, podemos subir as escadas de 2 maneiras 8 | ((1,1,1),(3)). 9 | 10 | Seja $x_n$ número de maneira de subir uma escada de $n$ degraus. O primeiro passo para subir uma escada de n degraus pode ser dado de duas maneiras: 11 | 12 | - Se você subir apenas um degrau, então teremos $x_{n-1}$ maneiras de subir o restante da escada. 13 | - Se você subir três degraus, então teremos $x_{n-3}$ maneiras de subir o restante da escada. 14 | 15 | A recorrência para $x_n$ será: 16 | 17 | $$ 18 | x_n = \begin{cases} 19 | 1 & n = 1\\ 20 | 1 & n = 2\\ 21 | 2 & n = 3\\ 22 | x_{n-1} + x_{n-3} & n > 3\\ 23 | \end{cases} 24 | $$ 25 | 26 | ## Entrada 27 | 28 | A entrada é composta por uma única linha contendo um inteiro $n$ representando o número de degraus da escada 29 | 30 | ## Saída 31 | 32 | A saída é composta por uma única linha contendo o número de maneiras que uma escada com $n$ degraus pode ser subida saltando 1 ou 3 degraus por vez. 33 | 34 | ## Exemplo de Entrada 35 | 36 | ```txt 37 | 4 38 | ``` 39 | 40 | ## Exemplo de Saída 41 | 42 | ```txt 43 | 3 44 | ``` 45 | -------------------------------------------------------------------------------- /base/fib1/FibonacciRabbits1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fib1/FibonacciRabbits1.jpg -------------------------------------------------------------------------------- /base/fib2/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int f (int n) { 4 | (void) n; 5 | return 0; 6 | } 7 | 8 | int main() { 9 | int n; 10 | std::cin >> n; 11 | std::cout << f(n) << std::endl; 12 | } 13 | -------------------------------------------------------------------------------- /base/fib2/Fibonacci.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fib2/Fibonacci.png -------------------------------------------------------------------------------- /base/fib2/FibonacciRabbits1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fib2/FibonacciRabbits1.jpg -------------------------------------------------------------------------------- /base/fila/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fila/cover.jpg -------------------------------------------------------------------------------- /base/fila_enc/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 01 2 | push 4 3 | push 5 4 | push 6 5 | show 6 | end 7 | ======== EXPECT 8 | $push 4 9 | $push 5 10 | $push 6 11 | $show 12 | [4, 5, 6] 13 | $end 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 02 18 | push 1 3 5 7 8 19 | show 20 | pop 21 | show 22 | pop 23 | show 24 | end 25 | ======== EXPECT 26 | $push 1 3 5 7 8 27 | $show 28 | [1, 3, 5, 7, 8] 29 | $pop 30 | $show 31 | [3, 5, 7, 8] 32 | $pop 33 | $show 34 | [5, 7, 8] 35 | $end 36 | <<<<<<<< FINISH 37 | 38 | 39 | >>>>>>>> INSERT 03 40 | push 10 41 | push 20 42 | push 30 43 | peek 44 | pop 45 | peek 46 | pop 47 | peek 48 | pop 49 | peek 50 | pop 51 | end 52 | ======== EXPECT 53 | $push 10 54 | $push 20 55 | $push 30 56 | $peek 57 | 10 58 | $pop 59 | $peek 60 | 20 61 | $pop 62 | $peek 63 | 30 64 | $pop 65 | $peek 66 | falha: fila vazia 67 | $pop 68 | falha: fila vazia 69 | $end 70 | <<<<<<<< FINISH 71 | 72 | -------------------------------------------------------------------------------- /base/formatada/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT um 2 | 4 # # 3 | ======== EXPECT 4 | 4 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT dois 9 | 1 # 0 # # 10 | ======== EXPECT 11 | ....# 12 | 1 13 | ....0 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT tres 18 | 4 # 8 2 # # # 19 | ======== EXPECT 20 | ....# 21 | 4 22 | ........2 23 | ....8 24 | ........# 25 | <<<<<<<< FINISH 26 | 27 | 28 | >>>>>>>> INSERT quatro 29 | 0 9 4 # # # 5 # # 30 | ======== EXPECT 31 | ........4 32 | ....9 33 | ........# 34 | 0 35 | ....5 36 | <<<<<<<< FINISH 37 | 38 | 39 | >>>>>>>> INSERT cinco 40 | 0 4 # # 2 0 # # 3 # # 41 | ======== EXPECT 42 | ....4 43 | 0 44 | ........0 45 | ....2 46 | ........3 47 | <<<<<<<< FINISH 48 | 49 | 50 | >>>>>>>> INSERT seis 51 | 2 0 0 # # # 3 # 7 # 9 # # 52 | ======== EXPECT 53 | ........0 54 | ....0 55 | ........# 56 | 2 57 | ........# 58 | ....3 59 | ............# 60 | ........7 61 | ............9 62 | <<<<<<<< FINISH 63 | 64 | 65 | >>>>>>>> INSERT dez 66 | 1 8 7 # # 4 # 6 # # 5 0 # # 9 # 3 2 # # # 67 | ======== EXPECT 68 | ........7 69 | ....8 70 | ............# 71 | ........4 72 | ............6 73 | 1 74 | ........0 75 | ....5 76 | ............# 77 | ........9 78 | ................2 79 | ............3 80 | ................# 81 | <<<<<<<< FINISH 82 | 83 | -------------------------------------------------------------------------------- /base/formatada/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/formatada/cover.jpg -------------------------------------------------------------------------------- /base/fracao/.cache/draft/cpp/fracao.cpp: -------------------------------------------------------------------------------- 1 | #include "fracao.hpp" 2 | 3 | int Frac::mdc(int a, int b) { 4 | (void) a; 5 | (void) b; 6 | return 0; 7 | } 8 | 9 | void Frac::reduce() { 10 | } 11 | 12 | bool Frac::operator<(const Frac& other) const { 13 | (void) other; 14 | return false; 15 | } 16 | 17 | bool Frac::operator==(const Frac& other) const { 18 | (void) other; 19 | return false; 20 | } 21 | 22 | Frac Frac::operator+(const Frac& other) const { 23 | (void) other; 24 | return Frac(); 25 | } 26 | 27 | // função que ordena uma fração 28 | // você pode usar a função std::sort 29 | // ou implementar um algoritmo de ordenação 30 | void ordena_frac(std::vector& vet) { 31 | (void) vet; 32 | } 33 | -------------------------------------------------------------------------------- /base/fracao/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "fracao.hpp" 3 | #include "fn.hpp" 4 | 5 | Frac str2frac(std::string str) { 6 | auto [num, den] = fn::unpack(str, '/'); 7 | return Frac(num, den); 8 | } 9 | 10 | int main() { 11 | auto vet = fn::input() | fn::SPLIT(' ') | fn::MAP(str2frac); 12 | vet | fn::JOIN(" ") | fn::WRITE(); 13 | ordena_frac(vet); 14 | vet | fn::JOIN(" ") | fn::WRITE(); 15 | } 16 | -------------------------------------------------------------------------------- /base/fracao/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 01 2 | 1/2 1/3 2/3 3/4 8/4 10/50 20/5 13/5 4/50 50/30 3 | ======== EXPECT 4 | 1/2 1/3 2/3 3/4 2/1 1/5 4/1 13/5 2/25 5/3 5 | 2/25 1/5 1/3 1/2 2/3 3/4 5/3 2/1 13/5 4/1 6 | <<<<<<<< FINISH 7 | 8 | -------------------------------------------------------------------------------- /base/fracao/Readme.md: -------------------------------------------------------------------------------- 1 | # Implemente a classe fração reduzida 2 | 3 | ## Intro 4 | 5 | Implemente a classe fração e os métodos orientados no arquivo `fracao.hpp`. 6 | 7 | ## Draft 8 | 9 | - Você deve implementar os métodos solicitados no arquivo `fracao.cpp`. 10 | - Estude a interface da classe `Fracao` no arquivo `fracao.hpp` e veja a descrição dos métodos. 11 | - Estude também a forma como ela foi construída para aprender mais sobre sobrecarga de operadores, construtores e métodos canônicos. 12 | - A classe `main.cpp` já está implementada e você não deve alterá-la. 13 | - A classe `fn.hpp` contém funções auxiliares para ajudar na implementação dos testes. 14 | 15 | 16 | - cpp 17 | - [fn.hpp](.cache/draft/cpp/fn.hpp) 18 | - [fracao.cpp](.cache/draft/cpp/fracao.cpp) 19 | - [fracao.hpp](.cache/draft/cpp/fracao.hpp) 20 | - [main.cpp](.cache/draft/cpp/main.cpp) 21 | 22 | 23 | ## Tests 24 | 25 | - As saídas devem ser realizadas com 2 casas decimais. 26 | 27 | - Entrada 28 | - Lista de frações no formato `numerador/denominador` 29 | - Saída 30 | - Lista de frações reduzidas no formato `numerador/denominador` 31 | - Lista ordenada pelo valor da fração. 32 | 33 | ```txt 34 | >>>>>>>> 01 35 | 1/2 1/3 2/3 3/4 8/4 10/50 20/5 13/5 4/50 50/30 36 | ======== 37 | 1/2 1/3 2/3 3/4 2/1 1/5 4/1 13/5 2/25 5/3 38 | 2/25 1/5 1/3 1/2 2/3 3/4 5/3 2/1 13/5 4/1 39 | <<<<<<<< 40 | ``` 41 | -------------------------------------------------------------------------------- /base/fracaoGo/.cache/draft/cpp/fracao.cpp: -------------------------------------------------------------------------------- 1 | #include "fracao.hpp" 2 | 3 | int Frac::mdc(int a, int b) { 4 | (void) a; 5 | (void) b; 6 | return 0; 7 | } 8 | 9 | void Frac::reduce() { 10 | } 11 | 12 | bool Frac::operator<(const Frac& other) const { 13 | (void) other; 14 | return false; 15 | } 16 | 17 | bool Frac::operator==(const Frac& other) const { 18 | (void) other; 19 | return false; 20 | } 21 | 22 | Frac Frac::operator+(const Frac& other) const { 23 | (void) other; 24 | return Frac(); 25 | } 26 | 27 | // função que ordena uma fração 28 | // você pode usar a função std::sort 29 | // ou implementar um algoritmo de ordenação 30 | void ordena_frac(std::vector& vet) { 31 | (void) vet; 32 | } 33 | -------------------------------------------------------------------------------- /base/fracaoGo/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "fracao.hpp" 3 | #include "fn.hpp" 4 | 5 | Frac str2frac(std::string str) { 6 | auto [num, den] = fn::unpack(str, '/'); 7 | return Frac(num, den); 8 | } 9 | 10 | int main() { 11 | auto vet = fn::input() | fn::SPLIT(' ') | fn::MAP(str2frac); 12 | vet | fn::JOIN(" ") | fn::WRITE(); 13 | ordena_frac(vet); 14 | vet | fn::JOIN(" ") | fn::WRITE(); 15 | } 16 | -------------------------------------------------------------------------------- /base/fracaoGo/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 01 2 | 1/2 1/3 2/3 3/4 8/4 10/50 20/5 13/5 4/50 50/30 3 | ======== EXPECT 4 | 1/2 1/3 2/3 3/4 2/1 1/5 4/1 13/5 2/25 5/3 5 | 2/25 1/5 1/3 1/2 2/3 3/4 5/3 2/1 13/5 4/1 6 | <<<<<<<< FINISH 7 | 8 | -------------------------------------------------------------------------------- /base/fracaoGo/Readme.md: -------------------------------------------------------------------------------- 1 | # Implemente a classe fração reduzida 2 | 3 | ## Intro 4 | 5 | Implemente a classe fração e os métodos orientados no arquivo `fracao.hpp`. 6 | 7 | ## Draft 8 | 9 | - Você deve implementar os métodos solicitados no arquivo `fracao.cpp`. 10 | - Estude a interface da classe `Fracao` no arquivo `fracao.hpp` e veja a descrição dos métodos. 11 | - Estude também a forma como ela foi construída para aprender mais sobre sobrecarga de operadores, construtores e métodos canônicos. 12 | - A classe `main.cpp` já está implementada e você não deve alterá-la. 13 | - A classe `fn.hpp` contém funções auxiliares para ajudar na implementação dos testes. 14 | 15 | 16 | - cpp 17 | - [fn.hpp](.cache/draft/cpp/fn.hpp) 18 | - [fracao.cpp](.cache/draft/cpp/fracao.cpp) 19 | - [fracao.hpp](.cache/draft/cpp/fracao.hpp) 20 | - [main.cpp](.cache/draft/cpp/main.cpp) 21 | 22 | 23 | ## Tests 24 | 25 | - As saídas devem ser realizadas com 2 casas decimais. 26 | 27 | - Entrada 28 | - Lista de frações no formato `numerador/denominador` 29 | - Saída 30 | - Lista de frações reduzidas no formato `numerador/denominador` 31 | - Lista ordenada pelo valor da fração. 32 | 33 | ```txt 34 | >>>>>>>> 01 35 | 1/2 1/3 2/3 3/4 8/4 10/50 20/5 13/5 4/50 50/30 36 | ======== 37 | 1/2 1/3 2/3 3/4 2/1 1/5 4/1 13/5 2/25 5/3 38 | 2/25 1/5 1/3 1/2 2/3 3/4 5/3 2/1 13/5 4/1 39 | <<<<<<<< 40 | ``` 41 | -------------------------------------------------------------------------------- /base/fractais/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Desenhando Fractais 2 | 3 | Utilizando o módulo de desenho de fractais em svg disponível no rascunho, tente desenhar os seguintes fractais: 4 | 5 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais/./desenhos/arvore.png) 6 | 7 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais/./desenhos/circulos.png) 8 | 9 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais/./desenhos/gelo.png) 10 | 11 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais/./desenhos/quadrados.png) 12 | 13 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais/./desenhos/rotacao.png) 14 | 15 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais/./desenhos/carpete.jpg) 16 | 17 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais/./desenhos/triangulos.png) 18 | 19 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais/./desenhos/trigo.png) 20 | -------------------------------------------------------------------------------- /base/fractais/.cache/draft/go/draw.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "math/rand" 6 | ) 7 | 8 | func randInt(min, max int) int { 9 | return min + rand.Intn(max-min+1) 10 | } 11 | 12 | func tree(p *Pen, tam float64) { 13 | fator := 0.75 14 | ang := 35.0 15 | 16 | if tam < 10 { 17 | if randInt(0, 10) < 1 { 18 | p.SetColor(255, 0, 0) 19 | p.DrawCircle(tam) 20 | } 21 | return 22 | } 23 | p.SetColor(randInt(0, 255), randInt(0, 255), randInt(0, 255)) 24 | p.SetStrokeWidth(int(tam / 10)) 25 | p.Walk(tam) 26 | p.Rotate(-ang) 27 | tree(p, tam*fator) 28 | p.Rotate(2 * ang) 29 | tree(p, tam*fator) 30 | p.Rotate(-ang) 31 | p.Walk(-tam) 32 | } 33 | 34 | func main() { 35 | pen := NewPen(500, 500) 36 | pen.SetColor(255, 0, 0) 37 | pen.SetPosition(250, 500) 38 | pen.SetHeading(90) 39 | tree(pen, 100) 40 | pen.SaveToFile("tree.svg") 41 | fmt.Println("SVG file created successfully.") 42 | } 43 | -------------------------------------------------------------------------------- /base/fractais/.cache/draft/go/extra.md: -------------------------------------------------------------------------------- 1 | # GO 2 | 3 | - Navegue até a pasta do projeto em database/fractais 4 | 5 | ```bash 6 | # rode o projeto 7 | tko run *.go 8 | # abra o editor para ver o desenho gerado 9 | code tree.svg 10 | ``` 11 | -------------------------------------------------------------------------------- /base/fractais/.cache/q.tio: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais/.cache/q.tio -------------------------------------------------------------------------------- /base/fractais/Readme.md: -------------------------------------------------------------------------------- 1 | # Desenhando Fractais 2 | 3 | Utilizando o módulo de desenho de fractais em svg disponível no rascunho, tente desenhar os seguintes fractais: 4 | 5 | ![_](./desenhos/arvore.png) 6 | 7 | ![_](./desenhos/circulos.png) 8 | 9 | ![_](./desenhos/gelo.png) 10 | 11 | ![_](./desenhos/quadrados.png) 12 | 13 | ![_](./desenhos/rotacao.png) 14 | 15 | ![_](./desenhos/carpete.jpg) 16 | 17 | ![_](./desenhos/triangulos.png) 18 | 19 | ![_](./desenhos/trigo.png) 20 | -------------------------------------------------------------------------------- /base/fractais/desenho.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /base/fractais/desenhos/arvore.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais/desenhos/arvore.png -------------------------------------------------------------------------------- /base/fractais/desenhos/carpete.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais/desenhos/carpete.jpg -------------------------------------------------------------------------------- /base/fractais/desenhos/circulos.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais/desenhos/circulos.png -------------------------------------------------------------------------------- /base/fractais/desenhos/gelo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais/desenhos/gelo.png -------------------------------------------------------------------------------- /base/fractais/desenhos/quadrados.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais/desenhos/quadrados.png -------------------------------------------------------------------------------- /base/fractais/desenhos/rotacao.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais/desenhos/rotacao.png -------------------------------------------------------------------------------- /base/fractais/desenhos/triangulos.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais/desenhos/triangulos.png -------------------------------------------------------------------------------- /base/fractais/desenhos/trigo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais/desenhos/trigo.png -------------------------------------------------------------------------------- /base/fractais_png/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Desenhando Fractais 2 | 3 | - Veja o arquivo `extra.md` para detalhes de como instalar a biblioteca para desenhar pngs. 4 | - Após isso, vamos treinar o desenho de alguns fractais. 5 | 6 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais_png/./desenhos/arvore.png) 7 | 8 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais_png/./desenhos/circulos.png) 9 | 10 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais_png/./desenhos/gelo.png) 11 | 12 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais_png/./desenhos/quadrados.png) 13 | 14 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais_png/./desenhos/rotacao.png) 15 | 16 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais_png/./desenhos/carpete.jpg) 17 | 18 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais_png/./desenhos/triangulos.png) 19 | 20 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/fractais_png/./desenhos/trigo.png) 21 | -------------------------------------------------------------------------------- /base/fractais_png/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "math/rand" 6 | ) 7 | 8 | func randInt(min, max int) int { 9 | return min + rand.Intn(max-min+1) 10 | } 11 | 12 | func main() { 13 | pen := NewPen(500, 500) // cria um canvas de 500 de largura por 500 de altura 14 | pen.SetRGB(255, 0, 0) // muda a cor do pincel para vermelho 15 | pen.SetPosition(250, 500) // move o pincel para x 250, y 500 16 | pen.SetHeading(90) // coloca o pincel apontando para cima 17 | pen.Walk(100) // anda 100 pixels 18 | pen.Left(30) // dobra 30 graus para esquerda 19 | pen.Walk(100) // anda 100 pixels 20 | pen.DrawCircle(50) // desenha um círculo de raio 50 21 | pen.Right(60) // gira para direita 60 graus 22 | pen.Walk(150) 23 | for range 10 { 24 | pen.Up() 25 | pen.Walk(30) // anda sem riscar 26 | pen.Down() 27 | 28 | pen.DrawCircle(10) //desenha um circulo pequeno 29 | 30 | pen.Up() 31 | pen.Walk(-30) // volta sem riscar 32 | pen.Down() 33 | 34 | pen.Left(36) // gira 35 | } 36 | 37 | pen.SavePNG("tree.png") 38 | fmt.Println("PNG file created successfully.") 39 | } 40 | -------------------------------------------------------------------------------- /base/fractais_png/.cache/q.tio: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais_png/.cache/q.tio -------------------------------------------------------------------------------- /base/fractais_png/Readme.md: -------------------------------------------------------------------------------- 1 | # Desenhando Fractais 2 | 3 | - Veja o arquivo `extra.md` para detalhes de como instalar a biblioteca para desenhar pngs. 4 | - Após isso, vamos treinar o desenho de alguns fractais. 5 | 6 | ![_](./desenhos/arvore.png) 7 | 8 | ![_](./desenhos/circulos.png) 9 | 10 | ![_](./desenhos/gelo.png) 11 | 12 | ![_](./desenhos/quadrados.png) 13 | 14 | ![_](./desenhos/rotacao.png) 15 | 16 | ![_](./desenhos/carpete.jpg) 17 | 18 | ![_](./desenhos/triangulos.png) 19 | 20 | ![_](./desenhos/trigo.png) 21 | -------------------------------------------------------------------------------- /base/fractais_png/desenho.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /base/fractais_png/desenhos/arvore.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais_png/desenhos/arvore.png -------------------------------------------------------------------------------- /base/fractais_png/desenhos/carpete.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais_png/desenhos/carpete.jpg -------------------------------------------------------------------------------- /base/fractais_png/desenhos/circulos.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais_png/desenhos/circulos.png -------------------------------------------------------------------------------- /base/fractais_png/desenhos/gelo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais_png/desenhos/gelo.png -------------------------------------------------------------------------------- /base/fractais_png/desenhos/quadrados.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais_png/desenhos/quadrados.png -------------------------------------------------------------------------------- /base/fractais_png/desenhos/rotacao.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais_png/desenhos/rotacao.png -------------------------------------------------------------------------------- /base/fractais_png/desenhos/triangulos.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais_png/desenhos/triangulos.png -------------------------------------------------------------------------------- /base/fractais_png/desenhos/trigo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/fractais_png/desenhos/trigo.png -------------------------------------------------------------------------------- /base/hex/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Desenhando labirinto perfeito 2 | 3 | - Baixe o rascunho em go. 4 | - Navegue até a pasta do projeto em ed/database/hex 5 | 6 | ```bash 7 | touch grid.svg # cria pela primeira vez o arquivo 8 | code grid.svg # abre o arquivo no vscode 9 | tko run *.go # executa o código 10 | ``` 11 | 12 | - Abre o arquivo grid.svg e veja o svg sendo atualizado em tempo real. 13 | -------------------------------------------------------------------------------- /base/hex/.cache/q.tio: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/hex/.cache/q.tio -------------------------------------------------------------------------------- /base/hex/Readme.md: -------------------------------------------------------------------------------- 1 | # Desenhando labirinto perfeito 2 | 3 | - Baixe o rascunho em go. 4 | - Navegue até a pasta do projeto em ed/database/hex 5 | 6 | ```bash 7 | touch grid.svg # cria pela primeira vez o arquivo 8 | code grid.svg # abre o arquivo no vscode 9 | tko run *.go # executa o código 10 | ``` 11 | 12 | - Abre o arquivo grid.svg e veja o svg sendo atualizado em tempo real. 13 | -------------------------------------------------------------------------------- /base/incompleta/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT test_fill 2 | test_fill 3 | ======== EXPECT 4 | TESTE fill 5 | insert 32 6 | insert 45 7 | insert 37 8 | insert 10 9 | insert 12 10 | BinaryTree: Node-32{(Node-45{(Node-10{(, )}, Node-37{(, )})}, Node-12{(, )})} 11 | fill 12 | Node(32, -1, 5, 1, 3) 13 | Node(45, 32, 3, 2, 2) 14 | Node(10, 45, 1, 3, 1) 15 | Node(37, 45, 1, 3, 1) 16 | Node(12, 32, 1, 2, 1) 17 | <<<<<<<< FINISH 18 | 19 | 20 | >>>>>>>> INSERT test_fill_2 21 | test_fill_2 22 | ======== EXPECT 23 | TESTE fill 2 24 | BinaryTree: Node-32{(Node-11{(Node-6{(, )}, Node-2{(, )})}, Node-112{(Node-63{(Node-66{(, )}, Node-11{(Node--45{(, )}, Node-19{(Node--1000{(, )}, Node-1223{(, )})})})}, Node-21{(, )})})} 25 | fill 26 | Node(32, -1, 13, 1, 6) 27 | Node(11, 32, 3, 2, 2) 28 | Node(6, 11, 1, 3, 1) 29 | Node(2, 11, 1, 3, 1) 30 | Node(112, 32, 9, 2, 5) 31 | Node(63, 112, 7, 3, 4) 32 | Node(66, 63, 1, 4, 1) 33 | Node(11, 63, 5, 4, 3) 34 | Node(-45, 11, 1, 5, 1) 35 | Node(19, 11, 3, 5, 2) 36 | Node(-1000, 19, 1, 6, 1) 37 | Node(1223, 19, 1, 6, 1) 38 | Node(21, 112, 1, 3, 1) 39 | <<<<<<<< FINISH 40 | 41 | -------------------------------------------------------------------------------- /base/incompleta/cases.vpl: -------------------------------------------------------------------------------- 1 | Case=test_fill 2 | Input=test_fill 3 | Output=TESTE fill 4 | insert 32 5 | insert 45 6 | insert 37 7 | insert 10 8 | insert 12 9 | BinaryTree: Node-32{(Node-45{(Node-10{(, )}, Node-37{(, )})}, Node-12{(, )})} 10 | fill 11 | Node(32, -1, 5, 1, 3) 12 | Node(45, 32, 3, 2, 2) 13 | Node(10, 45, 1, 3, 1) 14 | Node(37, 45, 1, 3, 1) 15 | Node(12, 32, 1, 2, 1) 16 | 17 | 18 | Case=test_fill_2 19 | Input=test_fill_2 20 | Output=TESTE fill 2 21 | BinaryTree: Node-32{(Node-11{(Node-6{(, )}, Node-2{(, )})}, Node-112{(Node-63{(Node-66{(, )}, Node-11{(Node--45{(, )}, Node-19{(Node--1000{(, )}, Node-1223{(, )})})})}, Node-21{(, )})})} 22 | fill 23 | Node(32, -1, 13, 1, 6) 24 | Node(11, 32, 3, 2, 2) 25 | Node(6, 11, 1, 3, 1) 26 | Node(2, 11, 1, 3, 1) 27 | Node(112, 32, 9, 2, 5) 28 | Node(63, 112, 7, 3, 4) 29 | Node(66, 63, 1, 4, 1) 30 | Node(11, 63, 5, 4, 3) 31 | Node(-45, 11, 1, 5, 1) 32 | Node(19, 11, 3, 5, 2) 33 | Node(-1000, 19, 1, 6, 1) 34 | Node(1223, 19, 1, 6, 1) 35 | Node(21, 112, 1, 3, 1) -------------------------------------------------------------------------------- /base/incompleta/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> Teste 1 2 | test_fill 3 | ======== 4 | TESTE fill 5 | insert 32 6 | insert 45 7 | insert 37 8 | insert 10 9 | insert 12 10 | BinaryTree: Node-32{(Node-45{(Node-10{(, )}, Node-37{(, )})}, Node-12{(, )})} 11 | fill 12 | Node(32, -1, 5, 1, 3) 13 | Node(45, 32, 3, 2, 2) 14 | Node(10, 45, 1, 3, 1) 15 | Node(37, 45, 1, 3, 1) 16 | Node(12, 32, 1, 2, 1) 17 | <<<<<<<< 18 | 19 | >>>>>>>> Teste 2 20 | test_fill_2 21 | ======== 22 | TESTE fill 2 23 | BinaryTree: Node-32{(Node-11{(Node-6{(, )}, Node-2{(, )})}, Node-112{(Node-63{(Node-66{(, )}, Node-11{(Node--45{(, )}, Node-19{(Node--1000{(, )}, Node-1223{(, )})})})}, Node-21{(, )})})} 24 | fill 25 | Node(32, -1, 13, 1, 6) 26 | Node(11, 32, 3, 2, 2) 27 | Node(6, 11, 1, 3, 1) 28 | Node(2, 11, 1, 3, 1) 29 | Node(112, 32, 9, 2, 5) 30 | Node(63, 112, 7, 3, 4) 31 | Node(66, 63, 1, 4, 1) 32 | Node(11, 63, 5, 4, 3) 33 | Node(-45, 11, 1, 5, 1) 34 | Node(19, 11, 3, 5, 2) 35 | Node(-1000, 19, 1, 6, 1) 36 | Node(1223, 19, 1, 6, 1) 37 | Node(21, 112, 1, 3, 1) 38 | <<<<<<<< -------------------------------------------------------------------------------- /base/indices/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Índices originais 2 | 3 | 4 | [Intro](#intro) | [Draft](#draft) | [Tests](#tests) 5 | -- | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Você recebe um vetor A de inteiros não negativos de tamanho n. Sua tarefa é ordenar o vetor em ordem crescente e imprimir os índices originais dos elementos. 11 | 12 | Considere o vetor `A = {4,5,3,7,1}` 13 | 14 | Após a ordenação, o vetor ordenado será: `A = {1,3,4,5,7}`. 15 | 16 | A saída deve ser os índices originais dos elementos do vetor ordenado: `4 2 0 1 3` 17 | 18 | **NOTA:** A indexação da vetor começa com 0. 19 | 20 | ## Draft 21 | 22 | - Você deve implementar um algoritmo de ordenação e a função `originalIndices` no arquivo `main.cpp`. 23 | 24 | 25 | - cpp 26 | - [main.cpp](https://github.com/qxcodeed/arcade/blob/master/base/indices/.cache/draft/cpp/main.cpp) 27 | 28 | 29 | ## Tests 30 | 31 | ### Entrada 32 | 33 | - A primeira linha de entrada consiste em um número inteiro n, representando o tamanho do vetor A. 34 | - A segunda linha de entrada contém n inteiros não negativos, representando os elementos do vetor A. 35 | - Restrições: 36 | - $1 \le n \le 10^{6} $ 37 | - $0 \le A[i] \le 10^6$ 38 | 39 | ### Saída 40 | 41 | - A saída consiste em uma única linha de n inteiros, representando os índices originais de cada elemento no vetor ordenado. 42 | 43 | ```txt 44 | >>>>>>>> 45 | 5 46 | 4 5 3 7 1 47 | ======== 48 | 4 2 0 1 3 49 | <<<<<<<< 50 | ``` 51 | -------------------------------------------------------------------------------- /base/indices/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | //Escolha e implemente um algoritmo de ordenação 5 | std::vector ordenar(std::vector arr) { 6 | (void) arr; 7 | return arr; 8 | } 9 | 10 | std::vector originalIndices(std::vector& arr, std::vector& arrOrdenado) { 11 | (void) arr; 12 | (void) arrOrdenado; 13 | return std::vector {}; 14 | } 15 | 16 | int main() { 17 | int n; 18 | std::cin >> n; 19 | std::vector arr(n); 20 | for (int i = 0; i < n; i++) { 21 | std::cin >> arr[i]; 22 | } 23 | 24 | std::vector arrOrdenado = ordenar(arr); 25 | std::vector indices = originalIndices(arr, arrOrdenado); 26 | 27 | for (int i = 0; i < (int) indices.size(); i++) { 28 | if (i != 0) { 29 | std:: cout << " "; 30 | } 31 | std::cout << indices[i]; 32 | } 33 | 34 | std::cout << std::endl; 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /base/indices/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 5 3 | 4 5 3 7 1 4 | ======== EXPECT 5 | 4 2 0 1 3 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 10 | 10 11 | 7 5 4 3 2 1 8 0 9 6 12 | ======== EXPECT 13 | 7 5 4 3 2 1 9 0 6 8 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 18 | 50 19 | 41 18467 6334 26500 19169 15724 11478 29358 26962 24464 5705 28145 23281 16827 9961 491 2995 11942 4827 5436 32391 14604 3902 153 292 12382 17421 18716 19718 19895 5447 21726 14771 11538 1869 19912 25667 26299 17035 9894 28703 23811 31322 30333 17673 4664 15141 7711 28253 6868 20 | ======== EXPECT 21 | 0 23 24 15 34 16 22 45 18 19 30 10 2 49 47 39 14 6 33 17 25 21 32 46 5 13 38 26 44 1 27 4 28 29 35 31 12 41 9 36 37 3 8 11 48 40 7 43 42 20 22 | <<<<<<<< FINISH 23 | 24 | -------------------------------------------------------------------------------- /base/indices/Readme.md: -------------------------------------------------------------------------------- 1 | # Índices originais 2 | 3 | 4 | [Intro](#intro) | [Draft](#draft) | [Tests](#tests) 5 | -- | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Você recebe um vetor A de inteiros não negativos de tamanho n. Sua tarefa é ordenar o vetor em ordem crescente e imprimir os índices originais dos elementos. 11 | 12 | Considere o vetor `A = {4,5,3,7,1}` 13 | 14 | Após a ordenação, o vetor ordenado será: `A = {1,3,4,5,7}`. 15 | 16 | A saída deve ser os índices originais dos elementos do vetor ordenado: `4 2 0 1 3` 17 | 18 | **NOTA:** A indexação da vetor começa com 0. 19 | 20 | ## Draft 21 | 22 | - Você deve implementar um algoritmo de ordenação e a função `originalIndices` no arquivo `main.cpp`. 23 | 24 | 25 | - cpp 26 | - [main.cpp](.cache/draft/cpp/main.cpp) 27 | 28 | 29 | ## Tests 30 | 31 | ### Entrada 32 | 33 | - A primeira linha de entrada consiste em um número inteiro n, representando o tamanho do vetor A. 34 | - A segunda linha de entrada contém n inteiros não negativos, representando os elementos do vetor A. 35 | - Restrições: 36 | - $1 \le n \le 10^{6} $ 37 | - $0 \le A[i] \le 10^6$ 38 | 39 | ### Saída 40 | 41 | - A saída consiste em uma única linha de n inteiros, representando os índices originais de cada elemento no vetor ordenado. 42 | 43 | ```txt 44 | >>>>>>>> 45 | 5 46 | 4 5 3 7 1 47 | ======== 48 | 4 2 0 1 3 49 | <<<<<<<< 50 | ``` 51 | -------------------------------------------------------------------------------- /base/indices/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 2 | 10 3 | 7 5 4 3 2 1 8 0 9 6 4 | ======== 5 | 7 5 4 3 2 1 9 0 6 8 6 | <<<<<<<< 7 | 8 | >>>>>>>> 9 | 50 10 | 41 18467 6334 26500 19169 15724 11478 29358 26962 24464 5705 28145 23281 16827 9961 491 2995 11942 4827 5436 32391 14604 3902 153 292 12382 17421 18716 19718 19895 5447 21726 14771 11538 1869 19912 25667 26299 17035 9894 28703 23811 31322 30333 17673 4664 15141 7711 28253 6868 11 | ======== 12 | 0 23 24 15 34 16 22 45 18 19 30 10 2 49 47 39 14 6 33 17 25 21 32 46 5 13 38 26 44 1 27 4 28 29 35 31 12 41 9 36 37 3 8 11 48 40 7 43 42 20 13 | <<<<<<<< 14 | -------------------------------------------------------------------------------- /base/invertendo/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Inversão usando next e previous 2 | 3 | Receba o nó cabeça de uma lista duplamente encadeada, e inverta a relação entre os nós através de seus ponteiros 'next' e 'previous'. 4 | 5 | ## Entrada 6 | 7 | - Ponteiro para nó cabeça 'head' 8 | 9 | ## Saída 10 | 11 | - Não há retorno. a lista deve estar invertida no final da função. 12 | -------------------------------------------------------------------------------- /base/invertendo/Readme.md: -------------------------------------------------------------------------------- 1 | # Inversão usando next e previous 2 | 3 | Receba o nó cabeça de uma lista duplamente encadeada, e inverta a relação entre os nós através de seus ponteiros 'next' e 'previous'. 4 | 5 | ## Entrada 6 | 7 | - Ponteiro para nó cabeça 'head' 8 | 9 | ## Saída 10 | 11 | - Não há retorno. a lista deve estar invertida no final da função. 12 | -------------------------------------------------------------------------------- /base/invertendo/cases.vpl: -------------------------------------------------------------------------------- 1 | Case = Teste 1 2 | <<<<<<< HEAD 3 | Input =0 4 | Output =Pilha: [ ] 5 | invert 6 | Pilha: [ ] 7 | 8 | Case = Teste 2 9 | Input =1 10 | 100 11 | Output =Pilha: [ 100 ] 12 | invert 13 | Pilha: [ 100 ] 14 | 15 | Case = Teste 3 16 | Input =6 17 | 1 2 3 4 5 6 18 | Output =Pilha: [ 1 2 3 4 5 6 ] 19 | invert 20 | Pilha: [ 6 5 4 3 2 1 ] 21 | 22 | Case = Teste 4 23 | Input=100 24 | 23 73 56 20 93 81 9 18 57 16 55 84 49 15 22 76 4 48 19 67 78 40 35 17 24 33 94 47 86 45 98 27 43 64 79 7 37 75 92 89 87 85 34 60 8 46 72 95 2 61 54 11 90 59 99 91 65 38 71 63 13 30 39 100 28 69 26 32 5 14 21 31 68 1 36 62 53 66 97 42 58 74 77 51 10 44 80 12 3 50 83 25 70 82 41 96 6 88 29 52 25 | Output=Pilha: [ 23 73 56 20 93 81 9 18 57 16 55 84 49 15 22 76 4 48 19 67 78 40 35 17 24 33 94 47 86 45 98 27 43 64 79 7 37 75 92 89 87 85 34 60 8 46 72 95 2 61 54 11 90 59 99 91 65 38 71 63 13 30 39 100 28 69 26 32 5 14 21 31 68 1 36 62 53 66 97 42 58 74 77 51 10 44 80 12 3 50 83 25 70 82 41 96 6 88 29 52 ] 26 | invert 27 | Pilha: [ 52 29 88 6 96 41 82 70 25 83 50 3 12 80 44 10 51 77 74 58 42 97 66 53 62 36 1 68 31 21 14 5 32 26 69 28 100 39 30 13 63 71 38 65 91 99 59 90 11 54 61 2 95 72 46 8 60 34 85 87 89 92 75 37 7 79 64 43 27 98 45 86 47 94 33 24 17 35 40 78 67 19 48 4 76 22 15 49 84 55 16 57 18 9 81 93 20 56 73 23 ] 28 | 29 | ======= 30 | Input= main 31 | Output=[ azul branco cinza dourado escarlate ] 32 | [ escarlate dourado cinza branco azul ] 33 | [ azul branco cinza dourado escarlate ] 34 | [ escarlate dourado cinza branco azul ] 35 | >>>>>>> origin/sequencial-encadeada 36 | -------------------------------------------------------------------------------- /base/invertendo/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT Teste 1 2 | main 3 | ======== EXPECT 4 | [ azul branco cinza dourado escarlate ] 5 | [ escarlate dourado cinza branco azul ] 6 | [ azul branco cinza dourado escarlate ] 7 | [ escarlate dourado cinza branco azul ] 8 | <<<<<<<< FINISH 9 | 10 | -------------------------------------------------------------------------------- /base/invertendo2/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Pilha - invertendo com pilhas auxiliares 2 | 3 | 4 | [Intro](#intro) | [Draft](#draft) | [Tests](#tests) 5 | -- | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Neste exercício, o objetivo é inverter os elementos de uma pilha. A pilha original será fornecida com uma sequência de inteiros, e você deverá reordenar os elementos de modo que a sequência final seja invertida em relação à original. 11 | 12 | Para realizar essa inversão, você terá acesso a duas pilhas auxiliares, **PilhaB** e **PilhaC**, e não é permitido o uso de outras estruturas auxiliares, como arrays ou listas. 13 | 14 | ## Draft 15 | 16 | - Você deve alterar o método `invertStack` no arquivo `main.cpp` 17 | 18 | 19 | - cpp 20 | - [main.cpp](https://github.com/qxcodeed/arcade/blob/master/base/invertendo2/.cache/draft/cpp/main.cpp) 21 | 22 | 23 | ## Tests 24 | 25 | ### Entrada 26 | 27 | - A entrada consistirá em um número inteiro seguido de uma sequência de elementos da pilha. 28 | 29 | ### Saída 30 | 31 | - A saída deve exibir a pilha com os elementos na ordem invertida. 32 | 33 | ```txt 34 | >>>>>>>> 35 | 5 36 | 1 2 3 4 5 37 | ======== 38 | Pilha: [ 1 2 3 4 5 ] 39 | invert 40 | Pilha: [ 5 4 3 2 1 ] 41 | ``` 42 | -------------------------------------------------------------------------------- /base/invertendo2/Readme.md: -------------------------------------------------------------------------------- 1 | # Pilha - invertendo com pilhas auxiliares 2 | 3 | 4 | [Intro](#intro) | [Draft](#draft) | [Tests](#tests) 5 | -- | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Neste exercício, o objetivo é inverter os elementos de uma pilha. A pilha original será fornecida com uma sequência de inteiros, e você deverá reordenar os elementos de modo que a sequência final seja invertida em relação à original. 11 | 12 | Para realizar essa inversão, você terá acesso a duas pilhas auxiliares, **PilhaB** e **PilhaC**, e não é permitido o uso de outras estruturas auxiliares, como arrays ou listas. 13 | 14 | ## Draft 15 | 16 | - Você deve alterar o método `invertStack` no arquivo `main.cpp` 17 | 18 | 19 | - cpp 20 | - [main.cpp](.cache/draft/cpp/main.cpp) 21 | 22 | 23 | ## Tests 24 | 25 | ### Entrada 26 | 27 | - A entrada consistirá em um número inteiro seguido de uma sequência de elementos da pilha. 28 | 29 | ### Saída 30 | 31 | - A saída deve exibir a pilha com os elementos na ordem invertida. 32 | 33 | ```txt 34 | >>>>>>>> 35 | 5 36 | 1 2 3 4 5 37 | ======== 38 | Pilha: [ 1 2 3 4 5 ] 39 | invert 40 | Pilha: [ 5 4 3 2 1 ] 41 | ``` 42 | -------------------------------------------------------------------------------- /base/invertendo2/cases.vpl: -------------------------------------------------------------------------------- 1 | Case = Teste 1 2 | <<<<<<< HEAD 3 | Input =0 4 | Output =Pilha: [ ] 5 | invert 6 | Pilha: [ ] 7 | 8 | Case = Teste 2 9 | Input =1 10 | 100 11 | Output =Pilha: [ 100 ] 12 | invert 13 | Pilha: [ 100 ] 14 | 15 | Case = Teste 3 16 | Input =6 17 | 1 2 3 4 5 6 18 | Output =Pilha: [ 1 2 3 4 5 6 ] 19 | invert 20 | Pilha: [ 6 5 4 3 2 1 ] 21 | 22 | Case = Teste 4 23 | Input=100 24 | 23 73 56 20 93 81 9 18 57 16 55 84 49 15 22 76 4 48 19 67 78 40 35 17 24 33 94 47 86 45 98 27 43 64 79 7 37 75 92 89 87 85 34 60 8 46 72 95 2 61 54 11 90 59 99 91 65 38 71 63 13 30 39 100 28 69 26 32 5 14 21 31 68 1 36 62 53 66 97 42 58 74 77 51 10 44 80 12 3 50 83 25 70 82 41 96 6 88 29 52 25 | Output=Pilha: [ 23 73 56 20 93 81 9 18 57 16 55 84 49 15 22 76 4 48 19 67 78 40 35 17 24 33 94 47 86 45 98 27 43 64 79 7 37 75 92 89 87 85 34 60 8 46 72 95 2 61 54 11 90 59 99 91 65 38 71 63 13 30 39 100 28 69 26 32 5 14 21 31 68 1 36 62 53 66 97 42 58 74 77 51 10 44 80 12 3 50 83 25 70 82 41 96 6 88 29 52 ] 26 | invert 27 | Pilha: [ 52 29 88 6 96 41 82 70 25 83 50 3 12 80 44 10 51 77 74 58 42 97 66 53 62 36 1 68 31 21 14 5 32 26 69 28 100 39 30 13 63 71 38 65 91 99 59 90 11 54 61 2 95 72 46 8 60 34 85 87 89 92 75 37 7 79 64 43 27 98 45 86 47 94 33 24 17 35 40 78 67 19 48 4 76 22 15 49 84 55 16 57 18 9 81 93 20 56 73 23 ] 28 | 29 | ======= 30 | Input= main 31 | Output=[ azul branco cinza dourado escarlate ] 32 | [ escarlate dourado cinza branco azul ] 33 | [ azul branco cinza dourado escarlate ] 34 | [ escarlate dourado cinza branco azul ] 35 | >>>>>>> origin/sequencial-encadeada 36 | -------------------------------------------------------------------------------- /base/invertendo2/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> Teste 1 2 | 0 3 | ======== 4 | Pilha: [ ] 5 | invert 6 | Pilha: [ ] 7 | <<<<<<<< 8 | 9 | >>>>>>>> Teste 2 10 | 1 11 | 100 12 | ======== 13 | Pilha: [ 100 ] 14 | invert 15 | Pilha: [ 100 ] 16 | <<<<<<<< 17 | 18 | >>>>>>>> Teste 3 19 | 6 20 | 1 2 3 4 5 6 21 | ======== 22 | Pilha: [ 1 2 3 4 5 6 ] 23 | invert 24 | Pilha: [ 6 5 4 3 2 1 ] 25 | <<<<<<<< 26 | 27 | >>>>>>>> Teste 4 28 | 100 29 | 23 73 56 20 93 81 9 18 57 16 55 84 49 15 22 76 4 48 19 67 78 40 35 17 24 33 94 47 86 45 98 27 43 64 79 7 37 75 92 89 87 85 34 60 8 46 72 95 2 61 54 11 90 59 99 91 65 38 71 63 13 30 39 100 28 69 26 32 5 14 21 31 68 1 36 62 53 66 97 42 58 74 77 51 10 44 80 12 3 50 83 25 70 82 41 96 6 88 29 52 30 | ======== 31 | Pilha: [ 23 73 56 20 93 81 9 18 57 16 55 84 49 15 22 76 4 48 19 67 78 40 35 17 24 33 94 47 86 45 98 27 43 64 79 7 37 75 92 89 87 85 34 60 8 46 72 95 2 61 54 11 90 59 99 91 65 38 71 63 13 30 39 100 28 69 26 32 5 14 21 31 68 1 36 62 53 66 97 42 58 74 77 51 10 44 80 12 3 50 83 25 70 82 41 96 6 88 29 52 ] 32 | invert 33 | Pilha: [ 52 29 88 6 96 41 82 70 25 83 50 3 12 80 44 10 51 77 74 58 42 97 66 53 62 36 1 68 31 21 14 5 32 26 69 28 100 39 30 13 63 71 38 65 91 99 59 90 11 54 61 2 95 72 46 8 60 34 85 87 89 92 75 37 7 79 64 43 27 98 45 86 47 94 33 24 17 35 40 78 67 19 48 4 76 22 15 49 84 55 16 57 18 9 81 93 20 56 73 23 ] 34 | <<<<<<<< -------------------------------------------------------------------------------- /base/iterador/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Criando um iterador 2 | 3 | Um iterador pode ser utilizado para esconder a forma como os elementos são organizados e acessados. 4 | 5 | - É responsabilidade do iterador saber como chegar no próximo elemento. 6 | - Saber se chegou ao fim da estrutura. 7 | - Opcional dependendo da estrutura: 8 | - Saber como voltar para o elemento anterior. 9 | 10 | Vamos criar iteradores para navegar em um vetor utilizando a sintaxe simplificada dos iteradores do Java. 11 | 12 | Um iterador é criado a partir da estrutura a ser percorrida e possui dois métodos principais. 13 | 14 | - hasNext(): bool, que informa se ainda tem algum elemento. 15 | - next(): int, que pega o próximo elemento. 16 | 17 | Os nomes mudam um pouco dependendo da linguagem utilizada. Veja o diagrama dos métodos a serem implementados e o exemplo nos arquivos `extra.md` e no rascunho da linguagem. 18 | 19 | Você vai receber implementado um iterador que percorre a estrutura do início ao fim e deve implementar outros dois iteradores. 20 | 21 | - ReverseIterator: percorre a estrutura do fim para o início. 22 | - CyclicIterator: percorre a estrutura como se fosse uma lista cíclica infinita. 23 | 24 | ## Shell 25 | 26 | ```py 27 | #TEST_CASE show 28 | $read 1 4 2 3 5 6 9 7 29 | $show 30 | [ 1 4 2 3 5 6 9 7 ] 31 | $end 32 | ``` 33 | 34 | ```py 35 | #TEST_CASE show 36 | $read 1 4 2 3 5 6 9 7 37 | $reverse 38 | [ 7 9 6 5 3 2 4 1 ] 39 | $end 40 | ``` 41 | 42 | ```py 43 | #TEST_CASE show 44 | $read 1 2 3 45 | $cyclic 10 46 | [ 1 2 3 1 2 3 1 2 3 1 ] 47 | $end 48 | ``` 49 | -------------------------------------------------------------------------------- /base/iterador/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT show 2 | read 1 4 2 3 5 6 9 7 3 | show 4 | end 5 | ======== EXPECT 6 | $read 1 4 2 3 5 6 9 7 7 | $show 8 | [ 1 4 2 3 5 6 9 7 ] 9 | $end 10 | <<<<<<<< FINISH 11 | 12 | 13 | >>>>>>>> INSERT show 14 | read 1 4 2 3 5 6 9 7 15 | reverse 16 | end 17 | ======== EXPECT 18 | $read 1 4 2 3 5 6 9 7 19 | $reverse 20 | [ 7 9 6 5 3 2 4 1 ] 21 | $end 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT show 26 | read 1 2 3 27 | cyclic 10 28 | end 29 | ======== EXPECT 30 | $read 1 2 3 31 | $cyclic 10 32 | [ 1 2 3 1 2 3 1 2 3 1 ] 33 | $end 34 | <<<<<<<< FINISH 35 | 36 | -------------------------------------------------------------------------------- /base/iterador/Readme.md: -------------------------------------------------------------------------------- 1 | # Criando um iterador 2 | 3 | Um iterador pode ser utilizado para esconder a forma como os elementos são organizados e acessados. 4 | 5 | - É responsabilidade do iterador saber como chegar no próximo elemento. 6 | - Saber se chegou ao fim da estrutura. 7 | - Opcional dependendo da estrutura: 8 | - Saber como voltar para o elemento anterior. 9 | 10 | Vamos criar iteradores para navegar em um vetor utilizando a sintaxe simplificada dos iteradores do Java. 11 | 12 | Um iterador é criado a partir da estrutura a ser percorrida e possui dois métodos principais. 13 | 14 | - hasNext(): bool, que informa se ainda tem algum elemento. 15 | - next(): int, que pega o próximo elemento. 16 | 17 | Os nomes mudam um pouco dependendo da linguagem utilizada. Veja o diagrama dos métodos a serem implementados e o exemplo nos arquivos `extra.md` e no rascunho da linguagem. 18 | 19 | Você vai receber implementado um iterador que percorre a estrutura do início ao fim e deve implementar outros dois iteradores. 20 | 21 | - ReverseIterator: percorre a estrutura do fim para o início. 22 | - CyclicIterator: percorre a estrutura como se fosse uma lista cíclica infinita. 23 | 24 | ## Shell 25 | 26 | ```py 27 | #TEST_CASE show 28 | $read 1 4 2 3 5 6 9 7 29 | $show 30 | [ 1 4 2 3 5 6 9 7 ] 31 | $end 32 | ``` 33 | 34 | ```py 35 | #TEST_CASE show 36 | $read 1 4 2 3 5 6 9 7 37 | $reverse 38 | [ 7 9 6 5 3 2 4 1 ] 39 | $end 40 | ``` 41 | 42 | ```py 43 | #TEST_CASE show 44 | $read 1 2 3 45 | $cyclic 10 46 | [ 1 2 3 1 2 3 1 2 3 1 ] 47 | $end 48 | ``` 49 | -------------------------------------------------------------------------------- /base/labirinto/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/labirinto/cover.jpg -------------------------------------------------------------------------------- /base/list_basic/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Lista Simplesmente Encadeada - CPP 2 | 3 | Nesse exercício, implementaremos nossa primeira estrutura encadeada: Lista Simplesmente Encadeada. 4 | 5 | Uma lista simplesmente encadeada é uma estrutura de dados que consiste em uma sequência de elementos, onde cada elemento (chamado de Nó) contém dois componentes: uma informação do elemento e um ponteiro para o próximo Nó na sequência. 6 | 7 | Por simplicidade, implementaremos as informações como apenas um inteiro. 8 | 9 | No arquivo lib.cpp, se encontra a classe SLinkedList que possui os seguintes métodos: 10 | 11 | - SLinkedList(); 12 | - ~SLinkedList(); 13 | - bool hasInfo(int info); 14 | - int get(int index); 15 | - int operator[](int index); 16 | - void push_front(int info); 17 | - void push_back(int info); 18 | - ~~void pop_front();~~ 19 | - void pop_back(); 20 | - void clear(); 21 | - int length(); 22 | - bool empty(); 23 | - ~~Node\* sucessor(Node* node);~~ 24 | - Node\* predecessor(Node* node); 25 | - ~~void print();~~ 26 | 27 | Métodos riscados já estão implementados, você precisa implementar os demais. 28 | A funcionalidade de cada método está descrita em comentários no próprio arquivo lib.cpp. Sua tarefa é alterar o arquivo lib.cpp, implementando as funcionalidades faltantes citadas. Seu código deve passar no caso de teste para ser considerado correto. 29 | 30 | OBS.: Não altere os métodos já implementados. 31 | 32 | OBS.2: Não precisa escrever a main() nem alterar o arquivo main.cpp. 33 | 34 | 35 | -------------------------------------------------------------------------------- /base/list_basic/.cache/q.tio: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/list_basic/.cache/q.tio -------------------------------------------------------------------------------- /base/list_basic/Readme.md: -------------------------------------------------------------------------------- 1 | # Lista Simplesmente Encadeada - CPP 2 | 3 | Nesse exercício, implementaremos nossa primeira estrutura encadeada: Lista Simplesmente Encadeada. 4 | 5 | Uma lista simplesmente encadeada é uma estrutura de dados que consiste em uma sequência de elementos, onde cada elemento (chamado de Nó) contém dois componentes: uma informação do elemento e um ponteiro para o próximo Nó na sequência. 6 | 7 | Por simplicidade, implementaremos as informações como apenas um inteiro. 8 | 9 | No arquivo lib.cpp, se encontra a classe SLinkedList que possui os seguintes métodos: 10 | 11 | - SLinkedList(); 12 | - ~SLinkedList(); 13 | - bool hasInfo(int info); 14 | - int get(int index); 15 | - int operator[](int index); 16 | - void push_front(int info); 17 | - void push_back(int info); 18 | - ~~void pop_front();~~ 19 | - void pop_back(); 20 | - void clear(); 21 | - int length(); 22 | - bool empty(); 23 | - ~~Node\* sucessor(Node* node);~~ 24 | - Node\* predecessor(Node* node); 25 | - ~~void print();~~ 26 | 27 | Métodos riscados já estão implementados, você precisa implementar os demais. 28 | A funcionalidade de cada método está descrita em comentários no próprio arquivo lib.cpp. Sua tarefa é alterar o arquivo lib.cpp, implementando as funcionalidades faltantes citadas. Seu código deve passar no caso de teste para ser considerado correto. 29 | 30 | OBS.: Não altere os métodos já implementados. 31 | 32 | OBS.2: Não precisa escrever a main() nem alterar o arquivo main.cpp. 33 | 34 | 35 | -------------------------------------------------------------------------------- /base/lista_d1/.cache/draft/cpp/list.cpp: -------------------------------------------------------------------------------- 1 | #include "list.hpp" 2 | #include 3 | 4 | void LinkedList::clear() { 5 | } 6 | 7 | void LinkedList::push_back(int value) { 8 | (void) value; 9 | } 10 | 11 | void LinkedList::push_front(int value) { 12 | (void) value; 13 | } 14 | 15 | void LinkedList::pop_back() { 16 | } 17 | 18 | 19 | void LinkedList::pop_front() { 20 | } 21 | 22 | 23 | int LinkedList::size() const { 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /base/lista_d1/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include "list.hpp" 2 | #include "fn.hpp" 3 | using namespace std; 4 | using namespace fn; 5 | 6 | int main() { 7 | LinkedList ll; 8 | 9 | while(true) { 10 | auto line = std::cin | INPUT(); 11 | auto args = line | SPLIT(' '); 12 | fn::write("$" + line); 13 | auto cmd = args[0]; 14 | 15 | if (cmd == "show" ) { ll.str() | WRITE(); } 16 | else if (cmd == "size" ) { ll.size() | WRITE(); } 17 | else if (cmd == "push_back" ) { for (auto v : args | SLICE(1)) { ll.push_back(+v); } } 18 | else if (cmd == "push_front") { for (auto v : args | SLICE(1)) { ll.push_front(+v); }} 19 | else if (cmd == "pop_back" ) { ll.pop_back(); } 20 | else if (cmd == "pop_front" ) { ll.pop_front(); } 21 | else if (cmd == "clear" ) { ll.clear(); } 22 | 23 | else if (cmd == "end" ) { break; } 24 | else { "fail: comando invalido" | WRITE(); } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /base/lista_d1/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strings" 8 | ) 9 | 10 | 11 | func main() { 12 | scanner := bufio.NewScanner(os.Stdin) 13 | // ll := NewLList() 14 | 15 | for { 16 | fmt.Print("$") 17 | if !scanner.Scan() { 18 | break 19 | } 20 | line := scanner.Text() 21 | fmt.Println(line) 22 | args := strings.Fields(line) 23 | 24 | if len(args) == 0 { 25 | continue 26 | } 27 | 28 | cmd := args[0] 29 | 30 | switch cmd { 31 | case "show": 32 | // fmt.Println(ll.String()) 33 | case "size": 34 | // fmt.Println(ll.Size()) 35 | case "push_back": 36 | // for _, v := range args[1:] { 37 | // num, _ := strconv.Atoi(v) 38 | // ll.PushBack(num) 39 | // } 40 | case "push_front": 41 | // for _, v := range args[1:] { 42 | // num, _ := strconv.Atoi(v) 43 | // ll.PushFront(num) 44 | // } 45 | case "pop_back": 46 | // ll.PopBack() 47 | case "pop_front": 48 | // ll.PopFront() 49 | case "clear": 50 | // ll.Clear() 51 | case "end": 52 | return 53 | default: 54 | fmt.Println("fail: comando invalido") 55 | } 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /base/lista_d1/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/lista_d1/cover.jpg -------------------------------------------------------------------------------- /base/lista_d3/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Lista Dupla - Extra 2 | 3 | 4 | [Intro](#intro) | [Shell](#shell) 5 | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Utilizando a estrutura criada em @lista_d2, vamos fazer algumas manipulações de dados. 11 | 12 | ## Shell 13 | 14 | ```bash 15 | #TEST_CASE compare 16 | # compara se duas listas são iguais 17 | $compare [1,2,3,4,5] [1,2,3,4,5] 18 | iguais 19 | $compare [] [] 20 | iguais 21 | $compare [1] [2] 22 | diferentes 23 | $compare [1,2] [1] 24 | diferentes 25 | $compare [1] [1,2] 26 | diferentes 27 | $compare [1,2] [1,3] 28 | diferentes 29 | $compare [2,1] [1,2] 30 | diferentes 31 | $compare [1,3,2] [1,3,2] 32 | iguais 33 | $end 34 | ``` 35 | 36 | ```bash 37 | #TEST_CASE addsorted 38 | # insere os valores de forma ordenada dentro da estrutura 39 | $addsorted 4 5 7 4 2 8 1 9 0 40 | [0, 1, 2, 4, 4, 5, 7, 8, 9] 41 | $end 42 | ``` 43 | 44 | ```bash 45 | #TEST_CASE reverse 46 | $reverse [] 47 | [] 48 | $reverse [1] 49 | [1] 50 | $reverse [1,2] 51 | [2, 1] 52 | $reverse [1,2,3,4,5,6,7,8] 53 | [8, 7, 6, 5, 4, 3, 2, 1] 54 | $end 55 | ``` 56 | 57 | ```bash 58 | #TEST_CASE merge 59 | # faça o merge de duas listas ordenadas, inserindo a segunda lista na primeira 60 | # aproveitando a ideia de que ambas estão ordenadas 61 | $merge [1,5,6,8] [2,3,3,4,4,9] 62 | [1, 2, 3, 3, 4, 4, 5, 6, 8, 9] 63 | $merge [1] [2] 64 | [1, 2] 65 | $merge [2] [1] 66 | [1, 2] 67 | $merge [2,3] [1,2] 68 | [1, 2, 2, 3] 69 | $merge [2,3] [1,4,5] 70 | [1, 2, 3, 4, 5] 71 | $end 72 | ``` 73 | -------------------------------------------------------------------------------- /base/lista_d3/Readme.md: -------------------------------------------------------------------------------- 1 | # Lista Dupla - Extra 2 | 3 | 4 | [Intro](#intro) | [Shell](#shell) 5 | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Utilizando a estrutura criada em @lista_d2, vamos fazer algumas manipulações de dados. 11 | 12 | ## Shell 13 | 14 | ```bash 15 | #TEST_CASE compare 16 | # compara se duas listas são iguais 17 | $compare [1,2,3,4,5] [1,2,3,4,5] 18 | iguais 19 | $compare [] [] 20 | iguais 21 | $compare [1] [2] 22 | diferentes 23 | $compare [1,2] [1] 24 | diferentes 25 | $compare [1] [1,2] 26 | diferentes 27 | $compare [1,2] [1,3] 28 | diferentes 29 | $compare [2,1] [1,2] 30 | diferentes 31 | $compare [1,3,2] [1,3,2] 32 | iguais 33 | $end 34 | ``` 35 | 36 | ```bash 37 | #TEST_CASE addsorted 38 | # insere os valores de forma ordenada dentro da estrutura 39 | $addsorted 4 5 7 4 2 8 1 9 0 40 | [0, 1, 2, 4, 4, 5, 7, 8, 9] 41 | $end 42 | ``` 43 | 44 | ```bash 45 | #TEST_CASE reverse 46 | $reverse [] 47 | [] 48 | $reverse [1] 49 | [1] 50 | $reverse [1,2] 51 | [2, 1] 52 | $reverse [1,2,3,4,5,6,7,8] 53 | [8, 7, 6, 5, 4, 3, 2, 1] 54 | $end 55 | ``` 56 | 57 | ```bash 58 | #TEST_CASE merge 59 | # faça o merge de duas listas ordenadas, inserindo a segunda lista na primeira 60 | # aproveitando a ideia de que ambas estão ordenadas 61 | $merge [1,5,6,8] [2,3,3,4,4,9] 62 | [1, 2, 3, 3, 4, 4, 5, 6, 8, 9] 63 | $merge [1] [2] 64 | [1, 2] 65 | $merge [2] [1] 66 | [1, 2] 67 | $merge [2,3] [1,2] 68 | [1, 2, 2, 3] 69 | $merge [2,3] [1,4,5] 70 | [1, 2, 3, 4, 5] 71 | $end 72 | ``` 73 | -------------------------------------------------------------------------------- /base/lista_d4/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT forward 2 | push_back 1 2 3 4 5 3 | show 4 | forward 3 9 5 | end 6 | ======== EXPECT 7 | $push_back 1 2 3 4 5 8 | $show 9 | [1, 2, 3, 4, 5] 10 | $forward 3 9 11 | [ 3 4 5 1 2 3 4 5 1 ] 12 | $end 13 | <<<<<<<< FINISH 14 | 15 | 16 | >>>>>>>> INSERT forward 17 | push_back 1 18 | show 19 | forward 1 9 20 | end 21 | ======== EXPECT 22 | $push_back 1 23 | $show 24 | [1] 25 | $forward 1 9 26 | [ 1 1 1 1 1 1 1 1 1 ] 27 | $end 28 | <<<<<<<< FINISH 29 | 30 | 31 | >>>>>>>> INSERT backward 32 | push_back 1 2 3 4 5 33 | show 34 | backward 3 9 35 | end 36 | ======== EXPECT 37 | $push_back 1 2 3 4 5 38 | $show 39 | [1, 2, 3, 4, 5] 40 | $backward 3 9 41 | [ 3 2 1 5 4 3 2 1 5 ] 42 | $end 43 | <<<<<<<< FINISH 44 | 45 | -------------------------------------------------------------------------------- /base/magicsearch/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strconv" 8 | "strings" 9 | ) 10 | 11 | func MagicSearch(slice []int, value int) int { 12 | _, _ = slice, value 13 | return 0 14 | } 15 | 16 | func main() { 17 | scanner := bufio.NewScanner(os.Stdin) 18 | scanner.Scan() 19 | parts := strings.Fields(scanner.Text()) 20 | slice := make([]int, 0, 1) 21 | for _, elem := range parts[1 : len(parts)-1] { 22 | value, _ := strconv.Atoi(elem) 23 | slice = append(slice, value) 24 | } 25 | 26 | scanner.Scan() 27 | value, _ := strconv.Atoi(scanner.Text()) 28 | result := MagicSearch(slice, value) 29 | fmt.Println(result) 30 | } 31 | -------------------------------------------------------------------------------- /base/magicsearch/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | [ ] 3 | 4 4 | ======== EXPECT 5 | 0 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 10 | [ 1 1 1 ] 11 | 1 12 | ======== EXPECT 13 | 2 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 18 | [ 1 2 3 ] 19 | 1 20 | ======== EXPECT 21 | 0 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT 26 | [ 1 2 3 ] 27 | 3 28 | ======== EXPECT 29 | 2 30 | <<<<<<<< FINISH 31 | 32 | 33 | >>>>>>>> INSERT 34 | [ 1 1 1 2 2 3 ] 35 | 2 36 | ======== EXPECT 37 | 4 38 | <<<<<<<< FINISH 39 | 40 | 41 | >>>>>>>> INSERT 42 | [ 1 1 1 3 3 5 ] 43 | 0 44 | ======== EXPECT 45 | 0 46 | <<<<<<<< FINISH 47 | 48 | 49 | >>>>>>>> INSERT 50 | [ 1 1 1 4 4 6 6 ] 51 | 2 52 | ======== EXPECT 53 | 3 54 | <<<<<<<< FINISH 55 | 56 | 57 | >>>>>>>> INSERT 58 | [ 1 1 1 4 4 6 6 ] 59 | 5 60 | ======== EXPECT 61 | 5 62 | <<<<<<<< FINISH 63 | 64 | 65 | >>>>>>>> INSERT 66 | [ 1 1 1 4 4 6 6 ] 67 | 8 68 | ======== EXPECT 69 | 7 70 | <<<<<<<< FINISH 71 | 72 | 73 | >>>>>>>> INSERT 74 | [ 1 1 1 4 4 6 6 6 6 6 6 6 6 6 ] 75 | 6 76 | ======== EXPECT 77 | 13 78 | <<<<<<<< FINISH 79 | 80 | -------------------------------------------------------------------------------- /base/mdc/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Implemente o mdc recursivo 2 | 3 | Implemente a função que calcula o mdc de dois números de forma recursiva. 4 | 5 | O mdc de dois números inteiros é o maior número inteiro que divide ambos sem deixar resto. 6 | Para calcular o mdc de dois números, você pode usar o algoritmo de Euclides. 7 | 8 | [LINK](https://pt.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/the-euclidean-algorithm) 9 | 10 | ## O Algoritmo 11 | 12 | - O Algoritmo Euclidiano para encontrar o MDC(A,B) é dado por: 13 | 14 | - Se A = 0, então MDC(A,B)=B, uma vez que MDC(0,B)=B, e podemos parar a verificação. 15 | - Se B = 0, então MDC(A,B)=A, uma vez que o MDC(A,0)=A, e podemos parar a verificação. 16 | - Escreva A na forma do resto do quociente (A = B⋅Q + R), ou seja R = A % B. 17 | - Encontre o MDC(B,R) usando o Algoritmo Euclidiano, já que MDC(A,B) = MDC(B,R) 18 | 19 | ## I/O 20 | 21 | - Entrada 22 | - A entrada consiste de dois números inteiros positivos. 23 | - Saída 24 | - A saída consiste de um número inteiro positivo que representa o mdc dos dois números. 25 | 26 | ## Shell 27 | 28 | ```bash 29 | >>>>>>>> 30 | 3 31 | 5 32 | ======== 33 | 1 34 | <<<<<<<< 35 | 36 | >>>>>>>> 37 | 6 38 | 9 39 | ======== 40 | 3 41 | <<<<<<<< 42 | 43 | >>>>>>>> 44 | 50 45 | 15 46 | ======== 47 | 5 48 | <<<<<<<< 49 | 50 | >>>>>>>> 51 | 270 52 | 192 53 | ======== 54 | 6 55 | <<<<<<<< 56 | 57 | >>>>>>>> 58 | 192 59 | 276 60 | ======== 61 | 12 62 | <<<<<<<< 63 | ``` 64 | -------------------------------------------------------------------------------- /base/mdc/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int mdc(int a, int b) { 4 | return 0; 5 | } 6 | 7 | int main() { 8 | int a, b; 9 | std::cin >> a >> b; 10 | std::cout << mdc(a, b) << std::endl; 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /base/mdc/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func mdc(a, b int) int { 8 | return 0 9 | } 10 | 11 | func main() { 12 | var a, b int 13 | fmt.Scan(&a, &b) 14 | fmt.Println(mdc(a, b)) 15 | } 16 | -------------------------------------------------------------------------------- /base/mdc/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 3 3 | 5 4 | ======== EXPECT 5 | 1 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 10 | 6 11 | 9 12 | ======== EXPECT 13 | 3 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 18 | 50 19 | 15 20 | ======== EXPECT 21 | 5 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT 26 | 270 27 | 192 28 | ======== EXPECT 29 | 6 30 | <<<<<<<< FINISH 31 | 32 | 33 | >>>>>>>> INSERT 34 | 192 35 | 276 36 | ======== EXPECT 37 | 12 38 | <<<<<<<< FINISH 39 | 40 | -------------------------------------------------------------------------------- /base/mdc/Readme.md: -------------------------------------------------------------------------------- 1 | # Implemente o mdc recursivo 2 | 3 | Implemente a função que calcula o mdc de dois números de forma recursiva. 4 | 5 | O mdc de dois números inteiros é o maior número inteiro que divide ambos sem deixar resto. 6 | Para calcular o mdc de dois números, você pode usar o algoritmo de Euclides. 7 | 8 | [LINK](https://pt.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/the-euclidean-algorithm) 9 | 10 | ## O Algoritmo 11 | 12 | - O Algoritmo Euclidiano para encontrar o MDC(A,B) é dado por: 13 | 14 | - Se A = 0, então MDC(A,B)=B, uma vez que MDC(0,B)=B, e podemos parar a verificação. 15 | - Se B = 0, então MDC(A,B)=A, uma vez que o MDC(A,0)=A, e podemos parar a verificação. 16 | - Escreva A na forma do resto do quociente (A = B⋅Q + R), ou seja R = A % B. 17 | - Encontre o MDC(B,R) usando o Algoritmo Euclidiano, já que MDC(A,B) = MDC(B,R) 18 | 19 | ## I/O 20 | 21 | - Entrada 22 | - A entrada consiste de dois números inteiros positivos. 23 | - Saída 24 | - A saída consiste de um número inteiro positivo que representa o mdc dos dois números. 25 | 26 | ## Shell 27 | 28 | ```bash 29 | >>>>>>>> 30 | 3 31 | 5 32 | ======== 33 | 1 34 | <<<<<<<< 35 | 36 | >>>>>>>> 37 | 6 38 | 9 39 | ======== 40 | 3 41 | <<<<<<<< 42 | 43 | >>>>>>>> 44 | 50 45 | 15 46 | ======== 47 | 5 48 | <<<<<<<< 49 | 50 | >>>>>>>> 51 | 270 52 | 192 53 | ======== 54 | 6 55 | <<<<<<<< 56 | 57 | >>>>>>>> 58 | 192 59 | 276 60 | ======== 61 | 12 62 | <<<<<<<< 63 | ``` 64 | -------------------------------------------------------------------------------- /base/mergevet/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 1 3 | ======== EXPECT 4 | Criando vetor com capacidade 4 5 | size: 0 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 10 | 2 11 | ======== EXPECT 12 | Adicionando 1,2,3,0 usando push back 13 | Esperado: [1,2,3,0] 14 | Recebido: [1,2,3,0] 15 | Elemento 2: 3 16 | Mudando elemento 2 para 5 17 | Esperado: [1,2,5,0] 18 | Recebido: [1,2,5,0] 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT 23 | 3 24 | ======== EXPECT 25 | Criando vetor com lista de inicialização {1,2,3} 26 | Esperado: [1,2,3] 27 | Recebido: [1,2,3] 28 | Criando vetor com cópia do anterior 29 | Esperado: [1,2,3] 30 | Recebido: [1,2,3] 31 | <<<<<<<< FINISH 32 | 33 | 34 | >>>>>>>> INSERT 35 | 4 36 | ======== EXPECT 37 | Criando vetor v1 {4,5,1} 38 | Criando vetor v2 {4,5,1,7} 39 | Fazendo v1 == v2 40 | Esperado: 0 41 | Recebido: 0 42 | Fazendo pop_back em v2 43 | Fazendo v1 == v2 44 | Esperado: 1 45 | Recebido: 1 46 | <<<<<<<< FINISH 47 | 48 | 49 | >>>>>>>> INSERT 50 | 5 51 | ======== EXPECT 52 | Inicializando vetores va, vb e vc 53 | Criando vetor va {6,8,5} 54 | Criando vetor vb {3,2,1} 55 | Criando vetor vc {4,0,9} 56 | Fazendo merge 57 | Esperado: [3,2,1,4,0,6,8,5,9] 58 | Recebido: [3,2,1,4,0,6,8,5,9] 59 | <<<<<<<< FINISH 60 | 61 | -------------------------------------------------------------------------------- /base/multiset/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strings" 8 | ) 9 | 10 | func Join(slice []int, sep string) string { 11 | if len(slice) == 0 { 12 | return "" 13 | } 14 | result := fmt.Sprintf("%d", slice[0]) 15 | for _, value := range slice[1:] { 16 | result += sep + fmt.Sprintf("%d", value) 17 | } 18 | return result 19 | } 20 | 21 | func main() { 22 | var line, cmd string 23 | scanner := bufio.NewScanner(os.Stdin) 24 | // ms := NewMultiSet(0) 25 | 26 | for scanner.Scan() { 27 | fmt.Print("$") 28 | line = scanner.Text() 29 | args := strings.Fields(line) 30 | fmt.Println(line) 31 | if len(args) == 0 { 32 | continue 33 | } 34 | cmd = args[0] 35 | 36 | switch cmd { 37 | case "end": 38 | return 39 | case "init": 40 | // value, _ := strconv.Atoi(args[1]) 41 | // ms = NewMultiSet(value) 42 | case "insert": 43 | // for _, part := range args[1:] { 44 | // value, _ := strconv.Atoi(part) 45 | // } 46 | case "show": 47 | case "erase": 48 | // value, _ := strconv.Atoi(args[1]) 49 | case "contains": 50 | // value, _ := strconv.Atoi(args[1]) 51 | case "count": 52 | // value, _ := strconv.Atoi(args[1]) 53 | case "unique": 54 | case "clear": 55 | default: 56 | fmt.Println("fail: comando invalido") 57 | } 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /base/multiset/cover.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/multiset/cover.png -------------------------------------------------------------------------------- /base/padroes1/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Descobrindo quantos bloquinhos 2 | 3 | O diagrama mostra os três primeiros padrões em uma sequência em que cada padrão possui um buraco quadrado no meio. 4 | 5 | ![Padrões](https://github.com/WladimirTavares/ED2024.1/raw/main/padr%C3%B5es%20I/pattern.png) 6 | 7 | Escreva uma função que dado um inteiro `n` representando a posição de um padrão na sequência, calcule o número de quadrados sombreados. 8 | 9 | ## Entrada 10 | 11 | A entrada é composta por uma única linha contendo um inteiro `n` representando a posição de um padrão na sequência. 12 | 13 | ## Saída 14 | 15 | A saída é composta por uma única linha contendo o número de quadrados sombreados do n-ésimo padrão da sequência. 16 | 17 | ## Exemplo de Entrada 18 | 19 | ```txt 20 | 1 21 | ``` 22 | 23 | ## Exemplo de Saída 24 | 25 | ```txt 26 | 20 27 | ``` 28 | 29 | A primeira imagem do padrão pode ser decomposto em 4 retângulos 1x2 e 4 figuras no formato de L. 30 | 31 | ![decomposition](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/padroes1/./decomposition.jpeg) 32 | -------------------------------------------------------------------------------- /base/padroes1/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 1 3 | ======== EXPECT 4 | 20 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT 9 | 2 10 | ======== EXPECT 11 | 28 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT 16 | 3 17 | ======== EXPECT 18 | 36 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT 23 | 4 24 | ======== EXPECT 25 | 44 26 | <<<<<<<< FINISH 27 | 28 | -------------------------------------------------------------------------------- /base/padroes1/Readme.md: -------------------------------------------------------------------------------- 1 | # Descobrindo quantos bloquinhos 2 | 3 | O diagrama mostra os três primeiros padrões em uma sequência em que cada padrão possui um buraco quadrado no meio. 4 | 5 | ![Padrões](https://github.com/WladimirTavares/ED2024.1/raw/main/padr%C3%B5es%20I/pattern.png) 6 | 7 | Escreva uma função que dado um inteiro `n` representando a posição de um padrão na sequência, calcule o número de quadrados sombreados. 8 | 9 | ## Entrada 10 | 11 | A entrada é composta por uma única linha contendo um inteiro `n` representando a posição de um padrão na sequência. 12 | 13 | ## Saída 14 | 15 | A saída é composta por uma única linha contendo o número de quadrados sombreados do n-ésimo padrão da sequência. 16 | 17 | ## Exemplo de Entrada 18 | 19 | ```txt 20 | 1 21 | ``` 22 | 23 | ## Exemplo de Saída 24 | 25 | ```txt 26 | 20 27 | ``` 28 | 29 | A primeira imagem do padrão pode ser decomposto em 4 retângulos 1x2 e 4 figuras no formato de L. 30 | 31 | ![decomposition](./decomposition.jpeg) 32 | -------------------------------------------------------------------------------- /base/padroes1/decomposition.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/padroes1/decomposition.jpeg -------------------------------------------------------------------------------- /base/padroes1/pattern.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/padroes1/pattern.png -------------------------------------------------------------------------------- /base/padroes1/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 2 | 1 3 | ======== 4 | 20 5 | <<<<<<<< 6 | 7 | >>>>>>>> 8 | 2 9 | ======== 10 | 28 11 | <<<<<<<< 12 | 13 | >>>>>>>> 14 | 3 15 | ======== 16 | 36 17 | <<<<<<<< 18 | 19 | >>>>>>>> 20 | 4 21 | ======== 22 | 44 23 | <<<<<<<< 24 | 25 | 26 | -------------------------------------------------------------------------------- /base/padroes2/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Descobrindo quantas pecinhas 2 | 3 | Considere a seguinte sequência de imagem: 4 | 5 | ![Padrões](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/padroes2/seq1.png) 6 | 7 | Cada imagem na sequência é formada por um número de peças (uma peça pode ser um quadrado ou triângulo). 8 | 9 | A tabela seguinte apresenta uma relação entre a ordem da imagem na sequência e o número total de peças utilizadas: 10 | 11 | | ordem | 1 | 2 | 3 | 12 | |----------------------|---|---|----| 13 | | número de peças | 3 | 8 | 15 | 14 | 15 | Faça um programa que recebe um inteiro `n` e devolve o número total de peças da n-ésima imagem da sequência. 16 | 17 | ## Entrada 18 | 19 | A entrada é composta por uma única linha contendo um inteiro `n` representando a posição de um padrão na sequência. 20 | 21 | ## Saída 22 | 23 | A saída é composta por uma única linha contendo o total de peças da n-ésima imagem da sequência. 24 | 25 | ## Exemplo de Entrada 26 | 27 | ```txt 28 | 3 29 | ``` 30 | 31 | ## Exemplo de Saída 32 | 33 | ```txt 34 | 15 35 | ``` 36 | -------------------------------------------------------------------------------- /base/padroes2/Readme.md: -------------------------------------------------------------------------------- 1 | # Descobrindo quantas pecinhas 2 | 3 | Considere a seguinte sequência de imagem: 4 | 5 | ![Padrões](seq1.png) 6 | 7 | Cada imagem na sequência é formada por um número de peças (uma peça pode ser um quadrado ou triângulo). 8 | 9 | A tabela seguinte apresenta uma relação entre a ordem da imagem na sequência e o número total de peças utilizadas: 10 | 11 | | ordem | 1 | 2 | 3 | 12 | |----------------------|---|---|----| 13 | | número de peças | 3 | 8 | 15 | 14 | 15 | Faça um programa que recebe um inteiro `n` e devolve o número total de peças da n-ésima imagem da sequência. 16 | 17 | ## Entrada 18 | 19 | A entrada é composta por uma única linha contendo um inteiro `n` representando a posição de um padrão na sequência. 20 | 21 | ## Saída 22 | 23 | A saída é composta por uma única linha contendo o total de peças da n-ésima imagem da sequência. 24 | 25 | ## Exemplo de Entrada 26 | 27 | ```txt 28 | 3 29 | ``` 30 | 31 | ## Exemplo de Saída 32 | 33 | ```txt 34 | 15 35 | ``` 36 | -------------------------------------------------------------------------------- /base/padroes2/seq1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/padroes2/seq1.png -------------------------------------------------------------------------------- /base/padroes3/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Descobrindo quantos pontos 2 | 3 | 4 | [Intro](#intro) | [Draft](#draft) | [Tests](#tests) 5 | -- | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Considere as seguintes sequências de figuras geométricas: 11 | 12 | ![Padrões](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/padroes3/Padroes.png) 13 | 14 | Dado dois inteiros $3 \leq n \leq 20$ e $ 1 \leq m \leq 40$, encontre o número de pontos da m-ésima figura da sequência $F_n$. Por exemplo, a segunda figura da sequência $F_3$ é formada por 3 pontos. 15 | 16 | ## Draft 17 | 18 | - Você deve implementar de forma recursiva a função `calculaPontos` no arquivo `main.cpp`. 19 | 20 | 21 | - cpp 22 | - [main.cpp](https://github.com/qxcodeed/arcade/blob/master/base/padroes3/.cache/draft/cpp/main.cpp) 23 | 24 | 25 | ## Tests 26 | 27 | - Entrada 28 | - A entrada consiste em uma única linha que contém dois números inteiros, n e m. Esses números representam, respectivamente, a sequência e a posição m-ésima na sequência $F_n$. 29 | 30 | - Saída 31 | - A saída é composta por uma única linha contendo o número total de pontos. 32 | 33 | ```txt 34 | >>>>>>>> 35 | 6 2 36 | ======== 37 | 6 38 | <<<<<<<< 39 | ``` 40 | -------------------------------------------------------------------------------- /base/padroes3/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int calculaPontos(int n, int m) { 4 | (void) n; 5 | (void) m; 6 | return 0; 7 | } 8 | 9 | int main() { 10 | int m, n; 11 | std::cin >> n >> m; 12 | std::cout << calculaPontos(n, m) << std::endl; 13 | } 14 | -------------------------------------------------------------------------------- /base/padroes3/Padroes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/padroes3/Padroes.png -------------------------------------------------------------------------------- /base/padroes3/Readme.md: -------------------------------------------------------------------------------- 1 | # Descobrindo quantos pontos 2 | 3 | 4 | [Intro](#intro) | [Draft](#draft) | [Tests](#tests) 5 | -- | -- | -- 6 | 7 | 8 | ## Intro 9 | 10 | Considere as seguintes sequências de figuras geométricas: 11 | 12 | ![Padrões](Padroes.png) 13 | 14 | Dado dois inteiros $3 \leq n \leq 20$ e $ 1 \leq m \leq 40$, encontre o número de pontos da m-ésima figura da sequência $F_n$. Por exemplo, a segunda figura da sequência $F_3$ é formada por 3 pontos. 15 | 16 | ## Draft 17 | 18 | - Você deve implementar de forma recursiva a função `calculaPontos` no arquivo `main.cpp`. 19 | 20 | 21 | - cpp 22 | - [main.cpp](.cache/draft/cpp/main.cpp) 23 | 24 | 25 | ## Tests 26 | 27 | - Entrada 28 | - A entrada consiste em uma única linha que contém dois números inteiros, n e m. Esses números representam, respectivamente, a sequência e a posição m-ésima na sequência $F_n$. 29 | 30 | - Saída 31 | - A saída é composta por uma única linha contendo o número total de pontos. 32 | 33 | ```txt 34 | >>>>>>>> 35 | 6 2 36 | ======== 37 | 6 38 | <<<<<<<< 39 | ``` 40 | -------------------------------------------------------------------------------- /base/padroes3/seq1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/padroes3/seq1.png -------------------------------------------------------------------------------- /base/pilha/.cache/draft/go/extra.md: -------------------------------------------------------------------------------- 1 | # Orientações de Implementação 2 | 3 | ```go 4 | type Stack[T any] struct { // Uma pilha genérica que pode armazenar qualquer tipo de dado. 5 | data []T // Os dados são armazenados em um slice, a capacidade do slice é a capacidade da pilha. 6 | Push(value T) // Adiciona um valor ao topo da pilha utilizando append. 7 | Pop() error // Remove o valor do topo da pilha. 8 | Peek() (T, error) // Retorna o valor do topo da pilha sem removê-lo. 9 | IsEmpty() bool // Retorna true se a pilha estiver vazia. 10 | Size() int // Retorna o número de elementos na pilha. Isso equivale ao tamanho do slice. 11 | Clear() // Limpa a pilha, removendo todos os elementos. 12 | String() string // Retorna uma representação em string dos elementos da pilha para efeitos de debug. 13 | } 14 | 15 | func NewStack[T any](cap int) *Stack[T] // Cria uma nova pilha com a capacidade inicial especificada 16 | ``` 17 | 18 | Para remover o último elemento ou zerar o slice, você pode usar as operações de slice do Go, como `s = s[:len(s)-1]` para remover o último elemento ou `s = s[:0]` para zerar o slice. O operador de fatiamento mantém a capacidade original do bloco alocado, ele apenas manipula o tamanho do slice, o que é eficiente em termos de memória. 19 | -------------------------------------------------------------------------------- /base/pilha/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT empilhar 2 | init 2 3 | debug 4 | push 1 5 | debug 6 | push 2 7 | debug 8 | push 3 9 | debug 10 | end 11 | ======== EXPECT 12 | $init 2 13 | $debug 14 | _, _ 15 | $push 1 16 | $debug 17 | 1, _ 18 | $push 2 19 | $debug 20 | 1, 2 21 | $push 3 22 | $debug 23 | 1, 2, 3, _ 24 | $end 25 | <<<<<<<< FINISH 26 | 27 | 28 | >>>>>>>> INSERT desempilhar 29 | init 5 30 | push 5 31 | push 4 32 | push 3 33 | push 2 34 | push 8 35 | debug 36 | top 37 | size 38 | clear 39 | debug 40 | end 41 | ======== EXPECT 42 | $init 5 43 | $push 5 44 | $push 4 45 | $push 3 46 | $push 2 47 | $push 8 48 | $debug 49 | 5, 4, 3, 2, 8 50 | $top 51 | 8 52 | $size 53 | 5 54 | $clear 55 | $debug 56 | _, _, _, _, _ 57 | $end 58 | <<<<<<<< FINISH 59 | 60 | 61 | >>>>>>>> INSERT erros 62 | init 5 63 | pop 64 | top 65 | push 2 66 | push 8 67 | debug 68 | pop 69 | debug 70 | pop 71 | debug 72 | pop 73 | end 74 | ======== EXPECT 75 | $init 5 76 | $pop 77 | stack is empty 78 | $top 79 | stack is empty 80 | $push 2 81 | $push 8 82 | $debug 83 | 2, 8, _, _, _ 84 | $pop 85 | $debug 86 | 2, _, _, _, _ 87 | $pop 88 | $debug 89 | _, _, _, _, _ 90 | $pop 91 | stack is empty 92 | $end 93 | <<<<<<<< FINISH 94 | 95 | -------------------------------------------------------------------------------- /base/pilhado/.cache/draft/cpp/lib.cpp: -------------------------------------------------------------------------------- 1 | #include "lib.h" 2 | 3 | vector get_vizinhos(Pos p) { 4 | // Essa função deve retornar um vetor 5 | // com as posições vizinhas da posição p 6 | return {} 7 | } 8 | 9 | void procurar_saida(vector& mat, Pos inicio, Pos fim) { 10 | (void) mat; 11 | (void) inicio; 12 | (void) fim; 13 | } 14 | -------------------------------------------------------------------------------- /base/pilhado/.cache/draft/cpp/lib.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Pos { 7 | int l; 8 | int c; 9 | }; 10 | 11 | vector get_vizinhos(Pos p); 12 | void procurar_saida(vector& mat, Pos inicio, Pos fim); 13 | -------------------------------------------------------------------------------- /base/pilhado/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include "lib.h" 2 | 3 | int main() { 4 | int nl = 0, nc = 0; 5 | cin >> nl >> nc; 6 | vector mat(nl, ""); //começa com nl strings "" 7 | getchar(); //remove \n after nc 8 | Pos inicio, fim; 9 | 10 | //carregando matriz 11 | for (int i = 0; i < nl; i++) 12 | getline(cin, mat[i]); 13 | 14 | //procurando inicio e fim e colocando ' ' nas posições iniciais 15 | for (int l = 0; l < nl; l++) { 16 | for (int c = 0; c < nc; c++) { 17 | if (mat[l][c] == 'I') { 18 | mat[l][c] = ' '; 19 | inicio = Pos{ l, c }; 20 | } 21 | if (mat[l][c] == 'F') { 22 | mat[l][c] = ' '; 23 | fim = Pos{ l, c }; 24 | } 25 | } 26 | } 27 | 28 | procurar_saida(mat, inicio, fim); 29 | 30 | for (string line : mat) { 31 | cout << line << endl; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /base/pilhado/.cache/draft/go/stack.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Stack[T any] struct { 6 | data []T 7 | } 8 | 9 | func NewStack[T any](cap int) *Stack[T] { 10 | return &Stack[T]{data: make([]T, 0, cap)} 11 | } 12 | 13 | func (s *Stack[T]) Push(value T) { 14 | s.data = append(s.data, value) 15 | } 16 | 17 | func (s *Stack[T]) Pop() error { 18 | if len(s.data) == 0 { 19 | return fmt.Errorf("stack is empty") 20 | } 21 | s.data = s.data[:len(s.data)-1] 22 | return nil 23 | } 24 | 25 | func (s *Stack[T]) Top() (T, error) { 26 | if len(s.data) == 0 { 27 | var zero T 28 | return zero, fmt.Errorf("stack is empty") 29 | } 30 | return s.data[len(s.data)-1], nil 31 | } 32 | 33 | func (s *Stack[T]) IsEmpty() bool { 34 | return len(s.data) == 0 35 | } 36 | 37 | func (s *Stack[T]) Size() int { 38 | return len(s.data) 39 | } 40 | 41 | func (s *Stack[T]) Clear() { 42 | s.data = s.data[:0] 43 | } 44 | 45 | func (s *Stack[T]) String() string { 46 | output := "[" 47 | for i, v := range s.data { 48 | if i != 0 { 49 | output += ", " 50 | } 51 | output += fmt.Sprintf("%v", v) 52 | } 53 | output += "]" 54 | return output 55 | } 56 | -------------------------------------------------------------------------------- /base/pilhado/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/pilhado/cover.jpg -------------------------------------------------------------------------------- /base/polonesa/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Transforme da notação padrão para polonesa reversa 2 | 3 | ## Descrição 4 | 5 | - Faça o caso simples sem parênteses 6 | - Utilize os operadores `+`, `-`, `*`, `/` e `^` 7 | - Precedência 1(menor): `+` e `-` 8 | - Precedência 2: `*` e `/` 9 | - Precedência 3(maior): `^` 10 | 11 | ## Drafts 12 | 13 | 14 | - cpp 15 | - [fn.hpp](https://github.com/qxcodeed/arcade/blob/master/base/polonesa/.cache/draft/cpp/fn.hpp) 16 | - [main.cpp](https://github.com/qxcodeed/arcade/blob/master/base/polonesa/.cache/draft/cpp/main.cpp) 17 | 18 | 19 | ## Testes 20 | 21 | ```bash 22 | 23 | >>>>>>>> 24 | 3 + 4 * 2 25 | ======== 26 | 3 4 2 * + 27 | <<<<<<<< 28 | 29 | 30 | >>>>>>>> 31 | 3 + 4 * 2 - 1 32 | ======== 33 | 3 4 2 * + 1 - 34 | <<<<<<<< 35 | 36 | >>>>>>>> 37 | 3 + 4 * 2 - 1 / 2 38 | ======== 39 | 3 4 2 * + 1 2 / - 40 | <<<<<<<< 41 | 42 | >>>>>>>> 43 | 1 + 2 * 3 ^ 4 44 | ======== 45 | 1 2 3 4 ^ * + 46 | <<<<<<<< 47 | 48 | >>>>>>>> 49 | 1 + 2 * 3 ^ 4 - 5 50 | ======== 51 | 1 2 3 4 ^ * + 5 - 52 | <<<<<<<< 53 | 54 | ``` 55 | -------------------------------------------------------------------------------- /base/polonesa/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include "fn.hpp" 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | bool isdigit(const string& s) { 8 | (void) s; 9 | return false; 10 | } 11 | 12 | vector shunting_yard(vector tokens) { 13 | (void) tokens; 14 | return {}; 15 | } 16 | 17 | int main() { 18 | vector data = fn::input() | fn::SPLIT(' '); 19 | shunting_yard(data) | fn::JOIN(" ") | fn::WRITE(); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /base/polonesa/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 3 + 4 * 2 3 | ======== EXPECT 4 | 3 4 2 * + 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT 9 | 3 + 4 * 2 - 1 10 | ======== EXPECT 11 | 3 4 2 * + 1 - 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT 16 | 3 + 4 * 2 - 1 / 2 17 | ======== EXPECT 18 | 3 4 2 * + 1 2 / - 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT 23 | 1 + 2 * 3 ^ 4 24 | ======== EXPECT 25 | 1 2 3 4 ^ * + 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT 30 | 1 + 2 * 3 ^ 4 - 5 31 | ======== EXPECT 32 | 1 2 3 4 ^ * + 5 - 33 | <<<<<<<< FINISH 34 | 35 | -------------------------------------------------------------------------------- /base/polonesa/Readme.md: -------------------------------------------------------------------------------- 1 | # Transforme da notação padrão para polonesa reversa 2 | 3 | ## Descrição 4 | 5 | - Faça o caso simples sem parênteses 6 | - Utilize os operadores `+`, `-`, `*`, `/` e `^` 7 | - Precedência 1(menor): `+` e `-` 8 | - Precedência 2: `*` e `/` 9 | - Precedência 3(maior): `^` 10 | 11 | ## Drafts 12 | 13 | 14 | - cpp 15 | - [fn.hpp](.cache/draft/cpp/fn.hpp) 16 | - [main.cpp](.cache/draft/cpp/main.cpp) 17 | 18 | 19 | ## Testes 20 | 21 | ```bash 22 | 23 | >>>>>>>> 24 | 3 + 4 * 2 25 | ======== 26 | 3 4 2 * + 27 | <<<<<<<< 28 | 29 | 30 | >>>>>>>> 31 | 3 + 4 * 2 - 1 32 | ======== 33 | 3 4 2 * + 1 - 34 | <<<<<<<< 35 | 36 | >>>>>>>> 37 | 3 + 4 * 2 - 1 / 2 38 | ======== 39 | 3 4 2 * + 1 2 / - 40 | <<<<<<<< 41 | 42 | >>>>>>>> 43 | 1 + 2 * 3 ^ 4 44 | ======== 45 | 1 2 3 4 ^ * + 46 | <<<<<<<< 47 | 48 | >>>>>>>> 49 | 1 + 2 * 3 ^ 4 - 5 50 | ======== 51 | 1 2 3 4 ^ * + 5 - 52 | <<<<<<<< 53 | 54 | ``` 55 | -------------------------------------------------------------------------------- /base/ponto/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "point.hpp" 5 | #include "fn.hpp" 6 | 7 | Ponto str2point(std::string token) { 8 | token = token.substr(1, token.size() - 2); //remover () 9 | size_t pos = token.find(','); 10 | std::string x_str = token.substr(0, pos); 11 | std::string y_str = token.substr(pos + 1); 12 | return Ponto(std::stod(x_str), std::stod(y_str)); 13 | } 14 | 15 | 16 | int main() { 17 | Ponto origem = str2point(fn::input()); 18 | auto vet = fn::input() | fn::SPLIT(' ') | fn::MAP(str2point); 19 | auto vet_incl = vet | fn::MAP([&](Ponto p) { return reta(origem, p); }); 20 | auto vet_dist = vet | fn::MAP([&](Ponto p) { return origem.dist(p); }); 21 | auto min_idx = min_dist(origem, vet); 22 | 23 | vet_incl | fn::JOIN(" ", "%.2f") | fn::WRITE(); 24 | vet_dist | fn::JOIN(" ", "%.2f") | fn::WRITE(); 25 | min_idx | fn::WRITE(); 26 | } 27 | -------------------------------------------------------------------------------- /base/ponto/.cache/draft/cpp/point.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "point.hpp" 6 | 7 | Ponto::Ponto(int x, int y) { 8 | (void) x; 9 | (void) y; 10 | } 11 | 12 | double Ponto::dist(const Ponto& p) const { 13 | (void) p; 14 | return 0.0; 15 | } 16 | 17 | double reta(const Ponto& p, const Ponto& q) { 18 | (void) p; 19 | (void) q; 20 | return 0.0; 21 | } 22 | 23 | 24 | int min_dist(const Ponto& p, std::vector vet) { 25 | return best_i; 26 | (void) p; 27 | (void) vet; 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /base/ponto/.cache/draft/cpp/point.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class Ponto { 5 | double x; // abcissa 6 | double y; // ordenada 7 | public: 8 | // Construtor 9 | Ponto(int x = 0, int y = 0); // TODO 10 | // Calcula a distância entre dois pontos 11 | double dist(const Ponto& p) const; //TODO 12 | 13 | //----------------------------------------- 14 | 15 | // acesso por referência 16 | double& X() { return x; } 17 | double& Y() { return y; } 18 | // acesso por valor 19 | double X() const { return x; } 20 | double Y() const { return y; } 21 | }; 22 | 23 | // Função que calcula a inclinação da reta que passa pelos pontos p e q 24 | double reta(const Ponto& p, const Ponto& q); // TODO 25 | 26 | // Função que calcula qual dos pontos do vetor está mais próximo do ponto p 27 | // Retorna o índice do ponto mais próximo 28 | int min_dist(const Ponto& p, std::vector vet); // TODO 29 | -------------------------------------------------------------------------------- /base/ponto/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | (0,0) 3 | (1,1) (2,2) (3,3) 4 | ======== EXPECT 5 | 1.00 1.00 1.00 6 | 1.41 2.83 4.24 7 | 0 8 | <<<<<<<< FINISH 9 | 10 | 11 | >>>>>>>> INSERT 12 | (5.2,3.1) 13 | (1.2,1.3) (2.2,2.3) (3.3,5.9) 14 | ======== EXPECT 15 | 0.50 0.33 -1.00 16 | 4.47 3.16 2.83 17 | 2 18 | <<<<<<<< FINISH 19 | 20 | -------------------------------------------------------------------------------- /base/pontoGo/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "point.hpp" 5 | #include "fn.hpp" 6 | 7 | Ponto str2point(std::string token) { 8 | token = token.substr(1, token.size() - 2); //remover () 9 | size_t pos = token.find(','); 10 | std::string x_str = token.substr(0, pos); 11 | std::string y_str = token.substr(pos + 1); 12 | return Ponto(std::stod(x_str), std::stod(y_str)); 13 | } 14 | 15 | 16 | int main() { 17 | Ponto origem = str2point(fn::input()); 18 | auto vet = fn::input() | fn::SPLIT(' ') | fn::MAP(str2point); 19 | auto vet_incl = vet | fn::MAP([&](Ponto p) { return reta(origem, p); }); 20 | auto vet_dist = vet | fn::MAP([&](Ponto p) { return origem.dist(p); }); 21 | auto min_idx = min_dist(origem, vet); 22 | 23 | vet_incl | fn::JOIN(" ", "%.2f") | fn::WRITE(); 24 | vet_dist | fn::JOIN(" ", "%.2f") | fn::WRITE(); 25 | min_idx | fn::WRITE(); 26 | } 27 | -------------------------------------------------------------------------------- /base/pontoGo/.cache/draft/cpp/point.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "point.hpp" 6 | 7 | Ponto::Ponto(int x, int y) { 8 | (void) x; 9 | (void) y; 10 | } 11 | 12 | double Ponto::dist(const Ponto& p) const { 13 | (void) p; 14 | return 0.0; 15 | } 16 | 17 | double reta(const Ponto& p, const Ponto& q) { 18 | (void) p; 19 | (void) q; 20 | return 0.0; 21 | } 22 | 23 | 24 | int min_dist(const Ponto& p, std::vector vet) { 25 | return best_i; 26 | (void) p; 27 | (void) vet; 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /base/pontoGo/.cache/draft/cpp/point.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class Ponto { 5 | double x; // abcissa 6 | double y; // ordenada 7 | public: 8 | // Construtor 9 | Ponto(int x = 0, int y = 0); // TODO 10 | // Calcula a distância entre dois pontos 11 | double dist(const Ponto& p) const; //TODO 12 | 13 | //----------------------------------------- 14 | 15 | // acesso por referência 16 | double& X() { return x; } 17 | double& Y() { return y; } 18 | // acesso por valor 19 | double X() const { return x; } 20 | double Y() const { return y; } 21 | }; 22 | 23 | // Função que calcula a inclinação da reta que passa pelos pontos p e q 24 | double reta(const Ponto& p, const Ponto& q); // TODO 25 | 26 | // Função que calcula qual dos pontos do vetor está mais próximo do ponto p 27 | // Retorna o índice do ponto mais próximo 28 | int min_dist(const Ponto& p, std::vector vet); // TODO 29 | -------------------------------------------------------------------------------- /base/pontoGo/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | $dist (0,0) (1,1) 3 | 4 | ======== EXPECT 5 | 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 10 | (5.2,3.1) 11 | (1.2,1.3) (2.2,2.3) (3.3,5.9) 12 | ======== EXPECT 13 | <<<<<<<< FINISH 14 | 15 | -------------------------------------------------------------------------------- /base/pontoGo/Readme.md: -------------------------------------------------------------------------------- 1 | # Implemente a classe ponto 2 | 3 | ## Intro 4 | 5 | Implemente a classe ponto e faça a equação da reta. 6 | 7 | ## Draft 8 | 9 | - O único arquivo que você deve modificar é `point.cpp`. 10 | - Você deve implementar o construtor, o método `dist` e os métodos para calcular a inclinação da reta e o ponto mais próximo. 11 | - Estude o arquivo `point.hpp` para entender a interface da classe e aprender como usar os métodos. 12 | - O arquivo `main.cpp` contém o código que lê os pontos e chama os métodos da classe ponto, além de imprimir os resultados. 13 | 14 | 15 | - cpp 16 | - [fn.hpp](.cache/draft/cpp/fn.hpp) 17 | - [main.cpp](.cache/draft/cpp/main.cpp) 18 | - [point.cpp](.cache/draft/cpp/point.cpp) 19 | - [point.hpp](.cache/draft/cpp/point.hpp) 20 | - go 21 | - [point.go](.cache/draft/go/point.go) 22 | 23 | 24 | ## Testes 25 | 26 | - Entrada 27 | - 1a linha: ponto de origem no formato (x, y). 28 | - 2a linha: lista de N pontos no formato (x, y). 29 | - Saída 30 | - Todas as saídas devem ser formatadas com 2 casas decimais. 31 | - 1a linha: inclinação da reta de cada ponto de origem para cada ponto da lista. 32 | - 2a linha: vetor com as distâncias do ponto de origem para cada ponto da lista. 33 | - 3a linha: índice do ponto da lista mais próximo do ponto de origem. 34 | 35 | ```bash 36 | >>>>>>>> 37 | $dist (0,0) (1,1) 38 | 39 | ======== 40 | 41 | <<<<<<<< 42 | 43 | >>>>>>>> 44 | (5.2,3.1) 45 | (1.2,1.3) (2.2,2.3) (3.3,5.9) 46 | ======== 47 | <<<<<<<< 48 | ``` 49 | -------------------------------------------------------------------------------- /base/priminhos/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Carrega a lista de primos 2 | 3 | ## Intro 4 | 5 | Gere um vetor com os `n` primeiros números primos. 6 | 7 | ## Draft 8 | 9 | 10 | - cpp 11 | - [main.cpp](https://github.com/qxcodeed/arcade/blob/master/base/priminhos/.cache/draft/cpp/main.cpp) 12 | 13 | 14 | ## Testes 15 | 16 | ```bash 17 | >>>>>>>> 18 | 1 19 | ======== 20 | [2] 21 | <<<<<<<< 22 | 23 | >>>>>>>> 24 | 2 25 | ======== 26 | [2, 3] 27 | <<<<<<<< 28 | 29 | >>>>>>>> 30 | 3 31 | ======== 32 | [2, 3, 5] 33 | <<<<<<<<< 34 | 35 | >>>>>>>> 36 | 7 37 | ======== 38 | [2, 3, 5, 7, 11, 13, 17] 39 | <<<<<<<<< 40 | ``` 41 | -------------------------------------------------------------------------------- /base/priminhos/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // x: número que está sendo testado 4 | // div: divisor que está sendo testado 5 | bool eh_primo(int x, int div = 2) { 6 | (void) x; 7 | (void) div; 8 | return false; 9 | } 10 | 11 | // n: n-ésimo número primo 12 | // cont: contador de quantos números primos já foram encontrados 13 | // i: número que está sendo testado 14 | int n_esimo(int n, int cont = 0, int i = 2) { 15 | (void) n; 16 | (void) cont; 17 | (void) i; 18 | return 0; 19 | } 20 | 21 | // M: vetor de inteiros 22 | // n: tamanho do vetor 23 | void load_prime_list(int M[], int n) { 24 | (void) M; 25 | (void) n; 26 | } 27 | 28 | int main() { 29 | int n {}; 30 | std::cin >> n; 31 | int M[n]; 32 | load_prime_list(M, n); 33 | 34 | std::cout << "["; 35 | for (int i = 0; i < n; i++) { 36 | std::cout << (i == 0 ? "" : ", "); 37 | std::cout << M[i]; 38 | } 39 | std::cout << "]\n"; 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /base/priminhos/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 1 3 | ======== EXPECT 4 | [2] 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT 9 | 2 10 | ======== EXPECT 11 | [2, 3] 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT 16 | 3 17 | ======== EXPECT 18 | [2, 3, 5] 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT 23 | 7 24 | ======== EXPECT 25 | [2, 3, 5, 7, 11, 13, 17] 26 | <<<<<<<< FINISH 27 | 28 | -------------------------------------------------------------------------------- /base/priminhos/Readme.md: -------------------------------------------------------------------------------- 1 | # Carrega a lista de primos 2 | 3 | ## Intro 4 | 5 | Gere um vetor com os `n` primeiros números primos. 6 | 7 | ## Draft 8 | 9 | 10 | - cpp 11 | - [main.cpp](.cache/draft/cpp/main.cpp) 12 | 13 | 14 | ## Testes 15 | 16 | ```bash 17 | >>>>>>>> 18 | 1 19 | ======== 20 | [2] 21 | <<<<<<<< 22 | 23 | >>>>>>>> 24 | 2 25 | ======== 26 | [2, 3] 27 | <<<<<<<< 28 | 29 | >>>>>>>> 30 | 3 31 | ======== 32 | [2, 3, 5] 33 | <<<<<<<<< 34 | 35 | >>>>>>>> 36 | 7 37 | ======== 38 | [2, 3, 5, 7, 11, 13, 17] 39 | <<<<<<<<< 40 | ``` 41 | -------------------------------------------------------------------------------- /base/prin_list1/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "container/list" 5 | "fmt" 6 | ) 7 | 8 | // mostra a lista com o elemento sword destacado 9 | func ToStr(l *list.List, sword *list.Element) string { 10 | return "" 11 | } 12 | 13 | // move para frente na lista circular 14 | func Next(l *list.List, it *list.Element) *list.Element { 15 | return nil 16 | } 17 | 18 | func main() { 19 | var qtd, chosen int 20 | fmt.Scan(&qtd, &chosen) 21 | l := list.New() 22 | for i := 1; i <= qtd; i++ { 23 | l.PushBack(i) 24 | } 25 | sword := l.Front() 26 | for range chosen - 1 { 27 | sword = Next(l, sword) 28 | } 29 | for range qtd - 1 { 30 | fmt.Println(ToStr(l, sword)) 31 | l.Remove(Next(l, sword)) 32 | sword = Next(l, sword) 33 | } 34 | fmt.Println(ToStr(l, sword)) 35 | } 36 | -------------------------------------------------------------------------------- /base/prin_list1/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/prin_list1/cover.jpg -------------------------------------------------------------------------------- /base/prin_list2/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "container/list" 5 | "fmt" 6 | ) 7 | 8 | // mostra a lista com o elemento sword destacado 9 | func ToStr(l *list.List, sword *list.Element) string { 10 | return "" 11 | } 12 | 13 | // move para frente na lista circular 14 | func Next(l *list.List, it *list.Element) *list.Element { 15 | return nil 16 | } 17 | 18 | // move para tras na lista circular 19 | func Prev(l *list.List, it *list.Element) *list.Element { 20 | return l.Front() 21 | } 22 | 23 | func main() { 24 | var qtd, chosen, fase int 25 | fmt.Scan(&qtd, &chosen, &fase) 26 | l := list.New() 27 | for i := 1; i <= qtd; i++ { 28 | l.PushBack(i * fase) 29 | fase = -fase 30 | } 31 | sword := l.Front() 32 | for range chosen - 1 { 33 | sword = Next(l, sword) 34 | } 35 | for range qtd - 1 { 36 | fmt.Println(ToStr(l, sword)) 37 | if sword.Value.(int) > 0 { 38 | l.Remove(Next(l, sword)) 39 | sword = Next(l, sword) 40 | } else { 41 | l.Remove(Prev(l, sword)) 42 | sword = Prev(l, sword) 43 | } 44 | } 45 | fmt.Println(ToStr(l, sword)) 46 | } 47 | -------------------------------------------------------------------------------- /base/prin_list2/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/prin_list2/cover.jpg -------------------------------------------------------------------------------- /base/princesa/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/princesa/cover.jpg -------------------------------------------------------------------------------- /base/princesa/solv_marcacao.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | //find the next alive element from start + 1 5 | int find_alive(std::vector vet, int pos) { 6 | do { 7 | pos = (pos + 1) % vet.size(); 8 | } while (vet[pos] == false); 9 | return pos; 10 | } 11 | 12 | //print the vector showing who has the sword 13 | void show_vector(std::vector vet, int sword) { 14 | std::cout << "["; 15 | for (int i = 0; i < (int) vet.size(); i++) { 16 | if (vet[i]) 17 | std::cout << " " << (i + 1); 18 | if(i == sword) 19 | std::cout << ">"; 20 | } 21 | std::cout << " ]\n"; 22 | } 23 | 24 | int main(){ 25 | int size { }; 26 | std::cin >> size; 27 | std::vector vet(size, true); 28 | int sword { }; //chosen one 29 | std::cin >> sword; 30 | sword = sword - 1; 31 | show_vector(vet, sword); 32 | int qtd = size - 1; 33 | while(qtd--) { 34 | int to_die {find_alive(vet, sword)}; 35 | vet[to_die] = false; 36 | sword = find_alive(vet, to_die); 37 | show_vector(vet, sword); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /base/princesa/student.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | const int MORTO = 0; 5 | 6 | //acha o proximo elemento vivo a partir de inicio + 1 7 | int achar_vivo(int vet[], int size, int inicio){ 8 | int pos = (inicio + 1) % size; 9 | while(vet[pos] == MORTO) 10 | pos = (pos + 1) % size; 11 | return pos; 12 | } 13 | 14 | void mostrar_vetor(int vet[], int size, int e){ 15 | printf("["); 16 | for(int i = 0; i < size; i++){ 17 | if(vet[i] != MORTO) 18 | printf(" %d", vet[i]); 19 | if(i == e) 20 | printf(">"); 21 | } 22 | printf(" ]\n"); 23 | } 24 | 25 | int main(){ 26 | int size = 0; 27 | scanf("%d", &size); 28 | int vet[size]; 29 | for(int i = 0; i < size; i++) 30 | vet[i] = i + 1; 31 | int esc = 0; //o escolhido 32 | scanf("%d", &esc); 33 | esc = esc - 1; 34 | mostrar_vetor(vet, size, esc); 35 | int qtd = size - 1; 36 | while(qtd--){ 37 | int vai_morrer = achar_vivo(vet, size, esc); 38 | vet[vai_morrer] = 0; 39 | esc = achar_vivo(vet, size, vai_morrer); 40 | mostrar_vetor(vet, size, esc); 41 | } 42 | } 43 | 44 | -------------------------------------------------------------------------------- /base/quadrado/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Aragão calculando n ao quadrado 2 | 3 | Aragão está profundamente envolvido em seu aprendizado sobre recursão. Recentemente, ele fez uma descoberta fascinante: o cálculo de $n^2$ pode ser expresso de maneira recursiva por meio da seguinte fórmula iterativa: $(n+1)^2 = n^2 + 2n + 1$, começando com $1^2 = 1$ como caso base. 4 | 5 | Empolgado com essa revelação, Aragão deseja desenvolver um algoritmo recursivo que não apenas calcule $n^2$, mas também mostre cada passo do processo. No entanto, ele enfrenta algumas dificuldades para elaborar tal algoritmo. É aí que entra a sua ajuda. 6 | 7 | ## Entrada 8 | 9 | A entrada é composta por uma única linha contendo um inteiro $n$ 10 | 11 | ## Saída 12 | 13 | A saída é composta por várias linhas mostrando o passo-a-passo do algoritmo recursivo. 14 | 15 | ## Exemplo de Entrada 16 | 17 | ```txt 18 | 10 19 | ``` 20 | 21 | ## Exemplo de Saída 22 | 23 | ```txt 24 | 10^2 = 9^2 + 2*9 + 1 = ? 25 | 9^2 = 8^2 + 2*8 + 1 = ? 26 | 8^2 = 7^2 + 2*7 + 1 = ? 27 | 7^2 = 6^2 + 2*6 + 1 = ? 28 | 6^2 = 5^2 + 2*5 + 1 = ? 29 | 5^2 = 4^2 + 2*4 + 1 = ? 30 | 4^2 = 3^2 + 2*3 + 1 = ? 31 | 3^2 = 2^2 + 2*2 + 1 = ? 32 | 2^2 = 1^2 + 2*1 + 1 = ? 33 | 1^2 = 1 34 | 2^2 = 1^2 + 2*1 + 1 = 4 35 | 3^2 = 2^2 + 2*2 + 1 = 9 36 | 4^2 = 3^2 + 2*3 + 1 = 16 37 | 5^2 = 4^2 + 2*4 + 1 = 25 38 | 6^2 = 5^2 + 2*5 + 1 = 36 39 | 7^2 = 6^2 + 2*6 + 1 = 49 40 | 8^2 = 7^2 + 2*7 + 1 = 64 41 | 9^2 = 8^2 + 2*8 + 1 = 81 42 | 10^2 = 9^2 + 2*9 + 1 = 100 43 | ``` 44 | -------------------------------------------------------------------------------- /base/quadrado/Readme.md: -------------------------------------------------------------------------------- 1 | # Aragão calculando n ao quadrado 2 | 3 | Aragão está profundamente envolvido em seu aprendizado sobre recursão. Recentemente, ele fez uma descoberta fascinante: o cálculo de $n^2$ pode ser expresso de maneira recursiva por meio da seguinte fórmula iterativa: $(n+1)^2 = n^2 + 2n + 1$, começando com $1^2 = 1$ como caso base. 4 | 5 | Empolgado com essa revelação, Aragão deseja desenvolver um algoritmo recursivo que não apenas calcule $n^2$, mas também mostre cada passo do processo. No entanto, ele enfrenta algumas dificuldades para elaborar tal algoritmo. É aí que entra a sua ajuda. 6 | 7 | ## Entrada 8 | 9 | A entrada é composta por uma única linha contendo um inteiro $n$ 10 | 11 | ## Saída 12 | 13 | A saída é composta por várias linhas mostrando o passo-a-passo do algoritmo recursivo. 14 | 15 | ## Exemplo de Entrada 16 | 17 | ```txt 18 | 10 19 | ``` 20 | 21 | ## Exemplo de Saída 22 | 23 | ```txt 24 | 10^2 = 9^2 + 2*9 + 1 = ? 25 | 9^2 = 8^2 + 2*8 + 1 = ? 26 | 8^2 = 7^2 + 2*7 + 1 = ? 27 | 7^2 = 6^2 + 2*6 + 1 = ? 28 | 6^2 = 5^2 + 2*5 + 1 = ? 29 | 5^2 = 4^2 + 2*4 + 1 = ? 30 | 4^2 = 3^2 + 2*3 + 1 = ? 31 | 3^2 = 2^2 + 2*2 + 1 = ? 32 | 2^2 = 1^2 + 2*1 + 1 = ? 33 | 1^2 = 1 34 | 2^2 = 1^2 + 2*1 + 1 = 4 35 | 3^2 = 2^2 + 2*2 + 1 = 9 36 | 4^2 = 3^2 + 2*3 + 1 = 16 37 | 5^2 = 4^2 + 2*4 + 1 = 25 38 | 6^2 = 5^2 + 2*5 + 1 = 36 39 | 7^2 = 6^2 + 2*6 + 1 = 49 40 | 8^2 = 7^2 + 2*7 + 1 = 64 41 | 9^2 = 8^2 + 2*8 + 1 = 81 42 | 10^2 = 9^2 + 2*9 + 1 = 100 43 | ``` 44 | -------------------------------------------------------------------------------- /base/queimada/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void tocar_fogo(std::vector &mat, int l, int c) { 5 | int nl = mat.size(); 6 | int nc = mat[0].size(); 7 | (void) mat; 8 | (void) l; 9 | (void) c; 10 | (void) nl; 11 | (void) nc; 12 | // se estiver fora da matriz, retorne 13 | // se o elemento atual não for uma arvore, retorne 14 | // queime a arvore colocando o caractere 'o' na posição atual 15 | // chame a recursão para todos os 4 vizinhos 16 | } 17 | 18 | 19 | void show_mat(std::vector mat); 20 | void read_mat(std::vector &mat, int nl); 21 | 22 | int main(){ 23 | int nl = 0, nc = 0, lfire = 0, cfire = 0; 24 | std::cin >> nl >> nc >> lfire >> cfire; 25 | std::vector mat; 26 | read_mat(mat, nl); 27 | 28 | tocar_fogo(mat, lfire, cfire); 29 | show_mat(mat); 30 | } 31 | 32 | void show_mat(std::vector mat){ 33 | for(int l = 0; l < (int) mat.size(); l++) { 34 | std::cout << mat[l] << "\n"; 35 | } 36 | } 37 | 38 | void read_mat(std::vector &mat, int nl){ 39 | for(int l = 0; l < nl; l++) { 40 | std::string linha; 41 | std::cin >> linha; 42 | mat.push_back(linha); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /base/queimada/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | ) 8 | 9 | func tocarFogo(mat [][]rune, l, c int) { 10 | nl := len(mat) 11 | nc := len(mat[0]) 12 | _, _, _, _, _ = mat, l, c, nl, nc 13 | // se estiver fora da matriz, retorne 14 | // se o elemento atual não for uma arvore, retorne 15 | // queime a arvore colocando o caractere 'o' na posição atual 16 | // chame a recursão para todos os 4 vizinhos 17 | } 18 | 19 | func main() { 20 | scanner := bufio.NewScanner(os.Stdin) 21 | scanner.Scan() 22 | line := scanner.Text() 23 | var nl, nc, lfire, cfire int 24 | fmt.Sscanf(line, "%d %d %d %d", &nl, &nc, &lfire, &cfire) 25 | 26 | mat := make([][]rune, 0, nl) 27 | for range nl { 28 | scanner.Scan() 29 | linha := []rune(scanner.Text()) 30 | mat = append(mat, linha) 31 | } 32 | tocarFogo(mat, lfire, cfire) 33 | showMat(mat) 34 | } 35 | 36 | func showMat(mat [][]rune) { 37 | for _, linha := range mat { 38 | fmt.Println(string(linha)) 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /base/queimada/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/queimada/cover.jpg -------------------------------------------------------------------------------- /base/queimando/.cache/draft/go/pilha.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type Stack[T any] struct { 4 | data []T 5 | } 6 | 7 | func NewStack[T any]() *Stack[T] { 8 | return &Stack[T]{data: []T{}} 9 | } 10 | 11 | func (s *Stack[T]) Push(value T) { 12 | s.data = append(s.data, value) 13 | } 14 | 15 | func (s *Stack[T]) Top() *T { 16 | if len(s.data) == 0 { 17 | panic("stack is empty") 18 | } 19 | return &s.data[len(s.data)-1] 20 | } 21 | 22 | func (s *Stack[T]) IsEmpty() bool { 23 | return len(s.data) == 0 24 | } 25 | 26 | func (s *Stack[T]) Pop() { 27 | if s.IsEmpty() { 28 | panic("stack is empty") 29 | } 30 | s.data = s.data[:len(s.data)-1] 31 | } 32 | -------------------------------------------------------------------------------- /base/queimando/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/queimando/cover.jpg -------------------------------------------------------------------------------- /base/resto/.cache/draft/cpp/lib.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void process(int value) { 4 | if (value == 0) { 5 | return; 6 | } 7 | int div = value / 2; 8 | int resto = value % 2; 9 | process(div); 10 | std::cout << div << " " << resto << std::endl; 11 | (void) value; 12 | if (/* ponto de parada */) { 13 | ____return; 14 | } 15 | faz os calculos de div e resto 16 | chama a recursão para div 17 | imprime os valores depois da chamada recursiva 18 | } 19 | -------------------------------------------------------------------------------- /base/resto/.cache/draft/cpp/lib.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void process(int); 4 | -------------------------------------------------------------------------------- /base/resto/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "lib.h" 3 | 4 | int main() { 5 | int value {}; 6 | std::cin >> value; 7 | process(value); 8 | } 9 | -------------------------------------------------------------------------------- /base/resto/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 5 3 | ======== EXPECT 4 | 0 1 5 | 1 0 6 | 2 1 7 | <<<<<<<< FINISH 8 | 9 | 10 | >>>>>>>> INSERT 11 | 100 12 | ======== EXPECT 13 | 0 1 14 | 1 1 15 | 3 0 16 | 6 0 17 | 12 1 18 | 25 0 19 | 50 0 20 | <<<<<<<< FINISH 21 | 22 | 23 | >>>>>>>> INSERT 24 | 101 25 | ======== EXPECT 26 | 0 1 27 | 1 1 28 | 3 0 29 | 6 0 30 | 12 1 31 | 25 0 32 | 50 1 33 | <<<<<<<< FINISH 34 | 35 | 36 | >>>>>>>> INSERT 37 | 150 38 | ======== EXPECT 39 | 0 1 40 | 1 0 41 | 2 0 42 | 4 1 43 | 9 0 44 | 18 1 45 | 37 1 46 | 75 0 47 | <<<<<<<< FINISH 48 | 49 | -------------------------------------------------------------------------------- /base/resto/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/resto/cover.jpg -------------------------------------------------------------------------------- /base/rotacoes/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Rotacoes em uma lista 2 | 3 | ![_](https://raw.githubusercontent.com/qxcodeed/arcade/master/base/rotacoes/cover.jpg) 4 | 5 | Uma rotação desloca os elementos do vetor em uma determinada direção. Uma rotação à direita equivale a pegar o último elemento e inserir na primeira posição. 6 | 7 | Implemente a operação de rotação. Observe que calculando as posições finais corretamente você fará uma única operação de transposição das posições do vetor. 8 | 9 | - Entrada 10 | - Linha 1: tamanho do vetor `T` e número de elementos rotacionados `R` 11 | - Linha 2: elementos do vetor 12 | - Saída 13 | - Vetor rotacionado 14 | 15 | O custo do algorítmo deve ser O(N). 16 | 17 | ```txt 18 | >>>>>>>> 19 | 5 0 20 | 1 2 3 4 5 21 | ======== 22 | [ 1 2 3 4 5 ] 23 | <<<<<<<< 24 | 25 | >>>>>>>> 26 | 5 1 27 | 1 2 3 4 5 28 | ======== 29 | [ 5 1 2 3 4 ] 30 | <<<<<<<< 31 | 32 | >>>>>>>> 33 | 5 4 34 | 1 2 3 4 5 35 | ======== 36 | [ 2 3 4 5 1 ] 37 | <<<<<<<< 38 | 39 | >>>>>>>> 40 | 5 9 41 | 1 2 3 4 5 42 | ======== 43 | [ 2 3 4 5 1 ] 44 | <<<<<<<< 45 | 46 | 47 | ``` 48 | -------------------------------------------------------------------------------- /base/rotacoes/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 5 0 3 | 1 2 3 4 5 4 | ======== EXPECT 5 | [ 1 2 3 4 5 ] 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 10 | 5 1 11 | 1 2 3 4 5 12 | ======== EXPECT 13 | [ 5 1 2 3 4 ] 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 18 | 5 4 19 | 1 2 3 4 5 20 | ======== EXPECT 21 | [ 2 3 4 5 1 ] 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT 26 | 5 9 27 | 1 2 3 4 5 28 | ======== EXPECT 29 | [ 2 3 4 5 1 ] 30 | <<<<<<<< FINISH 31 | 32 | 33 | >>>>>>>> INSERT 34 | 5 5008 35 | 1 2 3 4 5 36 | ======== EXPECT 37 | [ 3 4 5 1 2 ] 38 | <<<<<<<< FINISH 39 | 40 | -------------------------------------------------------------------------------- /base/rotacoes/Readme.md: -------------------------------------------------------------------------------- 1 | # Rotacoes em uma lista 2 | 3 | ![_](cover.jpg) 4 | 5 | Uma rotação desloca os elementos do vetor em uma determinada direção. Uma rotação à direita equivale a pegar o último elemento e inserir na primeira posição. 6 | 7 | Implemente a operação de rotação. Observe que calculando as posições finais corretamente você fará uma única operação de transposição das posições do vetor. 8 | 9 | - Entrada 10 | - Linha 1: tamanho do vetor `T` e número de elementos rotacionados `R` 11 | - Linha 2: elementos do vetor 12 | - Saída 13 | - Vetor rotacionado 14 | 15 | O custo do algorítmo deve ser O(N). 16 | 17 | ```txt 18 | >>>>>>>> 19 | 5 0 20 | 1 2 3 4 5 21 | ======== 22 | [ 1 2 3 4 5 ] 23 | <<<<<<<< 24 | 25 | >>>>>>>> 26 | 5 1 27 | 1 2 3 4 5 28 | ======== 29 | [ 5 1 2 3 4 ] 30 | <<<<<<<< 31 | 32 | >>>>>>>> 33 | 5 4 34 | 1 2 3 4 5 35 | ======== 36 | [ 2 3 4 5 1 ] 37 | <<<<<<<< 38 | 39 | >>>>>>>> 40 | 5 9 41 | 1 2 3 4 5 42 | ======== 43 | [ 2 3 4 5 1 ] 44 | <<<<<<<< 45 | 46 | 47 | ``` 48 | -------------------------------------------------------------------------------- /base/rotacoes/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/rotacoes/cover.jpg -------------------------------------------------------------------------------- /base/rotacoes/student.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | void right_rotation(vector& vet, int nrot){ 6 | 7 | } 8 | 9 | void show(vector &vet) { 10 | cout << "[ "; 11 | for(int value : vet) 12 | cout << value << " "; 13 | cout << "]\n"; 14 | } 15 | 16 | int main(){ 17 | int size, nrot; 18 | cin >> size >> nrot; 19 | vector vet(size); 20 | for(int i = 0; i < size; i++) 21 | cin >> vet[i]; 22 | 23 | right_rotation(vet, nrot); 24 | show(vet); 25 | } 26 | 27 | -------------------------------------------------------------------------------- /base/rotacoes/t.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 2 | 5 5008 3 | 1 2 3 4 5 4 | ======== 5 | [ 3 4 5 1 2 ] 6 | <<<<<<<< -------------------------------------------------------------------------------- /base/santo/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # O milagre de ficar pobre 2 | 3 | Jota Marcelo estava pensando em um método para ficar rico. Ele entrou na igreja de Santo Antônio e disse: 4 | 5 | >>Santo Antônio, eu estou muito preocupado com os pobres, se você dobrar o dinheiro que eu estou no bolso, eu doarei X reais para os pobres. 6 | 7 | Quando ele saiu da igreja e olhou no bolso, o dinheiro tinha dobrado. Ele doou a parte que cabia aos pobres e voltou e em seguida, ele entrou em mais duas igrejas repetindo o processo. Quando ele saiu da terceira igreja, depois que doou o dinheiro que estava no bolso, ele estava com os bolsos vazios. 8 | 9 | Sua tarefa é descobrir com quanto de dinheiro ele entrou na primeira igreja. 10 | 11 | ## Entrada 12 | 13 | A entrada possui dois inteiros N e C, separado por um espaço, representando o número de igrejas que Jota Marcelo entrou e valor que seria doado para os pobres, respectivamente 14 | 15 | ## Saída 16 | 17 | Um inteiro representando a quantidade de dinheiro que Jota Marcelinho entrou na primeira igreja. 18 | 19 | ## Exemplo de Entrada 20 | 21 | ```txt 22 | 3 20 23 | ``` 24 | 25 | ## Exemplo de Saída 26 | 27 | ```txt 28 | 17.5 29 | ``` 30 | -------------------------------------------------------------------------------- /base/santo/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 3 20 3 | ======== EXPECT 4 | 17.50 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT 9 | 6 20 10 | ======== EXPECT 11 | 19.69 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT 16 | 6 10 17 | ======== EXPECT 18 | 9.84 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT 23 | 5 20 24 | ======== EXPECT 25 | 19.38 26 | <<<<<<<< FINISH 27 | 28 | -------------------------------------------------------------------------------- /base/santo/Readme.md: -------------------------------------------------------------------------------- 1 | # O milagre de ficar pobre 2 | 3 | Jota Marcelo estava pensando em um método para ficar rico. Ele entrou na igreja de Santo Antônio e disse: 4 | 5 | >>Santo Antônio, eu estou muito preocupado com os pobres, se você dobrar o dinheiro que eu estou no bolso, eu doarei X reais para os pobres. 6 | 7 | Quando ele saiu da igreja e olhou no bolso, o dinheiro tinha dobrado. Ele doou a parte que cabia aos pobres e voltou e em seguida, ele entrou em mais duas igrejas repetindo o processo. Quando ele saiu da terceira igreja, depois que doou o dinheiro que estava no bolso, ele estava com os bolsos vazios. 8 | 9 | Sua tarefa é descobrir com quanto de dinheiro ele entrou na primeira igreja. 10 | 11 | ## Entrada 12 | 13 | A entrada possui dois inteiros N e C, separado por um espaço, representando o número de igrejas que Jota Marcelo entrou e valor que seria doado para os pobres, respectivamente 14 | 15 | ## Saída 16 | 17 | Um inteiro representando a quantidade de dinheiro que Jota Marcelinho entrou na primeira igreja. 18 | 19 | ## Exemplo de Entrada 20 | 21 | ```txt 22 | 3 20 23 | ``` 24 | 25 | ## Exemplo de Saída 26 | 27 | ```txt 28 | 17.5 29 | ``` 30 | -------------------------------------------------------------------------------- /base/santo/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 2 | 3 20 3 | ======== 4 | 17.50 5 | <<<<<<<< 6 | 7 | >>>>>>>> 8 | 6 20 9 | ======== 10 | 19.69 11 | <<<<<<<< 12 | 13 | >>>>>>>> 14 | 6 10 15 | ======== 16 | 9.84 17 | <<<<<<<< 18 | 19 | >>>>>>>> 20 | 5 20 21 | ======== 22 | 19.38 23 | <<<<<<<< 24 | -------------------------------------------------------------------------------- /base/serial/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT um 2 | 4 # # 3 | ======== EXPECT 4 | [ 4 ] 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT dois 9 | 1 # 0 # # 10 | ======== EXPECT 11 | [ 1 0 ] 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT tres 16 | 4 # 8 2 # # # 17 | ======== EXPECT 18 | [ 4 2 8 ] 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT quatro 23 | 0 9 4 # # # 5 # # 24 | ======== EXPECT 25 | [ 4 9 0 5 ] 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT cinco 30 | 0 4 # # 2 0 # # 3 # # 31 | ======== EXPECT 32 | [ 4 0 0 2 3 ] 33 | <<<<<<<< FINISH 34 | 35 | 36 | >>>>>>>> INSERT seis 37 | 2 0 0 # # # 3 # 7 # 9 # # 38 | ======== EXPECT 39 | [ 0 0 2 3 7 9 ] 40 | <<<<<<<< FINISH 41 | 42 | 43 | >>>>>>>> INSERT dez 44 | 1 8 7 # # 4 # 6 # # 5 0 # # 9 # 3 2 # # # 45 | ======== EXPECT 46 | [ 7 8 4 6 1 0 5 9 2 3 ] 47 | <<<<<<<< FINISH 48 | 49 | -------------------------------------------------------------------------------- /base/serial/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/serial/cover.jpg -------------------------------------------------------------------------------- /base/setbuild/.cache/draft/go/extra.md: -------------------------------------------------------------------------------- 1 | # Vector 2 | 3 | ```ts 4 | class Set { 5 | - data: []int ' Guarda os elementos da lista ordenada 6 | - size: int ' Número atual de elementos na lista 7 | - capacity: int ' Capacidade alocada da lista (tamanho de data) 8 | -- 9 | + NewSet(): *Set ' Cria uma nova lista ordenada com capacidade inicial padrão 10 | - reserve(newCapacity: int): void ' Redimensiona a capacidade da lista se necessário (interno) 11 | - binarySearch(value: int): int ' Realiza busca binária e retorna o índice do valor, ou -1 se não for encontrado 12 | - insert(value: int, index: int): error ' Insere value no índice indicado, deslocando os elementos à direita 13 | - erase(index: int): error ' Remove o elemento na posição index, deslocando os demais 14 | -- 15 | + Insert(value: int): void ' Insere um valor na posição correta da lista, mantendo a ordem e sem duplicatas 16 | + Contains(value: int): bool ' Retorna true se o valor existir na lista, false caso contrário 17 | + Erase(value: int): bool ' Remove o valor da lista, se existir, e retorna true. Retorna false se não for encontrado 18 | + String(): string ' Retorna uma representação em string dos elementos da lista 19 | } 20 | ``` 21 | -------------------------------------------------------------------------------- /base/setbuild/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strings" 8 | ) 9 | 10 | func main() { 11 | var line, cmd string 12 | scanner := bufio.NewScanner(os.Stdin) 13 | 14 | // v := NewSet(0) 15 | for scanner.Scan() { 16 | fmt.Print("$") 17 | line = scanner.Text() 18 | fmt.Println(line) 19 | parts := strings.Fields(line) 20 | if len(parts) == 0 { 21 | continue 22 | } 23 | cmd = parts[0] 24 | 25 | switch cmd { 26 | case "end": 27 | return 28 | case "init": 29 | // value, _ := strconv.Atoi(parts[1]) 30 | // v = NewSet(value) 31 | case "insert": 32 | // for _, part := range parts[1:] { 33 | // value, _ := strconv.Atoi(part) 34 | // } 35 | case "show": 36 | case "erase": 37 | // value, _ := strconv.Atoi(parts[1]) 38 | case "contains": 39 | // value, _ := strconv.Atoi(parts[1]) 40 | case "clear": 41 | default: 42 | fmt.Println("fail: comando invalido") 43 | } 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /base/setbuild/.cache/draft/java/Main.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class Main { 3 | static Scanner scanner = new Scanner(System.in); 4 | public static void main(String[] args) { 5 | // Set set = new Set(0); 6 | 7 | while (true) { 8 | System.out.print("$"); 9 | String line = scanner.nextLine(); 10 | System.out.println(line); 11 | String[] parts = line.trim().split("\\s+"); 12 | if (parts.length == 0) continue; 13 | 14 | String cmd = parts[0]; 15 | 16 | if (cmd.equals("end")) { 17 | break; 18 | } else if (cmd.equals("init")) { 19 | // int capacity = Integer.parseInt(parts[1]); 20 | // set = new Set(capacity); 21 | } else if (cmd.equals("insert")) { 22 | // for (int i = 1; i < parts.length; i++) { 23 | // int val = Integer.parseInt(parts[i]); 24 | // } 25 | } else if (cmd.equals("show")) { 26 | } else if (cmd.equals("erase")) { 27 | // int valErase = Integer.parseInt(parts[1]); 28 | } else if (cmd.equals("contains")) { 29 | // int valCheck = Integer.parseInt(parts[1]); 30 | } else if (cmd.equals("clear")) { 31 | } else { 32 | System.out.println("comando invalido"); 33 | } 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /base/setbuild/.cache/draft/java/extra.md: -------------------------------------------------------------------------------- 1 | # Java Set 2 | 3 | ```ts 4 | class Set { 5 | - data: int[] ' Armazena os elementos da lista ordenada 6 | - size: int ' Número atual de elementos na lista 7 | - capacity: int ' Capacidade alocada da lista (tamanho de data) 8 | -- 9 | + Set(): Set ' Construtor: cria nova lista com capacidade inicial padrão 10 | - reserve(newCapacity: int): void ' Redimensiona a capacidade da lista se necessário (interno) 11 | - binarySearch(value: int): int ' Busca binária: retorna índice ou -1 se não encontrado 12 | - insertAt(value: int, index: int): void ' Insere value na posição indicada, deslocando à direita 13 | - eraseAt(index: int): void ' Remove o valor na posição indicada, deslocando os demais 14 | -- 15 | + insert(value: int): boolean ' Insere valor mantendo ordem e sem duplicatas 16 | + contains(value: int): boolean ' Retorna true se o valor existir na lista 17 | + erase(value: int): boolean ' Remove valor se existir e retorna true, senão false 18 | + toString(): String ' Representação em string dos elementos da lista 19 | } 20 | ``` 21 | -------------------------------------------------------------------------------- /base/setbuild/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT insert 2 | init 1 3 | show 4 | insert 3 5 | show 6 | insert 4 7 | show 8 | insert 5 9 | show 10 | insert 1 11 | show 12 | insert 2 13 | show 14 | insert 3 15 | show 16 | end 17 | ======== EXPECT 18 | $init 1 19 | $show 20 | [] 21 | $insert 3 22 | $show 23 | [3] 24 | $insert 4 25 | $show 26 | [3, 4] 27 | $insert 5 28 | $show 29 | [3, 4, 5] 30 | $insert 1 31 | $show 32 | [1, 3, 4, 5] 33 | $insert 2 34 | $show 35 | [1, 2, 3, 4, 5] 36 | $insert 3 37 | $show 38 | [1, 2, 3, 4, 5] 39 | $end 40 | <<<<<<<< FINISH 41 | 42 | 43 | >>>>>>>> INSERT contains 44 | init 10 45 | insert 10 2 8 12 6 46 | show 47 | contains 10 48 | contains 3 49 | end 50 | ======== EXPECT 51 | $init 10 52 | $insert 10 2 8 12 6 53 | $show 54 | [2, 6, 8, 10, 12] 55 | $contains 10 56 | true 57 | $contains 3 58 | false 59 | $end 60 | <<<<<<<< FINISH 61 | 62 | 63 | >>>>>>>> INSERT erase 64 | init 6 65 | insert 1 2 3 4 5 6 66 | show 67 | erase 3 68 | show 69 | erase 1 70 | show 71 | erase 8 72 | show 73 | end 74 | ======== EXPECT 75 | $init 6 76 | $insert 1 2 3 4 5 6 77 | $show 78 | [1, 2, 3, 4, 5, 6] 79 | $erase 3 80 | $show 81 | [1, 2, 4, 5, 6] 82 | $erase 1 83 | $show 84 | [2, 4, 5, 6] 85 | $erase 8 86 | value not found 87 | $show 88 | [2, 4, 5, 6] 89 | $end 90 | <<<<<<<< FINISH 91 | 92 | -------------------------------------------------------------------------------- /base/setbuild/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/setbuild/cover.jpg -------------------------------------------------------------------------------- /base/soma/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 01 um 2 | 4 # # 3 | ======== EXPECT 4 | 4 4 5 | <<<<<<<< FINISH 6 | 7 | 8 | >>>>>>>> INSERT 02 dois 9 | 1 # 0 # # 10 | ======== EXPECT 11 | 1 0 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT 03 tres 16 | 4 # 8 2 # # # 17 | ======== EXPECT 18 | 14 2 19 | <<<<<<<< FINISH 20 | 21 | 22 | >>>>>>>> INSERT 04 quatro 23 | 0 9 4 # # # 5 # # 24 | ======== EXPECT 25 | 18 0 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT 05 cinco 30 | 0 4 # # 2 0 # # -3 # # 31 | ======== EXPECT 32 | 3 -3 33 | <<<<<<<< FINISH 34 | 35 | 36 | >>>>>>>> INSERT 06 seis 37 | 2 0 5 # # # 3 # 7 # -9 # # 38 | ======== EXPECT 39 | 8 -9 40 | <<<<<<<< FINISH 41 | 42 | 43 | >>>>>>>> INSERT 07 dez 44 | 1 8 7 # # 4 # 6 # # 5 0 # # 9 # 3 2 # # # 45 | ======== EXPECT 46 | 45 0 47 | <<<<<<<< FINISH 48 | 49 | -------------------------------------------------------------------------------- /base/soma/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/soma/cover.jpg -------------------------------------------------------------------------------- /base/sudoku/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 4 3 | 1.3. 4 | 2... 5 | ...4 6 | .1.. 7 | ======== EXPECT 8 | 1432 9 | 2341 10 | 3214 11 | 4123 12 | <<<<<<<< FINISH 13 | 14 | 15 | >>>>>>>> INSERT 16 | 4 17 | ..2. 18 | .1.. 19 | ..4. 20 | .3.. 21 | ======== EXPECT 22 | 3421 23 | 2134 24 | 1243 25 | 4312 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT 30 | 4 31 | .... 32 | .2.1 33 | 1.3. 34 | .... 35 | ======== EXPECT 36 | 4123 37 | 3241 38 | 1432 39 | 2314 40 | <<<<<<<< FINISH 41 | 42 | 43 | >>>>>>>> INSERT 44 | 4 45 | .... 46 | 3.2. 47 | .1.4 48 | .... 49 | ======== EXPECT 50 | 1243 51 | 3421 52 | 2134 53 | 4312 54 | <<<<<<<< FINISH 55 | 56 | 57 | >>>>>>>> INSERT 58 | 9 59 | 53..7.... 60 | 6..195... 61 | .98....6. 62 | 8...6...3 63 | 4..8.3..1 64 | 7...2...6 65 | .6....28. 66 | ...419..5 67 | ....8..79 68 | ======== EXPECT 69 | 534678912 70 | 672195348 71 | 198342567 72 | 859761423 73 | 426853791 74 | 713924856 75 | 961537284 76 | 287419635 77 | 345286179 78 | <<<<<<<< FINISH 79 | 80 | -------------------------------------------------------------------------------- /base/sudoku/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/sudoku/cover.jpg -------------------------------------------------------------------------------- /base/tapioca/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | //Realiza as viradas na pilha de tapiocas 5 | void flip(std::vector& tapiocas, int i) { 6 | (void) tapiocas; 7 | (void) i; 8 | } 9 | 10 | //Retorna o indice do maior elemento da sequência 11 | int findMax(std::vector& tapiocas, int n) { 12 | (void) tapiocas; 13 | (void) n; 14 | return 0; 15 | } 16 | 17 | std::vector tapiocaSort(std::vector& tapiocas, int n) { 18 | (void) tapiocas; 19 | (void) n; 20 | return std::vector {}; 21 | } 22 | 23 | int main() { 24 | int n; 25 | std::cin >> n; 26 | std::vector tapiocas(n); 27 | for (int i = 0; i < n; i++) { 28 | std::cin >> tapiocas[i]; 29 | } 30 | std::vector viradas = tapiocaSort(tapiocas, n); 31 | 32 | for (int i = 0; i < (int) viradas.size(); i++){ 33 | if(i != 0) { 34 | std:: cout << " "; 35 | } 36 | std::cout << viradas[i]; 37 | } 38 | std::cout << std::endl; 39 | 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /base/tapioca/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 5 3 | 5 1 2 3 4 4 | ======== EXPECT 5 | 1 2 0 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 10 | 5 11 | 5 4 3 2 1 12 | ======== EXPECT 13 | 1 0 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 18 | 5 19 | 1 2 3 4 5 20 | ======== EXPECT 21 | 0 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT 26 | 5 27 | 5 1 2 3 4 28 | ======== EXPECT 29 | 1 2 0 30 | <<<<<<<< FINISH 31 | 32 | 33 | >>>>>>>> INSERT 34 | 8 35 | 7 1 6 5 3 4 8 2 36 | ======== EXPECT 37 | 2 1 7 2 5 3 6 5 6 0 38 | <<<<<<<< FINISH 39 | 40 | 41 | >>>>>>>> INSERT 42 | 6 43 | 5 3 6 2 1 4 44 | ======== EXPECT 45 | 4 1 3 2 5 3 5 0 46 | <<<<<<<< FINISH 47 | 48 | -------------------------------------------------------------------------------- /base/tapioca/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 2 | 5 3 | 1 2 3 4 5 4 | ======== 5 | 0 6 | <<<<<<<< 7 | 8 | 9 | >>>>>>>> 10 | 5 11 | 5 4 3 2 1 12 | ======== 13 | 1 0 14 | <<<<<<<< 15 | 16 | >>>>>>>> 17 | 5 18 | 5 1 2 3 4 19 | ======== 20 | 1 2 0 21 | <<<<<<<< 22 | 23 | >>>>>>>> 24 | 8 25 | 7 1 6 5 3 4 8 2 26 | ======== 27 | 2 1 7 2 5 3 6 5 6 0 28 | <<<<<<<< 29 | 30 | 31 | >>>>>>>> 32 | 6 33 | 5 3 6 2 1 4 34 | ======== 35 | 4 1 3 2 5 3 5 0 36 | <<<<<<<< 37 | -------------------------------------------------------------------------------- /base/treinando/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/treinando/cover.jpg -------------------------------------------------------------------------------- /base/triangulo/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void processa(std::vector vet); 6 | 7 | int main(){ 8 | std::string line; 9 | std::getline(std::cin, line); 10 | std::stringstream ss(line); 11 | std::vector vet; 12 | int value {}; 13 | while(ss >> value) { 14 | vet.push_back(value); 15 | } 16 | processa(vet); 17 | } 18 | -------------------------------------------------------------------------------- /base/triangulo/.cache/draft/cpp/user.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | void processa(std::vector vet){ 6 | (void) vet; 7 | // 1. defina o ponto de parada 8 | // 2. monte o vetor auxiliar com os resultados das somas 9 | // 3. chame recursivamente a função processa para o vetor auxiliar 10 | // 4. imprima o vetor original 11 | } 12 | -------------------------------------------------------------------------------- /base/triangulo/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strconv" 8 | "strings" 9 | ) 10 | 11 | func processa(vet []int) { 12 | _ = vet; 13 | // 1. defina o ponto de parada 14 | // 2. monte o vetor auxiliar com os resultados das somas 15 | // 3. chame recursivamente a função processa para o vetor auxiliar 16 | // 4. imprima o vetor original 17 | } 18 | 19 | func main() { 20 | scanner := bufio.NewScanner(os.Stdin) 21 | if !scanner.Scan() { 22 | return 23 | } 24 | line := scanner.Text() 25 | parts := strings.Fields(line) 26 | vet := []int{} 27 | for _, part := range parts { 28 | if value, err := strconv.Atoi(part); err == nil { 29 | vet = append(vet, value) 30 | } 31 | } 32 | processa(vet) 33 | } 34 | 35 | func Join[T any](v []T, sep string) string { 36 | if len(v) == 0 { 37 | return "" 38 | } 39 | s := "" 40 | for i, x := range v { 41 | if i > 0 { 42 | s += sep 43 | } 44 | s += fmt.Sprintf("%v", x) 45 | } 46 | return s 47 | } 48 | -------------------------------------------------------------------------------- /base/triangulo/.cache/draft/py/main.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | from typing import List 3 | 4 | def processa(vet: List[int]) -> None: 5 | if len(vet) == 0: 6 | return 7 | aux: List[int] = [] 8 | for i in range(len(vet) - 1): 9 | aux.append(vet[i] + vet[i + 1]) 10 | processa(aux) 11 | out = [str(x) for x in vet] 12 | print("[ {} ]".format(" ".join(out))) 13 | # $$ 14 | # pass 15 | # == 16 | # 1. defina o ponto de parada 17 | # 2. monte o vetor auxiliar com os resultados das somas 18 | # 3. chame recursivamente a função processa para o vetor auxiliar 19 | # 4. imprima o vetor original 20 | 21 | 22 | def main(): 23 | line = input().split(" ") 24 | vet = [int(x) for x in line] 25 | processa(vet) 26 | 27 | if __name__ == "__main__": 28 | main() 29 | -------------------------------------------------------------------------------- /base/triangulo/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 01 2 | 1 2 3 3 | ======== EXPECT 4 | [ 8 ] 5 | [ 3 5 ] 6 | [ 1 2 3 ] 7 | <<<<<<<< FINISH 8 | 9 | 10 | >>>>>>>> INSERT 02 11 | 3 2 1 12 | ======== EXPECT 13 | [ 8 ] 14 | [ 5 3 ] 15 | [ 3 2 1 ] 16 | <<<<<<<< FINISH 17 | 18 | 19 | >>>>>>>> INSERT 03 20 | 4 3 2 1 21 | ======== EXPECT 22 | [ 20 ] 23 | [ 12 8 ] 24 | [ 7 5 3 ] 25 | [ 4 3 2 1 ] 26 | <<<<<<<< FINISH 27 | 28 | 29 | >>>>>>>> INSERT 04 30 | 1 1 2 3 5 8 31 | ======== EXPECT 32 | [ 89 ] 33 | [ 34 55 ] 34 | [ 13 21 34 ] 35 | [ 5 8 13 21 ] 36 | [ 2 3 5 8 13 ] 37 | [ 1 1 2 3 5 8 ] 38 | <<<<<<<< FINISH 39 | 40 | 41 | >>>>>>>> INSERT 42 | 1 2 4 8 16 32 64 43 | ======== EXPECT 44 | [ 729 ] 45 | [ 243 486 ] 46 | [ 81 162 324 ] 47 | [ 27 54 108 216 ] 48 | [ 9 18 36 72 144 ] 49 | [ 3 6 12 24 48 96 ] 50 | [ 1 2 4 8 16 32 64 ] 51 | <<<<<<<< FINISH 52 | 53 | -------------------------------------------------------------------------------- /base/triangulo/Readme.md: -------------------------------------------------------------------------------- 1 | # Imprimindo ao contrário 2 | 3 | ![_](cover.jpg) 4 | 5 | Dado um vetor de inteiros A, imprima um triângulo de números tal que na base do triângulo estejam todos os elementos do vetor original, e tal que, a cada i-ésimo nível acima da base, o número de elementos seja um a menos que no nível inferior e cada elemento do i-ésimo nível seja a soma de dois elementos consecutivos do nível inferior. 6 | 7 | - Entrada 8 | - Os elementos da base. 9 | - Saída 10 | - O triângulo. 11 | 12 | ## Dica 13 | 14 | Veja a resolução da atividade "Empilhamento da Recursão" para entender como funciona a impressão de trás pra frente. 15 | 16 | ## Arquivos 17 | 18 | Você deve implementar a função `processa` no arquivo `lib.cpp`. 19 | 20 | 21 | - cpp 22 | - [main.cpp](.cache/draft/cpp/main.cpp) 23 | - [user.cpp](.cache/draft/cpp/user.cpp) 24 | - go 25 | - [main.go](.cache/draft/go/main.go) 26 | - py 27 | - [main.py](.cache/draft/py/main.py) 28 | 29 | 30 | ## Testes 31 | 32 | ```txt 33 | 34 | >>>>>>>> 01 35 | 1 2 3 36 | ======== 37 | [ 8 ] 38 | [ 3 5 ] 39 | [ 1 2 3 ] 40 | <<<<<<<< 41 | 42 | >>>>>>>> 02 43 | 3 2 1 44 | ======== 45 | [ 8 ] 46 | [ 5 3 ] 47 | [ 3 2 1 ] 48 | <<<<<<<< 49 | 50 | >>>>>>>> 03 51 | 4 3 2 1 52 | ======== 53 | [ 20 ] 54 | [ 12 8 ] 55 | [ 7 5 3 ] 56 | [ 4 3 2 1 ] 57 | <<<<<<<< 58 | 59 | >>>>>>>> 04 60 | 1 1 2 3 5 8 61 | ======== 62 | [ 89 ] 63 | [ 34 55 ] 64 | [ 13 21 34 ] 65 | [ 5 8 13 21 ] 66 | [ 2 3 5 8 13 ] 67 | [ 1 1 2 3 5 8 ] 68 | <<<<<<<< 69 | 70 | ``` 71 | -------------------------------------------------------------------------------- /base/triangulo/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/triangulo/cover.jpg -------------------------------------------------------------------------------- /base/triangulo/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 2 | 1 2 4 8 16 32 64 3 | ======== 4 | [ 729 ] 5 | [ 243 486 ] 6 | [ 81 162 324 ] 7 | [ 27 54 108 216 ] 8 | [ 9 18 36 72 144 ] 9 | [ 3 6 12 24 48 96 ] 10 | [ 1 2 4 8 16 32 64 ] 11 | <<<<<<<< 12 | -------------------------------------------------------------------------------- /base/vacina/.cache/draft/cpp/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | //Escolha e implemente um algoritmo de ordenação 5 | void ordenar(std::vector& arr) { 6 | (void) arr; 7 | } 8 | 9 | void vacinou(std::vector& vacinas, std::vector& pacientes){ 10 | (void) vacinas; 11 | (void) pacientes; 12 | } 13 | 14 | int main(){ 15 | int n; 16 | std::cin >> n; 17 | 18 | std::vector vacinas(n); 19 | for (int i = 0; i < n; i++) { 20 | std::cin >> vacinas[i]; 21 | } 22 | 23 | std::vector pacientes(n); 24 | for (int i = 0; i < n; i++) { 25 | std::cin >> pacientes[i]; 26 | } 27 | 28 | ordenar(vacinas); 29 | ordenar(pacientes); 30 | 31 | vacinou(vacinas, pacientes); 32 | } 33 | -------------------------------------------------------------------------------- /base/vacina/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | 5 3 | 123 146 454 542 456 4 | 100 328 248 689 200 5 | ======== EXPECT 6 | No 7 | <<<<<<<< FINISH 8 | 9 | 10 | >>>>>>>> INSERT 11 | 5 12 | 123 690 454 150 456 13 | 100 328 248 689 145 14 | ======== EXPECT 15 | Yes 16 | <<<<<<<< FINISH 17 | 18 | 19 | >>>>>>>> INSERT 20 | 5 21 | 10 61 55 88 17 22 | 15 76 21 73 19 23 | ======== EXPECT 24 | No 25 | <<<<<<<< FINISH 26 | 27 | -------------------------------------------------------------------------------- /base/vacina/testes.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> 2 | 5 3 | 10 61 55 88 17 4 | 15 76 21 73 19 5 | ======== 6 | No 7 | <<<<<<<< 8 | 9 | >>>>>>>> 10 | 5 11 | 123 146 454 542 456 12 | 100 328 248 689 200 13 | ======== 14 | No 15 | <<<<<<<< 16 | 17 | >>>>>>>> 18 | 5 19 | 123 690 454 150 456 20 | 100 328 248 689 145 21 | ======== 22 | Yes 23 | <<<<<<<< -------------------------------------------------------------------------------- /base/vetbuild/cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/base/vetbuild/cover.jpg -------------------------------------------------------------------------------- /base/vetequals/.cache/Readme.md: -------------------------------------------------------------------------------- 1 | # Verifique se dois vetores são iguais recursivamente 2 | 3 | Este documento descreve um método para verificar se dois vetores são iguais de forma recursiva. 4 | 5 | Você não deve usar laço, nem len ou size para verificar o tamanho dos vetores. 6 | 7 | ## Entrada 8 | 9 | - 1a linha: valores do primeiro vetor separados por espaço entre colchetes 10 | - 2a linha: valores do segundo vetor separados por espaço entre colchetes 11 | 12 | ## Saída 13 | 14 | - "iguais" se os vetores forem iguais 15 | - "diferentes" se os vetores forem diferentes 16 | 17 | ## Testes 18 | 19 | ```txt 20 | 21 | >>>>>>>> 22 | [ ] 23 | [ ] 24 | ======== 25 | iguais 26 | <<<<<<<< 27 | ``` 28 | 29 | ```txt 30 | >>>>>>>> 31 | [ 1 ] 32 | [ 1 ] 33 | ======== 34 | iguais 35 | <<<<<<<< 36 | ``` 37 | 38 | ```txt 39 | >>>>>>>> 40 | [ 1 ] 41 | [ 1 2 ] 42 | ======== 43 | diferentes 44 | <<<<<<<< 45 | 46 | >>>>>>>> 47 | [ 1 2 ] 48 | [ 1 ] 49 | ======== 50 | diferentes 51 | <<<<<<<< 52 | 53 | >>>>>>>> 54 | [ 2 1 ] 55 | [ 1 ] 56 | ======== 57 | diferentes 58 | <<<<<<<< 59 | 60 | >>>>>>>> 61 | [ 1 ] 62 | [ 2 1 ] 63 | ======== 64 | diferentes 65 | <<<<<<<< 66 | 67 | >>>>>>>> 68 | [ 1 3 ] 69 | [ 2 1 ] 70 | ======== 71 | diferentes 72 | <<<<<<<< 73 | 74 | >>>>>>>> 75 | [ 3 1 ] 76 | [ 2 1 ] 77 | ======== 78 | diferentes 79 | <<<<<<<< 80 | 81 | >>>>>>>> 82 | [ 1 2 3 ] 83 | [ 1 2 3 ] 84 | ======== 85 | iguais 86 | <<<<<<<< 87 | 88 | >>>>>>>> 89 | [ 1 2 3 4 ] 90 | [ 1 2 3 ] 91 | ======== 92 | diferentes 93 | <<<<<<<< 94 | ``` 95 | -------------------------------------------------------------------------------- /base/vetequals/.cache/draft/go/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "fmt" 6 | "os" 7 | "strconv" 8 | "strings" 9 | ) 10 | 11 | func EhVazio(vet []int) bool { 12 | return fmt.Sprint(vet) == "[]" 13 | } 14 | 15 | // não altere a assinatura 16 | func equals(a []int, b []int) bool { 17 | // não use a função len para ver ou comparar os tamanhos 18 | // utilize a função EhVazio para ver se o vetor é vazio 19 | // você só pode consultar o primeiro elemento do vetor 20 | // e não pode usar nenhum tipo de laço 21 | // Use recursao para consultar os outros elementos equals(a[1:], b[1:]) 22 | // não altere o protótipo da função nem crie funções auxiliares 23 | _, _ = a, b 24 | return false 25 | } 26 | 27 | func main() { 28 | scanner := bufio.NewScanner(os.Stdin) 29 | 30 | scanner.Scan() 31 | vet1 := str2slice(scanner.Text()) 32 | scanner.Scan() 33 | vet2 := str2slice(scanner.Text()) 34 | if equals(vet1, vet2) { 35 | fmt.Println("iguais") 36 | } else { 37 | fmt.Println("diferentes") 38 | } 39 | } 40 | 41 | func str2slice(line string) []int { 42 | parts := strings.Fields(line) 43 | nums := make([]int, 0) 44 | for i := 1; i < len(parts)-1; i++ { 45 | value, _ := strconv.Atoi(parts[i]) 46 | nums = append(nums, value) 47 | } 48 | return nums 49 | } 50 | -------------------------------------------------------------------------------- /base/vetequals/.cache/q.tio: -------------------------------------------------------------------------------- 1 | >>>>>>>> INSERT 2 | [ ] 3 | [ ] 4 | ======== EXPECT 5 | iguais 6 | <<<<<<<< FINISH 7 | 8 | 9 | >>>>>>>> INSERT 10 | [ 1 ] 11 | [ 1 ] 12 | ======== EXPECT 13 | iguais 14 | <<<<<<<< FINISH 15 | 16 | 17 | >>>>>>>> INSERT 18 | [ 1 ] 19 | [ 1 2 ] 20 | ======== EXPECT 21 | diferentes 22 | <<<<<<<< FINISH 23 | 24 | 25 | >>>>>>>> INSERT 26 | [ 1 2 ] 27 | [ 1 ] 28 | ======== EXPECT 29 | diferentes 30 | <<<<<<<< FINISH 31 | 32 | 33 | >>>>>>>> INSERT 34 | [ 2 1 ] 35 | [ 1 ] 36 | ======== EXPECT 37 | diferentes 38 | <<<<<<<< FINISH 39 | 40 | 41 | >>>>>>>> INSERT 42 | [ 1 ] 43 | [ 2 1 ] 44 | ======== EXPECT 45 | diferentes 46 | <<<<<<<< FINISH 47 | 48 | 49 | >>>>>>>> INSERT 50 | [ 1 3 ] 51 | [ 2 1 ] 52 | ======== EXPECT 53 | diferentes 54 | <<<<<<<< FINISH 55 | 56 | 57 | >>>>>>>> INSERT 58 | [ 3 1 ] 59 | [ 2 1 ] 60 | ======== EXPECT 61 | diferentes 62 | <<<<<<<< FINISH 63 | 64 | 65 | >>>>>>>> INSERT 66 | [ 1 2 3 ] 67 | [ 1 2 3 ] 68 | ======== EXPECT 69 | iguais 70 | <<<<<<<< FINISH 71 | 72 | 73 | >>>>>>>> INSERT 74 | [ 1 2 3 4 ] 75 | [ 1 2 3 ] 76 | ======== EXPECT 77 | diferentes 78 | <<<<<<<< FINISH 79 | 80 | -------------------------------------------------------------------------------- /base/vetequals/Readme.md: -------------------------------------------------------------------------------- 1 | # Verifique se dois vetores são iguais recursivamente 2 | 3 | Este documento descreve um método para verificar se dois vetores são iguais de forma recursiva. 4 | 5 | Você não deve usar laço, nem len ou size para verificar o tamanho dos vetores. 6 | 7 | ## Entrada 8 | 9 | - 1a linha: valores do primeiro vetor separados por espaço entre colchetes 10 | - 2a linha: valores do segundo vetor separados por espaço entre colchetes 11 | 12 | ## Saída 13 | 14 | - "iguais" se os vetores forem iguais 15 | - "diferentes" se os vetores forem diferentes 16 | 17 | ## Testes 18 | 19 | ```txt 20 | 21 | >>>>>>>> 22 | [ ] 23 | [ ] 24 | ======== 25 | iguais 26 | <<<<<<<< 27 | ``` 28 | 29 | ```txt 30 | >>>>>>>> 31 | [ 1 ] 32 | [ 1 ] 33 | ======== 34 | iguais 35 | <<<<<<<< 36 | ``` 37 | 38 | ```txt 39 | >>>>>>>> 40 | [ 1 ] 41 | [ 1 2 ] 42 | ======== 43 | diferentes 44 | <<<<<<<< 45 | 46 | >>>>>>>> 47 | [ 1 2 ] 48 | [ 1 ] 49 | ======== 50 | diferentes 51 | <<<<<<<< 52 | 53 | >>>>>>>> 54 | [ 2 1 ] 55 | [ 1 ] 56 | ======== 57 | diferentes 58 | <<<<<<<< 59 | 60 | >>>>>>>> 61 | [ 1 ] 62 | [ 2 1 ] 63 | ======== 64 | diferentes 65 | <<<<<<<< 66 | 67 | >>>>>>>> 68 | [ 1 3 ] 69 | [ 2 1 ] 70 | ======== 71 | diferentes 72 | <<<<<<<< 73 | 74 | >>>>>>>> 75 | [ 3 1 ] 76 | [ 2 1 ] 77 | ======== 78 | diferentes 79 | <<<<<<<< 80 | 81 | >>>>>>>> 82 | [ 1 2 3 ] 83 | [ 1 2 3 ] 84 | ======== 85 | iguais 86 | <<<<<<<< 87 | 88 | >>>>>>>> 89 | [ 1 2 3 4 ] 90 | [ 1 2 3 ] 91 | ======== 92 | diferentes 93 | <<<<<<<< 94 | ``` 95 | -------------------------------------------------------------------------------- /wiki/analise/grafico-comparacao.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/analise/grafico-comparacao.png -------------------------------------------------------------------------------- /wiki/busca_ordenacao/assets/BubbleSort.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/busca_ordenacao/assets/BubbleSort.gif -------------------------------------------------------------------------------- /wiki/busca_ordenacao/assets/InsertionSort.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/busca_ordenacao/assets/InsertionSort.gif -------------------------------------------------------------------------------- /wiki/busca_ordenacao/assets/SelectionSort.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/busca_ordenacao/assets/SelectionSort.gif -------------------------------------------------------------------------------- /wiki/busca_ordenacao/assets/binarySearch.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/busca_ordenacao/assets/binarySearch.webp -------------------------------------------------------------------------------- /wiki/busca_ordenacao/assets/cartasNaMão.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/busca_ordenacao/assets/cartasNaMão.png -------------------------------------------------------------------------------- /wiki/busca_ordenacao/assets/linearSearch.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/busca_ordenacao/assets/linearSearch.webp -------------------------------------------------------------------------------- /wiki/busca_ordenacao/assets/vetorOrdenado.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/busca_ordenacao/assets/vetorOrdenado.png -------------------------------------------------------------------------------- /wiki/images/play.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/images/play.png -------------------------------------------------------------------------------- /wiki/objetivos_intro.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /wiki/ordenacao_recursiva/assets/merge.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/ordenacao_recursiva/assets/merge.gif -------------------------------------------------------------------------------- /wiki/ordenacao_recursiva/assets/quick.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | // Função para trocar dois elementos 5 | void swap(int& a, int& b) { 6 | int temp = a; 7 | a = b; 8 | b = temp; 9 | } 10 | 11 | // Função para particionar o vetor 12 | int partition(std::vector& arr, int low, int high) { 13 | int pivot = arr[high]; // Escolhe o último elemento como pivô 14 | int i = (low - 1); // Índice do menor elemento 15 | 16 | for (int j = low; j <= high - 1; j++) { 17 | if (arr[j] < pivot) { 18 | i++; 19 | swap(arr[i], arr[j]); 20 | } 21 | } 22 | swap(arr[i + 1], arr[high]); 23 | return (i + 1); 24 | } 25 | 26 | // Função principal do QuickSort 27 | void quickSort(std::vector& arr, int low, int high) { 28 | if (low < high) { 29 | int pi = partition(arr, low, high); 30 | 31 | // Recursivamente ordena os elementos antes e depois do pivô 32 | quickSort(arr, low, pi - 1); 33 | quickSort(arr, pi + 1, high); 34 | } 35 | } 36 | 37 | int main() { 38 | std::vector arr = {12, 11, 13, 5, 6, 7}; 39 | int n = arr.size(); 40 | 41 | std::cout << "Vetor original: "; 42 | for (int i = 0; i < n; i++) { 43 | std::cout << arr[i] << " "; 44 | } 45 | std::cout << std::endl; 46 | 47 | quickSort(arr, 0, n - 1); 48 | 49 | std::cout << "Vetor ordenado: "; 50 | for (int i = 0; i < n; i++) { 51 | std::cout << arr[i] << " "; 52 | } 53 | std::cout << std::endl; 54 | 55 | return 0; 56 | } 57 | -------------------------------------------------------------------------------- /wiki/ordenacao_recursiva/assets/quick.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/ordenacao_recursiva/assets/quick.gif -------------------------------------------------------------------------------- /wiki/recursao/boneca.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qxcodeed/arcade/47809a0315d108be1c610b354d1142e60f4df8bb/wiki/recursao/boneca.jpeg -------------------------------------------------------------------------------- /wiki/tad/imprimindo.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class Foo { 5 | int value = 10; 6 | float f = 3.14; 7 | 8 | public: 9 | // sugestão de criar um método str() para converter o objeto em string 10 | std::string str() const { 11 | std::ostringstream ss; //crie a saida dos seus dados 12 | ss << "value: " << value << ", f: " << f; 13 | return ss.str(); 14 | } 15 | }; 16 | 17 | // ensine o ostream a imprimir Foo 18 | std::ostream& operator<<(std::ostream& os, const Foo& foo) { 19 | return os << foo.str(); 20 | } 21 | 22 | int main() { 23 | Foo f; 24 | std::cout << f.str() << '\n'; // convertendo manualmente 25 | std::cout << f << '\n'; // usando o operador << 26 | } 27 | -------------------------------------------------------------------------------- /wiki/tad/sobrecarga_operadores.md: -------------------------------------------------------------------------------- 1 | # Sobrecarga de operadores de classes 2 | 3 | ## Imprimindo um classe usando operator<< 4 | 5 | 6 | 7 | ```cpp 8 | #include 9 | #include 10 | 11 | class Foo { 12 | int value = 10; 13 | float f = 3.14; 14 | 15 | public: 16 | // sugestão de criar um método str() para converter o objeto em string 17 | std::string str() const { 18 | std::ostringstream ss; //crie a saida dos seus dados 19 | ss << "value: " << value << ", f: " << f; 20 | return ss.str(); 21 | } 22 | }; 23 | 24 | // ensine o ostream a imprimir Foo 25 | std::ostream& operator<<(std::ostream& os, const Foo& foo) { 26 | return os << foo.str(); 27 | } 28 | 29 | int main() { 30 | Foo f; 31 | std::cout << f.str() << '\n'; // convertendo manualmente 32 | std::cout << f << '\n'; // usando o operador << 33 | } 34 | ``` 35 | 36 | -------------------------------------------------------------------------------- /wiki/tad/tad.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class Foo { 4 | 5 | int x; 6 | 7 | 8 | public: 9 | 10 | Foo(int value = 0) { 11 | x = value; 12 | } 13 | 14 | // esse método é chamado quando posso alterar o objeto 15 | int& getX() { 16 | std::cout << "obtendo por referencia\n"; 17 | return x; 18 | } 19 | 20 | // esse método é chamado quando não posso alterar o objeto 21 | int getX() const { 22 | std::cout << "obtendo por valor\n"; 23 | return x; 24 | } 25 | }; 26 | 27 | int main() { 28 | Foo f(5); 29 | f.getX() = 10; // chama o método int& getX() 30 | std::cout << f.getX() << '\n'; // 10 31 | 32 | const Foo f2(5); 33 | // f2.getX() = 10; // erro de compilação 34 | std::cout << f2.getX() << '\n'; // 5 35 | } 36 | --------------------------------------------------------------------------------