├── 0-cheque ├── cheque.py └── test.py ├── 1-intervalos ├── README.md ├── main.py └── test.py ├── 10-buraco-nas-letras ├── README.md ├── __pycache__ │ └── main.cpython-310.pyc ├── main.py └── test.py ├── 11-array-TW └── javascript │ ├── .gitignore │ ├── instalacoes.md │ ├── package-lock.json │ ├── package.json │ └── src │ └── estudantes │ ├── estudantes.todo │ ├── feedback.md │ ├── intervalos.js │ └── intervalos.test.js ├── 12-desafio ├── README.md ├── main.py ├── main2.py └── test.py ├── 13-escrevendo-celular ├── main.py ├── problema.md └── tests │ ├── __init__.py │ └── test_main.py ├── 2-cheque-por-extenso ├── main.py ├── retro.md └── test.py ├── 3-caixa-eletronico ├── main.py ├── retro.md └── test.py ├── 4-unknown ├── __pycache__ │ └── main.cpython-311.pyc ├── main.py ├── retro.md └── test.py ├── 6-mictorios ├── Feedback.md ├── __pycache__ │ └── main.cpython-311.pyc ├── main.py ├── mijoes.todo ├── retro.md └── test.py ├── 7-palavras-primas ├── .gitignore ├── instalacoes.md ├── package-lock.json ├── package.json └── src │ ├── index.js │ ├── index.test.js │ ├── palavras-primas.todo │ └── retro.md ├── 8-algarismos-romanos ├── README.MD ├── main.py └── test.py ├── 9-sequencia-de-cinco ├── README.md ├── main.py └── test.py ├── Makefile ├── README.md ├── ambientes └── javascript │ ├── .gitignore │ ├── instalacoes.md │ ├── package-lock.json │ ├── package.json │ └── src │ └── estudantes │ ├── estudantes.js │ ├── estudantes.test.js │ └── estudantes.todo ├── cheque └── cheque.pyc └── setup_tests ├── README.md └── setup_python.py /0-cheque/cheque.py: -------------------------------------------------------------------------------- 1 | # coding: utf-8 2 | from decimal import Decimal 3 | from operator import mul 4 | 5 | labels = { 6 | 'zero': 0, 7 | 'um': 1, 8 | 'dois': 2, 9 | 'três': 3, 10 | 'quatro': 4, 11 | 'cinco': 5, 12 | 'seis': 6, 13 | 'sete': 7, 14 | 'oito': 8, 15 | 'nove': 9, 16 | 'dez': 10, 17 | 'onze': 11, 18 | 'doze': 12, 19 | 'treze': 13, 20 | 'quatorze': 14, 21 | 'catorze': 14, 22 | 'quinze': 15, 23 | 'dezesseis': 16, 24 | 'dezessete': 17, 25 | 'dezoito': 18, 26 | 'dezenove': 19, 27 | 'vinte': 20, 28 | 'trinta': 30, 29 | 'quarenta': 40, 30 | 'cinquenta': 50, 31 | 'sessenta': 60, 32 | 'setenta': 70, 33 | 'oitenta': 80, 34 | 'noventa': 90, 35 | 'cem': 100, 36 | 'cento': 100, 37 | 'duzentos': 200, 38 | 'trezentos': 300, 39 | 'quatrocentos': 400, 40 | 'quinhentos': 500, 41 | 'seiscentos': 600, 42 | 'setecentos': 700, 43 | 'oitocentos': 800, 44 | 'novecentos': 900, 45 | 'mil': 1000, 46 | 'milhão': 1000000, 47 | 'bilhão': 1000000000, 48 | 'milhões': 1000000, 49 | 'bilhões': 1000000000, 50 | 'e': '+', 51 | } 52 | 53 | stop_words = { 54 | 55 | } 56 | 57 | def cheque(valor): 58 | if 'real' in valor: 59 | return '1.00' 60 | valores = valor.split(' reais')[0].split(' de')[0].split(' e ') 61 | resultado = 0 62 | # cinquenta e tres 63 | # 50 + 3 64 | for valor in valores: 65 | numeros = valor.split() 66 | if len(numeros) == 2: 67 | resultado += mul(*(labels[n] for n in numeros)) 68 | else: 69 | resultado += labels[valor] 70 | 71 | return '%.2f' % resultado -------------------------------------------------------------------------------- /0-cheque/test.py: -------------------------------------------------------------------------------- 1 | # coding: utf-8 2 | import unittest 3 | from cheque import cheque 4 | 5 | class TestCheque(unittest.TestCase): 6 | 7 | def test_um_real(self): 8 | self.assertEqual(cheque('um real'), '1.00') 9 | 10 | def test_dois_reais(self): 11 | self.assertEqual(cheque('dois reais'), '2.00') 12 | 13 | def test_dez_reais(self): 14 | self.assertEqual(cheque('dez reais'), '10.00') 15 | 16 | def test_cinquenta_reais(self): 17 | self.assertEqual(cheque('cinquenta reais'), '50.00') 18 | 19 | def test_cinquenta_e_tres_reais(self): 20 | self.assertEqual(cheque('cinquenta e três reais'), '53.00') 21 | 22 | def test_cento_e_cinquenta_e_tres_reais(self): 23 | self.assertEqual(cheque('cento e cinquenta e três reais'), '153.00') 24 | 25 | def test_dois_milhoes_reais(self): 26 | self.assertEqual(cheque('dois milhões de reais'), '2000000.00') 27 | 28 | if __name__ == '__main__': 29 | unittest.main() -------------------------------------------------------------------------------- /1-intervalos/README.md: -------------------------------------------------------------------------------- 1 | ### Retrospectiva 2 | 3 | | :slightly_smiling_face: :sparkles: | :frowning_face: :sparkles: | 4 | | ------------- |---------------------------------| 5 | | em suma, boa primeira tentativa | respeitar mais o baby-steps | 6 | | comida boa | timing errado da entrega do lanche | 7 | | o equipamento funcionou | lembrar de trazer pratinhos | 8 | | aprender TDD | falta de quebra-gelo | 9 | | boa interação dos dojinhos <3 | problema complexo de primeira | 10 | | nice hat =P | link do grupo do dojo no forms | 11 | | boo quantidade de pessoas | | 12 | | Entender diversidade de Raciocínios | | 13 | 14 | 15 | 16 | **Foto do quadro** 17 | 18 | 19 | -------------------------------------------------------------------------------- /1-intervalos/main.py: -------------------------------------------------------------------------------- 1 | # Intervalos (https://dojopuzzles.com/problems/intervalos/) 2 | # 3 | # Este problema foi utilizado em 313 Dojo(s). 4 | # 5 | # Dado uma lista de números inteiros, agrupe a lista em um conjunto de intervalos 6 | # 7 | # Exemplo: 8 | # 9 | # Entrada: 100, 101, 102, 103, 104, 105, 110, 111, 113, 114, 115, 150 10 | # 11 | # Saída: [100-105], [110-111], [113-115], [150] 12 | 13 | 14 | 15 | def intervals(numbers_list): 16 | #return [[numbers_list[0], numbers_list[-1]]] 17 | interval = [] 18 | output = [] 19 | secundary = [] 20 | 21 | for position, i in enumerate(numbers_list): 22 | if position == 0 or position == 1: 23 | interval.append(i) 24 | elif i == interval[-1] + 1: 25 | interval[-1] = i 26 | elif i != interval[-1] + 1: 27 | secundary.append(i) 28 | 29 | if interval: 30 | output.append(interval) 31 | if secundary: 32 | output.append(secundary) 33 | 34 | return output -------------------------------------------------------------------------------- /1-intervalos/test.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from main import intervals 3 | 4 | class TestCase(unittest.TestCase): 5 | 6 | def test_simple_list(self): 7 | result = intervals([100, 101]) 8 | self.assertEqual(result, [[100,101]]) 9 | 10 | def test_three_numbers(self): 11 | result = intervals([1, 2, 3]) 12 | self.assertEqual(result, [[1, 3]]) 13 | 14 | def test_no_sequence(self): 15 | result = intervals([1,2,3,5,6]) 16 | self.assertEqual(result, [[1,3], [5,6]]) 17 | 18 | 19 | 20 | if __name__ == "__main__": 21 | unittest.main() -------------------------------------------------------------------------------- /10-buraco-nas-letras/README.md: -------------------------------------------------------------------------------- 1 | ## Foi bom 2 | - Seguir a risca as partes dos testes (nos outros a gente dava um passo maior, pulava algumas etapas). Mas depende do publico. 3 | - Ter pessoa moderadora martelando o que deve ser feito, pra seguir tdd e baby steps (passos pequenos) 4 | - Desafio foi otimo, porque nao tinha tanta confusao em qual seria o proximo passo. Ex: As vezes um desafio tem varias formas de resolver e acaba deixando as pessoas em sintonia diferente 5 | - Ter conseguido concluir 6 | - Ter chegado a uma conclusao foi legal, liberdade pra resolver o desafio 7 | 8 | 9 | ## Foi ruim 10 | - Faltou gente no dojo, acostumado com maior quantidade de gente 11 | - Ter possibilidade de linguagens diferentes de javascript e python 12 | - Deixar sugestoes na chamada, no proximo usaremos tal linguagem => mas pode ser tendencioso 13 | - Alternar linguagem entre python e outra linguagem aleatoria, a cada 15 dias 14 | - Local mais fixo 15 | - Criar um server no discord 16 | - Providenciar email (pra comunicacao, caso n tenha outro meio) 17 | 18 | 19 | 20 | doctest 21 | 22 | 23 | ## Linguagens Sugeridas 24 | - Rust 25 | - Elixir 26 | - Lua 27 | - Javascript/Typescript 28 | - C++ 29 | - Cobol 30 | - PHP 31 | - Ruby 32 | - Dart 33 | - Go 34 | - Shell script (Eric) 35 | - Elm 36 | - Haskell 37 | - Java 38 | - C# 39 | 40 | 41 | 42 | -------------------------------------------------------------------------------- /10-buraco-nas-letras/__pycache__/main.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dojo-recife/dojo/f3dd4ac5d67dd0ffaaadf0b4e1fe8fedcc82a84e/10-buraco-nas-letras/__pycache__/main.cpython-310.pyc -------------------------------------------------------------------------------- /10-buraco-nas-letras/main.py: -------------------------------------------------------------------------------- 1 | def conta_buraco(frase:str): 2 | contador_buracos = 0 3 | letras_com_1_buraco = "ADOPQRabdegopq" 4 | for letra in frase: 5 | if letra in letras_com_1_buraco: 6 | contador_buracos += 1 7 | elif letra == "B": 8 | contador_buracos += 2 9 | 10 | return contador_buracos 11 | -------------------------------------------------------------------------------- /10-buraco-nas-letras/test.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from main import conta_buraco 3 | 4 | # Buracos nas Letras 5 | # Se você pensar em um papel como um plano e uma letra como uma marcação neste plano, então estas letras dividem o plano em regiões. Por exemplo, as letras A, D e O dividem o plano em 2 pois possuem um espaço confinado em seu desenho, ou um “buraco”. Outras letras como B possuem 2 buracos e letras como C e E não possuem buracos. 6 | 7 | # Deste modo podemos considerar que o número de buracos em um texto é igual a soma dos buracos nas palavras dele. 8 | 9 | # A sua tarefa é, dado um texto qualquer, encontre a quantidade de buracos nele. 10 | 11 | 12 | class TestCase(unittest.TestCase): 13 | def test_um_caractere_com_buraco(self): 14 | buracos = conta_buraco("A") 15 | self.assertEqual(buracos, 1) 16 | 17 | def test_caractere_b_maiusculo_com_buraco(self): 18 | buracos = conta_buraco("B") 19 | self.assertEqual(buracos, 2) 20 | 21 | def test_caractere_b_minusculo_com_buraco(self): 22 | buracos = conta_buraco("b") 23 | self.assertEqual(buracos, 1) 24 | 25 | def test_caractere_sem_buraco(self): 26 | buracos = conta_buraco("C") 27 | self.assertEqual(buracos, 0) 28 | 29 | def test_dois_caracteres_sem_buraco(self): 30 | buracos = conta_buraco("CC") 31 | self.assertEqual(buracos, 0) 32 | 33 | def test_dois_caracteres_com_um_buraco(self): 34 | buracos = conta_buraco("CD") 35 | self.assertEqual(buracos, 1) 36 | 37 | def test_caractere_P_maiusculo(self): 38 | buracos = conta_buraco("P") 39 | self.assertEqual(buracos, 1) 40 | 41 | def test_todos_caracteres_com_1_buraco(self): 42 | buracos = conta_buraco("ADOPQRabdegopq") 43 | self.assertEqual(buracos, 14) 44 | 45 | def test_todos_caracteres_como_B(self): 46 | buracos = conta_buraco("BBBBB") 47 | self.assertEqual(buracos, 10) 48 | 49 | def test_todos_caracteres_como_B(self): 50 | buracos = conta_buraco("Buraco") 51 | self.assertEqual(buracos, 4) 52 | 53 | def test_muitos_caracteres(self): 54 | buracos = conta_buraco("Prazer em te conhecer") 55 | self.assertEqual(buracos, 8) 56 | 57 | def test_todos_caracteres_como_B(self): 58 | buracos = conta_buraco(" ") 59 | self.assertEqual(buracos, 0) 60 | 61 | 62 | 63 | if __name__ == "__main__": 64 | unittest.main() -------------------------------------------------------------------------------- /11-array-TW/javascript/.gitignore: -------------------------------------------------------------------------------- 1 | *node_modules/* -------------------------------------------------------------------------------- /11-array-TW/javascript/instalacoes.md: -------------------------------------------------------------------------------- 1 | Supondo que nao haja node, npm na maquina 2 | 3 | // 4 | sudo apt install nodejs 5 | sudo apt install npm 6 | nodejs -v 7 | 8 | Na pasta a ser utilizada no dojo, rode o comando 9 | 10 | // 11 | npm init -y 12 | npm i -D jest 13 | 14 | Para rodar os testes em atualizacao continua 15 | 16 | // 17 | npx jest --watchAll -------------------------------------------------------------------------------- /11-array-TW/javascript/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "javascript", 3 | "version": "1.0.0", 4 | "description": "", 5 | "main": "index.js", 6 | "scripts": { 7 | "test": "echo \"Error: no test specified\" && exit 1" 8 | }, 9 | "keywords": [], 10 | "author": "", 11 | "license": "ISC", 12 | "devDependencies": { 13 | "jest": "^29.5.0" 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /11-array-TW/javascript/src/estudantes/estudantes.todo: -------------------------------------------------------------------------------- 1 | #Regras de Negocio para o caso 2 | 3 | Regras: 4 | Somar notas 5 | Se nota for 0, a soma deve retornar 0 6 | Caso o aluno tenha mais de 5 notas a soma deve ser multiplicada por dois 7 | -------------------------------------------------------------------------------- /11-array-TW/javascript/src/estudantes/feedback.md: -------------------------------------------------------------------------------- 1 | # Foi bom 2 | 3 | Foi bom horario e lugar 4 | Melhor do que dia de semana 5 | Mais acessivel final de semana 6 | Gostou de ter usado mais de uma linguagem 7 | Lanche top 8 | Gostou de ter bastante pessoas 9 | Ter um tempo para ficar conversando no inicio do evento 10 | Separacao foi boa pela quantidade de pessoas, pois aumentou a rotatividade e interacao 11 | 12 | # Poderia ser melhor 13 | 14 | Encurtar a parte de propagacao de conteudo 15 | Ver se tempo limite de palestra poderia ser possivel (Sugestao: 30 minutos) 16 | Disponibilizar materia antes do evento para dar introducao 17 | Passar um conteudo especificamente isolado mas bem estruturado 18 | Poderia falar do framework do teste nas palestras ou no material, pois foi usado 19 | Poderia fazer um material no discord do dojo, dividir por linguagens 20 | Comprometimento 21 | Colocar um video dos palestrantes 22 | Mostrar exemplos praticos na palestra 23 | No meio desses 15 dias encabecar um evento online 24 | Uma spreadsheet com os lanches a serem levados por cada um 25 | Diminuir a quantidade de linguagens no formulario 26 | Verificar se desafios do hackerrank eh viavel 27 | Deixar campo de linguagens abertas a escrita 28 | Seguir exatamente o horario, pontualidade necessaria 29 | 30 | -------------------------------------------------------------------------------- /11-array-TW/javascript/src/estudantes/intervalos.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | calcula: listaArray => calculaIntervalos(listaArray) 3 | } 4 | 5 | function calculaIntervalos(arr){ 6 | 7 | if (typeof(arr) != "Array"){return "Nao e um array"} 8 | 9 | if (arr.length === 0) { 10 | return "Array Vazio" 11 | } 12 | 13 | for (let i = 0; i < arr.length; i++){ 14 | if( typeof(arr[i]) !== "Number"){ 15 | return "Dados invalidos" 16 | } 17 | 18 | let primeiroNumero = arr[0] 19 | if (arr[i + 1] == arr[i] + 1) { 20 | 21 | } 22 | } 23 | 24 | 25 | } 26 | -------------------------------------------------------------------------------- /11-array-TW/javascript/src/estudantes/intervalos.test.js: -------------------------------------------------------------------------------- 1 | const intervalos = require('./intervalos') 2 | 3 | describe('Testes para arrays', () => { 4 | it('Deve retornar "Dados invalidos" caso algum item do array nao seja do tipo number', () => { 5 | const entrada = [1, 2, 3, 'a', 5] 6 | expect(intervalos.calcula(entrada)).toEqual("Dados invalidos") 7 | 8 | }) 9 | 10 | it('Verificar se o array eh vazio', () => { 11 | const entrada = [] 12 | expect(intervalos.calcula(entrada)).toEqual("Array Vazio") 13 | 14 | }) 15 | 16 | it('Verificar tipo de entrada',() => { 17 | const entrada = "entrada" 18 | expect(intervalos.calcula(entrada)).toEqual("Nao e um array") 19 | }) 20 | 21 | it('Se numero for igual',() => { 22 | const entrada = [1,1] 23 | expect(intervalos.calcula(entrada)).toEqual("O numero e igual") 24 | }) 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | // it('Deve retornar o intervalo um array com 1 e 3', () => { 36 | // const entrada = [1, 2, 3] 37 | // expect(intervalos.calcula(entrada).toEqual("[1, 3]")) 38 | // }) // it('Deve retornar o intervalo um array com 1 e 3', () => { 39 | // const entrada = [1, 2, 3] 40 | // expect(intervalos.calcula(entrada).toEqual("[1, 3]")) 41 | // }) 42 | }) 43 | 44 | -------------------------------------------------------------------------------- /12-desafio/README.md: -------------------------------------------------------------------------------- 1 | Problema: [https://adventofcode.com/2023/day/1](https://adventofcode.com/2023/day/1) 2 | 3 | 4 | ## Foi bom 5 | - Remoto 6 | - Participação de pessoas fora de Recife 7 | - Participação parcial de pessoas 8 | - Ter mais tempo para concluir 9 | 10 | 11 | ## Foi ruim 12 | 13 | 14 | ## Linguagens Sugeridas 15 | Python 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /12-desafio/main.py: -------------------------------------------------------------------------------- 1 | def numeros_na_linha(text): 2 | digit_map = { 3 | "one": 1, 4 | "two": 2, 5 | "three": 3, 6 | "four": 4, 7 | "five": 5, 8 | "six": 6, 9 | "seven": 7, 10 | "eight": 8, 11 | "nine": 9, 12 | } 13 | numbers = digit_map.keys() 14 | value = '' 15 | find_numbers = [] 16 | 17 | 18 | for c in text: 19 | if c.isdigit(): 20 | find_numbers.append(int(c)) 21 | value = '' 22 | continue 23 | 24 | value += c 25 | reverse = '' 26 | for x in range(len(value), 0, -1): 27 | reverse = value[x-1:] 28 | if reverse in numbers: 29 | find_numbers.append(reverse) 30 | value = '' 31 | break 32 | 33 | if value in numbers: 34 | find_numbers.append(value) 35 | 36 | find_numbers = [num.replace(num, str(digit_map[num])) 37 | if not str(num).isdigit() else str(num) 38 | for num in find_numbers] 39 | 40 | return str(find_numbers[0]) + str(find_numbers[-1]) 41 | 42 | 43 | -------------------------------------------------------------------------------- /12-desafio/main2.py: -------------------------------------------------------------------------------- 1 | def numeros_na_linha(linha: str): 2 | digit_map = { 3 | "one": 1, 4 | "two": 2, 5 | "three": 3, 6 | "four": 4, 7 | "five": 5, 8 | "six": 6, 9 | "seven": 7, 10 | "eight": 8, 11 | "nine": 9, 12 | } 13 | 14 | str_number = {digit:linha.index(digit) for digit in digit_map if digit in linha} 15 | print(str_number) 16 | first_position_digit = "" 17 | for digit in digit_map: 18 | if digit in linha: 19 | index = linha.index(digit) 20 | # linha = linha.replace(digit, str(digit_map[digit])) 21 | min_value = min(str_number.values()) 22 | max_value = max(str_number.values()) 23 | 24 | linha = linha.replace(digit, str(digit_map[digit])) 25 | 26 | digits = [number for number in linha if number.isdigit()] 27 | 28 | return f"{digits[0]}{digits[-1]}" 29 | -------------------------------------------------------------------------------- /12-desafio/test.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from main import numeros_na_linha 3 | # 4 | 5 | 6 | class TestCase(unittest.TestCase): 7 | 8 | def test_duas_strings(self): 9 | numero = numeros_na_linha("onetwo") 10 | self.assertEqual(numero, "12") 11 | 12 | def test_duas_strings_com_caractere_separador(self): 13 | numero = numeros_na_linha("two$two") 14 | self.assertEqual(numero, "22") 15 | 16 | def test_apenas_int(self): 17 | numero = numeros_na_linha("1234") 18 | self.assertEqual(numero, "14") 19 | 20 | def test_apenas_int_2(self): 21 | numero = numeros_na_linha("123458") 22 | self.assertEqual(numero, "18") 23 | 24 | def test_int_and_str(self): 25 | numero = numeros_na_linha("12a345") 26 | self.assertEqual(numero, "15") 27 | 28 | def test_int_and_pipe_and_int(self): 29 | numero = numeros_na_linha("12|345") 30 | self.assertEqual(numero, "15") 31 | 32 | def test_str_and_number(self): 33 | numero = numeros_na_linha("one5") 34 | self.assertEqual(numero, "15") 35 | 36 | def test_first_str_and_number_2(self): 37 | numero = numeros_na_linha("xtwoone3four") 38 | self.assertEqual(numero, "24") 39 | 40 | def test_str_and_number_3(self): 41 | numero = numeros_na_linha("twoone3fourx") 42 | self.assertEqual(numero, "24") 43 | 44 | def test_str_and_number_4(self): 45 | numero = numeros_na_linha("twone3furx") 46 | self.assertEqual(numero, "23") 47 | 48 | def test_treb7uchet(self): 49 | num = numeros_na_linha("treb7uchet") 50 | self.assertEqual(num, "77") 51 | 52 | 53 | 54 | 55 | 56 | # twone3fourx 57 | # xtwone3fourx 58 | # 59 | 60 | if __name__ == "__main__": 61 | unittest.main() -------------------------------------------------------------------------------- /13-escrevendo-celular/main.py: -------------------------------------------------------------------------------- 1 | def key_letter(letter): 2 | if letter == "a": 3 | return "2" 4 | elif letter == "b": 5 | return "22" 6 | elif letter == "c": 7 | return "222" 8 | elif letter == "d": 9 | return "3" 10 | elif letter == "e": 11 | return "33" 12 | elif letter == "f": 13 | return "333" 14 | elif letter == "g": 15 | return "4" 16 | elif letter == "h": 17 | return "44" 18 | elif letter == "i": 19 | return "444" 20 | elif letter == "j": 21 | return "5" 22 | elif letter == "k": 23 | return "55" 24 | elif letter == "l": 25 | return "555" 26 | elif letter == "m": 27 | return "6" 28 | elif letter == "n": 29 | return "66" 30 | elif letter == "o": 31 | return "666" 32 | elif letter == "p": 33 | return "7" 34 | elif letter == "q": 35 | return "77" 36 | elif letter == "r": 37 | return "777" 38 | elif letter == "s": 39 | return "7777" 40 | elif letter == "t": 41 | return "8" 42 | elif letter == "u": 43 | return "88" 44 | elif letter == "v": 45 | return "888" 46 | elif letter == "w": 47 | return "9" 48 | elif letter == "x": 49 | return "99" 50 | elif letter == "y": 51 | return "999" 52 | elif letter == "z": 53 | return "9999" 54 | 55 | elif letter == " ": 56 | return "0" 57 | elif letter == " ": 58 | return "0" 59 | 60 | def generic_function(text): 61 | text = text.lower() 62 | output = "" 63 | 64 | for letter in text: 65 | code = key_letter(letter) 66 | if output != "" and output[-1] in code: 67 | 68 | output = output + "_" 69 | 70 | 71 | 72 | output = output + code 73 | return output 74 | 75 | -------------------------------------------------------------------------------- /13-escrevendo-celular/problema.md: -------------------------------------------------------------------------------- 1 | # Escrevendo no Celular 2 | 3 | Um dos serviços mais utilizados pelos usuários de aparelhos celulares são os SMS (Short Message Service), que permite o envio de mensagens curtas (até 255 caracteres em redes GSM e 160 caracteres em redes CDMA). 4 | 5 | Para digitar uma mensagem em um aparelho que não possui um teclado QWERTY embutido é necessário fazer algumas combinações das 10 teclas numéricas do aparelho para conseguir digitar. Cada número é associado a um conjunto de letras como a seguir: 6 | 7 | Letras -> Número 8 | ABC -> 2 9 | DEF -> 3 10 | GHI -> 4 11 | JKL -> 5 12 | MNO -> 6 13 | PQRS -> 7 14 | TUV -> 8 15 | WXYZ -> 9 16 | Espaço -> 0 17 | Desenvolva um programa que, dada uma mensagem de texto limitada a 255 caracteres, retorne a seqüência de números que precisa ser digitada. Uma pausa, para ser possível obter duas letras referenciadas pelo mesmo número, deve ser indicada como _. 18 | 19 | Por exemplo, para digitar "SEMPRE ACESSO O DOJOPUZZLES", você precisa digitar: 20 | 21 | 77773367_7773302_222337777_777766606660366656667889999_9999555337777 -------------------------------------------------------------------------------- /13-escrevendo-celular/tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dojo-recife/dojo/f3dd4ac5d67dd0ffaaadf0b4e1fe8fedcc82a84e/13-escrevendo-celular/tests/__init__.py -------------------------------------------------------------------------------- /13-escrevendo-celular/tests/test_main.py: -------------------------------------------------------------------------------- 1 | """ 2 | Letras -> Número 3 | ABC -> 2 4 | DEF -> 3 5 | GHI -> 4 6 | JKL -> 5 7 | MNO -> 6 8 | PQRS -> 7 9 | TUV -> 8 10 | WXYZ -> 9 11 | Espaço -> 0 12 | """ 13 | 14 | from main import generic_function 15 | 16 | def test_one_letter(): 17 | output = generic_function("a") 18 | assert output == "2" 19 | 20 | def test_j(): 21 | output = generic_function("j") 22 | assert output == "5" 23 | 24 | 25 | def test_b(): 26 | output = generic_function("b") 27 | assert output == "22" 28 | 29 | def test_oi(): 30 | output = generic_function("oi") 31 | assert output == "666444" 32 | 33 | def test_espaco(): 34 | output = generic_function(" ") 35 | assert output == "0" 36 | 37 | def test_palavra_com_espaco(): 38 | output = generic_function("dojo recife") 39 | assert output == "36665666077733222444333_33" 40 | 41 | def test_final(): 42 | output = generic_function("SEMPRE ACESSO O DOJOPUZZLES") 43 | assert output == "77773367_7773302_222337777_777766606660366656667889999_9999555337777" 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /2-cheque-por-extenso/main.py: -------------------------------------------------------------------------------- 1 | def cheque(num): 2 | lista1 = ["um", "dois", "tres", "quatro", "cinco", 3 | "seis", "sete", "oito", "nove", "dez", 4 | "onze", "doze", "treze", "quatorze", "quinze", 5 | "dezesseis", "dezessete", "dezoito", "dezenove"] 6 | 7 | lista2 = ["vinte", "trinta", "quarenta", "cinquenta", "sessenta", "setenta", "oitenta", "noventa"] 8 | 9 | return lista[num - 1] 10 | 11 | -------------------------------------------------------------------------------- /2-cheque-por-extenso/retro.md: -------------------------------------------------------------------------------- 1 | # Foi massa 2 | 3 | - Melhoramos pontos do último encontro 4 | - Nos comunicamos melhor 5 | - Interagimos melhor 6 | - Comida 7 | - Respeitamos os baby steps 8 | - É divertido seguir o raciocínio dos outros 9 | 10 | # Pode melhorar 11 | 12 | - Demoramos muito definindo os casos de testes e o código avançou pouco 13 | - Colocar no convite a sugestão de trazer um lanche 14 | - Complicamos demais os testes 15 | - Música 16 | - Microfone 17 | - Pensar em outros lugares -------------------------------------------------------------------------------- /2-cheque-por-extenso/test.py: -------------------------------------------------------------------------------- 1 | # Este problema foi utilizado em 1308 Dojo(s). 2 | # 3 | # Apesar de o volume de cheques emitidos tenha diminuído drásticamente nos últimos anos, principalmente devido a popularização dos cartões de crédito e débito, eles ainda são utilizados em muitas compras, especialmente a de valores altos. E para auxiliar no seu preenchimento, vários estabelecimentos possuem máquinas que dado o valor da compra, preenchem o cheque com o seu valor por extenso. 4 | # 5 | # Desenvolva um programa que dado um valor monetário, seja retornado o valor em reais por extenso. 6 | # 7 | # Exemplo: 8 | # 9 | # 15415,16 -> quinze mil quatrocentos e quinze reais e dezesseis centavos 10 | # 0,05 -> cinco centavos 11 | # 2,25 -> dois reais e vinte e cinco centavos 12 | # https://dojopuzzles.com/problems/cheque-por-extenso/ 13 | 14 | from unittest import TestCase 15 | import unittest 16 | from main import * 17 | import random 18 | class Test(TestCase): 19 | def test_um(self): 20 | self.assertEqual(cheque(1),"um") 21 | def test_dois(self): 22 | self.assertEqual(cheque(2),"dois") 23 | 24 | def test_nove(self): 25 | self.assertEqual(cheque(9), "nove") 26 | 27 | def test_numero_com_1_digito(self): 28 | lista = ["um","dois","tres","quatro","cinco","seis","sete","oito","nove"] 29 | 30 | for i in range(1, 10): 31 | self.assertEqual(cheque(i), lista[i - 1]) 32 | 33 | def test_numero_com_2_digitos(self): 34 | lista = ["dez", "onze", "doze", "treze", "quatorze", "quinze", "dezesseis", "dezessete", "dezoito", "dezenove"] 35 | 36 | # 1 37 | 38 | for i in range(10,20): 39 | n = i % 10 40 | self.assertEqual(cheque(i), lista[n]) 41 | 42 | def test_numero_com_maior_20(self): 43 | 44 | 45 | self.assertEqual(cheque(22), "vinte e dois") 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | if __name__ == "__main__": 57 | unittest.main() -------------------------------------------------------------------------------- /3-caixa-eletronico/main.py: -------------------------------------------------------------------------------- 1 | def retorna_saque(dinheiros): 2 | notas = [100, 50, 20, 10] 3 | saque = [] 4 | for nota in notas: 5 | if dinheiros % nota == 0: 6 | qnt_notas = dinheiros // nota 7 | saque.extend([nota] * qnt_notas) 8 | dinheiros -= nota * qnt_notas 9 | elif nota <= dinheiros: 10 | saque.append(nota) 11 | dinheiros -= nota 12 | 13 | return saque -------------------------------------------------------------------------------- /3-caixa-eletronico/retro.md: -------------------------------------------------------------------------------- 1 | # Foi massa 2 | 3 | - Explicação da resolução do problema 4 | - Contribuição de todas para o lanche 5 | - Respeito a pilota e co-pilota (pouca interrupção do público) 6 | - Pouca conversa paralela 7 | - Resolução completa do problema 8 | 9 | # Pode melhorar 10 | 11 | - Iniciar com quadro branco ao lado da projeção 12 | - Oralização do código ou raciocínio que está sendo desenvolvido 13 | - Maior participação do público como pilota e co-pilota 14 | - Alternancia e linguagem de programação 15 | - Organização informar a linguagem de programação a ser usada na resolução do exercício 16 | - Quebra gelo no início do encontro 17 | - Repositório de problemas (Site de exercícios fora do ar) -------------------------------------------------------------------------------- /3-caixa-eletronico/test.py: -------------------------------------------------------------------------------- 1 | # Caixa Eletrônico - Resolução 2 | # Desenvolva um programa que simule a entrega de notas quando um cliente efetuar um saque em um caixa eletrônico. Os requisitos básicos são os seguintes: 3 | # 4 | # Entregar o menor número de notas; 5 | # É possível sacar o valor solicitado com as notas disponíveis; 6 | # Saldo do cliente infinito; 7 | # Quantidade de notas infinito (pode-se colocar um valor finito de cédulas para aumentar a dificuldade do problema); 8 | # Notas disponíveis de R$ 100,00; R$ 50,00; R$ 20,00 e R$ 10,00 9 | # Exemplos: 10 | # 11 | # Valor do Saque: R$ 30,00 – Resultado Esperado: Entregar 1 nota de R$20,00 e 1 nota de R$ 10,00. 12 | # Valor do Saque: R$ 80,00 – Resultado Esperado: Entregar 1 nota de R$50,00 1 nota de R$ 20,00 e 1 nota de R$ 10,00. 13 | 14 | from unittest import TestCase 15 | import unittest 16 | from main import * 17 | import random 18 | class Test(TestCase): 19 | def test_sacar_10_reais(self): 20 | self.assertEqual(retorna_saque(10), [10]) 21 | 22 | def test_sacar_30_reais(self): 23 | self.assertEqual((retorna_saque(30)), [20, 10]) 24 | 25 | def test_sacar_40_reais(self): 26 | self.assertEqual((retorna_saque(40)), [20, 20]) 27 | 28 | def test_sacar_40_reais(self): 29 | self.assertEqual((retorna_saque(40)), [20, 20]) 30 | 31 | def test_sacar_50_reais(self): 32 | self.assertEqual((retorna_saque(50)), [50]) 33 | 34 | def test_sacar_120_reais(self): 35 | self.assertEqual((retorna_saque(120)), [100, 20]) 36 | 37 | def test_sacar_300_reais(self): 38 | self.assertEqual((retorna_saque(300)), [100, 100, 100]) 39 | 40 | 41 | def test_sacar_170_reais(self): 42 | self.assertEqual((retorna_saque(170)), [100, 50, 20]) 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | if __name__ == "__main__": 52 | unittest.main() -------------------------------------------------------------------------------- /4-unknown/__pycache__/main.cpython-311.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dojo-recife/dojo/f3dd4ac5d67dd0ffaaadf0b4e1fe8fedcc82a84e/4-unknown/__pycache__/main.cpython-311.pyc -------------------------------------------------------------------------------- /4-unknown/main.py: -------------------------------------------------------------------------------- 1 | # def quebra_de_linha(frase, colunas): 2 | 3 | # formatado = "" 4 | # palavras = frase.split() 5 | 6 | # for palavra in palavras: 7 | 8 | # if len(palavras): 9 | # formatado += palavra 10 | # else: 11 | # formatado += palavra + "\n" 12 | 13 | # return formatado 14 | 15 | def quebra_de_coluna(texto, qtdCaracteres): 16 | 17 | index = qtdCaracteres 18 | if (texto[index] != " "): 19 | texto 20 | len(texto) 21 | 22 | for index,letra in enumerate(texto): 23 | while -------------------------------------------------------------------------------- /4-unknown/retro.md: -------------------------------------------------------------------------------- 1 | # Foi massa 2 | 3 | A localizacao dos pilotos foi estrategica 4 | 5 | A dinamica em dupla 6 | 7 | Intinerante variado 8 | 9 | Acendemos a chama da programacao 10 | 11 | # Pode melhorar 12 | 13 | Ter outros ambientes ja disponiveis 14 | 15 | Levar em consideracao a votacao 16 | 17 | Dinamica de interacao (Dividir em grupos baseados em niveis, delimitar apresentacoes com tecnicas ageis como o Scrum) 18 | 19 | Verificar se todos ja foram introduzidos a programacao 20 | Alinhar sobre topicos abordados durante o evento (TDD) 21 | 22 | Determinar uma logica apos definir a questao 23 | 24 | Ter um quadro onde a pessoa mostra a logica que quer usar 25 | 26 | Combinar antes da dinamica o tempo confortavel para desenvolvimento 27 | 28 | Criar README de boas praticas sobre o evento 29 | 30 | Definir previamente a questao a ser desenvolvida. Discutir sobre a utilizacao do telegram. 31 | Organizacao pensar como dificultar as easter egg 32 | 33 | 34 | Discutir sobre divisao de senioridade entre piloto e copiloto 35 | 36 | 37 | 38 | -------------------------------------------------------------------------------- /4-unknown/test.py: -------------------------------------------------------------------------------- 1 | from unittest import TestCase 2 | import unittest 3 | from main import * 4 | import random 5 | 6 | class Test(TestCase): 7 | def test_duas_palavras(self): 8 | self.assertEqual(quebra_de_linha("Coding dojo", 1), "Coding\ndojo") 9 | 10 | def test_tres_palavras(self): 11 | self.assertEqual(quebra_de_linha("Coding dojo Recife", 1), "Coding\ndojo\nRecife") 12 | 13 | if __name__ == "__main__": 14 | unittest.main() -------------------------------------------------------------------------------- /6-mictorios/Feedback.md: -------------------------------------------------------------------------------- 1 | Foi massa 2 | 3 | 1- Deu certo a ideia da plateia interagir por estar discutindo mais 4 | 2- Questao assertiva para todos 5 | 3- Foi super positivo o encontro 6 | 7 | Poderia Melhorar 8 | 9 | 1- Mais gente participando na mesa 10 | 2- Incentivar mais mulheres a participar do DOJO 11 | 3- Discutir a dinamica do DOJO Classico (Piloto e copiloto) 12 | 4- Deixar anotado as regras de negocio (TODO visivel durante desenvolvimento) 13 | 5- Fazer um doublecheck presencial da proeficiencia de linguagem 14 | 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /6-mictorios/__pycache__/main.cpython-311.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dojo-recife/dojo/f3dd4ac5d67dd0ffaaadf0b4e1fe8fedcc82a84e/6-mictorios/__pycache__/main.cpython-311.pyc -------------------------------------------------------------------------------- /6-mictorios/main.py: -------------------------------------------------------------------------------- 1 | # Distribuição de Mictórios 2 | # Gostei! Vamos usar esse! 3 | # Não gostei! Mostre-me outro. 4 | 5 | # Este problema foi utilizado em 323 Dojo(s). 6 | 7 | # Um problema enfrentado pelos homens no uso de mictórios em banheiros públicos é o constrangimento causado por outro homem urinando no mictório ao lado. Uma situação contrangedora é definida quando dois "mijões" deveriam ocupar mictórios adjacentes. 8 | 9 | # Dada uma quantidade de mictórios em um banheiro e a ocupação inicial deles (informando em qual deles já existe um "mijão"), determine quantos "mijões" ainda podem usar os mictórios e qual a posição deles antes para que não ocorra uma situação constrangedora 10 | 11 | def mictorio(mictorios): 12 | if mictorios == [0]: 13 | return [0] 14 | 15 | ocupado = '' 16 | for i, mictorio in enumerate(mictorios): 17 | if mictorio == 1: 18 | if i % 2 == 0: 19 | ocupado = 'par' 20 | else: 21 | ocupado = 'impar' 22 | 23 | for i, m in enumerate(mictorios): 24 | if i == 0 and m == 1: 25 | return [2] 26 | 27 | return [0, 2] -------------------------------------------------------------------------------- /6-mictorios/mijoes.todo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dojo-recife/dojo/f3dd4ac5d67dd0ffaaadf0b4e1fe8fedcc82a84e/6-mictorios/mijoes.todo -------------------------------------------------------------------------------- /6-mictorios/retro.md: -------------------------------------------------------------------------------- 1 | # Foi massa 2 | 3 | A localizacao dos pilotos foi estrategica 4 | 5 | A dinamica em dupla 6 | 7 | Intinerante variado 8 | 9 | Acendemos a chama da programacao 10 | 11 | # Pode melhorar 12 | 13 | Ter outros ambientes ja disponiveis 14 | 15 | Levar em consideracao a votacao 16 | 17 | Dinamica de interacao (Dividir em grupos baseados em niveis, delimitar apresentacoes com tecnicas ageis como o Scrum) 18 | 19 | Verificar se todos ja foram introduzidos a programacao 20 | Alinhar sobre topicos abordados durante o evento (TDD) 21 | 22 | Determinar uma logica apos definir a questao 23 | 24 | Ter um quadro onde a pessoa mostra a logica que quer usar 25 | 26 | Combinar antes da dinamica o tempo confortavel para desenvolvimento 27 | 28 | Criar README de boas praticas sobre o evento 29 | 30 | Definir previamente a questao a ser desenvolvida. Discutir sobre a utilizacao do telegram. 31 | Organizacao pensar como dificultar as easter egg 32 | 33 | 34 | Discutir sobre divisao de senioridade entre piloto e copiloto 35 | 36 | 37 | 38 | -------------------------------------------------------------------------------- /6-mictorios/test.py: -------------------------------------------------------------------------------- 1 | from unittest import TestCase 2 | import unittest 3 | from main import * 4 | import random 5 | 6 | # entrada: lista de mictorios 7 | # saida: lista de mictorios disponiveis respeitando as regras 8 | # de adjacencia. 9 | 10 | class Test(TestCase): 11 | def test_mictorio_simples(self): 12 | self.assertEqual(mictorio([0]), [0]) 13 | 14 | 15 | def test_mictorio_tres(self): 16 | self.assertEqual( 17 | mictorio([0, 0, 0]), [0, 2] 18 | ) 19 | 20 | def test_mictorio_tres_livres_um_ocupado(self): 21 | self.assertEqual( 22 | mictorio([1, 0, 0]), [2] 23 | ) 24 | 25 | def test_mictorio_tres_livres_meio_ocupado(self): 26 | self.assertEqual( 27 | mictorio([0, 1 , 0]), [] 28 | ) 29 | 30 | if __name__ == "__main__": 31 | unittest.main() -------------------------------------------------------------------------------- /7-palavras-primas/.gitignore: -------------------------------------------------------------------------------- 1 | *node_modules/* -------------------------------------------------------------------------------- /7-palavras-primas/instalacoes.md: -------------------------------------------------------------------------------- 1 | Supondo que nao haja node, npm na maquina 2 | 3 | // 4 | sudo apt install nodejs 5 | sudo apt install npm 6 | nodejs -v 7 | 8 | Na pasta a ser utilizada no dojo, rode o comando 9 | 10 | // 11 | npm init -y 12 | npm i -D jest 13 | 14 | Para rodar os testes em atualizacao continua 15 | 16 | // 17 | npx jest --watchAll -------------------------------------------------------------------------------- /7-palavras-primas/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "javascript", 3 | "version": "1.0.0", 4 | "main": "index.js", 5 | "scripts": { 6 | "test": "echo \"Error: no test specified\" && exit 1" 7 | }, 8 | "keywords": [], 9 | "author": "", 10 | "license": "ISC", 11 | "devDependencies": { 12 | "jest": "^29.5.0" 13 | }, 14 | "description": "" 15 | } 16 | -------------------------------------------------------------------------------- /7-palavras-primas/src/index.js: -------------------------------------------------------------------------------- 1 | // Palavras Primas https://dojopuzzles.com/problems/palavras-primas/ 2 | // Um número primo é definido se ele possuir exatamente dois divisores: o número um e ele próprio. São exemplos de números primos: 2, 3, 5, 101, 367 e 523. 3 | // 4 | // Neste problema, você deve ler uma palavra composta somente por letras [a-zA-Z]. Cada letra possui um valor específico, a vale 1, b vale 2 e assim por diante, até a letra z que vale 26. Do mesmo modo A vale 27, B vale 28, até a letra Z que vale 52. 5 | // 6 | // Você precisa definir se cada palavra em um conjunto de palavras é prima ou não. Para ela ser prima, a soma dos valores de suas letras deve ser um número primo. 7 | 8 | 9 | 10 | module.exports = { 11 | verificaPalavraPrima: palavra => verificaPalavraPrima(palavra) 12 | } 13 | 14 | const letras = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" 15 | const primos = [1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67] 16 | 17 | 18 | function verifica_primo(numero){ 19 | let restos = 0 20 | for(let index=1; index <= numero; index++){ 21 | if (numero%index == 0){ 22 | restos++ 23 | } 24 | 25 | } 26 | console.log(restos) 27 | return restos<=2 28 | } 29 | function verificaPalavraPrima(palavra){ 30 | let sum = 0; 31 | for (let letra of palavra) { 32 | let indice = letras.indexOf(letra); 33 | sum += indice; 34 | } 35 | 36 | console.log(palavra) 37 | console.log(sum) 38 | 39 | 40 | return verifica_primo(sum); 41 | 42 | 43 | 44 | } 45 | 46 | -------------------------------------------------------------------------------- /7-palavras-primas/src/index.test.js: -------------------------------------------------------------------------------- 1 | const lerPalavra = require('./index') 2 | describe('Testes para alunos', () => { 3 | it('Deve retornar true para a', () => { 4 | expect(lerPalavra.verificaPalavraPrima("a")) 5 | .toEqual(true) 6 | }) 7 | 8 | it('Deve retornar false para d', () => { 9 | expect(lerPalavra.verificaPalavraPrima("d")) 10 | .toEqual(false) 11 | }) 12 | 13 | it('Deve retornar para A', () => { 14 | expect(lerPalavra.verificaPalavraPrima("A")) 15 | .toEqual(false) 16 | }) 17 | 18 | it('Deve retornar para oi', () => { 19 | expect(lerPalavra.verificaPalavraPrima("oi")) 20 | .toEqual(false) 21 | }) 22 | 23 | it('Deve retornar para da', () => { 24 | expect(lerPalavra.verificaPalavraPrima("da")) 25 | .toEqual(true) 26 | }) 27 | 28 | it('Deve retornar para Ana', () => { 29 | expect(lerPalavra.verificaPalavraPrima("Ana")) 30 | .toEqual(false) 31 | }) 32 | 33 | it('Deve retornar para MUljdo', () => { 34 | expect(lerPalavra.verificaPalavraPrima("MUljdo")) 35 | .toEqual(true) 36 | }) 37 | 38 | it('Deve retornar para zzzzzzzzz', () => { 39 | expect(lerPalavra.verificaPalavraPrima("zzzzzzzzz")) 40 | .toEqual(false) 41 | }) 42 | 43 | 44 | 45 | 46 | 47 | 48 | }) -------------------------------------------------------------------------------- /7-palavras-primas/src/palavras-primas.todo: -------------------------------------------------------------------------------- 1 | // Palavras Primas https://dojopuzzles.com/problems/palavras-primas/ 2 | // Um número primo é definido se ele possuir exatamente dois divisores: o número um e ele próprio. São exemplos de números primos: 2, 3, 5, 101, 367 e 523. 3 | // 4 | // Neste problema, você deve ler uma palavra composta somente por letras [a-zA-Z]. Cada letra possui um valor específico, a vale 1, b vale 2 e assim por diante, até a letra z que vale 26. Do mesmo modo A vale 27, B vale 28, até a letra Z que vale 52. 5 | // 6 | // Você precisa definir se cada palavra em um conjunto de palavras é prima ou não. Para ela ser prima, a soma dos valores de suas letras deve ser um número primo. 7 | 8 | 9 | #Regras de Negocio para o caso 10 | 11 | Regras: 12 | Somar notas 13 | Se nota for 0, a soma deve retornar 0 14 | Caso o aluno tenha mais de 5 notas a soma deve ser multiplicada por dois 15 | 16 | A n a 17 | 27 14 1 18 | 19 | 42 20 | 21 | -------------------------------------------------------------------------------- /7-palavras-primas/src/retro.md: -------------------------------------------------------------------------------- 1 | ### Foi massa 2 | - No curto prazo é ruim mas é massa ter contato com a lingugem nova 3 | - Primeira vez que concluimos!! :D 4 | - Network, conhecer gente diferente 5 | - Tirar da zona de conforto 6 | - Estar na universidade publica 7 | - 8 | 9 | 10 | ### Foi ruim 11 | 12 | - Faltou avisar que era muito frio 13 | - Organizado por python e foi em javascript 14 | - Foi ruim esse povo reclamando do javascript hhah 15 | - Comunicação da divulgação confunde (pugpe e pyladies) 16 | - Faltou estudantes da UFPE 17 | 18 | ### Sugestao 19 | - Deixa claro que é um coding dojo de qualquer linguagem e não um coding dojo somente de python 20 | - Rodar o teste no console porque perde a noção do que falhou por causa do scroll 21 | - Lembrar de colocar proeficiencia e linguagem no form 22 | - Verificar se as pessoas que participaram do ultimo vao participar do proximo 23 | - Disponibilizar no github sugestao de temas -------------------------------------------------------------------------------- /8-algarismos-romanos/README.MD: -------------------------------------------------------------------------------- 1 | ### Retrospectiva 2 | 3 | https://dojopuzzles.com/problems/numeros-romanos/ 4 | 5 | - Feedbacks 6 | 7 | - Pode melhorar: 8 | 1. Melhorar a explicação de como chegar ao local do evento. 9 | 2. Utilizar um método visual de rabisco para explicações do algorítmo - Tentar trazer uma Mesa Digitalizadora para utilizar um Miro ou a disponibilidade de um quadro branco/negro para rabisco. 10 | 3. Adicionar sessão de acessibilidade no forms. 11 | 12 | - Foi bom 13 | 1. Trouxeram mais lanches 14 | 2. Momentos de pausa para discussão e alinhamento de entendimento 15 | 3. Lanche durante o evento (funcionou pois tiveram poucos indivíduos) 16 | 4. Local com menos burocracia de alimentação 17 | 5. Utlização de Python como linguagem no dojo -------------------------------------------------------------------------------- /8-algarismos-romanos/main.py: -------------------------------------------------------------------------------- 1 | algarismos = { 2 | 1: "I", 3 | 5: "V", 4 | 10: "X", 5 | 50: "L", 6 | 100: "C", 7 | 500: "D", 8 | 1000: "M", 9 | } 10 | romanos = { 11 | value: key for key,value in algarismos.items() 12 | } 13 | 14 | 15 | def numeros_arabicos_romanos(numero): 16 | 17 | 18 | if numero in algarismos: 19 | return algarismos[numero] 20 | 21 | contador = "" 22 | for chave in reversed(algarismos.keys()): 23 | if chave < numero and numero: 24 | divisao = int((numero / chave)) 25 | resto = numero % chave 26 | contador += divisao * algarismos[chave] 27 | numero = resto 28 | return contador 29 | 30 | def numeros_romanos_arabicos(romano): 31 | #return romanos[number] 32 | 33 | soma= 0 34 | 35 | for item in romano: 36 | valor = romanos[item] 37 | soma += valor 38 | 39 | return soma 40 | 41 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /8-algarismos-romanos/test.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from main import numeros_arabicos_romanos, numeros_romanos_arabicos 3 | 4 | class TestCase(unittest.TestCase): 5 | 6 | def test_um_arabico(self): 7 | result = numeros_arabicos_romanos(1) 8 | self.assertEqual(result, "I") 9 | 10 | def test_cinco_arabico(self): 11 | result = numeros_arabicos_romanos(5) 12 | self.assertEqual(result, "V") 13 | 14 | def test_dez_arabico(self): 15 | result = numeros_arabicos_romanos(10) 16 | self.assertEqual(result, "X") 17 | 18 | def test_um_romano(self): 19 | result = numeros_romanos_arabicos("I") 20 | self.assertEqual(result, 1) 21 | 22 | def test_trezentos_romano(self): 23 | result = numeros_romanos_arabicos("CCC") 24 | self.assertEqual(result, 300) 25 | 26 | def test_trinta_romano(self): 27 | result = numeros_romanos_arabicos("XXX") 28 | self.assertEqual(result, 30) 29 | 30 | def test_trinta_arabico(self): 31 | result = numeros_arabicos_romanos(30) 32 | self.assertEqual(result, "XXX") 33 | 34 | def test_dois_mil_arabico(self): 35 | result = numeros_arabicos_romanos(2000) 36 | self.assertEqual(result, "MM") 37 | 38 | def test_seis_romano(self): 39 | result = numeros_romanos_arabicos("VI") 40 | self.assertEqual(result, 6) 41 | 42 | def test_seis_arabico(self): 43 | result = numeros_arabicos_romanos(6) 44 | self.assertEqual(result, "VI") 45 | 46 | if __name__ == "__main__": 47 | unittest.main() -------------------------------------------------------------------------------- /9-sequencia-de-cinco/README.md: -------------------------------------------------------------------------------- 1 | https://dojopuzzles.com/problems/sequencia-de-cinco/ 2 | 3 | 4 | Você está resolvendo este problema. 5 | Este problema foi utilizado em 222 Dojo(s). 6 | 7 | Dado uma matriz de números inteiros positivos de dimensões n x n, onde n >= 5, encontre o maior produto de uma seqüência de 5 números consecutivos (a seqüência pode estar na vertical, na horizontal ou na diagonal). 8 | 9 | Por exemplo, a matriz abaixo retorna 32: 10 | 11 | 2 1 1 1 1 12 | 1 2 1 1 1 13 | 1 1 2 1 1 14 | 1 1 1 2 1 15 | 1 1 1 1 2 16 | 17 | 18 | 19 | 20 | 21 | # Ruim 22 | 23 | Bom 24 | -------------------------------------------------------------------------------- /9-sequencia-de-cinco/main.py: -------------------------------------------------------------------------------- 1 | def maior_q_ou_igual_acinco(matriz): 2 | return len(matriz) >= 5 3 | 4 | def produto_matriz(matriz): 5 | maior_linha = 0 6 | for linha in matriz: 7 | valor = 1 8 | for numero in linha: 9 | valor = valor * numero 10 | if valor >= maior_linha: 11 | maior_linha = valor 12 | 13 | maior_coluna = 1 14 | maior_coluna_list = [[x[y] for x in matriz] for y in list(range(len(matriz)))] 15 | for linha in maior_coluna_list: 16 | valor = 1 17 | for numero in linha: 18 | valor = valor * numero 19 | if valor >= maior_coluna: 20 | maior_coluna = valor 21 | 22 | lista_diagonal = [linha[linha[linha.index]] for linha in matriz] 23 | diagonal = 1 24 | for numero in lista_diagonal: 25 | diagonal = diagonal * numero 26 | 27 | return linha_produto -------------------------------------------------------------------------------- /9-sequencia-de-cinco/test.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from main import maior_q_ou_igual_acinco,produto_matriz 3 | 4 | 5 | class TestCase(unittest.TestCase): 6 | 7 | def test_n_igual_maior_que_cinco(self): 8 | maior_que_igual_5 = maior_q_ou_igual_acinco([1, 2, 3, 4, 5]) 9 | self.assertEqual(maior_que_igual_5, True) 10 | 11 | def test_n_menor_que_cinco(self): 12 | maior_que_igual_5 = maior_q_ou_igual_acinco([1, 2]) 13 | 14 | self.assertEqual(maior_que_igual_5, False) 15 | 16 | def test_produto_vetor_de_1(self): 17 | acumulador=produto_matriz([1,1,1,1,1]) 18 | self.assertEqual(acumulador,1) 19 | 20 | def test_produto_vetor_de_2(self): 21 | acumulador = produto_matriz([2, 2, 2, 2, 2]) 22 | self.assertEqual(acumulador, 32) 23 | 24 | def test_produto_vetor_de_dez_elementos(self): 25 | acumulador = produto_matriz([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) 26 | self.assertEqual(acumulador, 3628800) 27 | 28 | def test_produto_vetor_lista_de_lista(self): 29 | matriz = [ 30 | [2, 2, 2, 2, 2], 31 | [1, 1, 1, 1, 1] 32 | ] 33 | acumulador = produto_matriz(matriz) 34 | 35 | 36 | 37 | if __name__ == "__main__": 38 | unittest.main() 39 | #escrever as diagonais -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # O Makefile é um arquivo onde você consegue definir uma série de tarefas a serem 2 | # executadas pelo comando criado tendo o comando `make` como antecessor. 3 | # Exemplos de tarefas que podem ser criadas no Makefile: 4 | # - Criação de diretórios, execução de comandos etc 5 | SHELL = /bin/bash -l 6 | 7 | DIR_NAME = dojo_recife 8 | 9 | python_setup: 10 | mkdir ${DIR_NAME} && touch ${DIR_NAME}/test.py ${DIR_NAME}/main.py && 11 | cp setup_tests/setup_python.py ${DIR_NAME}/test.py -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Dojo Recife 2 | 3 | Nesse repositório estão reunidas as soluções dos exercícios realizados durante as sessões de Dojo em Recife. 4 | 5 | Incentivamos você a forkar esse repositório e implementar a resolução do exercício da sua maneira e na linguagem de programação que você mais se sente confortável. Essa é uma ótima forma de praticar e seguir aprendendo! 6 | 7 | A cada novo encontro escolhemos um exercícios na plataforma [Dojo Puzzle](https://dojopuzzles.com/problems/intervalos/) para resolver. 8 | 9 | 10 | ## Criando diretório com setup de teste pronto 11 | ```shell 12 | make {linguagem}_setup DIR_NAME={nome_do_diretório} 13 | ``` 14 | Obs: verificar linguagens com setup disponíveis no diretório setup_tests 15 | -------------------------------------------------------------------------------- /ambientes/javascript/.gitignore: -------------------------------------------------------------------------------- 1 | *node_modules/* -------------------------------------------------------------------------------- /ambientes/javascript/instalacoes.md: -------------------------------------------------------------------------------- 1 | Supondo que nao haja node, npm na maquina 2 | 3 | // 4 | sudo apt install nodejs 5 | sudo apt install npm 6 | nodejs -v 7 | 8 | Na pasta a ser utilizada no dojo, rode o comando 9 | 10 | // 11 | npm init -y 12 | npm i -D jest 13 | 14 | Para rodar os testes em atualizacao continua 15 | 16 | // 17 | npx jest --watchAll -------------------------------------------------------------------------------- /ambientes/javascript/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "javascript", 3 | "version": "1.0.0", 4 | "description": "", 5 | "main": "index.js", 6 | "scripts": { 7 | "test": "echo \"Error: no test specified\" && exit 1" 8 | }, 9 | "keywords": [], 10 | "author": "", 11 | "license": "ISC", 12 | "devDependencies": { 13 | "jest": "^29.5.0" 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /ambientes/javascript/src/estudantes/estudantes.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | soma: notas => somaLocal(notas) 3 | } 4 | 5 | function somaLocal(notas){ 6 | if(Math.min(...notas)){ 7 | var resultado = notas.reduce((acc,nota) => { 8 | acc += nota 9 | return acc 10 | },0) 11 | return notas.length > 5 ? resultado *2 : resultado 12 | } 13 | 14 | return 0 15 | } 16 | 17 | -------------------------------------------------------------------------------- /ambientes/javascript/src/estudantes/estudantes.test.js: -------------------------------------------------------------------------------- 1 | const estudante = require('./estudantes') 2 | describe('Testes para alunos', () => { 3 | it('Deve retornar 10 quando as notas forem 5,3 e 2', () => { 4 | const notas = [3,5,2,2,5,1] 5 | expect(estudante.soma(notas)).toEqual(36) 6 | }) 7 | 8 | it('Deve retornar zero quando uma das notas forem 0', () => { 9 | const notas = [3,5,2,0] 10 | expect(estudante.soma(notas)).toEqual(0) 11 | }) 12 | 13 | it('Deve retornar X quando o aluno tiver mais de 5 notas', () => { 14 | const notas = [3,5,7,8] 15 | expect(estudante.soma(notas)).toEqual(23) 16 | }) 17 | 18 | }) -------------------------------------------------------------------------------- /ambientes/javascript/src/estudantes/estudantes.todo: -------------------------------------------------------------------------------- 1 | #Regras de Negocio para o caso 2 | 3 | Regras: 4 | Somar notas 5 | Se nota for 0, a soma deve retornar 0 6 | Caso o aluno tenha mais de 5 notas a soma deve ser multiplicada por dois 7 | -------------------------------------------------------------------------------- /cheque/cheque.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dojo-recife/dojo/f3dd4ac5d67dd0ffaaadf0b4e1fe8fedcc82a84e/cheque/cheque.pyc -------------------------------------------------------------------------------- /setup_tests/README.md: -------------------------------------------------------------------------------- 1 | # Setup Tests 2 | 3 | Para criar o setup de testes de uma linguagem que ainda não tem o setup criado siga os seguintes passos: 4 | - Crie um arquivo com o modelo de testes na linguagem em questão; 5 | - Nomeie o arquivo com o padrão setup_{linguagem}.extension; 6 | - Adicione no [Makefile](https://github.com/dojo_recife/dojo/blob/main/Makefile) o comando {linguagem}_setup para criar um novo diretório com os arquivos necessários para escrever a função que será criada no dojo e com o arquivo de testes contendo o código do modelo do setup correspondente -------------------------------------------------------------------------------- /setup_tests/setup_python.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from main import * 3 | 4 | 5 | class TestName(unittest.TestCase): 6 | """ 7 | local onde é adicionado os testes como o do exemplo abaixo: 8 | ex: 9 | def test_example(self): 10 | self.assertEqual(module(arg), expected_result) 11 | """ 12 | def test_example(self): 13 | self.assertEqual(function(), None) 14 | 15 | 16 | if __name__ == '__main__': 17 | unittest.main() 18 | --------------------------------------------------------------------------------