Merge branch 'master' of github.com:TheAlgorithms/Python

Author: Erfaniaa

.gitignore

@@ -89,4 +89,5 @@ ENV/
 # Rope project settings
 .ropeproject
 .idea
-.DS_Store
+.DS_Store
+.try

.travis.yml

@@ -16,7 +16,7 @@ install:
     - pip install flake8  # pytest  # add another testing frameworks later
 before_script:
     # stop the build if there are Python syntax errors or undefined names
-    - flake8 . --count --select=E901,E999,F821,F822,F823 --show-source --statistics
+    - flake8 . --count --select=E9,F63,F72,F82 --show-source --statistics
     # exit-zero treats all errors as warnings.  The GitHub editor is 127 chars wide
     - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
 script:

Graphs/prim.py

@@ -0,0 +1,82 @@
+"""
+Prim's Algorithm.
+
+Determines the minimum spanning tree(MST) of a graph using the Prim's Algorithm
+
+Create a list to store x the vertices.
+G = [vertex(n) for n in range(x)]
+
+For each vertex in G, add the neighbors:
+G[x].addNeighbor(G[y])
+G[y].addNeighbor(G[x])
+
+For each vertex in G, add the edges:
+G[x].addEdge(G[y], w)
+G[y].addEdge(G[x], w)
+
+To solve run:
+MST = prim(G, G[0])
+"""
+
+import math
+
+
+class vertex():
+    """Class Vertex."""
+
+    def __init__(self, id):
+        """
+        Arguments:
+            id - input an id to identify the vertex
+
+        Attributes:
+            neighbors - a list of the vertices it is linked to
+            edges     - a dict to store the edges's weight
+        """
+        self.id = str(id)
+        self.key = None
+        self.pi = None
+        self.neighbors = []
+        self.edges = {}  # [vertex:distance]
+
+    def __lt__(self, other):
+        """Comparison rule to < operator."""
+        return (self.key < other.key)
+
+    def __repr__(self):
+        """Return the vertex id."""
+        return self.id
+
+    def addNeighbor(self, vertex):
+        """Add a pointer to a vertex at neighbor's list."""
+        self.neighbors.append(vertex)
+
+    def addEdge(self, vertex, weight):
+        """Destination vertex and weight."""
+        self.edges[vertex.id] = weight
+
+
+def prim(graph, root):
+    """
+    Prim's Algorithm.
+
+    Return a list with the edges of a Minimum Spanning Tree
+
+    prim(graph, graph[0])
+    """
+    A = []
+    for u in graph:
+        u.key = math.inf
+        u.pi = None
+    root.key = 0
+    Q = graph[:]
+    while Q:
+        u = min(Q)
+        Q.remove(u)
+        for v in u.neighbors:
+            if (v in Q) and (u.edges[v.id] < v.key):
+                v.pi = u
+                v.key = u.edges[v.id]
+    for i in range(1, len(graph)):
+        A.append([graph[i].id, graph[i].pi.id])
+    return(A)

License

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016 The Algorithms
+Copyright (c) 2019 The Algorithms
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Maths/lucasSeries.py

@@ -0,0 +1,13 @@
+# Lucas Sequence Using Recursion
+
+def recur_luc(n):
+  if n == 1:
+    return n
+  if n == 0:
+    return 2
+  return (recur_luc(n-1) + recur_luc(n-2))
+    
+limit = int(input("How many terms to include in Lucas series:"))
+print("Lucas series:")
+for i in range(limit):
+  print(recur_luc(i))

Project Euler/Problem 01/sol5.py

@@ -0,0 +1,8 @@
+a=3
+result=0
+while a=<1000:
+  if(a%3==0 and a%5==0):
+    result+=a
+  elif(a%15==0):
+    result-=a
+print(result)

README.md

@@ -0,0 +1,14 @@
+def Atbash():
+    inp=raw_input("Enter the sentence to be encrypted  ")
+    output=""
+    for i in inp:
+        extract=ord(i)
+        if extract>=65 and extract<=90:
+            output+=(unichr(155-extract))
+        elif extract>=97 and extract<=122:
+            output+=(unichr(219-extract))
+        else:
+            output+=i
+    print (output)
+
+Atbash()   ;

ciphers/Atbash.py

@@ -0,0 +1,82 @@
+# Python program to implement Morse Code Translator
+
+
+# Dictionary representing the morse code chart
+MORSE_CODE_DICT = { 'A':'.-', 'B':'-...',
+                    'C':'-.-.', 'D':'-..', 'E':'.',
+                    'F':'..-.', 'G':'--.', 'H':'....',
+                    'I':'..', 'J':'.---', 'K':'-.-',
+                    'L':'.-..', 'M':'--', 'N':'-.',
+                    'O':'---', 'P':'.--.', 'Q':'--.-',
+                    'R':'.-.', 'S':'...', 'T':'-',
+                    'U':'..-', 'V':'...-', 'W':'.--',
+                    'X':'-..-', 'Y':'-.--', 'Z':'--..',
+                    '1':'.----', '2':'..---', '3':'...--',
+                    '4':'....-', '5':'.....', '6':'-....',
+                    '7':'--...', '8':'---..', '9':'----.',
+                    '0':'-----', ', ':'--..--', '.':'.-.-.-',
+                    '?':'..--..', '/':'-..-.', '-':'-....-',
+                    '(':'-.--.', ')':'-.--.-'}
+
+
+def encrypt(message):
+    cipher = ''
+    for letter in message:
+        if letter != ' ':
+
+
+            cipher += MORSE_CODE_DICT[letter] + ' '
+        else:
+
+            cipher += ' '
+
+    return cipher
+
+
+def decrypt(message):
+
+    message += ' '
+
+    decipher = ''
+    citext = ''
+    for letter in message:
+
+        if (letter != ' '):
+
+
+            i = 0
+
+
+            citext += letter
+
+        else:
+
+            i += 1
+
+
+            if i == 2 :
+
+
+                decipher += ' '
+            else:
+
+
+                decipher += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT
+                .values()).index(citext)]
+                citext = ''
+
+    return decipher
+
+
+def main():
+    message = "Morse code here"
+    result = encrypt(message.upper())
+    print (result)
+
+    message = result
+    result = decrypt(message)
+    print (result)
+
+
+if __name__ == '__main__':
+    main()

ciphers/morse_Code_implementation.py

@@ -18,7 +18,7 @@ def __init__(self, freq, left, right):
 
 
 def parse_file(file_path):
-    """ 
+    """
     Read the file and build a dict of all letters and their
     frequences, then convert the dict into a list of Letters.
     """
@@ -29,15 +29,10 @@ def parse_file(file_path):
             if not c:
                 break
             chars[c] = chars[c] + 1 if c in chars.keys() else 1
-    letters = []
-    for char, freq in chars.items():
-        letter = Letter(char, freq)
-        letters.append(letter)
-    letters.sort(key=lambda l: l.freq)
-    return letters
+    return sorted([Letter(c, f) for c, f in chars.items()], key=lambda l: l.freq)
 
 def build_tree(letters):
-    """ 
+    """
     Run through the list of Letters and build the min heap
     for the Huffman Tree.
     """
@@ -51,7 +46,7 @@ def build_tree(letters):
     return letters[0]
 
 def traverse_tree(root, bitstring):
-    """ 
+    """
     Recursively traverse the Huffman Tree to set each
     Letter's bitstring, and return the list of Letters
     """
@@ -64,9 +59,9 @@ def traverse_tree(root, bitstring):
     return letters
 
 def huffman(file_path):
-    """ 
+    """
     Parse the file, build the tree, then run through the file
-    again, using the list of Letters to find and print out the 
+    again, using the list of Letters to find and print out the
     bitstring for each letter.
     """
     letters_list = parse_file(file_path)