Add dojo 059 (#44)

059/1.py

@@ -0,0 +1,49 @@
+"""
+1) Dado um número inteiro n_coluna, retorne o título da coluna correspondente como aparece em uma planilha do Excel.
+
+Por exemplo:
+A -> 1
+B -> 2
+C -> 3
+...
+Z -> 26
+AA -> 27
+AB -> 28
+...
+
+Exemplo 1:
+Entrada: n_coluna = 1
+Saída: "A"
+
+Exemplo 2:
+Entrada: n_coluna = 28
+Saída: "AB"
+
+Exemplo 3:
+Entrada: n_coluna = 701
+Saída: "ZY"
+
+>>> Converte_Coluna(1)
+'A'
+
+>>> Converte_Coluna(2)
+'B'
+
+>>> Converte_Coluna(28)
+'AB'
+
+>>> Converte_Coluna(701)
+'ZY'
+
+>>> Converte_Coluna(26)
+'Z'
+
+>>> Converte_Coluna(703)
+'AAA'
+"""
+def Converte_Coluna(n_coluna):
+    if n_coluna <= 26:
+        if n_coluna == 26:
+            return 'Z'
+        return chr(n_coluna + ord('A') - 1)
+    return Converte_Coluna(n_coluna // 26) + Converte_Coluna(n_coluna % 26)

059/2.py

@@ -0,0 +1,75 @@
+"""
+2) Os numerais romanos são representados por sete símbolos diferentes: I, V, X, L, C, D e M.
+
+Valores:
+I -> 1
+V -> 5
+X -> 10
+L -> 50
+C -> 100
+D -> 500
+M -> 1000
+
+Por exemplo, o número 2 é escrito como II em numeral romano, apenas dois "uns" somados.
+O número 12 é escrito como XII, que é simplesmente X + II. O número 27 é escrito como XXVII, que é XX + V + II.
+
+Os numerais romanos geralmente são escritos do maior para o menor, da esquerda para a direita.
+No entanto, o numeral para quatro não é IIII. Em vez disso, o número quatro é escrito como IV.
+Como o um está antes do cinco, subtraímos, resultando em quatro.
+O mesmo princípio se aplica ao número nove, que é escrito como IX.
+
+Existem seis casos em que a subtração é usada:
+    I pode ser colocado antes de V (5) e X (10) para formar 4 e 9.
+    X pode ser colocado antes de L (50) e C (100) para formar 40 e 90.
+    C pode ser colocado antes de D (500) e M (1000) para formar 400 e 900.
+
+Dado um numeral romano, converta-o para um número inteiro.
+
+Exemplo 1:
+Entrada: s = "III"
+Saída: 3
+Explicação: III = 3.
+
+Exemplo 2:
+Entrada: s = "LVIII"
+Saída: 58
+Explicação: L = 50, V = 5, III = 3.
+
+Exemplo 3:
+Entrada: s = "MCMXCIV"
+Saída: 1994
+Explicação: M = 1000, CM = 900, XC = 90 e IV = 4.
+
+>>> converte_romano("I")
+1
+
+>>> converte_romano("V")
+5
+
+>>> converte_romano("IV")
+4
+
+>>> converte_romano("MCMXCIV")
+1994
+
+>>> converte_romano("LVIII")
+58
+
+"""
+def converte_romano(n_romano):
+    romanos = {
+        "I": 1,
+        "V": 5,
+        "X": 10,
+        "L": 50,
+        "C": 100,
+        "D": 500,
+        "M": 1000
+    }
+    result = 0
+    for idx, n in enumerate(n_romano):
+        if idx < len(n_romano)-1 and romanos[n] < romanos[n_romano[idx+1]]:
+            result -= romanos[n]
+        else:
+            result += romanos[n]
+    return result

059/3.py

@@ -0,0 +1,80 @@
+"""
+3) Se fôssemos configurar um jogo da velha, gostaríamos de saber se o estado atual do tabuleiro está resolvido, não é?
+Nosso objetivo é criar uma função que verifique isso para nós!
+
+Assuma que o tabuleiro vem na forma de um array 3x3, onde o valor é 0 se uma posição estiver vazia, 1 se for um "X",
+ou 2 se for um "O", como neste exemplo:
+
+[[0, 0, 1],
+ [0, 1, 2],
+ [2, 1, 0]]
+
+Queremos que nossa função retorne:
+    -1 se o tabuleiro ainda não estiver finalizado E ninguém ganhou (existem posições vazias),
+    1 se o "X" ganhou,
+    2 se o "O" ganhou,
+    0 se for um empate (ou seja, um jogo sem vencedor).
+
+Você pode assumir que o tabuleiro passado é válido no contexto de um jogo da velha.
+
+Exemplos:
+
+Entrada:
+[[1, 1, 1],
+ [0, 2, 0],
+ [2, 0, 0]]
+Saída: 1
+
+Entrada:
+[[2, 1, 0],
+ [1, 2, 0],
+ [0, 1, 2]]
+Saída: 2
+
+Entrada:
+[[2, 1, 2],
+ [2, 1, 1],
+ [1, 2, 1]]
+Saída: 0
+
+Entrada:
+[[1, 0, 0],
+ [0, 2, 0],
+ [0, 0, 0]]
+Saída: -1
+
+>>> checa_linha([1, 1, 1])
+1
+
+>>> checa_linha([2, 2, 2])
+2
+
+>>> checa_linha([1, 2, 1])
+0
+
+>>> checa_linha([1, 2, 0])
+0
+
+>>> verifica_tabuleiro([[1, 1, 1],[0, 2, 0],[2, 0, 0]])
+1
+
+>>> verifica_tabuleiro([[2, 1, 0],[2, 0, 1],[2, 1, 2]])
+2
+
+# >>> verifica_tabuleiro([[2, 1, 0],[1, 2, 0],[0, 1, 2]])
+# 2
+
+"""
+def checa_linha(linha):
+    if all([a == linha[0] for a in linha]):
+        return linha[0]
+    return 0
+
+def verifica_tabuleiro(tabuleiro):
+    for linha in tabuleiro:
+        resultado = checa_linha(linha)
+        if resultado > 0:
+            return resultado
+    for i in range(3):
+        for 
+        coluna = [tabuleiro[]

059/retro.md

@@ -0,0 +1,14 @@
+# O que foi bom
+* Bastante gente nova
+* Todos participaram
+* Divulgação nos grupos da UFSCar
+* Começou no horário
+
+# O que aprendemos
+* Recursividade
+* ord e chr
+* enumerate
+* all
+
+# O que podemos melhorar
+* Nível dos problemas em ordem de dificuldade

README.md

@@ -5,6 +5,8 @@ Dojos realizados pelos membros do grupy-sanca
 
 ## Dojos realizados
 
+### [059 - 20/09/2024](https://github.com/grupy-sanca/dojos/tree/master/059)
+
 ### [058 - 29/08/2024](https://github.com/grupy-sanca/dojos/tree/master/058)
 
 ### [057 - 16/07/2024](https://github.com/grupy-sanca/dojos/tree/master/057)