Ontem aconteceu na Lambda3 um encontro do Grupy de São Paulo, o grupo de usuários de Python. A convite do Guto Maia, o Grupy nos visitou para uma atividade ainda não definida (até o começo da tarde de ontem). No fim, deu tudo certo, fizemos um dojo, e foi super divertido.

20160822_222042

O problema escolhido foi Contando Letras e Números, e, a princípio, achamos que seria fácil demais, mas na verdade ficou na medida, quase terminamos o problema.

Pra deixar tudo mais divertido, sugeri que fizéssemos num ambiente novo para muitos pythonistas, o que acabou sendo contado como ponto positivo. A sugestão foi fazer com Vim (o melhor editor de textos ever, e, com certeza, melhor que Emacs), no Windows, usando um Surface Pro 4 (teclado menor do que o que a maioria está acostumada, e em padrão americano), usando Bash on Ubuntu on Windows. Preparei o ambiente, e coloquei no Conemu, para termos abas (algo que o terminal do Windows ainda não tem). Fizemos com Python3, e funcionou tudo super bem, na prática o pessoal mal percebeu que era um Windows. O grande desafio foi de fato o Vim, que fez com que déssemos boas risadas com letras desaparecendo na tela, buffers duplicando, e outras alterações malucas acontecendo. Pra ficar ainda mais interessante, as setas do teclado não estavam funcionando no Vim, algo que não foi proposital, mas que fez com todos usassem “hjkl” pra movimentar o cursos em modo normal, entre os outros movimentos. Foi massa.

20160822_211957

Subi o resultado do Dojo pro Gist, e você pode ver ele abaixo também. O desafio dizia que tínhamos que contar quantas letras cada número por extenso possui, sem os espaços. Então, 1 é “um”, e tem 2 caracteres, portanto a resposta é 2. 121 é “centoevinteeum” e dá 14. Vejam abaixo os testes:

import unittest
from letras import Letras

class LetrasTest(unittest.TestCase):
    def testUm(self):
        letra_um = Letras(1)
        self.assertEqual(letra_um.letras, 2)

    def testDois(self):
        letra = Letras(2)
        self.assertEqual(letra.letras, 4)

    def testTres(self):
        letra = Letras(3)
        self.assertEqual(letra.letras, 4)

    def testQuatro(self):
        letra = Letras(4)
        self.assertEqual(letra.letras, 6)

    def testCinco(self):
        letra = Letras(5)
        self.assertEqual(letra.letras, 5)

    def testSeis(self):
        letra = Letras(6)
        self.assertEqual(letra.letras, 4)

    def testSete(self):
        letra = Letras(7)
        self.assertEqual(letra.letras, 4)

    def testOito(self):
        letra = Letras(8)
        self.assertEqual(letra.letras, 4)

    def testVinteEUm(self):
        letra = Letras(21)
        self.assertEqual(letra.letras, 8)

    def testVinteEDois(self):
        letra = Letras(22)
        self.assertEqual(letra.letras, 10)

    def testVinteETres(self):
        letra = Letras(23)
        self.assertEqual(letra.letras, 10)

    def testCem(self):
        letra = Letras(100)
        self.assertEqual(letra.letras, 3)

    def testCentoEUm(self):
        letra = Letras(101)
        self.assertEqual(letra.letras, 8)

    def testCentoEVinteEUm(self):
        letra = Letras(121)
        self.assertEqual(letra.letras, len("centoevinteeum"))

if __name__ == '__main__':
unittest.main()

E aqui a resolução:

unidades = ['um', 'dois', 'tres', 'quatro', 'cinco', 'seis', 'sete', 'oito']
dezenas = ['dez', 'vinte']
centenas = ['cento']

class Letras:
    def __init__(self, numero):
        if numero > 100:
            centena = int(numero / 100)
            dezena = int((numero - (centena * 100))/ 10)
            unidade = numero - (centena * 100) - (dezena * 10)
            letras_centena = self.conta(centena, centenas, e=True)
            letras_dezena = self.conta(dezena,dezenas, e=True)
            letras_unidade = self.conta(unidade,unidades)
            if dezena > 0:
                self.letras = letras_centena + letras_dezena + letras_unidade
            else:
                self.letras = letras_centena + letras_unidade


        elif numero == 100:
            self.letras = 3

        elif numero > 20:
            dezena = int(numero / 10)
            unidade = numero % 10

            self.letras = self.conta(dezena,dezenas, e=True) + self.conta(unidade,unidades)
        else:
            self.letras = len(unidades[numero - 1])

    def conta(self, numero, lista, e=None):
        somae = 1 if e else 0
return len(lista[numero-1]) + somae

Foi ótimo, o grupo de Python é um grupo novo pra mim, e curti muito a conversa com todos, um pessoal muito legal, algo que já imaginava pelo contato que eu tenho com o Guto, que é também uma pessoa ótima. Percebi que essa comunidade tem interesses adicionais aos que costumo ver nas outras comunidade, falamos muito de Arduino, data science, e assuntos diversos, como programação artística. Data science era esperado, já sabia que Python é uma das principais linguagens usadas pra esse fim. Foi ótimo.

20160822_211904

Eu me preparei um pouco pro evento, instalei as ferramentas de Python pro Visual Studio, e fiquei impressionado com a facilidade com que tudo funcionou. No fim, acabamos não usando, mas foi bom entender que funciona e como funciona.

Outro ponto legal foi receber ex-funcionários da Lambda3 que vieram para o encontro, o Wagner Leonardi e o Paulo Jean participaram com a gente.

O único ponto chato é que tivemos 60 inscritos e metade somente apareceu, deixando muita comida sobrando, e gente que queria participar foi impedida de vir. Isso é bem comum em qualquer reunião gratuita (por isso que semana que vem faremos o dotNetConf.local com a módica cobrança de R$5), mas é algo que o grupo está discutindo como resolver. Já vi o mesmo problema em reuniões de outros grupos, como o NodeBR, e grupos de .NET e Ruby. É algo muito chato que precisamos resolver urgentemente.

Aqui o resultado da retrospectiva:

photo755677956926449650

Pra quem quiser se envolver com o Grupy, sequem os contatos: