├── source ├── __init__.py ├── merge.py ├── lower_bound.py ├── upper_bound.py ├── insertion_sort.py ├── conjunto.py ├── funcional_zip.py ├── funcional.py ├── busca_binaria.py ├── lista_ordenada.py ├── deque.py └── selection_sort.py ├── GitCS.pdf ├── README.md └── main.py /source/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /GitCS.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cs-ufrn/pygit-20191/master/GitCS.pdf -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # pygit-20191 2 | 3 | Repositório para prática de Git e Python, 2019.1. 4 | 5 | -------------------------------------------------------------------------------- /source/merge.py: -------------------------------------------------------------------------------- 1 | """ Retorna uma lista ordenada que combine a lista1 e lista2, ambas previamente ordenadas """ 2 | def merge(lista1, lista2): 3 | pass -------------------------------------------------------------------------------- /source/lower_bound.py: -------------------------------------------------------------------------------- 1 | """ Retorna a posição do maior valor que seja menor que o elemento buscado, caso ele não exista na lista """ 2 | def lower_bound(lista, elemento): 3 | pass -------------------------------------------------------------------------------- /source/upper_bound.py: -------------------------------------------------------------------------------- 1 | """ Retorna a posição do menor valor que seja maior que o elemento buscado, caso ele não exista na lista """ 2 | def upper_bound(lista, elemento): 3 | pass -------------------------------------------------------------------------------- /source/insertion_sort.py: -------------------------------------------------------------------------------- 1 | """ Retorna uma lista ordenada, utilizando o algoritmo insertion sort """ 2 | def insertion_sort(lista): 3 | for j in range(1,len(lista)): 4 | elemento = lista[j] 5 | i = j-1 6 | while (i>=0 and lista[i] > elemento): 7 | lista[i+1] = lista[i] 8 | i = i-1 9 | lista[i+1] = elemento 10 | return lista 11 | -------------------------------------------------------------------------------- /source/conjunto.py: -------------------------------------------------------------------------------- 1 | """ Insere um elemento no conjunto, caso ele não exista """ 2 | def insert(conjunto, elemento): 3 | pass 4 | 5 | """ Remove um elemento no conjunto, caso ele exista """ 6 | def remove(conjunto, elemento): 7 | pass 8 | 9 | """ Verifica se um elemento existe no conjunto """ 10 | def exists(conjunto, elemento): 11 | pass 12 | -------------------------------------------------------------------------------- /source/funcional_zip.py: -------------------------------------------------------------------------------- 1 | """ Retorna uma lista contendo os pares das listas """ 2 | def zip(lista1, lista2): 3 | pass 4 | 5 | """ Retorna um par de listas baseandos na lista de pares do argumento """ 6 | def unzip(lista): 7 | pass 8 | 9 | """ Retorna uma lista contendo a aplicação de f sobre as listas """ 10 | def zipwith(lista1, lista2, f): 11 | pass 12 | 13 | -------------------------------------------------------------------------------- /source/funcional.py: -------------------------------------------------------------------------------- 1 | """ Retorna uma lista contendo os ks primeiros elementos da lista """ 2 | def take(lista, k): 3 | pass 4 | 5 | """ Retorna uma lista contendo o resultado da aplicação da função 'f' em cada elemento da lista """ 6 | def map(lista, f): 7 | pass 8 | 9 | """ Retorna os elementos da lista que satisfaçam a função f """ 10 | def filter(lista, f): 11 | pass 12 | -------------------------------------------------------------------------------- /source/busca_binaria.py: -------------------------------------------------------------------------------- 1 | """ Retorna a posição do elemento na lista """ 2 | def busca_binaria(lista, elemento): 3 | try: 4 | lista_v = list(lista) 5 | except ValueError: 6 | print("The arg lista can not be parse to a type list") 7 | 8 | l=0 9 | r=len(lista_v)-1 10 | 11 | while(r >= l): 12 | middle = r+l//2 13 | if(lista_v[middle] == elemento): 14 | return middle 15 | elif(lista_v[middle] < elemento): 16 | l = middle +1 17 | else: 18 | r = middle - 1 19 | return -1 20 | -------------------------------------------------------------------------------- /source/lista_ordenada.py: -------------------------------------------------------------------------------- 1 | """ Insere um elemento na lista """ 2 | def insert(lista, elemento): 3 | for i, value in enumerate(lista): 4 | if(value > elemento): 5 | lista.insert(i, elemento) 6 | return lista 7 | 8 | lista.append(elemento) 9 | return lista 10 | 11 | """ Remove um elemento na lista """ 12 | def remove(lista, elemento): 13 | lista.remove(elemento) 14 | return lista 15 | 16 | """ Busca um elemento na lista e retorne a sua posição """ 17 | def find(lista, elemento): 18 | for i, value in enumerate(lista): 19 | if(elemento == value): 20 | return i 21 | return -1 22 | -------------------------------------------------------------------------------- /source/deque.py: -------------------------------------------------------------------------------- 1 | 2 | """ Insere um elemento no início do deque """ 3 | def push_front(deque, elemento): 4 | deque.insert(0, elemento) 5 | return deque 6 | """ Insere um elemento ao final do deque """ 7 | def push_back(deque, elemento): 8 | deque.append(elemento) 9 | return deque 10 | 11 | """ Retorna o elemento do início do deque """ 12 | def front(deque): 13 | return deque[0] 14 | 15 | """ Retorna o elemento do final do deque """ 16 | def back(deque): 17 | return deque[-1] 18 | 19 | """ Remove um elemento do início do deque """ 20 | def pop_front(deque): 21 | del deque[0] 22 | return deque 23 | """ Remove um elemento do final do deque """ 24 | def pop_back(deque): 25 | deque.pop() 26 | return deque 27 | -------------------------------------------------------------------------------- /source/selection_sort.py: -------------------------------------------------------------------------------- 1 | """ Retorna uma lista ordenada, utilizando o algoritmo selection sort """ 2 | def selection_sort(alist): 3 | for preencherLocal in range(len(alist)-1,0,-1): #for que inicia do último elemento da lista e volta até o primeiro 4 | posicaoDeMaximo=0 #Max =0 é o indice do primeiro elemento, considerado máximo 5 | for local in range(1,preencherLocal+1): # for que vai do segundo elemento até o elemento seguinte de fillslot 6 | if alist[local]>alist[posicaoDeMaximo]: #condicional para dizer qual elemento é o maior 7 | posicaoDeMaximo = local #caso atendido, o índice do máximo é atualizado 8 | alist[posicaoDeMaximo],alist[preencherLocal] = alist[preencherLocal], alist[posicaoDeMaximo] #após encontrado, posições são trocadas: elemento máximo com a maior posição determinada pelo fillslot (será a maior posição não ordenada) 9 | return alist 10 | -------------------------------------------------------------------------------- /main.py: -------------------------------------------------------------------------------- 1 | """ 2 | Testes das bibliotecas implementadas pelos candidatos. 3 | """ 4 | 5 | from source import deque, conjunto, busca_binaria, lower_bound, upper_bound, insertion_sort, selection_sort, merge, lista_ordenada, funcional, funcional_zip 6 | 7 | # Issue 1 8 | print("#1: DEQUE") 9 | print(deque.push_front([1,2], 3) == [3, 1, 2]) 10 | print(deque.push_back([1,2], 3) == [1, 2, 3]) 11 | print(deque.front([2,5,1,20]) == 2) 12 | print(deque.back([2,5,1,100]) == 100) 13 | print(deque.pop_front([2,5,1,100]) == [5, 1, 100]) 14 | print(deque.pop_back([2,5,1,100]) == [2, 5, 1]) 15 | 16 | # Issue 2 17 | print("#2: CONJUNTO") 18 | print(conjunto.insert([1, 2], 3) == [1, 2, 3]) 19 | print(conjunto.insert([1, 2, 3], 3) == [1, 2, 3]) 20 | print(conjunto.remove([1, 2, 3], 2) == [1, 3]) 21 | print(conjunto.exists([3, 2, 1], 2) == True) 22 | print(conjunto.exists([3, 2, 1], 10) == False) 23 | print(conjunto.exists([], 10) == False) 24 | 25 | # Issue 3 26 | print("#3: BUSCA BINÁRIA") 27 | print(busca_binaria.busca_binaria([1, 2, 3, 5], 2) == 1) 28 | print(busca_binaria.busca_binaria([1, 2, 3, 5], 0) == -1) 29 | print(busca_binaria.busca_binaria([1, 2, 3, 5], 6) == -1) 30 | print(busca_binaria.busca_binaria([1, 2, 3, 5], 1) == 0) 31 | print(busca_binaria.busca_binaria([1, 2, 3, 5], 5) == 3) 32 | 33 | # Issue 4 34 | print("#4: LOWER BOUND") 35 | print(lower_bound.lower_bound([1, 2, 3, 5], 6) == 3) 36 | print(lower_bound.lower_bound([1, 2, 3, 5], 2) == 1) 37 | print(lower_bound.lower_bound([1, 2, 3, 5], 0) == -1) 38 | print(lower_bound.lower_bound([1, 2, 3, 5], 2) == 1) 39 | 40 | # Issue 5 41 | print("#5: UPPER BOUND") 42 | print(upper_bound.upper_bound([1, 2, 3, 5], 6) == -1) 43 | print(upper_bound.upper_bound([1, 2, 3, 5], 1) == 1) 44 | print(upper_bound.upper_bound([1, 2, 3, 5], 4) == 3) 45 | print(upper_bound.upper_bound([1, 2, 3, 5], 2) == 2) 46 | 47 | # Issue 6 48 | print("#6: INSERTION") 49 | print(insertion_sort.insertion_sort([4, 3, 2, 1]) == [1, 2, 3, 4]) 50 | print(insertion_sort.insertion_sort([1, 2, 3, 4]) == [1, 2, 3, 4]) 51 | print(insertion_sort.insertion_sort([2, 1, 3, 4]) == [1, 2, 3, 4]) 52 | 53 | # Issue 7 54 | print("#7: SELECTION") 55 | print(selection_sort.selection_sort([4, 3, 2, 1]) == [1, 2, 3, 4]) 56 | print(selection_sort.selection_sort([1, 2, 3, 4]) == [1, 2, 3, 4]) 57 | print(selection_sort.selection_sort([2, 1, 3, 4]) == [1, 2, 3, 4]) 58 | 59 | # Issue 8 60 | print("#8: MERGE") 61 | print(merge.merge([1, 2, 3], [8, 9, 10]) == [1, 2, 3, 8, 9, 10]) 62 | print(merge.merge([1, 2, 3], [1, 2]) == [1, 1, 2, 2, 3]) 63 | print(merge.merge([1], [1, 2]) == [1, 1, 2]) 64 | print(merge.merge([],[]) == []) 65 | 66 | # Issue 9 67 | print("#9: LISTAS ORDENADAS") 68 | print(lista_ordenada.insert([1, 2, 3], 4) == [1, 2, 3, 4]) 69 | print(lista_ordenada.remove([1, 2, 3], 2) == [1, 3]) 70 | print(lista_ordenada.find([1, 2, 3], 2) == 1) 71 | print(lista_ordenada.find([1, 2, 3], 4) == -1) 72 | 73 | # Issue 10 74 | print("#10: PYTHON FUNCIONAL (TAKE, MAP, FILTER)") 75 | print(funcional.take([4, 2, 3, 1], 2) == [4, 2]) 76 | print(funcional.map([1, 2, 3, 4], lambda x: x + 1) == [2, 3, 4, 5]) 77 | print(funcional.filter([1, 2, 3, 4], lambda x: x > 3) == [4]) 78 | 79 | # Issue 11 80 | print("#11: PYTHON FUNCIONAL (ZIP, UNZIP, ZIPWITH)") 81 | print(funcional_zip.zip([1, 2, 3, 4], [5, 6, 7, 8]) == [(1, 5), (2, 6), (3, 7), (4, 8)]) 82 | print(funcional_zip.unzip([(1, 5), (2, 6), (3, 7), (4, 8)]) == ([1, 2, 3, 4],[5, 6, 7, 8])) 83 | print(funcional_zip.zipwith([1, 2, 3, 4], [5, 6, 7, 8], lambda x, y : x + y) == [6, 8, 10, 12]) 84 | --------------------------------------------------------------------------------