Add dojo 046

046/1.py

@@ -0,0 +1,33 @@
+"""
+Crie uma função que recebe uma string como entrada e retorna o primeiro caractere não repetido
+na string.
+
+Exemplo:
+Entrada: "abracadabra"
+Saída: "c"
+
+>>> conta_letra("abracadabra", "a")
+5
+
+>>> conta_letra("abracadabra", "b")
+2
+
+>>> nao_repete("abracadabra")
+'c'
+
+>>> nao_repete("abacaxi")
+'b'
+
+>>> nao_repete("aabb")
+''
+"""
+
+def nao_repete(palavra):
+    for i in palavra:
+        cont = conta_letra(palavra, i)
+        if cont == 1:
+            return i
+    return ''
+
+def conta_letra(palavra, letra):
+    return palavra.count(letra)

046/2.py

@@ -0,0 +1,80 @@
+"""
+Dado uma coleção de intervalos, mesclar quaisquer intervalos que se sobreponham.
+Escreva uma função que recebe uma lista de tuplas, onde cada tupla contém dois números
+inteiros representando o início e o fim de um intervalo. 
+
+Exemplo: 
+Entrada: [(1, 3), (2, 6), (8, 10), (15, 18)] 
+Saída: [(1, 6), (8, 10), (15, 18)] 
+
+
+
+>>> mescla((1, 3), (2, 6))
+(1, 6)
+>>> mescla((1, 3), (2, 10))
+(1, 10)
+
+
+
+
+
+>>> intersec((1,3), (2,6))
+True
+
+>>> intersec((5,6), (7,8))
+False
+
+>>> intersec((5, 5), (6, 6))
+False
+
+>>> ordena_entrada([(1, 3), (2, 6), (15, 18), (8, 10)])
+[(1, 3), (2, 6), (8, 10), (15, 18)]
+
+>>> ordena_entrada([(1, 3), (8, 10), (2, 6)])
+[(1, 3), (2, 6), (8, 10)]
+
+>>> resolve([(1, 3), (2, 6), (8, 10), (15, 18)] )
+[(1, 6), (8, 10), (15, 18)]
+>>> resolve([(1, 3), (2, 6), (8, 10)])
+[(1, 6), (8, 10)]
+
+>>> resolve([(1, 3), (2, 6), (8, 10), (9, 50)])
+[(1, 6), (8, 50)]
+
+>>> resolve([(1, 3), (9, 50)])
+[(1, 3), (9, 50)]
+
+>>> resolve([(9, 50), (1, 3)])
+[(1, 3), (9, 50)]
+
+>>> resolve([(9, 50)])
+[(9, 50)]
+"""
+def mescla(tp1, tp2):
+   return (tp1[0], tp2[1])
+
+
+
+def intersec(tp1, tp2):
+    return tp2[0] < tp1[1]
+
+
+def ordena_entrada(lista_de_tuplas):
+   return sorted(lista_de_tuplas)
+
+def resolve(lista_tuple):
+    lista_orde = ordena_entrada(lista_tuple)
+    resp = []
+    i = 0
+    while i < len(lista_orde):
+        tp = lista_orde[i]
+        for j in range(i + 1, len(lista_orde)): 
+            if intersec(tp,lista_orde[j]):
+                tp = mescla(tp,lista_orde[j])
+                i += 1
+            else:    
+                break
+        i += 1
+        resp.append(tp) 
+
+    return resp

046/3.py

@@ -0,0 +1,46 @@
+"""
+Escreva uma função que gere todos os números primos até n.
+Um número primo é um número natural maior que 1 que não possui divisores
+positivos além de 1 e ele mesmo.
+
+Exemplo:
+Entrada: 10
+Saída: [2, 3, 5, 7]
+
+Exemplo adicional:
+Entrada: 20
+Saída: [2, 3, 5, 7, 11, 13, 17, 19]
+
+>>> is_primo(5)
+True
+
+>>> is_primo(10)
+False
+
+>>> is_primo(16)
+False
+
+>>> is_primo(2358)
+False
+
+>>> escreve_primo(10)
+[2, 3, 5, 7]
+
+>>> escreve_primo(19)
+[2, 3, 5, 7, 11, 13, 17, 19]
+"""
+
+def is_primo(n):
+    for i in range(2, int(n**(0.5)+1)):
+        if n % i == 0:
+            return False
+    return True
+
+def escreve_primo(n):
+    lista_result =[]
+    for i in range(2, n+1):
+        if (is_primo(i)):
+            lista_result.append(i) 
+
+
+    return lista_result

046/retro.md

@@ -0,0 +1,14 @@
+# O que foi bom
+* Gente nova
+* Fizemos 3 problemas
+* Aprendemos mais sobre Python
+* Nível dos problemas foi interessante 
+
+# O que aprendemos
+* Sort em uma lista de tuplas funciona!
+* Conjuntos (set)
+* Raiz quadrada de um número para calcular primos
+
+# O que podemos melhorar
+* Dojo toolkit falhou bastante
+* Divulgação