From 47c5571087d38b9dd19ec85bd1f74451c949e1f1 Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 00:42:25 -0300 Subject: [PATCH 01/14] Addition of playfair cipher in python --- ciphers/README.md | 0 ciphers/playfair.py | 146 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 146 insertions(+) create mode 100644 ciphers/README.md create mode 100644 ciphers/playfair.py diff --git a/ciphers/README.md b/ciphers/README.md new file mode 100644 index 0000000..e69de29 diff --git a/ciphers/playfair.py b/ciphers/playfair.py new file mode 100644 index 0000000..7396cf9 --- /dev/null +++ b/ciphers/playfair.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import sys + +# @Author: Gleydson Rodrigues + +# ./playfair.py [encrypt/decrypt] key message + + +alphabet = "abcdefghijlmnopqrstuvwxyz".upper() + +def vetorize(text): + listText = [] + for letter in text: + listText.append(letter) + return listText + +def normalizeMessage(text): + newText = [] + text = text.upper() + text = text.replace(" ", "") + text = text.replace(".", "") + text = text.replace(",", "") + pos = 0 + while pos < len(text) - 1: + firstLetter = text[pos] + secondLetter = text[pos + 1] + if firstLetter == secondLetter: + if firstLetter == "X": + newText.append(firstLetter) + newText.append("Z") + pos += 1 + else: + newText.append(firstLetter) + newText.append("X") + pos += 1 + else: + newText.append(firstLetter) + newText.append(secondLetter) + pos += 2 + if pos < len(text): + if text[-1] == "X": + newText.append(text[pos]) + newText.append("Z") + else: + newText.append(text[pos]) + newText.append("X") + return newText + +def createMatrix(): + matrix = [] + for i in range(5): + matrix.append([]) + for j in range(5): + matrix[i].append("") + return matrix + +def mountGrid(matrix, key, alphabet): + alphabet = vetorize(alphabet) + line, column, pos = 0, 0, 0 + for letter in key: + line = pos / 5 + column = pos % 5 + if letter in alphabet: + alphabet.remove(letter) + matrix[line][column] = letter + pos += 1 + while len(alphabet) > 0: + line = pos / 5 + column = pos % 5 + matrix[line][column] = alphabet.pop(0) + pos += 1 + return matrix + +def getIndex(letter, matrix): + for i in range(5): + for j in range(5): + if matrix[i][j] == letter: + return [i, j] + +def encrypt(message, key): + matrix = mountGrid(createMatrix(), key, alphabet) + message = normalizeMessage(message) + messageEncrypted = "" + pos, line, column = 0, 0, 1 + while pos < len(message) - 1: + firstLetter = message[pos] + secondLetter = message[pos + 1] + indexFirstLetter = getIndex(firstLetter, matrix) + indexSecondLetter = getIndex(secondLetter, matrix) + if indexFirstLetter[line] == indexSecondLetter[line]: + messageEncrypted += matrix[indexFirstLetter[line]][(indexFirstLetter[column] + 1) % 5] + messageEncrypted += matrix[indexSecondLetter[line]][(indexSecondLetter[column] + 1) % 5] + elif indexFirstLetter[column] == indexSecondLetter[column]: + messageEncrypted += matrix[(indexFirstLetter[line] + 1) % 5][indexFirstLetter[column]] + messageEncrypted += matrix[(indexSecondLetter[line] + 1) % 5][indexSecondLetter[column]] + else: + messageEncrypted += matrix[indexFirstLetter[line]][indexSecondLetter[column]] + messageEncrypted += matrix[indexSecondLetter[line]][indexFirstLetter[column]] + pos += 2 + return messageEncrypted + +def decrypt(messageEncrypted, key): + matrix = mountGrid(createMatrix(), key, alphabet) + messageDecrypted = "" + pos, line, column = 0, 0, 1 + while pos < len(messageEncrypted): + firstLetter = messageEncrypted[pos] + secondLetter = messageEncrypted[pos + 1] + indexFirstLetter = getIndex(firstLetter, matrix) + indexSecondLetter = getIndex(secondLetter, matrix) + if indexFirstLetter[line] == indexSecondLetter[line]: + messageDecrypted += matrix[indexFirstLetter[line]][(indexFirstLetter[column] - 1) % 5] + messageDecrypted += matrix[indexSecondLetter[line]][(indexSecondLetter[column] - 1) % 5] + elif indexFirstLetter[column] == indexSecondLetter[column]: + messageDecrypted += matrix[(indexFirstLetter[line] - 1) % 5][indexFirstLetter[column]] + messageDecrypted += matrix[(indexSecondLetter[line] - 1) % 5][indexSecondLetter[column]] + else: + messageDecrypted += matrix[indexFirstLetter[line]][indexSecondLetter[column]] + messageDecrypted += matrix[indexSecondLetter[line]][indexFirstLetter[column]] + pos += 2 + return messageDecrypted + +def help(): + print( + "./playfair.py [encrypt/decrypt] key message" + ) + +def main(): + params = sys.argv[1:] + if len(params) == 0: + help() + elif params[0] == "encrypt": + key = params[1].upper() + message = params[2:] + print(encrypt("".join(x for x in message).upper(), key)) + elif params[0] == "decrypt": + key = params[1].upper() + message = params[2:] + print(decrypt("".join(x for x in message).upper(), key)) + else: + help() + +if __name__ == "__main__": + main() \ No newline at end of file From d1e0f31413a7f32422d5b457d18461999d6bdb54 Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 00:44:46 -0300 Subject: [PATCH 02/14] Delete README.md --- ciphers/README.md | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 ciphers/README.md diff --git a/ciphers/README.md b/ciphers/README.md deleted file mode 100644 index e69de29..0000000 From 9b3d0b4a8f09171f57cc772d55fec9c4daec6fd7 Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:48:28 -0300 Subject: [PATCH 03/14] add caesar cipher --- ciphers/caesar_cipher.py | 68 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 ciphers/caesar_cipher.py diff --git a/ciphers/caesar_cipher.py b/ciphers/caesar_cipher.py new file mode 100644 index 0000000..6cd35e7 --- /dev/null +++ b/ciphers/caesar_cipher.py @@ -0,0 +1,68 @@ +import sys +def encrypt(strng, key): + encrypted = '' + for x in strng: + indx = (ord(x) + key) % 256 + if indx > 126: + indx = indx - 95 + encrypted = encrypted + chr(indx) + return encrypted + + +def decrypt(strng, key): + decrypted = '' + for x in strng: + indx = (ord(x) - key) % 256 + if indx < 32: + indx = indx + 95 + decrypted = decrypted + chr(indx) + return decrypted + +def brute_force(strng): + key = 1 + decrypted = '' + while key <= 94: + for x in strng: + indx = (ord(x) - key) % 256 + if indx < 32: + indx = indx + 95 + decrypted = decrypted + chr(indx) + print("Key: {}\t| Message: {}".format(key, decrypted)) + decrypted = '' + key += 1 + return None + + +def main(): + print('-' * 10 + "\n**Menu**\n" + '-' * 10) + print("1.Encrpyt") + print("2.Decrypt") + print("3.BruteForce") + print("4.Quit") + while True: + choice = input("What would you like to do?: ") + if choice not in ['1', '2', '3', '4']: + print ("Invalid choice") + elif choice == '1': + strng = input("Please enter the string to be ecrypted: ") + while True: + key = int(input("Please enter off-set between 1-94: ")) + if key in range(1, 95): + print (encrypt(strng, key)) + main() + elif choice == '2': + strng = input("Please enter the string to be decrypted: ") + while True: + key = int(input("Please enter off-set between 1-94: ")) + if key > 0 and key <= 94: + print(decrypt(strng, key)) + main() + elif choice == '3': + strng = input("Please enter the string to be decrypted: ") + brute_force(strng) + main() + elif choice == '4': + print ("Goodbye.") + sys.exit() + +main() From c72e0d0c1512bd7ee085f61a95226d2e9ca76bfc Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:49:40 -0300 Subject: [PATCH 04/14] add avl data structure --- data-structures/AVL.py | 178 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 178 insertions(+) create mode 100644 data-structures/AVL.py diff --git a/data-structures/AVL.py b/data-structures/AVL.py new file mode 100644 index 0000000..d77692b --- /dev/null +++ b/data-structures/AVL.py @@ -0,0 +1,178 @@ +from __future__ import print_function + + +class Node: + + def __init__(self, label): + self.label = label + self._parent = None + self._left = None + self._right = None + self.height = 0 + + @property + def right(self): + return self._right + + @right.setter + def right(self, node): + if node is not None: + node._parent = self + self._right = node + + @property + def left(self): + return self._left + + @left.setter + def left(self, node): + if node is not None: + node._parent = self + self._left = node + + @property + def parent(self): + return self._parent + + @parent.setter + def parent(self, node): + if node is not None: + self._parent = node + self.height = self.parent.height + 1 + else: + self.height = 0 + + +class AVL: + + def __init__(self): + self.root = None + self.size = 0 + + def insert(self, value): + node = Node(value) + + if self.root is None: + self.root = node + self.root.height = 0 + self.size = 1 + else: + # Same as Binary Tree + dad_node = None + curr_node = self.root + + while True: + if curr_node is not None: + + dad_node = curr_node + + if node.label < curr_node.label: + curr_node = curr_node.left + else: + curr_node = curr_node.right + else: + node.height = dad_node.height + dad_node.height += 1 + if node.label < dad_node.label: + dad_node.left = node + else: + dad_node.right = node + self.rebalance(node) + self.size += 1 + break + + def rebalance(self, node): + n = node + + while n is not None: + height_right = n.height + height_left = n.height + + if n.right is not None: + height_right = n.right.height + + if n.left is not None: + height_left = n.left.height + + if abs(height_left - height_right) > 1: + if height_left > height_right: + left_child = n.left + if left_child is not None: + h_right = (left_child.right.height + if (left_child.right is not None) else 0) + h_left = (left_child.left.height + if (left_child.left is not None) else 0) + if (h_left > h_right): + self.rotate_left(n) + break + else: + self.double_rotate_right(n) + break + else: + right_child = n.right + if right_child is not None: + h_right = (right_child.right.height + if (right_child.right is not None) else 0) + h_left = (right_child.left.height + if (right_child.left is not None) else 0) + if (h_left > h_right): + self.double_rotate_left(n) + break + else: + self.rotate_right(n) + break + n = n.parent + + def rotate_left(self, node): + aux = node.parent.label + node.parent.label = node.label + node.parent.right = Node(aux) + node.parent.right.height = node.parent.height + 1 + node.parent.left = node.right + + + def rotate_right(self, node): + aux = node.parent.label + node.parent.label = node.label + node.parent.left = Node(aux) + node.parent.left.height = node.parent.height + 1 + node.parent.right = node.right + + def double_rotate_left(self, node): + self.rotate_right(node.getRight().getRight()) + self.rotate_left(node) + + def double_rotate_right(self, node): + self.rotate_left(node.getLeft().getLeft()) + self.rotate_right(node) + + def empty(self): + if self.root is None: + return True + return False + + def preShow(self, curr_node): + if curr_node is not None: + self.preShow(curr_node.left) + print(curr_node.label, end=" ") + self.preShow(curr_node.right) + + def preorder(self, curr_node): + if curr_node is not None: + self.preShow(curr_node.left) + self.preShow(curr_node.right) + print(curr_node.label, end=" ") + + def getRoot(self): + return self.root + +t = AVL() +t.insert(1) +t.insert(2) +t.insert(3) +# t.preShow(t.root) +# print("\n") +# t.insert(4) +# t.insert(5) +# t.preShow(t.root) +# t.preorden(t.root) From f968d5dec6554313de1e85b65f2545c3f4494c1f Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:51:09 -0300 Subject: [PATCH 05/14] add binary search --- data-structures/binary_search_tree.py | 237 ++++++++++++++++++++++++++ 1 file changed, 237 insertions(+) create mode 100644 data-structures/binary_search_tree.py diff --git a/data-structures/binary_search_tree.py b/data-structures/binary_search_tree.py new file mode 100644 index 0000000..1ceb107 --- /dev/null +++ b/data-structures/binary_search_tree.py @@ -0,0 +1,237 @@ +from __future__ import print_function +class Node: + + def __init__(self, label, parent): + self.label = label + self.left = None + self.right = None + #Added in order to delete a node easier + self.parent = parent + + def getLabel(self): + return self.label + + def setLabel(self, label): + self.label = label + + def getLeft(self): + return self.left + + def setLeft(self, left): + self.left = left + + def getRight(self): + return self.right + + def setRight(self, right): + self.right = right + + def getParent(self): + return self.parent + + def setParent(self, parent): + self.parent = parent + +class BinarySearchTree: + + def __init__(self): + self.root = None + + def insert(self, label): + # Create a new Node + new_node = Node(label, None) + # If Tree is empty + if self.empty(): + self.root = new_node + else: + #If Tree is not empty + curr_node = self.root + #While we don't get to a leaf + while curr_node is not None: + #We keep reference of the parent node + parent_node = curr_node + #If node label is less than current node + if new_node.getLabel() < curr_node.getLabel(): + #We go left + curr_node = curr_node.getLeft() + else: + #Else we go right + curr_node = curr_node.getRight() + #We insert the new node in a leaf + if new_node.getLabel() < parent_node.getLabel(): + parent_node.setLeft(new_node) + else: + parent_node.setRight(new_node) + #Set parent to the new node + new_node.setParent(parent_node) + + def delete(self, label): + if (not self.empty()): + #Look for the node with that label + node = self.getNode(label) + #If the node exists + if(node is not None): + #If it has no children + if(node.getLeft() is None and node.getRight() is None): + self.__reassignNodes(node, None) + node = None + #Has only right children + elif(node.getLeft() is None and node.getRight() is not None): + self.__reassignNodes(node, node.getRight()) + #Has only left children + elif(node.getLeft() is not None and node.getRight() is None): + self.__reassignNodes(node, node.getLeft()) + #Has two children + else: + #Gets the max value of the left branch + tmpNode = self.getMax(node.getLeft()) + #Deletes the tmpNode + self.delete(tmpNode.getLabel()) + #Assigns the value to the node to delete and keesp tree structure + node.setLabel(tmpNode.getLabel()) + + def getNode(self, label): + curr_node = None + #If the tree is not empty + if(not self.empty()): + #Get tree root + curr_node = self.getRoot() + #While we don't find the node we look for + #I am using lazy evaluation here to avoid NoneType Attribute error + while curr_node is not None and curr_node.getLabel() is not label: + #If node label is less than current node + if label < curr_node.getLabel(): + #We go left + curr_node = curr_node.getLeft() + else: + #Else we go right + curr_node = curr_node.getRight() + return curr_node + + def getMax(self, root = None): + if(root is not None): + curr_node = root + else: + #We go deep on the right branch + curr_node = self.getRoot() + if(not self.empty()): + while(curr_node.getRight() is not None): + curr_node = curr_node.getRight() + return curr_node + + def getMin(self, root = None): + if(root is not None): + curr_node = root + else: + #We go deep on the left branch + curr_node = self.getRoot() + if(not self.empty()): + curr_node = self.getRoot() + while(curr_node.getLeft() is not None): + curr_node = curr_node.getLeft() + return curr_node + + def empty(self): + if self.root is None: + return True + return False + + def __InOrderTraversal(self, curr_node): + nodeList = [] + if curr_node is not None: + nodeList.insert(0, curr_node) + nodeList = nodeList + self.__InOrderTraversal(curr_node.getLeft()) + nodeList = nodeList + self.__InOrderTraversal(curr_node.getRight()) + return nodeList + + def getRoot(self): + return self.root + + def __isRightChildren(self, node): + if(node == node.getParent().getRight()): + return True + return False + + def __reassignNodes(self, node, newChildren): + if(newChildren is not None): + newChildren.setParent(node.getParent()) + if(node.getParent() is not None): + #If it is the Right Children + if(self.__isRightChildren(node)): + node.getParent().setRight(newChildren) + else: + #Else it is the left children + node.getParent().setLeft(newChildren) + + #This function traversal the tree. By default it returns an + #In order traversal list. You can pass a function to traversal + #The tree as needed by client code + def traversalTree(self, traversalFunction = None, root = None): + if(traversalFunction is None): + #Returns a list of nodes in preOrder by default + return self.__InOrderTraversal(self.root) + else: + #Returns a list of nodes in the order that the users wants to + return traversalFunction(self.root) + + #Returns an string of all the nodes labels in the list + #In Order Traversal + def __str__(self): + list = self.__InOrderTraversal(self.root) + str = "" + for x in list: + str = str + " " + x.getLabel().__str__() + return str + +def InPreOrder(curr_node): + nodeList = [] + if curr_node is not None: + nodeList = nodeList + InPreOrder(curr_node.getLeft()) + nodeList.insert(0, curr_node.getLabel()) + nodeList = nodeList + InPreOrder(curr_node.getRight()) + return nodeList + +def testBinarySearchTree(): + t = BinarySearchTree() + t.insert(8) + t.insert(3) + t.insert(6) + t.insert(1) + t.insert(10) + t.insert(14) + t.insert(13) + t.insert(4) + t.insert(7) + + #Prints all the elements of the list in order traversal + print(t.__str__()) + + if(t.getNode(6) is not None): + print("The label 6 exists") + else: + print("The label 6 doesn't exist") + + if(t.getNode(-1) is not None): + print("The label -1 exists") + else: + print("The label -1 doesn't exist") + + if(not t.empty()): + print(("Max Value: ", t.getMax().getLabel())) + print(("Min Value: ", t.getMin().getLabel())) + + t.delete(13) + t.delete(10) + t.delete(8) + t.delete(3) + t.delete(6) + t.delete(14) + + #Gets all the elements of the tree In pre order + #And it prints them + list = t.traversalTree(InPreOrder, t.root) + for x in list: + print(x) + +if __name__ == "__main__": + testBinarySearchTree() From 61e849f47ec7dd85eb2b19ecb7a105f4d58e3100 Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:52:20 -0300 Subject: [PATCH 06/14] add hash table --- data-structures/hash_table.py | 80 +++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 data-structures/hash_table.py diff --git a/data-structures/hash_table.py b/data-structures/hash_table.py new file mode 100644 index 0000000..daa12d9 --- /dev/null +++ b/data-structures/hash_table.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python3 +from number_theory.prime_numbers import next_prime + +class HashTable: + + def __init__(self, size_table, charge_factor=None, lim_charge=None): + self.size_table = size_table + self.values = [None] * self.size_table + self.lim_charge = 0.75 if lim_charge is None else lim_charge + self.charge_factor = 1 if charge_factor is None else charge_factor + self.__aux_list = [] + self._keys = {} + + def keys(self): + return self._keys + + def balanced_factor(self): + return sum([1 for slot in self.values + if slot is not None]) / (self.size_table * self.charge_factor) + + def hash_function(self, key): + return key % self.size_table + + def _step_by_step(self, step_ord): + + print("step {0}".format(step_ord)) + print([i for i in range(len(self.values))]) + print(self.values) + + def bulk_insert(self, values): + i = 1 + self.__aux_list = values + for value in values: + self.insert_data(value) + self._step_by_step(i) + i += 1 + + def _set_value(self, key, data): + self.values[key] = data + self._keys[key] = data + + def _colision_resolution(self, key, data=None): + new_key = self.hash_function(key + 1) + + while self.values[new_key] is not None \ + and self.values[new_key] != key: + + if self.values.count(None) > 0: + new_key = self.hash_function(new_key + 1) + else: + new_key = None + break + + return new_key + + def rehashing(self): + survivor_values = [value for value in self.values if value is not None] + self.size_table = next_prime(self.size_table, factor=2) + self._keys.clear() + self.values = [None] * self.size_table #hell's pointers D: don't DRY ;/ + map(self.insert_data, survivor_values) + + def insert_data(self, data): + key = self.hash_function(data) + + if self.values[key] is None: + self._set_value(key, data) + + elif self.values[key] == data: + pass + + else: + colision_resolution = self._colision_resolution(key, data) + if colision_resolution is not None: + self._set_value(colision_resolution, data) + else: + self.rehashing() + self.insert_data(data) + + From 706a95919b1badd7a764bdd442ea522aadbafeba Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:53:08 -0300 Subject: [PATCH 07/14] add heap --- data-structures/heap.py | 90 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 data-structures/heap.py diff --git a/data-structures/heap.py b/data-structures/heap.py new file mode 100644 index 0000000..e66d02b --- /dev/null +++ b/data-structures/heap.py @@ -0,0 +1,90 @@ +#!/usr/bin/python + +from __future__ import print_function + +try: + raw_input # Python 2 +except NameError: + raw_input = input # Python 3 + +class Heap: + def __init__(self): + self.h = [] + self.currsize = 0 + + def leftChild(self,i): + if 2*i+1 < self.currsize: + return 2*i+1 + return None + + def rightChild(self,i): + if 2*i+2 < self.currsize: + return 2*i+2 + return None + + def maxHeapify(self,node): + if node < self.currsize: + m = node + lc = self.leftChild(node) + rc = self.rightChild(node) + if lc is not None and self.h[lc] > self.h[m]: + m = lc + if rc is not None and self.h[rc] > self.h[m]: + m = rc + if m!=node: + temp = self.h[node] + self.h[node] = self.h[m] + self.h[m] = temp + self.maxHeapify(m) + + def buildHeap(self,a): + self.currsize = len(a) + self.h = list(a) + for i in range(self.currsize/2,-1,-1): + self.maxHeapify(i) + + def getMax(self): + if self.currsize >= 1: + me = self.h[0] + temp = self.h[0] + self.h[0] = self.h[self.currsize-1] + self.h[self.currsize-1] = temp + self.currsize -= 1 + self.maxHeapify(0) + return me + return None + + def heapSort(self): + size = self.currsize + while self.currsize-1 >= 0: + temp = self.h[0] + self.h[0] = self.h[self.currsize-1] + self.h[self.currsize-1] = temp + self.currsize -= 1 + self.maxHeapify(0) + self.currsize = size + + def insert(self,data): + self.h.append(data) + curr = self.currsize + self.currsize+=1 + while self.h[curr] > self.h[curr/2]: + temp = self.h[curr/2] + self.h[curr/2] = self.h[curr] + self.h[curr] = temp + curr = curr/2 + + def display(self): + print(self.h) + +def main(): + l = list(map(int, raw_input().split())) + h = Heap() + h.buildHeap(l) + h.heapSort() + h.display() + +if __name__=='__main__': + main() + + From 062938fa4c33b630daf085e5d60e7a632186d340 Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:54:28 -0300 Subject: [PATCH 08/14] add edit distance --- dynamic-programming/edit_distance.py | 39 ++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 dynamic-programming/edit_distance.py diff --git a/dynamic-programming/edit_distance.py b/dynamic-programming/edit_distance.py new file mode 100644 index 0000000..15130a7 --- /dev/null +++ b/dynamic-programming/edit_distance.py @@ -0,0 +1,39 @@ +from __future__ import print_function + + +class EditDistance: + + def __init__(self): + self.__prepare__() + + def __prepare__(self, N = 0, M = 0): + self.dp = [[-1 for y in range(0,M)] for x in range(0,N)] + + def __solveDP(self, x, y): + if (x==-1): + return y+1 + elif (y==-1): + return x+1 + elif (self.dp[x][y]>-1): + return self.dp[x][y] + else: + if (self.A[x]==self.B[y]): + self.dp[x][y] = self.__solveDP(x-1,y-1) + else: + self.dp[x][y] = 1+min(self.__solveDP(x,y-1), self.__solveDP(x-1,y), self.__solveDP(x-1,y-1)) + + return self.dp[x][y] + + def solve(self, A, B): + if isinstance(A,bytes): + A = A.decode('ascii') + + if isinstance(B,bytes): + B = B.decode('ascii') + + self.A = str(A) + self.B = str(B) + + self.__prepare__(len(A), len(B)) + + return self.__solveDP(len(A)-1, len(B)-1) From 7cfefed7d55be18a0c5ddcee943f0ff392a8d1c2 Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:55:08 -0300 Subject: [PATCH 09/14] add floyd warshall --- dynamic-programming/FloydWarshall.py | 37 ++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 dynamic-programming/FloydWarshall.py diff --git a/dynamic-programming/FloydWarshall.py b/dynamic-programming/FloydWarshall.py new file mode 100644 index 0000000..038499c --- /dev/null +++ b/dynamic-programming/FloydWarshall.py @@ -0,0 +1,37 @@ +import math + +class Graph: + + def __init__(self, N = 0): # a graph with Node 0,1,...,N-1 + self.N = N + self.W = [[math.inf for j in range(0,N)] for i in range(0,N)] # adjacency matrix for weight + self.dp = [[math.inf for j in range(0,N)] for i in range(0,N)] # dp[i][j] stores minimum distance from i to j + + def addEdge(self, u, v, w): + self.dp[u][v] = w + + def floyd_warshall(self): + for k in range(0,self.N): + for i in range(0,self.N): + for j in range(0,self.N): + self.dp[i][j] = min(self.dp[i][j], self.dp[i][k] + self.dp[k][j]) + + def showMin(self, u, v): + return self.dp[u][v] + +if __name__ == '__main__': + graph = Graph(5) + graph.addEdge(0,2,9) + graph.addEdge(0,4,10) + graph.addEdge(1,3,5) + graph.addEdge(2,3,7) + graph.addEdge(3,0,10) + graph.addEdge(3,1,2) + graph.addEdge(3,2,1) + graph.addEdge(3,4,6) + graph.addEdge(4,1,3) + graph.addEdge(4,2,4) + graph.addEdge(4,3,9) + graph.floyd_warshall() + graph.showMin(1,4) + graph.showMin(0,3) From 62e865565083722bef51d62926ab41e164a192f0 Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:57:03 -0300 Subject: [PATCH 10/14] add bucket sort --- sorting/bucket_sort.py | 44 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 sorting/bucket_sort.py diff --git a/sorting/bucket_sort.py b/sorting/bucket_sort.py new file mode 100644 index 0000000..3765b2e --- /dev/null +++ b/sorting/bucket_sort.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python + +from __future__ import print_function +from insertion_sort import insertion_sort +import math + +DEFAULT_BUCKET_SIZE = 5 + +def bucketSort(myList, bucketSize=DEFAULT_BUCKET_SIZE): + if(len(myList) == 0): + print('You don\'t have any elements in array!') + + minValue = myList[0] + maxValue = myList[0] + + # For finding minimum and maximum values + for i in range(0, len(myList)): + if myList[i] < minValue: + minValue = myList[i] + elif myList[i] > maxValue: + maxValue = myList[i] + + # Initialize buckets + bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1 + buckets = [] + for i in range(0, bucketCount): + buckets.append([]) + + # For putting values in buckets + for i in range(0, len(myList)): + buckets[math.floor((myList[i] - minValue) / bucketSize)].append(myList[i]) + + # Sort buckets and place back into input array + sortedArray = [] + for i in range(0, len(buckets)): + insertion_sort(buckets[i]) + for j in range(0, len(buckets[i])): + sortedArray.append(buckets[i][j]) + + return sortedArray + +if __name__ == '__main__': + sortedArray = bucketSort([2, 34, 44, 2, 67, 13, 9, 102, 54, 21, 43, 99]) + print(sortedArray) From d89e7d3fb958700e3c0147ca697c21b8b354999a Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:58:01 -0300 Subject: [PATCH 11/14] add selection sort --- sorting/selection_sort.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 sorting/selection_sort.py diff --git a/sorting/selection_sort.py b/sorting/selection_sort.py new file mode 100644 index 0000000..86e95f3 --- /dev/null +++ b/sorting/selection_sort.py @@ -0,0 +1,26 @@ +from __future__ import print_function + + +def selection_sort(collection): + + length = len(collection) + for i in range(length): + least = i + for k in range(i + 1, length): + if collection[k] < collection[least]: + least = k + collection[least], collection[i] = ( + collection[i], collection[least] + ) + return collection + + +if __name__ == '__main__': + try: + raw_input # Python 2 + except NameError: + raw_input = input # Python 3 + + user_input = raw_input('Enter numbers separated by a comma:\n').strip() + unsorted = [int(item) for item in user_input.split(',')] + print(selection_sort(unsorted)) From 8823514bdc55cb88c69154f079ac786909aaf230 Mon Sep 17 00:00:00 2001 From: Gleydson Rodrigues Date: Wed, 3 Oct 2018 01:58:45 -0300 Subject: [PATCH 12/14] add quick sort --- sorting/quick_sort.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 sorting/quick_sort.py diff --git a/sorting/quick_sort.py b/sorting/quick_sort.py new file mode 100644 index 0000000..15f04c2 --- /dev/null +++ b/sorting/quick_sort.py @@ -0,0 +1,23 @@ +from __future__ import print_function + + +def quick_sort(ARRAY): + ARRAY_LENGTH = len(ARRAY) + if( ARRAY_LENGTH <= 1): + return ARRAY + else: + PIVOT = ARRAY[0] + GREATER = [ element for element in ARRAY[1:] if element > PIVOT ] + LESSER = [ element for element in ARRAY[1:] if element <= PIVOT ] + return quick_sort(LESSER) + [PIVOT] + quick_sort(GREATER) + + +if __name__ == '__main__': + try: + raw_input # Python 2 + except NameError: + raw_input = input # Python 3 + + user_input = raw_input('Enter numbers separated by a comma:\n').strip() + unsorted = [ int(item) for item in user_input.split(',') ] + print( quick_sort(unsorted) ) From 1765cfd72660f03226ac0c2e10c080544cea4ea2 Mon Sep 17 00:00:00 2001 From: Abraham Hernandez Date: Thu, 4 Oct 2018 01:06:50 -0400 Subject: [PATCH 13/14] delete bucket_sort to fix merge conflicts --- sorting/bucket_sort.py | 44 ------------------------------------------ 1 file changed, 44 deletions(-) delete mode 100644 sorting/bucket_sort.py diff --git a/sorting/bucket_sort.py b/sorting/bucket_sort.py deleted file mode 100644 index 3765b2e..0000000 --- a/sorting/bucket_sort.py +++ /dev/null @@ -1,44 +0,0 @@ -#!/usr/bin/env python - -from __future__ import print_function -from insertion_sort import insertion_sort -import math - -DEFAULT_BUCKET_SIZE = 5 - -def bucketSort(myList, bucketSize=DEFAULT_BUCKET_SIZE): - if(len(myList) == 0): - print('You don\'t have any elements in array!') - - minValue = myList[0] - maxValue = myList[0] - - # For finding minimum and maximum values - for i in range(0, len(myList)): - if myList[i] < minValue: - minValue = myList[i] - elif myList[i] > maxValue: - maxValue = myList[i] - - # Initialize buckets - bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1 - buckets = [] - for i in range(0, bucketCount): - buckets.append([]) - - # For putting values in buckets - for i in range(0, len(myList)): - buckets[math.floor((myList[i] - minValue) / bucketSize)].append(myList[i]) - - # Sort buckets and place back into input array - sortedArray = [] - for i in range(0, len(buckets)): - insertion_sort(buckets[i]) - for j in range(0, len(buckets[i])): - sortedArray.append(buckets[i][j]) - - return sortedArray - -if __name__ == '__main__': - sortedArray = bucketSort([2, 34, 44, 2, 67, 13, 9, 102, 54, 21, 43, 99]) - print(sortedArray) From 44ddbc3e9d6c3ece091a8264c9591583f0de001d Mon Sep 17 00:00:00 2001 From: Abraham Hernandez Date: Thu, 4 Oct 2018 01:07:19 -0400 Subject: [PATCH 14/14] delete quick_sort to fix merge conflicts --- sorting/quick_sort.py | 23 ----------------------- 1 file changed, 23 deletions(-) delete mode 100644 sorting/quick_sort.py diff --git a/sorting/quick_sort.py b/sorting/quick_sort.py deleted file mode 100644 index 15f04c2..0000000 --- a/sorting/quick_sort.py +++ /dev/null @@ -1,23 +0,0 @@ -from __future__ import print_function - - -def quick_sort(ARRAY): - ARRAY_LENGTH = len(ARRAY) - if( ARRAY_LENGTH <= 1): - return ARRAY - else: - PIVOT = ARRAY[0] - GREATER = [ element for element in ARRAY[1:] if element > PIVOT ] - LESSER = [ element for element in ARRAY[1:] if element <= PIVOT ] - return quick_sort(LESSER) + [PIVOT] + quick_sort(GREATER) - - -if __name__ == '__main__': - try: - raw_input # Python 2 - except NameError: - raw_input = input # Python 3 - - user_input = raw_input('Enter numbers separated by a comma:\n').strip() - unsorted = [ int(item) for item in user_input.split(',') ] - print( quick_sort(unsorted) )