AllAlgorithms · abranhe · Oct 4, 2018 · Oct 3, 2018 · Oct 3, 2018 · Oct 3, 2018
diff --git a/ciphers/caesar_cipher.py 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: &qu
10000
ot;)
+            brute_force(strng)
+            main()
+        elif choice == '4':
+            print ("Goodbye.")
+            sys.exit()
+
+main()
diff --git a/ciphers/playfair.py 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()
diff --git a/data-structures/AVL.py 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)