From b3873be7b55f5672fc0f9f6496358b4f802358a6 Mon Sep 17 00:00:00 2001 From: cclauss Date: Sat, 20 Jan 2018 12:31:12 +0100 Subject: [PATCH 001/105] noqa to silence flake8 on Python 3 only syntax --- data_structures/Trie/Trie.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/data_structures/Trie/Trie.py b/data_structures/Trie/Trie.py index 7c886144d1f4..b60afd29db3d 100644 --- a/data_structures/Trie/Trie.py +++ b/data_structures/Trie/Trie.py @@ -21,7 +21,7 @@ def insert_many(self, words: [str]): for word in words: self.insert(word) - def insert(self, word: str): + def insert(self, word: str): # noqa: F821 This syntax is Python 3 only """ Inserts a word into the Trie :param word: word to be inserted From cc5102ab019fca9b19c69db16fa1b43412acb5d7 Mon Sep 17 00:00:00 2001 From: cclauss Date: Sat, 20 Jan 2018 12:33:27 +0100 Subject: [PATCH 002/105] noqa to silence flake8 on Python 3 only syntax --- dynamic_programming/fastfibonacci.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dynamic_programming/fastfibonacci.py b/dynamic_programming/fastfibonacci.py index cdfa2dd08084..2c3960d114ca 100644 --- a/dynamic_programming/fastfibonacci.py +++ b/dynamic_programming/fastfibonacci.py @@ -7,14 +7,14 @@ # returns F(n) -def fibonacci(n: int): +def fibonacci(n: int): # noqa: F821 This syntax is Python 3 only if n < 0: raise ValueError("Negative arguments are not supported") return _fib(n)[0] # returns (F(n), F(n-1)) -def _fib(n: int): +def _fib(n: int): # noqa: F821 This syntax is Python 3 only if n == 0: # (F(0), F(1)) return (0, 1) From 3f6760ee159d2c2e6577aab0d052b7781aa10bb2 Mon Sep 17 00:00:00 2001 From: cclauss Date: Sat, 20 Jan 2018 12:35:12 +0100 Subject: [PATCH 003/105] noqa: F821 This syntax is Python 3 only --- data_structures/Trie/Trie.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/data_structures/Trie/Trie.py b/data_structures/Trie/Trie.py index b60afd29db3d..63e291b9738a 100644 --- a/data_structures/Trie/Trie.py +++ b/data_structures/Trie/Trie.py @@ -12,7 +12,7 @@ def __init__(self): self.nodes = dict() # Mapping from char to TrieNode self.is_leaf = False - def insert_many(self, words: [str]): + def insert_many(self, words: [str]): # noqa: F821 This syntax is Python 3 only """ Inserts a list of words into the Trie :param words: list of string words @@ -34,7 +34,7 @@ def insert(self, word: str): # noqa: F821 This syntax is Python 3 only curr = curr.nodes[char] curr.is_leaf = True - def find(self, word: str) -> bool: + def find(self, word: str) -> bool: # noqa: F821 This syntax is Python 3 only """ Tries to find word in a Trie :param word: word to look for @@ -48,7 +48,7 @@ def find(self, word: str) -> bool: return curr.is_leaf -def print_words(node: TrieNode, word: str): +def print_words(node: TrieNode, word: str): # noqa: F821 This syntax is Python 3 only """ Prints all the words in a Trie :param node: root node of Trie From 4ee0e620cbd15bf73143b3c5ffa63304551ddb31 Mon Sep 17 00:00:00 2001 From: cclauss Date: Sun, 21 Jan 2018 08:25:19 +0100 Subject: [PATCH 004/105] Modernize Python 2 code to get ready for Python 3 AGAIN --- File_Transfer_Protocol/ftp_client_server.py | 22 ++++++++++----------- Project Euler/Problem 29/solution.py | 17 ++++++++-------- data_structures/Trie/Trie.py | 8 ++++---- dynamic_programming/abbreviation.py | 4 +++- dynamic_programming/fastfibonacci.py | 4 ++-- machine_learning/scoring_functions.py | 6 +++--- 6 files changed, 31 insertions(+), 30 deletions(-) diff --git a/File_Transfer_Protocol/ftp_client_server.py b/File_Transfer_Protocol/ftp_client_server.py index ff7a8ec2edf1..f73f858431f3 100644 --- a/File_Transfer_Protocol/ftp_client_server.py +++ b/File_Transfer_Protocol/ftp_client_server.py @@ -8,21 +8,21 @@ s.bind((host, port)) # Bind to the port s.listen(5) # Now wait for client connection. -print 'Server listening....' +print('Server listening....') while True: conn, addr = s.accept() # Establish connection with client. - print 'Got connection from', addr + print('Got connection from', addr) data = conn.recv(1024) print('Server received', repr(data)) - filename='mytext.txt' - f = open(filename,'rb') - l = f.read(1024) - while (l): - conn.send(l) - print('Sent ',repr(l)) - l = f.read(1024) + filename = 'mytext.txt' + f = open(filename, 'rb') + in_data = f.read(1024) + while (in_data): + conn.send(in_data) + print('Sent ', repr(in_data)) + in_data = f.read(1024) f.close() print('Done sending') @@ -42,7 +42,7 @@ s.send("Hello server!") with open('received_file', 'wb') as f: - print 'file opened' + print('file opened') while True: print('receiving data...') data = s.recv(1024) @@ -55,4 +55,4 @@ f.close() print('Successfully get the file') s.close() -print('connection closed') \ No newline at end of file +print('connection closed') diff --git a/Project Euler/Problem 29/solution.py b/Project Euler/Problem 29/solution.py index 9d6148da3d87..64d35c84d9ca 100644 --- a/Project Euler/Problem 29/solution.py +++ b/Project Euler/Problem 29/solution.py @@ -1,16 +1,18 @@ def main(): - """ + """ Consider all integer combinations of ab for 2 <= a <= 5 and 2 <= b <= 5: 22=4, 23=8, 24=16, 25=32 32=9, 33=27, 34=81, 35=243 42=16, 43=64, 44=256, 45=1024 52=25, 53=125, 54=625, 55=3125 - If they are then placed in numerical order, with any repeats removed, we get the following sequence of 15 distinct terms: + If they are then placed in numerical order, with any repeats removed, + we get the following sequence of 15 distinct terms: 4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125 - How many distinct terms are in the sequence generated by ab for 2 <= a <= 100 and 2 <= b <= 100? + How many distinct terms are in the sequence generated by ab + for 2 <= a <= 100 and 2 <= b <= 100? """ collectPowers = set() @@ -19,15 +21,12 @@ def main(): N = 101 # maximum limit - for a in range(2,N): - - for b in range (2,N): - + for a in range(2, N): + for b in range(2, N): currentPow = a**b # calculates the current power collectPowers.add(currentPow) # adds the result to the set - - print "Number of terms ", len(collectPowers) + print("Number of terms ", len(collectPowers)) if __name__ == '__main__': diff --git a/data_structures/Trie/Trie.py b/data_structures/Trie/Trie.py index 63e291b9738a..b6234c6704c6 100644 --- a/data_structures/Trie/Trie.py +++ b/data_structures/Trie/Trie.py @@ -12,7 +12,7 @@ def __init__(self): self.nodes = dict() # Mapping from char to TrieNode self.is_leaf = False - def insert_many(self, words: [str]): # noqa: F821 This syntax is Python 3 only + def insert_many(self, words: [str]): # noqa: E999 This syntax is Python 3 only """ Inserts a list of words into the Trie :param words: list of string words @@ -21,7 +21,7 @@ def insert_many(self, words: [str]): # noqa: F821 This syntax is Python 3 only for word in words: self.insert(word) - def insert(self, word: str): # noqa: F821 This syntax is Python 3 only + def insert(self, word: str): # noqa: E999 This syntax is Python 3 only """ Inserts a word into the Trie :param word: word to be inserted @@ -34,7 +34,7 @@ def insert(self, word: str): # noqa: F821 This syntax is Python 3 only curr = curr.nodes[char] curr.is_leaf = True - def find(self, word: str) -> bool: # noqa: F821 This syntax is Python 3 only + def find(self, word: str) -> bool: # noqa: E999 This syntax is Python 3 only """ Tries to find word in a Trie :param word: word to look for @@ -48,7 +48,7 @@ def find(self, word: str) -> bool: # noqa: F821 This syntax is Python 3 only return curr.is_leaf -def print_words(node: TrieNode, word: str): # noqa: F821 This syntax is Python 3 only +def print_words(node: TrieNode, word: str): # noqa: E999 This syntax is Python 3 only """ Prints all the words in a Trie :param node: root node of Trie diff --git a/dynamic_programming/abbreviation.py b/dynamic_programming/abbreviation.py index 44a1689809b8..f4d07e402925 100644 --- a/dynamic_programming/abbreviation.py +++ b/dynamic_programming/abbreviation.py @@ -10,6 +10,8 @@ a=daBcd and b="ABC" daBcd -> capitalize a and c(dABCd) -> remove d (ABC) """ + + def abbr(a, b): n = len(a) m = len(b) @@ -26,4 +28,4 @@ def abbr(a, b): if __name__ == "__main__": - print abbr("daBcd", "ABC") # expect True + print(abbr("daBcd", "ABC")) # expect True diff --git a/dynamic_programming/fastfibonacci.py b/dynamic_programming/fastfibonacci.py index 2c3960d114ca..66d2b2ff0a54 100644 --- a/dynamic_programming/fastfibonacci.py +++ b/dynamic_programming/fastfibonacci.py @@ -7,14 +7,14 @@ # returns F(n) -def fibonacci(n: int): # noqa: F821 This syntax is Python 3 only +def fibonacci(n: int): # noqa: E999 This syntax is Python 3 only if n < 0: raise ValueError("Negative arguments are not supported") return _fib(n)[0] # returns (F(n), F(n-1)) -def _fib(n: int): # noqa: F821 This syntax is Python 3 only +def _fib(n: int): # noqa: E999 This syntax is Python 3 only if n == 0: # (F(0), F(1)) return (0, 1) diff --git a/machine_learning/scoring_functions.py b/machine_learning/scoring_functions.py index 861d45c1f210..a2d97b09ded2 100755 --- a/machine_learning/scoring_functions.py +++ b/machine_learning/scoring_functions.py @@ -70,9 +70,9 @@ def mbd(predict, actual): difference = predict - actual numerator = np.sum(difference) / len(predict) denumerator = np.sum(actual) / len(predict) - print str(numerator) - print str(denumerator) + print(numerator) + print(denumerator) score = float(numerator) / denumerator * 100 - return score \ No newline at end of file + return score From d043448fd983b49199a32c8446320bba7cbfe62b Mon Sep 17 00:00:00 2001 From: cclauss Date: Sun, 21 Jan 2018 08:56:16 +0100 Subject: [PATCH 005/105] Fix unresolved name: insert_tail() insert_tail(Head.next, data) --> Head.next.insert_tail(data) Fixes: $ __flake8 . --count --select=E901,E999,F821,F822,F823 --show-source --statistics__ ``` ./data_structures/LinkedList/singly_LinkedList.py:14:13: F821 undefined name 'insert_tail' insert_tail(Head.next, data) ^ 1 F821 undefined name 'insert_tail' ``` Also formats the code to be compliant with [PEP8](http://pep8.org). --- .../LinkedList/singly_LinkedList.py | 74 ++++++++++--------- 1 file changed, 38 insertions(+), 36 deletions(-) diff --git a/data_structures/LinkedList/singly_LinkedList.py b/data_structures/LinkedList/singly_LinkedList.py index 7358b3c07f35..b2e65870c0ac 100644 --- a/data_structures/LinkedList/singly_LinkedList.py +++ b/data_structures/LinkedList/singly_LinkedList.py @@ -1,61 +1,63 @@ from __future__ import print_function -class Node:#create a Node - def __int__(self,data): - self.data=data#given data - self.next=None#given next to None + + +class Node: # create a Node + def __int__(self, data): + self.data = data # given data + self.next = None # given next to None + + class Linked_List: - - pass - - def insert_tail(Head,data): + def insert_tail(Head, data): if(Head.next is None): Head.next = Node(data) else: - insert_tail(Head.next, data) + Head.next.insert_tail(data) - def insert_head(Head,data): + def insert_head(Head, data): tamp = Head - if (tamp == None): - newNod = Node()#create a new Node + if tamp is None: + newNod = Node() # create a new Node newNod.data = data newNod.next = None - Head = newNod#make new node to Head + Head = newNod # make new node to Head else: newNod = Node() newNod.data = data - newNod.next = Head#put the Head at NewNode Next - Head=newNod#make a NewNode to Head - return Head - - def printList(Head):#print every node data - tamp=Head - while tamp!=None: + newNod.next = Head # put the Head at NewNode Next + Head = newNod # make a NewNode to Head + return Head + + def printList(Head): # print every node data + tamp = Head + while tamp is not None: print(tamp.data) - tamp=tamp.next - - def delete_head(Head):#delete from head - if Head!=None: - Head=Head.next - return Head#return new Head - - def delete_tail(Head):#delete from tail - if Head!=None: + tamp = tamp.next + + def delete_head(Head): # delete from head + if Head is not None: + Head = Head.next + return Head # return new Head + + def delete_tail(Head): # delete from tail + if Head is not None: tamp = Node() tamp = Head - while (tamp.next).next!= None:#find the 2nd last element + while (tamp.next).next is not None: # find the 2nd last element tamp = tamp.next - tamp.next=None#delete the last element by give next None to 2nd last Element + # delete the last element by give next None to 2nd last Element + tamp.next = None return Head def isEmpty(Head): - return Head is None #Return if Head is none - + return Head is None # Return if Head is none + def reverse(Head): prev = None current = Head - + while(current): - # Store the current node's next node. + # Store the current node's next node. next_node = current.next # Make the current node's next point backwards current.next = prev @@ -63,5 +65,5 @@ def reverse(Head): prev = current # Make the current node the next node (to progress iteration) current = next_node - # Return prev in order to put the head at the end + # Return prev in order to put the head at the end Head = prev From a88ad60365f73c45eada1f9534f3a04aa6d3f491 Mon Sep 17 00:00:00 2001 From: cclauss Date: Sun, 21 Jan 2018 08:59:55 +0100 Subject: [PATCH 006/105] Update singly_LinkedList.py --- data_structures/LinkedList/singly_LinkedList.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/data_structures/LinkedList/singly_LinkedList.py b/data_structures/LinkedList/singly_LinkedList.py index b2e65870c0ac..7285e37622b6 100644 --- a/data_structures/LinkedList/singly_LinkedList.py +++ b/data_structures/LinkedList/singly_LinkedList.py @@ -9,7 +9,7 @@ def __int__(self, data): class Linked_List: def insert_tail(Head, data): - if(Head.next is None): + if Head.next is None: Head.next = Node(data) else: Head.next.insert_tail(data) @@ -43,7 +43,7 @@ def delete_tail(Head): # delete from tail if Head is not None: tamp = Node() tamp = Head - while (tamp.next).next is not None: # find the 2nd last element + while tamp.next.next is not None: # find the 2nd last element tamp = tamp.next # delete the last element by give next None to 2nd last Element tamp.next = None @@ -56,7 +56,7 @@ def reverse(Head): prev = None current = Head - while(current): + while current: # Store the current node's next node. next_node = current.next # Make the current node's next point backwards From 1568432e82cfc69c7c02b334e0bcc89542d79881 Mon Sep 17 00:00:00 2001 From: Ben <34241521+arcsinecosine@users.noreply.github.com> Date: Sun, 21 Jan 2018 03:27:19 -0500 Subject: [PATCH 007/105] Add files via upload --- Project Euler/Problem 01/sol4.py | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 Project Euler/Problem 01/sol4.py diff --git a/Project Euler/Problem 01/sol4.py b/Project Euler/Problem 01/sol4.py new file mode 100644 index 000000000000..0f5dc370b441 --- /dev/null +++ b/Project Euler/Problem 01/sol4.py @@ -0,0 +1,32 @@ +def mulitples(limit): + xmulti = [] + zmulti = [] + z = 3 + x = 5 + temp = 1 + while True: + result = z * temp + if (result < limit): + zmulti.append(result) + temp += 1 + continue + else: + temp = 1 + break + while True: + result = x * temp + if (result < limit): + xmulti.append(result) + temp += 1 + continue + else: + temp = 1 + break + return (sum(zmulti) + sum(xmulti)) + + + + + + +print (mulitples(100)) From 92e0aa29b9c0db1590b0ec032177dd8dced750ff Mon Sep 17 00:00:00 2001 From: Ben <34241521+arcsinecosine@users.noreply.github.com> Date: Sun, 21 Jan 2018 03:34:09 -0500 Subject: [PATCH 008/105] Add files via upload --- Project Euler/Problem 02/sol2.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Project Euler/Problem 02/sol2.py diff --git a/Project Euler/Problem 02/sol2.py b/Project Euler/Problem 02/sol2.py new file mode 100644 index 000000000000..f0502a389707 --- /dev/null +++ b/Project Euler/Problem 02/sol2.py @@ -0,0 +1,13 @@ +def fib(n): + ls = [] + a,b = 0,1 + n += 1 + for i in range(n): + if (b % 2 == 0): + ls.append(b) + else: + pass + a,b = b, a+b + print (sum(ls)) + return None +fib(10) From 53681f199c46bebeca3c019d91af79c392f570b3 Mon Sep 17 00:00:00 2001 From: Ant Fitch Date: Tue, 30 Jan 2018 18:50:07 -0800 Subject: [PATCH 009/105] Fixed error in binary_search_by_recursion In binary_search_by_recursion, if you search array for a value that does not exist, you will get this error: RecursionError: maximum recursion depth exceeded in comparison To fix this, first check to make sure that the value is between left and right points like this: if (right < left): return None A similar construct has already been applied to binary_search, but did not exist in the recursive alternative. --- searches/binary_search.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/searches/binary_search.py b/searches/binary_search.py index 93bf189cc08f..7df45883c09a 100644 --- a/searches/binary_search.py +++ b/searches/binary_search.py @@ -110,6 +110,9 @@ def binary_search_by_recursion(sorted_collection, item, left, right): >>> binary_search_std_lib([0, 5, 7, 10, 15], 6) """ + if (right < left): + return None + midpoint = left + (right - left) // 2 if sorted_collection[midpoint] == item: From a1c146a624cf88ba1cc5076a1e2272461d28d540 Mon Sep 17 00:00:00 2001 From: Ant Fitch Date: Wed, 31 Jan 2018 10:48:48 -0800 Subject: [PATCH 010/105] Updated average case for Quicksort A small edit. Average case for quicksort changed from O(n^2) to O(n log n). Sited: https://en.wikipedia.org/wiki/Quicksort --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 70077e98fd5a..d20244c2aaef 100644 --- a/README.md +++ b/README.md @@ -55,7 +55,7 @@ From [Wikipedia][quick-wiki]: Quicksort (sometimes called partition-exchange sor __Properties__ * Worst case performance O(n^2) * Best case performance O(n log n) or O(n) with three-way partition -* Average case performance O(n^2) +* Average case performance O(n log n) ###### View the algorithm in [action][quick-toptal] From fe6e959ae32a7e0b7db574d18b3df40de82b16bc Mon Sep 17 00:00:00 2001 From: Mavroudo Date: Sun, 11 Feb 2018 12:18:37 +0200 Subject: [PATCH 011/105] Setting the files in the same folder --- Bisection.py => ArithmeticAnalysis/Bisection.py | 0 Intersection.py => ArithmeticAnalysis/Intersection.py | 0 NeutonMethod.py => ArithmeticAnalysis/NeutonMethod.py | 0 3 files changed, 0 insertions(+), 0 deletions(-) rename Bisection.py => ArithmeticAnalysis/Bisection.py (100%) rename Intersection.py => ArithmeticAnalysis/Intersection.py (100%) rename NeutonMethod.py => ArithmeticAnalysis/NeutonMethod.py (100%) diff --git a/Bisection.py b/ArithmeticAnalysis/Bisection.py similarity index 100% rename from Bisection.py rename to ArithmeticAnalysis/Bisection.py diff --git a/Intersection.py b/ArithmeticAnalysis/Intersection.py similarity index 100% rename from Intersection.py rename to ArithmeticAnalysis/Intersection.py diff --git a/NeutonMethod.py b/ArithmeticAnalysis/NeutonMethod.py similarity index 100% rename from NeutonMethod.py rename to ArithmeticAnalysis/NeutonMethod.py From a48836998b46131ec7698995e0603fbf31eefd55 Mon Sep 17 00:00:00 2001 From: Mavroudo Date: Sun, 11 Feb 2018 21:43:38 +0200 Subject: [PATCH 012/105] LU decomposition --- ArithmeticAnalysis/LUdecomposition.py | 34 +++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 ArithmeticAnalysis/LUdecomposition.py diff --git a/ArithmeticAnalysis/LUdecomposition.py b/ArithmeticAnalysis/LUdecomposition.py new file mode 100644 index 000000000000..bb0827bb39b1 --- /dev/null +++ b/ArithmeticAnalysis/LUdecomposition.py @@ -0,0 +1,34 @@ +import math +import numpy + +def LUDecompose (table): #table that contains our data + #table has to be a square array so we need to check first + rows,columns=numpy.shape(table) + L=numpy.zeros((rows,columns)) + U=numpy.zeros((rows,columns)) + if rows!=columns: + return + for i in range (columns): + for j in range(i-1): + sum=0 + for k in range (j-1): + sum+=L[i][k]*U[k][j] + L[i][j]=(table[i][j]-sum)/U[j][j] + L[i][i]=1 + for j in range(i-1,columns): + sum1=0 + for k in range(i-1): + sum1+=L[i][k]*U[k][j] + U[i][j]=table[i][j]-sum1 + return L,U + + + + + + + +matrix =numpy.array([[2,-2,1],[0,1,2],[5,3,1]]) +L,U = LUDecompose(matrix) +print(L) +print(U) \ No newline at end of file From ce3036144bb46ee7fb3cef998ff6381c73d2eb2a Mon Sep 17 00:00:00 2001 From: Akshay Kumar Date: Thu, 15 Feb 2018 21:56:51 +0530 Subject: [PATCH 013/105] Update Arrays Array implementation --- data_structures/Arrays | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/data_structures/Arrays b/data_structures/Arrays index e2c1243f5f96..da6fbff25a76 100644 --- a/data_structures/Arrays +++ b/data_structures/Arrays @@ -1 +1 @@ -Arrays implementation using python programming. +arr = [10, 20, 30, 40, 50] From 30cf24c84661ac409ca48fb548f57d7affdd4cb6 Mon Sep 17 00:00:00 2001 From: lane Date: Tue, 20 Feb 2018 17:39:45 -0700 Subject: [PATCH 014/105] added quadrature trapezoidal rule to Maths --- Maths/TrapezoidalRule.py | 45 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 Maths/TrapezoidalRule.py diff --git a/Maths/TrapezoidalRule.py b/Maths/TrapezoidalRule.py new file mode 100644 index 000000000000..f926ed2569e4 --- /dev/null +++ b/Maths/TrapezoidalRule.py @@ -0,0 +1,45 @@ +''' +Numerical integration or quadrature for a smooth function f with known values at x_i + +This method is the classical approch of suming 'Equally Spaced Abscissas' + +method 1: +"extended trapezoidal rule" + +''' + +def method_1(boundary, steps): +# "extended trapezoidal rule" +# int(f) = dx/2 * (f1 + 2f2 + ... + fn) + h = (boundary[1] - boundary[0]) / steps + a = boundary[0] + b = boundary[1] + x_i = makePoints(a,b,h) + y = 0.0 + y += (h/2.0)*f(a) + for i in x_i: + #print(i) + y += h*f(i) + y += (h/2.0)*f(b) + return y + +def makePoints(a,b,h): + x = a + h + while x < (b-h): + yield x + x = x + h + +def f(x): + y = (x-0)*(x-0) + return y + +def main(): + a = 0.0 #Lower bound of integration + b = 1.0 #Upper bound of integration + steps = 10.0 #define number of steps or resolution + boundary = [a, b] #define boundary of integration + y = method_1(boundary, steps) + print 'y = {0}'.format(y) + +if __name__ == '__main__': + main() From 537909df64a55df4b52f7b94d6cbb679a2550558 Mon Sep 17 00:00:00 2001 From: lane Date: Tue, 20 Feb 2018 17:48:22 -0700 Subject: [PATCH 015/105] added quadrature trapezoidal rule to Maths --- Maths/TrapezoidalRule.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Maths/TrapezoidalRule.py b/Maths/TrapezoidalRule.py index f926ed2569e4..2ad857390b50 100644 --- a/Maths/TrapezoidalRule.py +++ b/Maths/TrapezoidalRule.py @@ -29,7 +29,7 @@ def makePoints(a,b,h): yield x x = x + h -def f(x): +def f(x): #enter your function here y = (x-0)*(x-0) return y From 698faa9ca4bdb598aee3d2029b3c21d81fe0cc64 Mon Sep 17 00:00:00 2001 From: lane Date: Thu, 22 Feb 2018 08:40:00 -0700 Subject: [PATCH 016/105] Added Simpson Rule to Maths --- Maths/SimpsonRule.py | 47 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 Maths/SimpsonRule.py diff --git a/Maths/SimpsonRule.py b/Maths/SimpsonRule.py new file mode 100644 index 000000000000..51b5ed1e439a --- /dev/null +++ b/Maths/SimpsonRule.py @@ -0,0 +1,47 @@ + +''' +Numerical integration or quadrature for a smooth function f with known values at x_i + +This method is the classical approch of suming 'Equally Spaced Abscissas' + +method 2: +"Simpson Rule" + +''' + +def method_2(boundary, steps): +# "Simpson Rule" +# int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn) + h = (boundary[1] - boundary[0]) / steps + a = boundary[0] + b = boundary[1] + x_i = makePoints(a,b,h) + y = 0.0 + y += (h/3.0)*f(a) + cnt = 2 + for i in x_i: + y += (h/3)*(4-2*(cnt%2))*f(i) + cnt += 1 + y += (h/3.0)*f(b) + return y + +def makePoints(a,b,h): + x = a + h + while x < (b-h): + yield x + x = x + h + +def f(x): #enter your function here + y = (x-0)*(x-0) + return y + +def main(): + a = 0.0 #Lower bound of integration + b = 1.0 #Upper bound of integration + steps = 10.0 #define number of steps or resolution + boundary = [a, b] #define boundary of integration + y = method_2(boundary, steps) + print 'y = {0}'.format(y) + +if __name__ == '__main__': + main() From 1506ac90393034fa17fdc2775c4cdd2f956aa3f5 Mon Sep 17 00:00:00 2001 From: shivg7706 Date: Mon, 26 Feb 2018 17:25:09 +0530 Subject: [PATCH 017/105] MatrixChainOrder --- dynamic_programming/matrix_chain_order.py | 46 +++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 dynamic_programming/matrix_chain_order.py diff --git a/dynamic_programming/matrix_chain_order.py b/dynamic_programming/matrix_chain_order.py new file mode 100644 index 000000000000..839db03d828d --- /dev/null +++ b/dynamic_programming/matrix_chain_order.py @@ -0,0 +1,46 @@ +import sys +''' +Dynamic Programming +Implementation of Matrix Chain Multiplication +Time Complexity: O(n^3) +Space Complexity: O(n^2) +''' +def MatrixChainOrder(array): + N=len(array) + Matrix=[[0 for x in range(N)] for x in range(N)] + Sol=[[0 for x in range(N)] for x in range(N)] + for i in range(1,N): + Matrix[i][i]=0 + + for ChainLength in range(2,N): + for a in range(1,N-ChainLength+1): + b = a+ChainLength-1 + + Matrix[a][b] = sys.maxsize + for c in range(a , b): + cost = Matrix[a][c] + Matrix[c+1][b] + array[a-1]*array[c]*array[b] + if cost < Matrix[a][b]: + Matrix[a][b] = cost + Sol[a][b] = c + return Matrix , Sol +#Print order of matrix with Ai as Matrix +def PrintOptimalSolution(OptimalSolution,i,j): + if i==j: + print("A" + str(i),end = " ") + else: + print("(",end = " ") + PrintOptimalSolution(OptimalSolution,i,OptimalSolution[i][j]) + PrintOptimalSolution(OptimalSolution,OptimalSolution[i][j]+1,j) + print(")",end = " ") + +def main(): + array=[30,35,15,5,10,20,25] + n=len(array) + #Size of matrix created from above array will be + # 30*35 35*15 15*5 5*10 10*20 20*25 + Matrix , OptimalSolution = MatrixChainOrder(array) + + print("No. of Operation required: "+str((Matrix[1][n-1]))) + PrintOptimalSolution(OptimalSolution,1,n-1) +if __name__ == '__main__': + main() From 744803ad648d6984f00a23fd9abc3547bae6c32e Mon Sep 17 00:00:00 2001 From: shivg7706 Date: Tue, 27 Feb 2018 19:19:53 +0530 Subject: [PATCH 018/105] Adding Problem_08 --- Project Euler/Problem 08/sol1.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Project Euler/Problem 08/sol1.py diff --git a/Project Euler/Problem 08/sol1.py b/Project Euler/Problem 08/sol1.py new file mode 100644 index 000000000000..fb5ed25bfe93 --- /dev/null +++ b/Project Euler/Problem 08/sol1.py @@ -0,0 +1,15 @@ +import sys +def main(): + LargestProduct = -sys.maxsize-1 + number=input().strip() + for i in range(len(number)-13): + product=1 + for j in range(13): + product *= int(number[i+j]) + if product > LargestProduct: + LargestProduct = product + print(LargestProduct) + + +if __name__ == '__main__': + main() From 59c797eacec84df27369eb3dd3bc4322d69d8315 Mon Sep 17 00:00:00 2001 From: Akshay Kumar Date: Thu, 1 Mar 2018 18:58:00 +0530 Subject: [PATCH 019/105] Update Arrays --- data_structures/Arrays | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/data_structures/Arrays b/data_structures/Arrays index da6fbff25a76..5fbc08328833 100644 --- a/data_structures/Arrays +++ b/data_structures/Arrays @@ -1 +1,2 @@ -arr = [10, 20, 30, 40, 50] +arr = [10, 20, 30, 40] +arr[1] = 30 From 7a428c1cdd05771156c3eea8991510549f4dc044 Mon Sep 17 00:00:00 2001 From: Harshil Date: Fri, 2 Mar 2018 11:16:05 +0530 Subject: [PATCH 020/105] Update Arrays --- data_structures/Arrays | 1 + 1 file changed, 1 insertion(+) diff --git a/data_structures/Arrays b/data_structures/Arrays index 5fbc08328833..3ec9f8976673 100644 --- a/data_structures/Arrays +++ b/data_structures/Arrays @@ -1,2 +1,3 @@ arr = [10, 20, 30, 40] arr[1] = 30 +print(arr) From bae5762b095cf79ad19b2d98f11eff2467061930 Mon Sep 17 00:00:00 2001 From: Harshil Date: Fri, 2 Mar 2018 11:16:49 +0530 Subject: [PATCH 021/105] Rename Arrays to Arrays.py --- data_structures/{Arrays => Arrays.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename data_structures/{Arrays => Arrays.py} (100%) diff --git a/data_structures/Arrays b/data_structures/Arrays.py similarity index 100% rename from data_structures/Arrays rename to data_structures/Arrays.py From b6b7784b1bc9905be33b6826929b2e70fbd68839 Mon Sep 17 00:00:00 2001 From: shivg7706 Date: Sat, 3 Mar 2018 10:30:31 +0530 Subject: [PATCH 022/105] another sol for problem_20 --- Project Euler/Problem 20/sol2.py | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 Project Euler/Problem 20/sol2.py diff --git a/Project Euler/Problem 20/sol2.py b/Project Euler/Problem 20/sol2.py new file mode 100644 index 000000000000..bca9af9cb9ef --- /dev/null +++ b/Project Euler/Problem 20/sol2.py @@ -0,0 +1,5 @@ +from math import factorial +def main(): + print(sum([int(x) for x in str(factorial(100))])) +if __name__ == '__main__': + main() \ No newline at end of file From 744dd712386f1d9e86c0305a46dcf81061b769f4 Mon Sep 17 00:00:00 2001 From: Sichen Liu Date: Sat, 3 Mar 2018 21:27:05 -0500 Subject: [PATCH 023/105] Add sorts for python3 --- sorts/pancake_sort.py | 16 +++++++++++++++ sorts/tree_sort.py | 45 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+) create mode 100644 sorts/pancake_sort.py create mode 100644 sorts/tree_sort.py diff --git a/sorts/pancake_sort.py b/sorts/pancake_sort.py new file mode 100644 index 000000000000..26fd40b7f67c --- /dev/null +++ b/sorts/pancake_sort.py @@ -0,0 +1,16 @@ +# Pancake sort algorithm +# Only can reverse array from 0 to i + +def pancakesort(arr): + cur = len(arr) + while cur > 1: + # Find the maximum number in arr + mi = arr.index(max(arr[0:cur])) + # Reverse from 0 to mi + arr = arr[mi::-1] + arr[mi+1:len(arr)] + # Reverse whole list + arr = arr[cur-1::-1] + arr[cur:len(arr)] + cur -= 1 + return arr + +print(pancakesort([0,10,15,3,2,9,14,13])) diff --git a/sorts/tree_sort.py b/sorts/tree_sort.py new file mode 100644 index 000000000000..94cf68033b55 --- /dev/null +++ b/sorts/tree_sort.py @@ -0,0 +1,45 @@ +# Tree_sort algorithm +# Build a BST and in order traverse. + +class node(): + # BST data structure + def __init__(self, val): + self.val = val + self.left = None + self.right = None + + def insert(self,val): + if self.val: + if val < self.val: + if self.left == None: + self.left = node(val) + else: + self.left.insert(val) + elif val > self.val: + if self.right == None: + self.right = node(val) + else: + self.right.insert(val) + else: + self.val = val + +def inorder(root, res): + # Recursive travesal + if root: + inorder(root.left,res) + res.append(root.val) + inorder(root.right,res) + +def treesort(arr): + # Build BST + if len(arr) == 0: + return arr + root = node(arr[0]) + for i in range(1,len(arr)): + root.insert(arr[i]) + # Traverse BST in order. + res = [] + inorder(root,res) + return res + +print(treesort([10,1,3,2,9,14,13])) \ No newline at end of file From 0b8592918858dfc3af8cb464d475b4dac3df66fc Mon Sep 17 00:00:00 2001 From: Christian Bender Date: Sun, 4 Mar 2018 21:25:38 +0100 Subject: [PATCH 024/105] Add files via upload --- linear-algebra-python/README.md | 70 ++++++ linear-algebra-python/src/lib.py | 332 +++++++++++++++++++++++++++++ linear-algebra-python/src/lib.pyc | Bin 0 -> 11098 bytes linear-algebra-python/src/tests.py | 133 ++++++++++++ 4 files changed, 535 insertions(+) create mode 100644 linear-algebra-python/README.md create mode 100644 linear-algebra-python/src/lib.py create mode 100644 linear-algebra-python/src/lib.pyc create mode 100644 linear-algebra-python/src/tests.py diff --git a/linear-algebra-python/README.md b/linear-algebra-python/README.md new file mode 100644 index 000000000000..bca0af449d8a --- /dev/null +++ b/linear-algebra-python/README.md @@ -0,0 +1,70 @@ +# Linear algebra library for Python + +This module contains some useful classes and functions for dealing with linear algebra in python 2. + +--- + +## Overview + +- class Vector + - This class represents a vector of arbitray size and operations on it. + + **Overview about the methods:** + + - constructor(components : list) : init the vector + - set(components : list) : changes the vector components. + - __str__() : toString method + - component(i : int): gets the i-th component (start by 0) + - size() : gets the size of the vector (number of components) + - euclidLength() : returns the eulidean length of the vector. + - operator + : vector addition + - operator - : vector subtraction + - operator * : scalar multiplication and dot product + - copy() : copies this vector and returns it. + - changeComponent(pos,value) : changes the specified component. + +- function zeroVector(dimension) + - returns a zero vector of 'dimension' +- function unitBasisVector(dimension,pos) + - returns a unit basis vector with a One at index 'pos' (indexing at 0) +- function axpy(scalar,vector1,vector2) + - computes the axpy operation +- class Matrix + - This class represents a matrix of arbitrary size and operations on it. + + **Overview about the methods:** + + - __str__() : returns a string representation + - operator * : implements the matrix vector multiplication + implements the matrix-scalar multiplication. + - changeComponent(x,y,value) : changes the specified component. + - component(x,y) : returns the specified component. + - width() : returns the width of the matrix + - height() : returns the height of the matrix + - operator + : implements the matrix-addition. + - operator - _ implements the matrix-subtraction +- function squareZeroMatrix(N) + - returns a square zero-matrix of dimension NxN +--- + +## Documentation + +The module is well documented. You can use the python in-built ```help(...)``` function. +For instance: ```help(Vector)``` gives you all information about the Vector-class. +Or ```help(unitBasisVector)``` gives you all information you needed about the +global function ```unitBasisVector(...)```. If you need informations about a certain +method you type ```help(CLASSNAME.METHODNAME)```. + +--- + +## Usage + +You will find the module in the **src** directory its called ```lib.py```. You need to +import this module in your project. Alternative you can also use the file ```lib.pyc``` in python-bytecode. + +--- + +## Tests + +In the **src** directory you also find the test-suite, its called ```tests.py```. +The test-suite uses the built-in python-test-framework **unittest**. diff --git a/linear-algebra-python/src/lib.py b/linear-algebra-python/src/lib.py new file mode 100644 index 000000000000..efded3a2ae4e --- /dev/null +++ b/linear-algebra-python/src/lib.py @@ -0,0 +1,332 @@ +# -*- coding: utf-8 -*- +""" +Created on Mon Feb 26 14:29:11 2018 + +@author: Christian Bender +@license: MIT-license + +This module contains some useful classes and functions for dealing +with linear algebra in python. + +Overview: + +- class Vector +- function zeroVector(dimension) +- function unitBasisVector(dimension,pos) +- function axpy(scalar,vector1,vector2) +- class Matrix +- squareZeroMatrix(N) +""" + + +import math + + +class Vector(object): + """ + This class represents a vector of arbitray size. + You need to give the vector components. + + Overview about the methods: + + constructor(components : list) : init the vector + set(components : list) : changes the vector components. + __str__() : toString method + component(i : int): gets the i-th component (start by 0) + size() : gets the size of the vector (number of components) + euclidLength() : returns the eulidean length of the vector. + operator + : vector addition + operator - : vector subtraction + operator * : scalar multiplication and dot product + copy() : copies this vector and returns it. + changeComponent(pos,value) : changes the specified component. + TODO: compare-operator + """ + def __init__(self,components): + """ + input: components or nothing + simple constructor for init the vector + """ + self.__components = components + def set(self,components): + """ + input: new components + changes the components of the vector. + replace the components with newer one. + """ + if len(components) > 0: + self.__components = components + else: + raise Exception("please give any vector") + def __str__(self): + """ + returns a string representation of the vector + """ + ans = "(" + length = len(self.__components) + for i in range(length): + if i != length-1: + ans += str(self.__components[i]) + "," + else: + ans += str(self.__components[i]) + ")" + if len(ans) == 1: + ans += ")" + return ans + def component(self,i): + """ + input: index (start at 0) + output: the i-th component of the vector. + """ + if i < len(self.__components) and i >= 0: + return self.__components[i] + else: + raise Exception("index out of range") + def size(self): + """ + returns the size of the vector + """ + return len(self.__components) + def eulidLength(self): + """ + returns the eulidean length of the vector + """ + summe = 0 + for c in self.__components: + summe += c**2 + return math.sqrt(summe) + def __add__(self,other): + """ + input: other vector + assumes: other vector has the same size + returns a new vector that represents the sum. + """ + size = self.size() + result = [] + if size == other.size(): + for i in range(size): + result.append(self.__components[i] + other.component(i)) + else: + raise Exception("must have the same size") + return Vector(result) + def __sub__(self,other): + """ + input: other vector + assumes: other vector has the same size + returns a new vector that represents the differenz. + """ + size = self.size() + result = [] + if size == other.size(): + for i in range(size): + result.append(self.__components[i] - other.component(i)) + else: # error case + raise Exception("must have the same size") + return Vector(result) + def __mul__(self,other): + """ + mul implements the scalar multiplication + and the dot-product + """ + ans = [] + if isinstance(other,float) or isinstance(other,int): + for c in self.__components: + ans.append(c*other) + elif (isinstance(other,Vector) and (self.size() == other.size())): + size = self.size() + summe = 0 + for i in range(size): + summe += self.__components[i] * other.component(i) + return summe + else: # error case + raise Exception("invalide operand!") + return Vector(ans) + def copy(self): + """ + copies this vector and returns it. + """ + components = [x for x in self.__components] + return Vector(components) + def changeComponent(self,pos,value): + """ + input: an index (pos) and a value + changes the specified component (pos) with the + 'value' + """ + #precondition + assert (pos >= 0 and pos < len(self.__components)) + self.__components[pos] = value + +def zeroVector(dimension): + """ + returns a zero-vector of size 'dimension' + """ + #precondition + assert(isinstance(dimension,int)) + ans = [] + for i in range(dimension): + ans.append(0) + return Vector(ans) + + +def unitBasisVector(dimension,pos): + """ + returns a unit basis vector with a One + at index 'pos' (indexing at 0) + """ + #precondition + assert(isinstance(dimension,int) and (isinstance(pos,int))) + ans = [] + for i in range(dimension): + if i != pos: + ans.append(0) + else: + ans.append(1) + return Vector(ans) + + +def axpy(scalar,x,y): + """ + input: a 'scalar' and two vectors 'x' and 'y' + output: a vector + computes the axpy operation + """ + # precondition + assert(isinstance(x,Vector) and (isinstance(y,Vector)) \ + and (isinstance(scalar,int) or isinstance(scalar,float))) + return (x*scalar + y) + + +class Matrix(object): + """ + class: Matrix + This class represents a arbitrary matrix. + + Overview about the methods: + + __str__() : returns a string representation + operator * : implements the matrix vector multiplication + implements the matrix-scalar multiplication. + changeComponent(x,y,value) : changes the specified component. + component(x,y) : returns the specified component. + width() : returns the width of the matrix + height() : returns the height of the matrix + operator + : implements the matrix-addition. + operator - _ implements the matrix-subtraction + """ + def __init__(self,matrix,w,h): + """ + simple constructor for initialzes + the matrix with components. + """ + self.__matrix = matrix + self.__width = w + self.__height = h + def __str__(self): + """ + returns a string representation of this + matrix. + """ + ans = "" + for i in range(self.__height): + ans += "|" + for j in range(self.__width): + if j < self.__width -1: + ans += str(self.__matrix[i][j]) + "," + else: + ans += str(self.__matrix[i][j]) + "|\n" + return ans + def changeComponent(self,x,y, value): + """ + changes the x-y component of this matrix + """ + if x >= 0 and x < self.__height and y >= 0 and y < self.__width: + self.__matrix[x][y] = value + else: + raise Exception ("changeComponent: indices out of bounds") + def component(self,x,y): + """ + returns the specified (x,y) component + """ + if x >= 0 and x < self.__height and y >= 0 and y < self.__width: + return self.__matrix[x][y] + else: + raise Exception ("changeComponent: indices out of bounds") + def width(self): + """ + getter for the width + """ + return self.__width + def height(self): + """ + getter for the height + """ + return self.__height + def __mul__(self,other): + """ + implements the matrix-vector multiplication. + implements the matrix-scalar multiplication + """ + if isinstance(other, Vector): # vector-matrix + if (other.size() == self.__width): + ans = zeroVector(self.__height) + for i in range(self.__height): + summe = 0 + for j in range(self.__width): + summe += other.component(j) * self.__matrix[i][j] + ans.changeComponent(i,summe) + summe = 0 + return ans + else: + raise Exception("vector must have the same size as the " + + "number of columns of the matrix!") + elif isinstance(other,int) or isinstance(other,float): # matrix-scalar + matrix = [] + for i in range(self.__height): + row = [] + for j in range(self.__width): + row.append(self.__matrix[i][j] * other) + matrix.append(row) + return Matrix(matrix,self.__width,self.__height) + def __add__(self,other): + """ + implements the matrix-addition. + """ + if (self.__width == other.width() and self.__height == other.height()): + matrix = [] + for i in range(self.__height): + row = [] + for j in range(self.__width): + row.append(self.__matrix[i][j] + other.component(i,j)) + matrix.append(row) + return Matrix(matrix,self.__width,self.__height) + else: + raise Exception("matrix must have the same dimension!") + def __sub__(self,other): + """ + implements the matrix-subtraction. + """ + if (self.__width == other.width() and self.__height == other.height()): + matrix = [] + for i in range(self.__height): + row = [] + for j in range(self.__width): + row.append(self.__matrix[i][j] - other.component(i,j)) + matrix.append(row) + return Matrix(matrix,self.__width,self.__height) + else: + raise Exception("matrix must have the same dimension!") + + +def squareZeroMatrix(N): + """ + returns a square zero-matrix of dimension NxN + """ + ans = [] + for i in range(N): + row = [] + for j in range(N): + row.append(0) + ans.append(row) + return Matrix(ans,N,N) + + \ No newline at end of file diff --git a/linear-algebra-python/src/lib.pyc b/linear-algebra-python/src/lib.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7aeca0e1c6d56244f23a07bdeb3a1cf9cfa4ce82 GIT binary patch literal 11098 zcmd5?O>-Pa8SdF#t+Z>|Q6k455S+GSqE#Z9*aVvhhZtL-3X;gh$l$VwvW#{|(%7q6 zX?oUPxoi%Y;tG|5fZmpD6 zdyFqD71gdvWlXilrBYSxiF`uMO&C}0x^z!);pN65?uYeN{aO+RY1r1?Sighki{YBS za8aLsb>YHm3+K=43$L92Y`uOZ=%t(8WISDxtH_`1d z=tS{G{a%!AYSh9Y(LrY;TuTBS#d>=eCyCG1>(}pw$=xWtw@|Oo+vW7v!dBW%@S3lv z?}tg(wl><)77mJSW(NoK;wZfun8@rMHMiY0LnDL!_HM(pf=-ak-Ia~bXMZnnoLor1 z6QoJh$E(@t1xdJq?QK(IX|^8y9sicnDrj$ab0PpnsHpJ@< z{Igd|!tEq9VVr_l+Fo3D*L9GrMQIZ3Y7^ZL&$)@Wx;-6-kf*e(H=?_tPB+7RR;#-%-agV>$X{NV_XF?WzwWab~lP;^#TOOq_g-Nfv*F5yNM=D zM^9*N2Jr?2a`buK{ALsTHk%FZk#?8C?RZ1mbGk9^K#fRFlFlyZjS%$X+R;43+Ktc+ zlLkqu*LL+Qvu**BRCaK)*g~ogoURe~w${Rgt!_C;Y|g>3*Xl&=x5IcN-ITSGFzqGK zF)k7I&=*3BJJLVAa>2~*c9;Ypv3?o%$XFk=+Yy!3ZR7^c7lTZ14YDChy?@+G7-#iJ zZ}mE9v<=hU zG@I^DMh=r!Wn0&a;pAQDggWeh$s4T>cS| z%TsqMDmj(Y!c+02N`Yl1h2C$8MO$vjLB5B1LpRPy6NmQ-ZkVAFgL+z={~!q_6#-zK zpk@2A}C6#=i z6JT>VI~GKQuUtlroAceROxx|8Sk*?WStBX zj$B5Cltr1d;||U=C-i~nk4fDU-BTx*M@xQ)RovYvrJ3YM@T&T`RS42StH4pPjDj5_ zEXfdA3k0*`%*)xOXhe-XSZ*WFeU% zBqJ~m(ra0O%Djr^AsXb8!`tn*cy6dYp_2(&O!RH^Sp{ieKW|_=i(nPeGjf!Da>UP| zV)d;5yf9X&#nq!!G$Oia)wC$il)4G2x-IQcsAWL|^9H87^N~@5S9z?pb+d#~5osn% zT5;$3wt{ri;`UCG+CC9?62SDf;CztSt^AwM#4c;^%oU3&H-pfJ**I9NEl28>{QfAknT2GD}=1$c)XqS>L!f= zyjQ_77z1c4rU@l^EAvAXjwYmJrWi1fKx%9Bhx!pm^tM8?pa)0j&A@s(CP2(VSsI#? zb0>hWdN21R(oN`_!>Vk0Z>vxxa~x;e>X{U)XP&KFzCk$gsb)S&E*KPSZzD(&M*2^) zhwA0yQG%QzvLJ<0a&nn0^Wbj7FY*u8J_}v&#G1_j)6EgCS)KH%VCb~hC{6zF*m~ka zvh~L};SdY{uWW5c>+4|>#`pgv=K3dana8u$Kgl5?4j*IfNxX!^+-!C+@*rN4@f@2?C1wy#a+aiqy#{Mo@rQNQ-YD zw@)|d7>jot86+*zAZ~@Cr0bn-kcy8H#i`}K$N`2AD1M>n77>VPRv2gmeY%xaES_cU zNn(MUH=7SJ(r_y^R`pH+wNH369+iFCJL6TT?8JXsGd_ahFQNhgu`s^4I!XT#%zUq; zcIqNFIdEr|__G*4M7)0@(6ZK;N3hVwLs)2ITmLaWFpV2SyYJ$!;fty~=e6>SxXbWx zI6NedzSU{g2b~ExUuK5BFpLT0$U0>hb6FByT*Z6`#nAOK@Ie5a`CCl(Ncf2q2ZO|+ z(Ssq!h-gtWww%=xPe9;?rq0M}GpF{c;O1s-?Hhpr#XM;b*Ladjd8BL)7 zaTd?9&@9fdpvV;`liENiDWXA46hW>|SG`)bR<9kY)oNq43H&`$d!|<1FUViQ6wB-k zIro4e%n)Mi!1=!jg_3g(JXB;e3`;fPXCR z=Zwo4S`G^L8e+vifmQtHS-il4Hs6{BRICFBh=WU+CmnrJ|AY0Ns8b{>e}Xr|CN=h~ zDEiaZqLVF@hiiBY=rTkbMBF45w8NPLQ3{d@@#5=)r214IFG8shE8e2!43O-P z1Q&UI2}knJvUmcq$%Z|N-=Cu?v%P19;*;J~2~;Pw^GB$@goZ&fCzs_FrdX(+y<&_Q zVRJQS5qw;jXuMVgsDM>U9R<~oXAs=Sx{f|MKIs{2=w<|)(tF*Es7BB9ZQIOl0WNuP zn5Svoa*Wh^X_nk%9@|WRH_8+Hf*;a1CD0 z{TsQ){78qY@QyKik8x@A=XU>vgen(uIaw^hY-~;r3Hu+Hjm6}9QF}x_TUzrRpry*- z{WrsCV>8{C1-H!yPjjSa`g=6l@@)7JrQE!E-8^94-UNAz0LF*@qTmc|3$Pq00oAa6 zO%tz@&uhwuq0F9r0|N&y`?#!e6m;$b28M={>X{%3R6F*V;!;`8lepP@M|1#wgZvfW z#kC0^(xG7)?FFEDIYEJJF17!jAj#%PBoQ~{_ZVbRWUS`Zth3A2XoiJSAE3f;1n$6h zGqkl?(#6$pW*z}tK_+kdck+I*WQ(gSxfw*t0yHhF6YwUJ9WkOpX@*NB#4%a+G|!J- zJaEKVmO;I!ZtfgItiucuPinq`VuC@+s9M^-o z1$A*um}T}au;727D za)BI%VdDI3K}t8{KS(=DjYNzE?M9Q0VaQ+cII=xeB%6sPB6^HkNB{-RW22#4=#EXc zzD$OQpO@qQB7po-dQ0wEE2)WohKOj&6j+s3)_6jj=jd-S5ZjT zE$QAHjS3ngCMfaJJ@%CMEWY6#LlAe&dlA{PI&x%He91c{Eo{|Z7EV(q2p6Ikzd^;~ z2Bj9k9E=sxp1+Vr`}G3?lQ&Y95L9<^HOU-`uTv@52c>u;@57fArYFv2N&%JPKJwi| zbRp9c$Pt7H5uu3KyH+(sjiliUWDc@vGhFtl*c39yT&g5EXdU_Et}Yj&B{PJL@cC;0~u~@CCNU(b#hoTq5fso z$o0{T{y2KhkkOPoRe8xVbPfzXR%#LIKAJ4GUrGL5mNF6gAy_&PTNFU@(dFuMxYa8M zb5(wv=Feb|PpR-{S%|kqPt@Xz$d`zqNS|g0g++3dg)B);d%Vg7j7sh(ME;(jbP%fESM1Gew}c@jg~))T!01`Ls9K%sJ0*sZ~^~QsU@p!cpb;_+&>Gl9~a7x8|N)H6RDkM>ZSgY%n~bL zQ^^9$1@O{$5qE#7aQ~m6ektj__h*e)$T((}`8|1B5@%0C85=dUSXND=CNW=k?KXZj v>2s_v=3^rr|+Ei`w*zP|7Yf{hL literal 0 HcmV?d00001 diff --git a/linear-algebra-python/src/tests.py b/linear-algebra-python/src/tests.py new file mode 100644 index 000000000000..b84612b4ced4 --- /dev/null +++ b/linear-algebra-python/src/tests.py @@ -0,0 +1,133 @@ +# -*- coding: utf-8 -*- +""" +Created on Mon Feb 26 15:40:07 2018 + +@author: Christian Bender +@license: MIT-license + +This file contains the test-suite for the linear algebra library. +""" + +import unittest +from lib import * + +class Test(unittest.TestCase): + def test_component(self): + """ + test for method component + """ + x = Vector([1,2,3]) + self.assertEqual(x.component(0),1) + self.assertEqual(x.component(2),3) + try: + y = Vector() + self.assertTrue(False) + except: + self.assertTrue(True) + def test_str(self): + """ + test for toString() method + """ + x = Vector([0,0,0,0,0,1]) + self.assertEqual(x.__str__(),"(0,0,0,0,0,1)") + def test_size(self): + """ + test for size()-method + """ + x = Vector([1,2,3,4]) + self.assertEqual(x.size(),4) + def test_euclidLength(self): + """ + test for the eulidean length + """ + x = Vector([1,2]) + self.assertAlmostEqual(x.eulidLength(),2.236,3) + def test_add(self): + """ + test for + operator + """ + x = Vector([1,2,3]) + y = Vector([1,1,1]) + self.assertEqual((x+y).component(0),2) + self.assertEqual((x+y).component(1),3) + self.assertEqual((x+y).component(2),4) + def test_sub(self): + """ + test for - operator + """ + x = Vector([1,2,3]) + y = Vector([1,1,1]) + self.assertEqual((x-y).component(0),0) + self.assertEqual((x-y).component(1),1) + self.assertEqual((x-y).component(2),2) + def test_mul(self): + """ + test for * operator + """ + x = Vector([1,2,3]) + a = Vector([2,-1,4]) # for test of dot-product + b = Vector([1,-2,-1]) + self.assertEqual((x*3.0).__str__(),"(3.0,6.0,9.0)") + self.assertEqual((a*b),0) + def test_zeroVector(self): + """ + test for the global function zeroVector(...) + """ + self.assertTrue(zeroVector(10).__str__().count("0") == 10) + def test_unitBasisVector(self): + """ + test for the global function unitBasisVector(...) + """ + self.assertEqual(unitBasisVector(3,1).__str__(),"(0,1,0)") + def test_axpy(self): + """ + test for the global function axpy(...) (operation) + """ + x = Vector([1,2,3]) + y = Vector([1,0,1]) + self.assertEqual(axpy(2,x,y).__str__(),"(3,4,7)") + def test_copy(self): + """ + test for the copy()-method + """ + x = Vector([1,0,0,0,0,0]) + y = x.copy() + self.assertEqual(x.__str__(),y.__str__()) + def test_changeComponent(self): + """ + test for the changeComponent(...)-method + """ + x = Vector([1,0,0]) + x.changeComponent(0,0) + x.changeComponent(1,1) + self.assertEqual(x.__str__(),"(0,1,0)") + def test_str_matrix(self): + A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3) + self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n",A.__str__()) + def test__mul__matrix(self): + A = Matrix([[1,2,3],[4,5,6],[7,8,9]],3,3) + x = Vector([1,2,3]) + self.assertEqual("(14,32,50)",(A*x).__str__()) + self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n",(A*2).__str__()) + def test_changeComponent_matrix(self): + A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3) + A.changeComponent(0,2,5) + self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n",A.__str__()) + def test_component_matrix(self): + A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3) + self.assertEqual(7,A.component(2,1),0.01) + def test__add__matrix(self): + A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3) + B = Matrix([[1,2,7],[2,4,5],[6,7,10]],3,3) + self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n",(A+B).__str__()) + def test__sub__matrix(self): + A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3) + B = Matrix([[1,2,7],[2,4,5],[6,7,10]],3,3) + self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n",(A-B).__str__()) + def test_squareZeroMatrix(self): + self.assertEqual('|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|' + +'\n|0,0,0,0,0|\n',squareZeroMatrix(5).__str__()) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From a368d620ae41dece6382c4f14b3ec1d629502360 Mon Sep 17 00:00:00 2001 From: Christian Bender Date: Mon, 5 Mar 2018 13:27:27 +0100 Subject: [PATCH 025/105] Add files via upload --- linear-algebra-python/README.md | 4 ++++ linear-algebra-python/src/lib.py | 34 +++++++++++++++++++++++++++++++- 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/linear-algebra-python/README.md b/linear-algebra-python/README.md index bca0af449d8a..ebfcdab7b179 100644 --- a/linear-algebra-python/README.md +++ b/linear-algebra-python/README.md @@ -29,6 +29,8 @@ This module contains some useful classes and functions for dealing with linear a - returns a unit basis vector with a One at index 'pos' (indexing at 0) - function axpy(scalar,vector1,vector2) - computes the axpy operation +- function randomVector(N,a,b) + - returns a random vector of size N, with random integer components between 'a' and 'b'. - class Matrix - This class represents a matrix of arbitrary size and operations on it. @@ -45,6 +47,8 @@ This module contains some useful classes and functions for dealing with linear a - operator - _ implements the matrix-subtraction - function squareZeroMatrix(N) - returns a square zero-matrix of dimension NxN +- function randomMatrix(W,H,a,b) + - returns a random matrix WxH with integer components between 'a' and 'b' --- ## Documentation diff --git a/linear-algebra-python/src/lib.py b/linear-algebra-python/src/lib.py index efded3a2ae4e..66f27ff8946e 100644 --- a/linear-algebra-python/src/lib.py +++ b/linear-algebra-python/src/lib.py @@ -14,12 +14,15 @@ - function zeroVector(dimension) - function unitBasisVector(dimension,pos) - function axpy(scalar,vector1,vector2) +- function randomVector(N,a,b) - class Matrix -- squareZeroMatrix(N) +- function squareZeroMatrix(N) +- function randomMatrix(W,H,a,b) """ import math +import random class Vector(object): @@ -196,6 +199,20 @@ def axpy(scalar,x,y): return (x*scalar + y) +def randomVector(N,a,b): + """ + input: size (N) of the vector. + random range (a,b) + output: returns a random vector of size N, with + random integer components between 'a' and 'b'. + """ + ans = zeroVector(N) + random.seed(None) + for i in range(N): + ans.changeComponent(i,random.randint(a,b)) + return ans + + class Matrix(object): """ class: Matrix @@ -328,5 +345,20 @@ def squareZeroMatrix(N): row.append(0) ans.append(row) return Matrix(ans,N,N) + + +def randomMatrix(W,H,a,b): + """ + returns a random matrix WxH with integer components + between 'a' and 'b' + """ + matrix = [] + random.seed(None) + for i in range(H): + row = [] + for j in range(W): + row.append(random.randint(a,b)) + matrix.append(row) + return Matrix(matrix,W,H) \ No newline at end of file From c975cac371fbebd7a0de6c7693154da65a49a93e Mon Sep 17 00:00:00 2001 From: William Feng Date: Wed, 7 Mar 2018 15:04:37 +0800 Subject: [PATCH 026/105] function '__init__' miss a 'i' __int__ should be __init__ i think? --- data_structures/LinkedList/singly_LinkedList.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/data_structures/LinkedList/singly_LinkedList.py b/data_structures/LinkedList/singly_LinkedList.py index 7285e37622b6..eb7f48f17359 100644 --- a/data_structures/LinkedList/singly_LinkedList.py +++ b/data_structures/LinkedList/singly_LinkedList.py @@ -2,7 +2,7 @@ class Node: # create a Node - def __int__(self, data): + def __init__(self, data): self.data = data # given data self.next = None # given next to None From ab5f262fc1ba8c6952cee3d43d44d1ec7a2e9757 Mon Sep 17 00:00:00 2001 From: Sichen Liu Date: Thu, 8 Mar 2018 12:58:38 -0500 Subject: [PATCH 027/105] --- networking_flow/Ford-Fulkerson.py | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 networking_flow/Ford-Fulkerson.py diff --git a/networking_flow/Ford-Fulkerson.py b/networking_flow/Ford-Fulkerson.py new file mode 100644 index 000000000000..0be0fa5f147f --- /dev/null +++ b/networking_flow/Ford-Fulkerson.py @@ -0,0 +1,4 @@ +# Ford-Fulkerson Algorithm for Maximum Flow Problem +""" +""" + From 2f53847247366afb85d4b56b4d50d8f2ce44b678 Mon Sep 17 00:00:00 2001 From: Sichen Liu Date: Thu, 8 Mar 2018 15:52:16 -0500 Subject: [PATCH 028/105] --- networking_flow/Ford-Fulkerson.py | 4 --- networking_flow/Ford_Fulkerson.py | 56 +++++++++++++++++++++++++++++ networking_flow/Minimum_cut.py | 59 +++++++++++++++++++++++++++++++ 3 files changed, 115 insertions(+), 4 deletions(-) delete mode 100644 networking_flow/Ford-Fulkerson.py create mode 100644 networking_flow/Ford_Fulkerson.py create mode 100644 networking_flow/Minimum_cut.py diff --git a/networking_flow/Ford-Fulkerson.py b/networking_flow/Ford-Fulkerson.py deleted file mode 100644 index 0be0fa5f147f..000000000000 --- a/networking_flow/Ford-Fulkerson.py +++ /dev/null @@ -1,4 +0,0 @@ -# Ford-Fulkerson Algorithm for Maximum Flow Problem -""" -""" - diff --git a/networking_flow/Ford_Fulkerson.py b/networking_flow/Ford_Fulkerson.py new file mode 100644 index 000000000000..08749b3daff7 --- /dev/null +++ b/networking_flow/Ford_Fulkerson.py @@ -0,0 +1,56 @@ +# Ford-Fulkerson Algorithm for Maximum Flow Problem +""" +Description: + (1) Start with initial flow as 0; + (2) Choose augmenting path from source to sink and add path to flow; +""" + +def BFS(graph, s, t, parent): + # Return True if there is node that has not iterated. + visited = [False]*len(graph) + queue=[] + queue.append(s) + visited[s] = True + + while queue: + u = queue.pop(0) + for ind in range(len(graph[u])): + if visited[ind] == False and graph[u][ind] > 0: + queue.append(ind) + visited[ind] = True + parent[ind] = u + + return True if visited[t] else False + +def FordFulkerson(graph, source, sink): + # This array is filled by BFS and to store path + parent = [-1]*(len(graph)) + max_flow = 0 + while BFS(graph, source, sink, parent) : + path_flow = float("Inf") + s = sink + + while(s != source): + # Find the minimum value in select path + path_flow = min (path_flow, graph[parent[s]][s]) + s = parent[s] + + max_flow += path_flow + v = sink + + while(v != source): + u = parent[v] + graph[u][v] -= path_flow + graph[v][u] += path_flow + v = parent[v] + return max_flow + +graph = [[0, 16, 13, 0, 0, 0], + [0, 0, 10 ,12, 0, 0], + [0, 4, 0, 0, 14, 0], + [0, 0, 9, 0, 0, 20], + [0, 0, 0, 7, 0, 4], + [0, 0, 0, 0, 0, 0]] + +source, sink = 0, 5 +print(FordFulkerson(graph, source, sink)) \ No newline at end of file diff --git a/networking_flow/Minimum_cut.py b/networking_flow/Minimum_cut.py new file mode 100644 index 000000000000..0a61db49bb89 --- /dev/null +++ b/networking_flow/Minimum_cut.py @@ -0,0 +1,59 @@ +# Minimum cut on Ford_Fulkerson algorithm. + +def BFS(graph, s, t, parent): + # Return True if there is node that has not iterated. + visited = [False]*len(graph) + queue=[] + queue.append(s) + visited[s] = True + + while queue: + u = queue.pop(0) + for ind in range(len(graph[u])): + if visited[ind] == False and graph[u][ind] > 0: + queue.append(ind) + visited[ind] = True + parent[ind] = u + + return True if visited[t] else False + +def mincut(graph, source, sink): + # This array is filled by BFS and to store path + parent = [-1]*(len(graph)) + max_flow = 0 + res = [] + temp = [i[:] for i in graph] # Record orignial cut, copy. + while BFS(graph, source, sink, parent) : + path_flow = float("Inf") + s = sink + + while(s != source): + # Find the minimum value in select path + path_flow = min (path_flow, graph[parent[s]][s]) + s = parent[s] + + max_flow += path_flow + v = sink + + while(v != source): + u = parent[v] + graph[u][v] -= path_flow + graph[v][u] += path_flow + v = parent[v] + + for i in range(len(graph)): + for j in range(len(graph[0])): + if graph[i][j] == 0 and temp[i][j] > 0: + res.append((i,j)) + + return res + +graph = [[0, 16, 13, 0, 0, 0], + [0, 0, 10 ,12, 0, 0], + [0, 4, 0, 0, 14, 0], + [0, 0, 9, 0, 0, 20], + [0, 0, 0, 7, 0, 4], + [0, 0, 0, 0, 0, 0]] + +source, sink = 0, 5 +print(mincut(graph, source, sink)) \ No newline at end of file From e3a03c559ead639ce34cb68d04c2a08638119de9 Mon Sep 17 00:00:00 2001 From: Sichen Liu Date: Thu, 8 Mar 2018 15:53:10 -0500 Subject: [PATCH 029/105] networking_flow --- networking_flow/Ford_Fulkerson.py | 2 +- networking_flow/Minimum_cut.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/networking_flow/Ford_Fulkerson.py b/networking_flow/Ford_Fulkerson.py index 08749b3daff7..d51f1f0661b3 100644 --- a/networking_flow/Ford_Fulkerson.py +++ b/networking_flow/Ford_Fulkerson.py @@ -21,7 +21,7 @@ def BFS(graph, s, t, parent): parent[ind] = u return True if visited[t] else False - + def FordFulkerson(graph, source, sink): # This array is filled by BFS and to store path parent = [-1]*(len(graph)) diff --git a/networking_flow/Minimum_cut.py b/networking_flow/Minimum_cut.py index 0a61db49bb89..8ad6e03b00c6 100644 --- a/networking_flow/Minimum_cut.py +++ b/networking_flow/Minimum_cut.py @@ -16,7 +16,7 @@ def BFS(graph, s, t, parent): parent[ind] = u return True if visited[t] else False - + def mincut(graph, source, sink): # This array is filled by BFS and to store path parent = [-1]*(len(graph)) From 601edf31317b2ed11377869af4a20c07244cfe35 Mon Sep 17 00:00:00 2001 From: shivg7706 Date: Mon, 12 Mar 2018 15:11:38 +0530 Subject: [PATCH 030/105] QuineMcCluskey --- .../Quine_McCluskey/QuineMcCluskey.py | 116 ++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 boolean_algebra/Quine_McCluskey/QuineMcCluskey.py diff --git a/boolean_algebra/Quine_McCluskey/QuineMcCluskey.py b/boolean_algebra/Quine_McCluskey/QuineMcCluskey.py new file mode 100644 index 000000000000..eb3a11f7ee31 --- /dev/null +++ b/boolean_algebra/Quine_McCluskey/QuineMcCluskey.py @@ -0,0 +1,116 @@ +def compare_string(string1, string2): + l1 = list(string1); l2 = list(string2) + count = 0 + for i in range(len(l1)): + if l1[i] != l2[i]: + count += 1 + l1[i] = '_' + if count > 1: + return -1 + else: + return("".join(l1)) + +def check(binary): + pi = [] + while 1: + check1 = ['$']*len(binary) + temp = [] + for i in range(len(binary)): + for j in range(i+1, len(binary)): + k=compare_string(binary[i], binary[j]) + if k != -1: + check1[i] = '*' + check1[j] = '*' + temp.append(k) + for i in range(len(binary)): + if check1[i] == '$': + pi.append(binary[i]) + if len(temp) == 0: + return pi + binary = list(set(temp)) + +def decimal_to_binary(no_of_variable, minterms): + temp = [] + s = '' + for m in minterms: + for i in range(no_of_variable): + s = str(m%2) + s + m //= 2 + temp.append(s) + s = '' + return temp + +def is_for_table(string1, string2, count): + l1 = list(string1);l2=list(string2) + count_n = 0 + for i in range(len(l1)): + if l1[i] != l2[i]: + count_n += 1 + if count_n == count: + return True + else: + return False + +def selection(chart, prime_implicants): + temp = [] + select = [0]*len(chart) + for i in range(len(chart[0])): + count = 0 + rem = -1 + for j in range(len(chart)): + if chart[j][i] == 1: + count += 1 + rem = j + if count == 1: + select[rem] = 1 + for i in range(len(select)): + if select[i] == 1: + for j in range(len(chart[0])): + if chart[i][j] == 1: + for k in range(len(chart)): + chart[k][j] = 0 + temp.append(prime_implicants[i]) + while 1: + max_n = 0; rem = -1; count_n = 0 + for i in range(len(chart)): + count_n = chart[i].count(1) + if count_n > max_n: + max_n = count_n + rem = i + + if max_n == 0: + return temp + + temp.append(prime_implicants[rem]) + + for i in range(len(chart[0])): + if chart[rem][i] == 1: + for j in range(len(chart)): + chart[j][i] = 0 + +def prime_implicant_chart(prime_implicants, binary): + chart = [[0 for x in range(len(binary))] for x in range(len(prime_implicants))] + for i in range(len(prime_implicants)): + count = prime_implicants[i].count('_') + for j in range(len(binary)): + if(is_for_table(prime_implicants[i], binary[j], count)): + chart[i][j] = 1 + + return chart + +def main(): + no_of_variable = int(input("Enter the no. of variables\n")) + minterms = [int(x) for x in input("Enter the decimal representation of Minterms 'Spaces Seprated'\n").split()] + binary = decimal_to_binary(no_of_variable, minterms) + + prime_implicants = check(binary) + print("Prime Implicants are:") + print(prime_implicants) + chart = prime_implicant_chart(prime_implicants, binary) + + essential_prime_implicants = selection(chart,prime_implicants) + print("Essential Prime Implicants are:") + print(essential_prime_implicants) + +if __name__ == '__main__': + main() \ No newline at end of file From 7beaeae01402bd038bce9263e7f0a11665be4a4d Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Wed, 14 Mar 2018 14:35:16 -0400 Subject: [PATCH 031/105] Brute force solution to Problem 10 --- Project Euler/Problem 10/sol1.py | 33 ++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 Project Euler/Problem 10/sol1.py diff --git a/Project Euler/Problem 10/sol1.py b/Project Euler/Problem 10/sol1.py new file mode 100644 index 000000000000..ca9593afa969 --- /dev/null +++ b/Project Euler/Problem 10/sol1.py @@ -0,0 +1,33 @@ +from __future__ import print_function +from math import sqrt + +def is_prime(n): + for i in xrange(2, int(sqrt(n))+1): + if n%i == 0: + return False + + return True + +def sum_of_primes(n): + if n > 2: + sumOfPrimes = 2 + else: + return 0 + + for i in xrange(3, n, 2): + if is_prime(i): + sumOfPrimes += i + + return sumOfPrimes + +if __name__ == '__main__': + import sys + + if len(sys.argv) == 1: + print(sum_of_primes(2000000)) + else: + try: + n = int(sys.argv[1]) + print(sum_of_primes(n)) + except ValueError: + print('Invalid entry - please enter a number.') \ No newline at end of file From 301c90737674b9724be03fe7d25e5314cf406a04 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Wed, 14 Mar 2018 14:55:07 -0400 Subject: [PATCH 032/105] Dynamic programming solution to Problem 25 --- Project Euler/Problem 25/sol1.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Project Euler/Problem 25/sol1.py diff --git a/Project Euler/Problem 25/sol1.py b/Project Euler/Problem 25/sol1.py new file mode 100644 index 000000000000..67185774d036 --- /dev/null +++ b/Project Euler/Problem 25/sol1.py @@ -0,0 +1,26 @@ +from __future__ import print_function + +def fibonacci(n): + if n == 1 or type(n) is not int: + return 0 + elif n == 2: + return 1 + else: + sequence = [0, 1] + for i in xrange(2, n+1): + sequence.append(sequence[i-1] + sequence[i-2]) + + return sequence[n] + +def fibonacci_digits_index(n): + digits = 0 + index = 2 + + while digits < n: + index += 1 + digits = len(str(fibonacci(index))) + + return index + +if __name__ == '__main__': + print(fibonacci_digits_index(1000)) \ No newline at end of file From ac14455ac0448e0fb34221a316f4d9c48ab37107 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Wed, 14 Mar 2018 15:39:52 -0400 Subject: [PATCH 033/105] Combinatoric solution using Pascal's Triangle to Problem 15 --- Project Euler/Problem 15/sol1.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Project Euler/Problem 15/sol1.py diff --git a/Project Euler/Problem 15/sol1.py b/Project Euler/Problem 15/sol1.py new file mode 100644 index 000000000000..9b61b37d2081 --- /dev/null +++ b/Project Euler/Problem 15/sol1.py @@ -0,0 +1,20 @@ +from __future__ import print_function +from math import factorial, ceil + +def lattice_paths(n): + n = 2*n #middle entry of odd rows starting at row 3 is the solution for n = 1, 2, 3,... + k = n/2 + + return factorial(n)/(factorial(k)*factorial(n-k)) + +if __name__ == '__main__': + import sys + + if len(sys.argv) == 1: + print(lattice_paths(20)) + else: + try: + n = int(sys.argv[1]) + print(lattice_paths(n)) + except ValueError: + print('Invalid entry - please enter a number.') From 7704151504d38433bb7490298576dfbb604280b6 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Wed, 14 Mar 2018 16:03:44 -0400 Subject: [PATCH 034/105] Solution to Problem 28 --- Project Euler/Problem 28/sol1.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Project Euler/Problem 28/sol1.py diff --git a/Project Euler/Problem 28/sol1.py b/Project Euler/Problem 28/sol1.py new file mode 100644 index 000000000000..7944caa2109f --- /dev/null +++ b/Project Euler/Problem 28/sol1.py @@ -0,0 +1,23 @@ +from __future__ import print_function + +def diagonal_sum(n): + total = 1 + + for i in xrange(n/2): + odd = 2*(i+1)+1 + even = 2*(i+1) + total = total + 4*odd**2 - 6*even + + return total + +if __name__ == '__main__': + import sys + + if len(sys.argv) == 1: + print(diagonal_sum(1001)) + else: + try: + n = int(sys.argv[1]) + diagonal_sum(n) + except ValueError: + print('Invalid entry - please enter a number') \ No newline at end of file From 81dc221ee28f7e34e0293d08df11214cf9d06d5e Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Wed, 14 Mar 2018 17:18:59 -0400 Subject: [PATCH 035/105] Solution to Problem 28 --- Project Euler/Problem 28/sol1.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/Project Euler/Problem 28/sol1.py b/Project Euler/Problem 28/sol1.py index 7944caa2109f..d44d017892ce 100644 --- a/Project Euler/Problem 28/sol1.py +++ b/Project Euler/Problem 28/sol1.py @@ -1,11 +1,12 @@ from __future__ import print_function +from math import ceil def diagonal_sum(n): total = 1 - for i in xrange(n/2): - odd = 2*(i+1)+1 - even = 2*(i+1) + for i in xrange(1, int(ceil(n/2.0))): + odd = 2*i+1 + even = 2*i total = total + 4*odd**2 - 6*even return total From e6773616a67adcdb3c3d818f0a9be5d0239fdd86 Mon Sep 17 00:00:00 2001 From: Amir Naghibi Date: Wed, 14 Mar 2018 21:25:03 -0700 Subject: [PATCH 036/105] fixed spelling error --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d20244c2aaef..9b394e001d66 100644 --- a/README.md +++ b/README.md @@ -83,7 +83,7 @@ __Properties__ ###### View the algorithm in [action][shell-toptal] -### Time-Compexity Graphs +### Time-Complexity Graphs Comparing the complexity of sorting algorithms (Bubble Sort, Insertion Sort, Selection Sort) From 46b4e51d6e027905a3ae1530dc0dfbfee644ab91 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Sun, 18 Mar 2018 13:59:01 -0400 Subject: [PATCH 037/105] Solution to Problem 48 --- Project Euler/Problem 48/sol1.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Project Euler/Problem 48/sol1.py diff --git a/Project Euler/Problem 48/sol1.py b/Project Euler/Problem 48/sol1.py new file mode 100644 index 000000000000..5c4bdb0f6384 --- /dev/null +++ b/Project Euler/Problem 48/sol1.py @@ -0,0 +1,21 @@ +from __future__ import print_function +''' +Self Powers +Problem 48 + +The series, 11 + 22 + 33 + ... + 1010 = 10405071317. + +Find the last ten digits of the series, 11 + 22 + 33 + ... + 10001000. +''' + +try: + xrange +except NameError: + xrange = range + +total = 0 +for i in xrange(1, 1001): + total += i**i + + +print(str(total)[-10:]) \ No newline at end of file From 689e93439a9e8837e2597a814a0c4b3dc81c241c Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Sun, 18 Mar 2018 17:44:18 -0400 Subject: [PATCH 038/105] Solution to Problem 17 --- Project Euler/Problem 17/sol1.py | 35 ++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Project Euler/Problem 17/sol1.py diff --git a/Project Euler/Problem 17/sol1.py b/Project Euler/Problem 17/sol1.py new file mode 100644 index 000000000000..3baf0f9f79f4 --- /dev/null +++ b/Project Euler/Problem 17/sol1.py @@ -0,0 +1,35 @@ +from __future__ import print_function +''' +Number letter counts +Problem 17 + +If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total. + +If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used? + + +NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) +contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage. +''' + +ones_counts = [0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8] #number of letters in zero, one, two, ..., nineteen (0 for zero since its never said aloud) +tens_counts = [0, 0, 6, 6, 5, 5, 5, 7, 6, 6] #number of letters in twenty, thirty, ..., ninety (0 for numbers less than 20 due to inconsistency in teens) + +count = 0 + +for i in range(1, 1001): + if i < 1000: + if i >= 100: + count += ones_counts[i/100] + 7 #add number of letters for "n hundred" + + if i%100 is not 0: + count += 3 #add number of letters for "and" if number is not multiple of 100 + + if 0 < i%100 < 20: + count += ones_counts[i%100] #add number of letters for one, two, three, ..., nineteen (could be combined with below if not for inconsistency in teens) + else: + count += ones_counts[i%10] + tens_counts[(i%100-i%10)/10] #add number of letters for twenty, twenty one, ..., ninety nine + else: + count += ones_counts[i/1000] + 8 + +print(count) \ No newline at end of file From 2d2644ee1761dbd98e9e8ba7e1545666709248c4 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Sun, 18 Mar 2018 17:45:28 -0400 Subject: [PATCH 039/105] Solution to Problem 17 --- Project Euler/Problem 17/sol1.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Project Euler/Problem 17/sol1.py b/Project Euler/Problem 17/sol1.py index 3baf0f9f79f4..9de5d80b9b29 100644 --- a/Project Euler/Problem 17/sol1.py +++ b/Project Euler/Problem 17/sol1.py @@ -12,7 +12,7 @@ contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage. ''' -ones_counts = [0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8] #number of letters in zero, one, two, ..., nineteen (0 for zero since its never said aloud) +ones_counts = [0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8] #number of letters in zero, one, two, ..., nineteen (0 for zero since it's never said aloud) tens_counts = [0, 0, 6, 6, 5, 5, 5, 7, 6, 6] #number of letters in twenty, thirty, ..., ninety (0 for numbers less than 20 due to inconsistency in teens) count = 0 From 00a2b903568bfa03fa293e6e178e82fd710ca68a Mon Sep 17 00:00:00 2001 From: cclauss Date: Mon, 19 Mar 2018 02:48:09 +0100 Subject: [PATCH 040/105] Fix Python 2 syntax error in matrix_chain_order.py --- dynamic_programming/matrix_chain_order.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dynamic_programming/matrix_chain_order.py b/dynamic_programming/matrix_chain_order.py index 839db03d828d..011e85755d36 100644 --- a/dynamic_programming/matrix_chain_order.py +++ b/dynamic_programming/matrix_chain_order.py @@ -1,3 +1,5 @@ +from __future__ import print_function + import sys ''' Dynamic Programming From 705f43ad5b2995071ff370beb9b67b047524b552 Mon Sep 17 00:00:00 2001 From: cclauss Date: Mon, 19 Mar 2018 03:18:18 +0100 Subject: [PATCH 041/105] xrange() was removed in Python 3 in favor of range() @daniel-s-ingram Similar changes needed on Problems 25 and 28 so they can run on Python 3. flake8 testing of https://github.com/TheAlgorithms/Python on Python 3.6.3 $ __flake8 . --count --select=E901,E999,F821,F822,F823 --show-source --statistics__ ``` ./Project Euler/Problem 10/sol1.py:5:11: F821 undefined name 'xrange' for i in xrange(2, int(sqrt(n))+1): ^ ./Project Euler/Problem 10/sol1.py:17:11: F821 undefined name 'xrange' for i in xrange(3, n, 2): ^ ./Project Euler/Problem 25/sol1.py:10:12: F821 undefined name 'xrange' for i in xrange(2, n+1): ^ ./Project Euler/Problem 28/sol1.py:7:11: F821 undefined name 'xrange' for i in xrange(1, int(ceil(n/2.0))): ^ 4 F821 undefined name 'xrange' ``` --- Project Euler/Problem 10/sol1.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/Project Euler/Problem 10/sol1.py b/Project Euler/Problem 10/sol1.py index ca9593afa969..eace01a46bdc 100644 --- a/Project Euler/Problem 10/sol1.py +++ b/Project Euler/Problem 10/sol1.py @@ -1,6 +1,12 @@ from __future__ import print_function from math import sqrt +try: + xrange # Python 2 +except NameError: + xrange = range # Python 3 + + def is_prime(n): for i in xrange(2, int(sqrt(n))+1): if n%i == 0: @@ -30,4 +36,4 @@ def sum_of_primes(n): n = int(sys.argv[1]) print(sum_of_primes(n)) except ValueError: - print('Invalid entry - please enter a number.') \ No newline at end of file + print('Invalid entry - please enter a number.') From 0516bde45f15755a4d0014c21e14ef52b894ec98 Mon Sep 17 00:00:00 2001 From: cclauss Date: Mon, 19 Mar 2018 03:25:29 +0100 Subject: [PATCH 042/105] from __future__ import print_function For Python 3 @ltdouthit __print()__ is a function in Python 3 --- Maths/TrapezoidalRule.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Maths/TrapezoidalRule.py b/Maths/TrapezoidalRule.py index 2ad857390b50..52310c1ed3b0 100644 --- a/Maths/TrapezoidalRule.py +++ b/Maths/TrapezoidalRule.py @@ -7,6 +7,7 @@ "extended trapezoidal rule" ''' +from __future__ import print_function def method_1(boundary, steps): # "extended trapezoidal rule" @@ -39,7 +40,7 @@ def main(): steps = 10.0 #define number of steps or resolution boundary = [a, b] #define boundary of integration y = method_1(boundary, steps) - print 'y = {0}'.format(y) + print('y = {0}'.format(y)) if __name__ == '__main__': main() From 361532279052619e8fb705c7351ae22f8b76c11e Mon Sep 17 00:00:00 2001 From: cclauss Date: Mon, 19 Mar 2018 03:27:22 +0100 Subject: [PATCH 043/105] from __future__ import print_function for Python 3 @ltdouthit __print()__ is a function in Python 3 --- Maths/SimpsonRule.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Maths/SimpsonRule.py b/Maths/SimpsonRule.py index 51b5ed1e439a..ef9da5e55d6e 100644 --- a/Maths/SimpsonRule.py +++ b/Maths/SimpsonRule.py @@ -8,6 +8,8 @@ "Simpson Rule" ''' +from __future__ import print_function + def method_2(boundary, steps): # "Simpson Rule" From 4fd777e3b42d8c775497f55851b209077a34872e Mon Sep 17 00:00:00 2001 From: cclauss Date: Mon, 19 Mar 2018 03:28:00 +0100 Subject: [PATCH 044/105] Update SimpsonRule.py --- Maths/SimpsonRule.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Maths/SimpsonRule.py b/Maths/SimpsonRule.py index ef9da5e55d6e..091c86c17f1b 100644 --- a/Maths/SimpsonRule.py +++ b/Maths/SimpsonRule.py @@ -43,7 +43,7 @@ def main(): steps = 10.0 #define number of steps or resolution boundary = [a, b] #define boundary of integration y = method_2(boundary, steps) - print 'y = {0}'.format(y) + print('y = {0}'.format(y)) if __name__ == '__main__': main() From c6c5d6231154d374a194266ede6f8a33615604f4 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Mon, 19 Mar 2018 09:29:46 -0400 Subject: [PATCH 045/105] Fixed xrange compatibility for Python 3 --- Project Euler/Problem 10/sol1.py | 5 +++++ Project Euler/Problem 25/sol1.py | 5 +++++ Project Euler/Problem 28/sol1.py | 5 +++++ 3 files changed, 15 insertions(+) diff --git a/Project Euler/Problem 10/sol1.py b/Project Euler/Problem 10/sol1.py index ca9593afa969..2df3b6b59f73 100644 --- a/Project Euler/Problem 10/sol1.py +++ b/Project Euler/Problem 10/sol1.py @@ -1,6 +1,11 @@ from __future__ import print_function from math import sqrt +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + def is_prime(n): for i in xrange(2, int(sqrt(n))+1): if n%i == 0: diff --git a/Project Euler/Problem 25/sol1.py b/Project Euler/Problem 25/sol1.py index 67185774d036..f8cea3093dcf 100644 --- a/Project Euler/Problem 25/sol1.py +++ b/Project Euler/Problem 25/sol1.py @@ -1,5 +1,10 @@ from __future__ import print_function +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + def fibonacci(n): if n == 1 or type(n) is not int: return 0 diff --git a/Project Euler/Problem 28/sol1.py b/Project Euler/Problem 28/sol1.py index d44d017892ce..4942115ce537 100644 --- a/Project Euler/Problem 28/sol1.py +++ b/Project Euler/Problem 28/sol1.py @@ -1,6 +1,11 @@ from __future__ import print_function from math import ceil +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + def diagonal_sum(n): total = 1 From a4cd8978b4c10cb5482501bc7ae9df401f75c113 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Mon, 19 Mar 2018 10:10:10 -0400 Subject: [PATCH 046/105] Solution to Problem 11 --- Project Euler/Problem 11/grid.txt | 20 ++++++++++ Project Euler/Problem 11/sol1.py | 63 +++++++++++++++++++++++++++++++ 2 files changed, 83 insertions(+) create mode 100644 Project Euler/Problem 11/grid.txt create mode 100644 Project Euler/Problem 11/sol1.py diff --git a/Project Euler/Problem 11/grid.txt b/Project Euler/Problem 11/grid.txt new file mode 100644 index 000000000000..1fc75c66a314 --- /dev/null +++ b/Project Euler/Problem 11/grid.txt @@ -0,0 +1,20 @@ +08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 +49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 +81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 +52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 +22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 +24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 +32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 +67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 +24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 +21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 +78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 +16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 +86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 +19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 +04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 +88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 +04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 +20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 +20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 +01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 \ No newline at end of file diff --git a/Project Euler/Problem 11/sol1.py b/Project Euler/Problem 11/sol1.py new file mode 100644 index 000000000000..d432148fbc69 --- /dev/null +++ b/Project Euler/Problem 11/sol1.py @@ -0,0 +1,63 @@ +from __future__ import print_function +''' +What is the greatest product of four adjacent numbers (horizontally, vertically, or diagonally) in this 20x20 array? + +08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 +49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 +81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 +52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 +22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 +24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 +32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 +67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 +24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 +21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 +78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 +16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 +86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 +19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 +04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 +88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 +04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 +20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 +20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 +01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 +''' + +def largest_product(grid): + nColumns = len(grid[0]) + nRows = len(grid) + + largest = 0 + lrDiagProduct = 0 + rlDiagProduct = 0 + + #Check vertically, horizontally, diagonally at the same time (only works for nxn grid) + for i in range(nColumns): + for j in range(nRows-3): + vertProduct = grid[j][i]*grid[j+1][i]*grid[j+2][i]*grid[j+3][i] + horzProduct = grid[i][j]*grid[i][j+1]*grid[i][j+2]*grid[i][j+3] + + #Left-to-right diagonal (\) product + if (i < nColumns-3): + lrDiagProduct = grid[i][j]*grid[i+1][j+1]*grid[i+2][j+2]*grid[i+3][j+3] + + #Right-to-left diagonal(/) product + if (i > 2): + rlDiagProduct = grid[i][j]*grid[i-1][j+1]*grid[i-2][j+2]*grid[i-3][j+3] + + maxProduct = max(vertProduct, horzProduct, lrDiagProduct, rlDiagProduct) + if maxProduct > largest: + largest = maxProduct + + return largest + +if __name__ == '__main__': + grid = [] + with open('grid.txt') as file: + for line in file: + grid.append(line.strip('\n').split(' ')) + + grid = [[int(i) for i in grid[j]] for j in range(len(grid))] + + print(largest_product(grid)) \ No newline at end of file From 924d0a0552b919f908d2ec4752d9ddb7066a4cb1 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Mon, 19 Mar 2018 11:26:47 -0400 Subject: [PATCH 047/105] Added xrange compatibility for Python 3 --- Project Euler/Problem 11/sol1.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/Project Euler/Problem 11/sol1.py b/Project Euler/Problem 11/sol1.py index d432148fbc69..b882dc449156 100644 --- a/Project Euler/Problem 11/sol1.py +++ b/Project Euler/Problem 11/sol1.py @@ -24,6 +24,11 @@ 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 ''' +try: + xrange #Python 2 +except NameError: + xrange = range #Python 2 + def largest_product(grid): nColumns = len(grid[0]) nRows = len(grid) @@ -33,8 +38,8 @@ def largest_product(grid): rlDiagProduct = 0 #Check vertically, horizontally, diagonally at the same time (only works for nxn grid) - for i in range(nColumns): - for j in range(nRows-3): + for i in xrange(nColumns): + for j in xrange(nRows-3): vertProduct = grid[j][i]*grid[j+1][i]*grid[j+2][i]*grid[j+3][i] horzProduct = grid[i][j]*grid[i][j+1]*grid[i][j+2]*grid[i][j+3] @@ -58,6 +63,6 @@ def largest_product(grid): for line in file: grid.append(line.strip('\n').split(' ')) - grid = [[int(i) for i in grid[j]] for j in range(len(grid))] + grid = [[int(i) for i in grid[j]] for j in xrange(len(grid))] print(largest_product(grid)) \ No newline at end of file From a753acf1deddf28bb6a83a77a60dc8597398f67d Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Tue, 20 Mar 2018 15:23:09 -0400 Subject: [PATCH 048/105] Computes minimum cost for converting one string into another --- strings/min-cost-string-conversion.py | 124 ++++++++++++++++++++++++++ 1 file changed, 124 insertions(+) create mode 100644 strings/min-cost-string-conversion.py diff --git a/strings/min-cost-string-conversion.py b/strings/min-cost-string-conversion.py new file mode 100644 index 000000000000..1798e81cd9e0 --- /dev/null +++ b/strings/min-cost-string-conversion.py @@ -0,0 +1,124 @@ +from __future__ import print_function + +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + +def compute_transform_tables(X, Y, cC, cR, cD, cI): +''' +Algorithm for calculating the most cost-efficient sequence for converting one string into another. +The only allowed operations are +---Copy character with cost cC +---Replace character with cost cR +---Delete character with cost cD +---Insert character with cost cI +''' + X = list(X) + Y = list(Y) + m = len(X) + n = len(Y) + + costs = [[0 for _ in xrange(n+1)] for _ in xrange(m+1)] + ops = [[0 for _ in xrange(n+1)] for _ in xrange(m+1)] + + for i in xrange(1, m+1): + costs[i][0] = i*cD + ops[i][0] = 'D%c' % X[i-1] + + for i in xrange(1, n+1): + costs[0][i] = i*cI + ops[0][i] = 'I%c' % Y[i-1] + + for i in xrange(1, m+1): + for j in xrange(1, n+1): + if X[i-1] == Y[j-1]: + costs[i][j] = costs[i-1][j-1] + cC + ops[i][j] = 'C%c' % X[i-1] + else: + costs[i][j] = costs[i-1][j-1] + cR + ops[i][j] = 'R%c' % X[i-1] + str(Y[j-1]) + + if costs[i-1][j] + cD < costs[i][j]: + costs[i][j] = costs[i-1][j] + cD + ops[i][j] = 'D%c' % X[i-1] + + if costs[i][j-1] + cI < costs[i][j]: + costs[i][j] = costs[i][j-1] + cI + ops[i][j] = 'I%c' % Y[j-1] + + return costs, ops + +def assemble_transformation(ops, i, j): + if i == 0 and j == 0: + seq = [] + return seq + else: + if ops[i][j][0] == 'C' or ops[i][j][0] == 'R': + seq = assemble_transformation(ops, i-1, j-1) + seq.append(ops[i][j]) + return seq + elif ops[i][j][0] == 'D': + seq = assemble_transformation(ops, i-1, j) + seq.append(ops[i][j]) + return seq + else: + seq = assemble_transformation(ops, i, j-1) + seq.append(ops[i][j]) + return seq + +if __name__ == '__main__': + from time import sleep + _, operations = compute_transform_tables('Python', 'Algorithms', -1, 1, 2, 2) + + m = len(operations) + n = len(operations[0]) + sequence = assemble_transformation(operations, m-1, n-1) + + file = open('min_cost.txt', 'w') + + string = list('Python') + i = 0 + cost = 0 + for op in sequence: + print ''.join(string) + if op[0] == 'C': + file.write('%-16s' % 'Copy %c' % op[1]) + file.write('\t\t\t' + ''.join(string)) + file.write('\r\n') + + i += 1 + cost -= 1 + elif op[0] == 'R': + string[i] = op[2] + + file.write('%-16s' % ('Replace %c' % op[1] + ' with ' + str(op[2]))) + file.write('\t\t' + ''.join(string)) + file.write('\r\n') + + i += 1 + cost += 1 + elif op[0] == 'D': + string.pop(i) + + file.write('%-16s' % 'Delete %c' % op[1]) + file.write('\t\t\t' + ''.join(string)) + file.write('\r\n') + + i += 1 + cost += 2 + else: + string.insert(i, op[1]) + + file.write('%-16s' % 'Insert %c' % op[1]) + file.write('\t\t\t' + ''.join(string)) + file.write('\r\n') + + i += 1 + cost += 2 + + print ''.join(string) + print 'Cost: ', cost + + file.write('\r\nMinimum cost: ' + str(cost)) + file.close() \ No newline at end of file From 6abab54c2b1b5d1078140ddf46a20b34324c75a9 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Tue, 20 Mar 2018 18:49:47 -0400 Subject: [PATCH 049/105] Minimum cost for transformation from one string to another using basic operations --- strings/min-cost-string-conversion.py | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/strings/min-cost-string-conversion.py b/strings/min-cost-string-conversion.py index 1798e81cd9e0..8bad9c09405c 100644 --- a/strings/min-cost-string-conversion.py +++ b/strings/min-cost-string-conversion.py @@ -5,7 +5,6 @@ except NameError: xrange = range #Python 3 -def compute_transform_tables(X, Y, cC, cR, cD, cI): ''' Algorithm for calculating the most cost-efficient sequence for converting one string into another. The only allowed operations are @@ -14,6 +13,7 @@ def compute_transform_tables(X, Y, cC, cR, cD, cI): ---Delete character with cost cD ---Insert character with cost cI ''' +def compute_transform_tables(X, Y, cC, cR, cD, cI): X = list(X) Y = list(Y) m = len(X) @@ -81,13 +81,13 @@ def assemble_transformation(ops, i, j): i = 0 cost = 0 for op in sequence: - print ''.join(string) + print(''.join(string)) + if op[0] == 'C': file.write('%-16s' % 'Copy %c' % op[1]) file.write('\t\t\t' + ''.join(string)) file.write('\r\n') - i += 1 cost -= 1 elif op[0] == 'R': string[i] = op[2] @@ -96,7 +96,6 @@ def assemble_transformation(ops, i, j): file.write('\t\t' + ''.join(string)) file.write('\r\n') - i += 1 cost += 1 elif op[0] == 'D': string.pop(i) @@ -105,7 +104,6 @@ def assemble_transformation(ops, i, j): file.write('\t\t\t' + ''.join(string)) file.write('\r\n') - i += 1 cost += 2 else: string.insert(i, op[1]) @@ -114,11 +112,12 @@ def assemble_transformation(ops, i, j): file.write('\t\t\t' + ''.join(string)) file.write('\r\n') - i += 1 cost += 2 - print ''.join(string) - print 'Cost: ', cost + i += 1 + + print(''.join(string)) + print('Cost: ', cost) file.write('\r\nMinimum cost: ' + str(cost)) file.close() \ No newline at end of file From 0deb2277053a25616814cce00fad142e0e17e614 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Tue, 20 Mar 2018 18:50:55 -0400 Subject: [PATCH 050/105] Update min-cost-string-conversion.py --- strings/min-cost-string-conversion.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/strings/min-cost-string-conversion.py b/strings/min-cost-string-conversion.py index 8bad9c09405c..7e3298137c05 100644 --- a/strings/min-cost-string-conversion.py +++ b/strings/min-cost-string-conversion.py @@ -1,7 +1,7 @@ from __future__ import print_function try: - xrange #Python 2 + xrange #Python 2 except NameError: xrange = range #Python 3 @@ -120,4 +120,4 @@ def assemble_transformation(ops, i, j): print('Cost: ', cost) file.write('\r\nMinimum cost: ' + str(cost)) - file.close() \ No newline at end of file + file.close() From 1fa23f57d7753bd4a879b5246b6a694d3a7bdbb6 Mon Sep 17 00:00:00 2001 From: gabriel Date: Tue, 20 Mar 2018 20:48:58 -0300 Subject: [PATCH 051/105] hash functions added --- data_structures/hashing/__init__.py | 6 ++ data_structures/hashing/double_hash.py | 33 ++++++++ data_structures/hashing/hash_table.py | 84 +++++++++++++++++++ .../hashing/hash_table_with_linked_list.py | 24 ++++++ .../hashing/number_theory/__init__.py | 0 .../hashing/number_theory/prime_numbers.py | 29 +++++++ data_structures/hashing/quadratic_probing.py | 26 ++++++ 7 files changed, 202 insertions(+) create mode 100644 data_structures/hashing/__init__.py create mode 100644 data_structures/hashing/double_hash.py create mode 100644 data_structures/hashing/hash_table.py create mode 100644 data_structures/hashing/hash_table_with_linked_list.py create mode 100644 data_structures/hashing/number_theory/__init__.py create mode 100644 data_structures/hashing/number_theory/prime_numbers.py create mode 100644 data_structures/hashing/quadratic_probing.py diff --git a/data_structures/hashing/__init__.py b/data_structures/hashing/__init__.py new file mode 100644 index 000000000000..b96ddd478458 --- /dev/null +++ b/data_structures/hashing/__init__.py @@ -0,0 +1,6 @@ +from .hash_table import HashTable + +class QuadraticProbing(HashTable): + + def __init__(self): + super(self.__class__, self).__init__() diff --git a/data_structures/hashing/double_hash.py b/data_structures/hashing/double_hash.py new file mode 100644 index 000000000000..60098cda0ce1 --- /dev/null +++ b/data_structures/hashing/double_hash.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python3 + +from .hash_table import HashTable +from number_theory.prime_numbers import next_prime, check_prime + + +class DoubleHash(HashTable): + """ + Hash Table example with open addressing and Double Hash + """ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def __hash_function_2(self, value, data): + + next_prime_gt = next_prime(value % self.size_table) \ + if not check_prime(value % self.size_table) else value % self.size_table #gt = bigger than + return next_prime_gt - (data % next_prime_gt) + + def __hash_double_function(self, key, data, increment): + return (increment * self.__hash_function_2(key, data)) % self.size_table + + def _colision_resolution(self, key, data=None): + i = 1 + new_key = self.hash_function(data) + + while self.values[new_key] is not None and self.values[new_key] != key: + new_key = self.__hash_double_function(key, data, i) if \ + self.balanced_factor() >= self.lim_charge else None + if new_key is None: break + else: i += 1 + + return new_key diff --git a/data_structures/hashing/hash_table.py b/data_structures/hashing/hash_table.py new file mode 100644 index 000000000000..f0de128d1ad1 --- /dev/null +++ b/data_structures/hashing/hash_table.py @@ -0,0 +1,84 @@ +#!/usr/bin/env python3 +from number_theory.prime_numbers import next_prime + + +class HashTable: + """ + Basic Hash Table example with open addressing and linear probing + """ + + 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) + + diff --git a/data_structures/hashing/hash_table_with_linked_list.py b/data_structures/hashing/hash_table_with_linked_list.py new file mode 100644 index 000000000000..9689e4fc9fcf --- /dev/null +++ b/data_structures/hashing/hash_table_with_linked_list.py @@ -0,0 +1,24 @@ +from .hash_table import HashTable +from collections import deque + + +class HashTableWithLinkedList(HashTable): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def _set_value(self, key, data): + self.values[key] = deque([]) if self.values[key] is None else self.values[key] + self.values[key].appendleft(data) + self._keys[key] = self.values[key] + + def balanced_factor(self): + return sum([self.charge_factor - len(slot) for slot in self.values])\ + / self.size_table * self.charge_factor + + def _colision_resolution(self, key, data=None): + if not (len(self.values[key]) == self.charge_factor + and self.values.count(None) == 0): + return key + return super()._colision_resolution(key, data) + + diff --git a/data_structures/hashing/number_theory/__init__.py b/data_structures/hashing/number_theory/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/data_structures/hashing/number_theory/prime_numbers.py b/data_structures/hashing/number_theory/prime_numbers.py new file mode 100644 index 000000000000..8a521bc45758 --- /dev/null +++ b/data_structures/hashing/number_theory/prime_numbers.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python3 +""" + module to operations with prime numbers +""" + + +def check_prime(number): + """ + it's not the best solution + """ + special_non_primes = [0,1,2] + if number in special_non_primes[:2]: + return 2 + elif number == special_non_primes[-1]: + return 3 + + return all([number % i for i in range(2, number)]) + + +def next_prime(value, factor=1, **kwargs): + value = factor * value + first_value_val = value + + while not check_prime(value): + value += 1 if not ("desc" in kwargs.keys() and kwargs["desc"] is True) else -1 + + if value == first_value_val: + return next_prime(value + 1, **kwargs) + return value diff --git a/data_structures/hashing/quadratic_probing.py b/data_structures/hashing/quadratic_probing.py new file mode 100644 index 000000000000..f7a9ac1ae347 --- /dev/null +++ b/data_structures/hashing/quadratic_probing.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 + +from .hash_table import HashTable + + +class QuadraticProbing(HashTable): + """ + Basic Hash Table example with open addressing using Quadratic Probing + """ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def _colision_resolution(self, key, data=None): + i = 1 + new_key = self.hash_function(key + i*i) + + while self.values[new_key] is not None \ + and self.values[new_key] != key: + i += 1 + new_key = self.hash_function(key + i*i) if not \ + self.balanced_factor() >= self.lim_charge else None + + if new_key is None: + break + + return new_key From a5f0ae84eaae2831e94afb046efda027de22507e Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Tue, 20 Mar 2018 20:23:51 -0400 Subject: [PATCH 052/105] Solution to Problem 22 --- Project Euler/Problem 22/p022_names.txt | 1 + Project Euler/Problem 22/sol1.py | 37 +++++++++++++++++++++++++ 2 files changed, 38 insertions(+) create mode 100644 Project Euler/Problem 22/p022_names.txt create mode 100644 Project Euler/Problem 22/sol1.py diff --git a/Project Euler/Problem 22/p022_names.txt b/Project Euler/Problem 22/p022_names.txt new file mode 100644 index 000000000000..7b8986bf6ce9 --- /dev/null +++ b/Project Euler/Problem 22/p022_names.txt @@ -0,0 +1 @@ +"MARY","PATRICIA","LINDA","BARBARA","ELIZABETH","JENNIFER","MARIA","SUSAN","MARGARET","DOROTHY","LISA","NANCY","KAREN","BETTY","HELEN","SANDRA","DONNA","CAROL","RUTH","SHARON","MICHELLE","LAURA","SARAH","KIMBERLY","DEBORAH","JESSICA","SHIRLEY","CYNTHIA","ANGELA","MELISSA","BRENDA","AMY","ANNA","REBECCA","VIRGINIA","KATHLEEN","PAMELA","MARTHA","DEBRA","AMANDA","STEPHANIE","CAROLYN","CHRISTINE","MARIE","JANET","CATHERINE","FRANCES","ANN","JOYCE","DIANE","ALICE","JULIE","HEATHER","TERESA","DORIS","GLORIA","EVELYN","JEAN","CHERYL","MILDRED","KATHERINE","JOAN","ASHLEY","JUDITH","ROSE","JANICE","KELLY","NICOLE","JUDY","CHRISTINA","KATHY","THERESA","BEVERLY","DENISE","TAMMY","IRENE","JANE","LORI","RACHEL","MARILYN","ANDREA","KATHRYN","LOUISE","SARA","ANNE","JACQUELINE","WANDA","BONNIE","JULIA","RUBY","LOIS","TINA","PHYLLIS","NORMA","PAULA","DIANA","ANNIE","LILLIAN","EMILY","ROBIN","PEGGY","CRYSTAL","GLADYS","RITA","DAWN","CONNIE","FLORENCE","TRACY","EDNA","TIFFANY","CARMEN","ROSA","CINDY","GRACE","WENDY","VICTORIA","EDITH","KIM","SHERRY","SYLVIA","JOSEPHINE","THELMA","SHANNON","SHEILA","ETHEL","ELLEN","ELAINE","MARJORIE","CARRIE","CHARLOTTE","MONICA","ESTHER","PAULINE","EMMA","JUANITA","ANITA","RHONDA","HAZEL","AMBER","EVA","DEBBIE","APRIL","LESLIE","CLARA","LUCILLE","JAMIE","JOANNE","ELEANOR","VALERIE","DANIELLE","MEGAN","ALICIA","SUZANNE","MICHELE","GAIL","BERTHA","DARLENE","VERONICA","JILL","ERIN","GERALDINE","LAUREN","CATHY","JOANN","LORRAINE","LYNN","SALLY","REGINA","ERICA","BEATRICE","DOLORES","BERNICE","AUDREY","YVONNE","ANNETTE","JUNE","SAMANTHA","MARION","DANA","STACY","ANA","RENEE","IDA","VIVIAN","ROBERTA","HOLLY","BRITTANY","MELANIE","LORETTA","YOLANDA","JEANETTE","LAURIE","KATIE","KRISTEN","VANESSA","ALMA","SUE","ELSIE","BETH","JEANNE","VICKI","CARLA","TARA","ROSEMARY","EILEEN","TERRI","GERTRUDE","LUCY","TONYA","ELLA","STACEY","WILMA","GINA","KRISTIN","JESSIE","NATALIE","AGNES","VERA","WILLIE","CHARLENE","BESSIE","DELORES","MELINDA","PEARL","ARLENE","MAUREEN","COLLEEN","ALLISON","TAMARA","JOY","GEORGIA","CONSTANCE","LILLIE","CLAUDIA","JACKIE","MARCIA","TANYA","NELLIE","MINNIE","MARLENE","HEIDI","GLENDA","LYDIA","VIOLA","COURTNEY","MARIAN","STELLA","CAROLINE","DORA","JO","VICKIE","MATTIE","TERRY","MAXINE","IRMA","MABEL","MARSHA","MYRTLE","LENA","CHRISTY","DEANNA","PATSY","HILDA","GWENDOLYN","JENNIE","NORA","MARGIE","NINA","CASSANDRA","LEAH","PENNY","KAY","PRISCILLA","NAOMI","CAROLE","BRANDY","OLGA","BILLIE","DIANNE","TRACEY","LEONA","JENNY","FELICIA","SONIA","MIRIAM","VELMA","BECKY","BOBBIE","VIOLET","KRISTINA","TONI","MISTY","MAE","SHELLY","DAISY","RAMONA","SHERRI","ERIKA","KATRINA","CLAIRE","LINDSEY","LINDSAY","GENEVA","GUADALUPE","BELINDA","MARGARITA","SHERYL","CORA","FAYE","ADA","NATASHA","SABRINA","ISABEL","MARGUERITE","HATTIE","HARRIET","MOLLY","CECILIA","KRISTI","BRANDI","BLANCHE","SANDY","ROSIE","JOANNA","IRIS","EUNICE","ANGIE","INEZ","LYNDA","MADELINE","AMELIA","ALBERTA","GENEVIEVE","MONIQUE","JODI","JANIE","MAGGIE","KAYLA","SONYA","JAN","LEE","KRISTINE","CANDACE","FANNIE","MARYANN","OPAL","ALISON","YVETTE","MELODY","LUZ","SUSIE","OLIVIA","FLORA","SHELLEY","KRISTY","MAMIE","LULA","LOLA","VERNA","BEULAH","ANTOINETTE","CANDICE","JUANA","JEANNETTE","PAM","KELLI","HANNAH","WHITNEY","BRIDGET","KARLA","CELIA","LATOYA","PATTY","SHELIA","GAYLE","DELLA","VICKY","LYNNE","SHERI","MARIANNE","KARA","JACQUELYN","ERMA","BLANCA","MYRA","LETICIA","PAT","KRISTA","ROXANNE","ANGELICA","JOHNNIE","ROBYN","FRANCIS","ADRIENNE","ROSALIE","ALEXANDRA","BROOKE","BETHANY","SADIE","BERNADETTE","TRACI","JODY","KENDRA","JASMINE","NICHOLE","RACHAEL","CHELSEA","MABLE","ERNESTINE","MURIEL","MARCELLA","ELENA","KRYSTAL","ANGELINA","NADINE","KARI","ESTELLE","DIANNA","PAULETTE","LORA","MONA","DOREEN","ROSEMARIE","ANGEL","DESIREE","ANTONIA","HOPE","GINGER","JANIS","BETSY","CHRISTIE","FREDA","MERCEDES","MEREDITH","LYNETTE","TERI","CRISTINA","EULA","LEIGH","MEGHAN","SOPHIA","ELOISE","ROCHELLE","GRETCHEN","CECELIA","RAQUEL","HENRIETTA","ALYSSA","JANA","KELLEY","GWEN","KERRY","JENNA","TRICIA","LAVERNE","OLIVE","ALEXIS","TASHA","SILVIA","ELVIRA","CASEY","DELIA","SOPHIE","KATE","PATTI","LORENA","KELLIE","SONJA","LILA","LANA","DARLA","MAY","MINDY","ESSIE","MANDY","LORENE","ELSA","JOSEFINA","JEANNIE","MIRANDA","DIXIE","LUCIA","MARTA","FAITH","LELA","JOHANNA","SHARI","CAMILLE","TAMI","SHAWNA","ELISA","EBONY","MELBA","ORA","NETTIE","TABITHA","OLLIE","JAIME","WINIFRED","KRISTIE","MARINA","ALISHA","AIMEE","RENA","MYRNA","MARLA","TAMMIE","LATASHA","BONITA","PATRICE","RONDA","SHERRIE","ADDIE","FRANCINE","DELORIS","STACIE","ADRIANA","CHERI","SHELBY","ABIGAIL","CELESTE","JEWEL","CARA","ADELE","REBEKAH","LUCINDA","DORTHY","CHRIS","EFFIE","TRINA","REBA","SHAWN","SALLIE","AURORA","LENORA","ETTA","LOTTIE","KERRI","TRISHA","NIKKI","ESTELLA","FRANCISCA","JOSIE","TRACIE","MARISSA","KARIN","BRITTNEY","JANELLE","LOURDES","LAUREL","HELENE","FERN","ELVA","CORINNE","KELSEY","INA","BETTIE","ELISABETH","AIDA","CAITLIN","INGRID","IVA","EUGENIA","CHRISTA","GOLDIE","CASSIE","MAUDE","JENIFER","THERESE","FRANKIE","DENA","LORNA","JANETTE","LATONYA","CANDY","MORGAN","CONSUELO","TAMIKA","ROSETTA","DEBORA","CHERIE","POLLY","DINA","JEWELL","FAY","JILLIAN","DOROTHEA","NELL","TRUDY","ESPERANZA","PATRICA","KIMBERLEY","SHANNA","HELENA","CAROLINA","CLEO","STEFANIE","ROSARIO","OLA","JANINE","MOLLIE","LUPE","ALISA","LOU","MARIBEL","SUSANNE","BETTE","SUSANA","ELISE","CECILE","ISABELLE","LESLEY","JOCELYN","PAIGE","JONI","RACHELLE","LEOLA","DAPHNE","ALTA","ESTER","PETRA","GRACIELA","IMOGENE","JOLENE","KEISHA","LACEY","GLENNA","GABRIELA","KERI","URSULA","LIZZIE","KIRSTEN","SHANA","ADELINE","MAYRA","JAYNE","JACLYN","GRACIE","SONDRA","CARMELA","MARISA","ROSALIND","CHARITY","TONIA","BEATRIZ","MARISOL","CLARICE","JEANINE","SHEENA","ANGELINE","FRIEDA","LILY","ROBBIE","SHAUNA","MILLIE","CLAUDETTE","CATHLEEN","ANGELIA","GABRIELLE","AUTUMN","KATHARINE","SUMMER","JODIE","STACI","LEA","CHRISTI","JIMMIE","JUSTINE","ELMA","LUELLA","MARGRET","DOMINIQUE","SOCORRO","RENE","MARTINA","MARGO","MAVIS","CALLIE","BOBBI","MARITZA","LUCILE","LEANNE","JEANNINE","DEANA","AILEEN","LORIE","LADONNA","WILLA","MANUELA","GALE","SELMA","DOLLY","SYBIL","ABBY","LARA","DALE","IVY","DEE","WINNIE","MARCY","LUISA","JERI","MAGDALENA","OFELIA","MEAGAN","AUDRA","MATILDA","LEILA","CORNELIA","BIANCA","SIMONE","BETTYE","RANDI","VIRGIE","LATISHA","BARBRA","GEORGINA","ELIZA","LEANN","BRIDGETTE","RHODA","HALEY","ADELA","NOLA","BERNADINE","FLOSSIE","ILA","GRETA","RUTHIE","NELDA","MINERVA","LILLY","TERRIE","LETHA","HILARY","ESTELA","VALARIE","BRIANNA","ROSALYN","EARLINE","CATALINA","AVA","MIA","CLARISSA","LIDIA","CORRINE","ALEXANDRIA","CONCEPCION","TIA","SHARRON","RAE","DONA","ERICKA","JAMI","ELNORA","CHANDRA","LENORE","NEVA","MARYLOU","MELISA","TABATHA","SERENA","AVIS","ALLIE","SOFIA","JEANIE","ODESSA","NANNIE","HARRIETT","LORAINE","PENELOPE","MILAGROS","EMILIA","BENITA","ALLYSON","ASHLEE","TANIA","TOMMIE","ESMERALDA","KARINA","EVE","PEARLIE","ZELMA","MALINDA","NOREEN","TAMEKA","SAUNDRA","HILLARY","AMIE","ALTHEA","ROSALINDA","JORDAN","LILIA","ALANA","GAY","CLARE","ALEJANDRA","ELINOR","MICHAEL","LORRIE","JERRI","DARCY","EARNESTINE","CARMELLA","TAYLOR","NOEMI","MARCIE","LIZA","ANNABELLE","LOUISA","EARLENE","MALLORY","CARLENE","NITA","SELENA","TANISHA","KATY","JULIANNE","JOHN","LAKISHA","EDWINA","MARICELA","MARGERY","KENYA","DOLLIE","ROXIE","ROSLYN","KATHRINE","NANETTE","CHARMAINE","LAVONNE","ILENE","KRIS","TAMMI","SUZETTE","CORINE","KAYE","JERRY","MERLE","CHRYSTAL","LINA","DEANNE","LILIAN","JULIANA","ALINE","LUANN","KASEY","MARYANNE","EVANGELINE","COLETTE","MELVA","LAWANDA","YESENIA","NADIA","MADGE","KATHIE","EDDIE","OPHELIA","VALERIA","NONA","MITZI","MARI","GEORGETTE","CLAUDINE","FRAN","ALISSA","ROSEANN","LAKEISHA","SUSANNA","REVA","DEIDRE","CHASITY","SHEREE","CARLY","JAMES","ELVIA","ALYCE","DEIRDRE","GENA","BRIANA","ARACELI","KATELYN","ROSANNE","WENDI","TESSA","BERTA","MARVA","IMELDA","MARIETTA","MARCI","LEONOR","ARLINE","SASHA","MADELYN","JANNA","JULIETTE","DEENA","AURELIA","JOSEFA","AUGUSTA","LILIANA","YOUNG","CHRISTIAN","LESSIE","AMALIA","SAVANNAH","ANASTASIA","VILMA","NATALIA","ROSELLA","LYNNETTE","CORINA","ALFREDA","LEANNA","CAREY","AMPARO","COLEEN","TAMRA","AISHA","WILDA","KARYN","CHERRY","QUEEN","MAURA","MAI","EVANGELINA","ROSANNA","HALLIE","ERNA","ENID","MARIANA","LACY","JULIET","JACKLYN","FREIDA","MADELEINE","MARA","HESTER","CATHRYN","LELIA","CASANDRA","BRIDGETT","ANGELITA","JANNIE","DIONNE","ANNMARIE","KATINA","BERYL","PHOEBE","MILLICENT","KATHERYN","DIANN","CARISSA","MARYELLEN","LIZ","LAURI","HELGA","GILDA","ADRIAN","RHEA","MARQUITA","HOLLIE","TISHA","TAMERA","ANGELIQUE","FRANCESCA","BRITNEY","KAITLIN","LOLITA","FLORINE","ROWENA","REYNA","TWILA","FANNY","JANELL","INES","CONCETTA","BERTIE","ALBA","BRIGITTE","ALYSON","VONDA","PANSY","ELBA","NOELLE","LETITIA","KITTY","DEANN","BRANDIE","LOUELLA","LETA","FELECIA","SHARLENE","LESA","BEVERLEY","ROBERT","ISABELLA","HERMINIA","TERRA","CELINA","TORI","OCTAVIA","JADE","DENICE","GERMAINE","SIERRA","MICHELL","CORTNEY","NELLY","DORETHA","SYDNEY","DEIDRA","MONIKA","LASHONDA","JUDI","CHELSEY","ANTIONETTE","MARGOT","BOBBY","ADELAIDE","NAN","LEEANN","ELISHA","DESSIE","LIBBY","KATHI","GAYLA","LATANYA","MINA","MELLISA","KIMBERLEE","JASMIN","RENAE","ZELDA","ELDA","MA","JUSTINA","GUSSIE","EMILIE","CAMILLA","ABBIE","ROCIO","KAITLYN","JESSE","EDYTHE","ASHLEIGH","SELINA","LAKESHA","GERI","ALLENE","PAMALA","MICHAELA","DAYNA","CARYN","ROSALIA","SUN","JACQULINE","REBECA","MARYBETH","KRYSTLE","IOLA","DOTTIE","BENNIE","BELLE","AUBREY","GRISELDA","ERNESTINA","ELIDA","ADRIANNE","DEMETRIA","DELMA","CHONG","JAQUELINE","DESTINY","ARLEEN","VIRGINA","RETHA","FATIMA","TILLIE","ELEANORE","CARI","TREVA","BIRDIE","WILHELMINA","ROSALEE","MAURINE","LATRICE","YONG","JENA","TARYN","ELIA","DEBBY","MAUDIE","JEANNA","DELILAH","CATRINA","SHONDA","HORTENCIA","THEODORA","TERESITA","ROBBIN","DANETTE","MARYJANE","FREDDIE","DELPHINE","BRIANNE","NILDA","DANNA","CINDI","BESS","IONA","HANNA","ARIEL","WINONA","VIDA","ROSITA","MARIANNA","WILLIAM","RACHEAL","GUILLERMINA","ELOISA","CELESTINE","CAREN","MALISSA","LONA","CHANTEL","SHELLIE","MARISELA","LEORA","AGATHA","SOLEDAD","MIGDALIA","IVETTE","CHRISTEN","ATHENA","JANEL","CHLOE","VEDA","PATTIE","TESSIE","TERA","MARILYNN","LUCRETIA","KARRIE","DINAH","DANIELA","ALECIA","ADELINA","VERNICE","SHIELA","PORTIA","MERRY","LASHAWN","DEVON","DARA","TAWANA","OMA","VERDA","CHRISTIN","ALENE","ZELLA","SANDI","RAFAELA","MAYA","KIRA","CANDIDA","ALVINA","SUZAN","SHAYLA","LYN","LETTIE","ALVA","SAMATHA","ORALIA","MATILDE","MADONNA","LARISSA","VESTA","RENITA","INDIA","DELOIS","SHANDA","PHILLIS","LORRI","ERLINDA","CRUZ","CATHRINE","BARB","ZOE","ISABELL","IONE","GISELA","CHARLIE","VALENCIA","ROXANNA","MAYME","KISHA","ELLIE","MELLISSA","DORRIS","DALIA","BELLA","ANNETTA","ZOILA","RETA","REINA","LAURETTA","KYLIE","CHRISTAL","PILAR","CHARLA","ELISSA","TIFFANI","TANA","PAULINA","LEOTA","BREANNA","JAYME","CARMEL","VERNELL","TOMASA","MANDI","DOMINGA","SANTA","MELODIE","LURA","ALEXA","TAMELA","RYAN","MIRNA","KERRIE","VENUS","NOEL","FELICITA","CRISTY","CARMELITA","BERNIECE","ANNEMARIE","TIARA","ROSEANNE","MISSY","CORI","ROXANA","PRICILLA","KRISTAL","JUNG","ELYSE","HAYDEE","ALETHA","BETTINA","MARGE","GILLIAN","FILOMENA","CHARLES","ZENAIDA","HARRIETTE","CARIDAD","VADA","UNA","ARETHA","PEARLINE","MARJORY","MARCELA","FLOR","EVETTE","ELOUISE","ALINA","TRINIDAD","DAVID","DAMARIS","CATHARINE","CARROLL","BELVA","NAKIA","MARLENA","LUANNE","LORINE","KARON","DORENE","DANITA","BRENNA","TATIANA","SAMMIE","LOUANN","LOREN","JULIANNA","ANDRIA","PHILOMENA","LUCILA","LEONORA","DOVIE","ROMONA","MIMI","JACQUELIN","GAYE","TONJA","MISTI","JOE","GENE","CHASTITY","STACIA","ROXANN","MICAELA","NIKITA","MEI","VELDA","MARLYS","JOHNNA","AURA","LAVERN","IVONNE","HAYLEY","NICKI","MAJORIE","HERLINDA","GEORGE","ALPHA","YADIRA","PERLA","GREGORIA","DANIEL","ANTONETTE","SHELLI","MOZELLE","MARIAH","JOELLE","CORDELIA","JOSETTE","CHIQUITA","TRISTA","LOUIS","LAQUITA","GEORGIANA","CANDI","SHANON","LONNIE","HILDEGARD","CECIL","VALENTINA","STEPHANY","MAGDA","KAROL","GERRY","GABRIELLA","TIANA","ROMA","RICHELLE","RAY","PRINCESS","OLETA","JACQUE","IDELLA","ALAINA","SUZANNA","JOVITA","BLAIR","TOSHA","RAVEN","NEREIDA","MARLYN","KYLA","JOSEPH","DELFINA","TENA","STEPHENIE","SABINA","NATHALIE","MARCELLE","GERTIE","DARLEEN","THEA","SHARONDA","SHANTEL","BELEN","VENESSA","ROSALINA","ONA","GENOVEVA","COREY","CLEMENTINE","ROSALBA","RENATE","RENATA","MI","IVORY","GEORGIANNA","FLOY","DORCAS","ARIANA","TYRA","THEDA","MARIAM","JULI","JESICA","DONNIE","VIKKI","VERLA","ROSELYN","MELVINA","JANNETTE","GINNY","DEBRAH","CORRIE","ASIA","VIOLETA","MYRTIS","LATRICIA","COLLETTE","CHARLEEN","ANISSA","VIVIANA","TWYLA","PRECIOUS","NEDRA","LATONIA","LAN","HELLEN","FABIOLA","ANNAMARIE","ADELL","SHARYN","CHANTAL","NIKI","MAUD","LIZETTE","LINDY","KIA","KESHA","JEANA","DANELLE","CHARLINE","CHANEL","CARROL","VALORIE","LIA","DORTHA","CRISTAL","SUNNY","LEONE","LEILANI","GERRI","DEBI","ANDRA","KESHIA","IMA","EULALIA","EASTER","DULCE","NATIVIDAD","LINNIE","KAMI","GEORGIE","CATINA","BROOK","ALDA","WINNIFRED","SHARLA","RUTHANN","MEAGHAN","MAGDALENE","LISSETTE","ADELAIDA","VENITA","TRENA","SHIRLENE","SHAMEKA","ELIZEBETH","DIAN","SHANTA","MICKEY","LATOSHA","CARLOTTA","WINDY","SOON","ROSINA","MARIANN","LEISA","JONNIE","DAWNA","CATHIE","BILLY","ASTRID","SIDNEY","LAUREEN","JANEEN","HOLLI","FAWN","VICKEY","TERESSA","SHANTE","RUBYE","MARCELINA","CHANDA","CARY","TERESE","SCARLETT","MARTY","MARNIE","LULU","LISETTE","JENIFFER","ELENOR","DORINDA","DONITA","CARMAN","BERNITA","ALTAGRACIA","ALETA","ADRIANNA","ZORAIDA","RONNIE","NICOLA","LYNDSEY","KENDALL","JANINA","CHRISSY","AMI","STARLA","PHYLIS","PHUONG","KYRA","CHARISSE","BLANCH","SANJUANITA","RONA","NANCI","MARILEE","MARANDA","CORY","BRIGETTE","SANJUANA","MARITA","KASSANDRA","JOYCELYN","IRA","FELIPA","CHELSIE","BONNY","MIREYA","LORENZA","KYONG","ILEANA","CANDELARIA","TONY","TOBY","SHERIE","OK","MARK","LUCIE","LEATRICE","LAKESHIA","GERDA","EDIE","BAMBI","MARYLIN","LAVON","HORTENSE","GARNET","EVIE","TRESSA","SHAYNA","LAVINA","KYUNG","JEANETTA","SHERRILL","SHARA","PHYLISS","MITTIE","ANABEL","ALESIA","THUY","TAWANDA","RICHARD","JOANIE","TIFFANIE","LASHANDA","KARISSA","ENRIQUETA","DARIA","DANIELLA","CORINNA","ALANNA","ABBEY","ROXANE","ROSEANNA","MAGNOLIA","LIDA","KYLE","JOELLEN","ERA","CORAL","CARLEEN","TRESA","PEGGIE","NOVELLA","NILA","MAYBELLE","JENELLE","CARINA","NOVA","MELINA","MARQUERITE","MARGARETTE","JOSEPHINA","EVONNE","DEVIN","CINTHIA","ALBINA","TOYA","TAWNYA","SHERITA","SANTOS","MYRIAM","LIZABETH","LISE","KEELY","JENNI","GISELLE","CHERYLE","ARDITH","ARDIS","ALESHA","ADRIANE","SHAINA","LINNEA","KAROLYN","HONG","FLORIDA","FELISHA","DORI","DARCI","ARTIE","ARMIDA","ZOLA","XIOMARA","VERGIE","SHAMIKA","NENA","NANNETTE","MAXIE","LOVIE","JEANE","JAIMIE","INGE","FARRAH","ELAINA","CAITLYN","STARR","FELICITAS","CHERLY","CARYL","YOLONDA","YASMIN","TEENA","PRUDENCE","PENNIE","NYDIA","MACKENZIE","ORPHA","MARVEL","LIZBETH","LAURETTE","JERRIE","HERMELINDA","CAROLEE","TIERRA","MIRIAN","META","MELONY","KORI","JENNETTE","JAMILA","ENA","ANH","YOSHIKO","SUSANNAH","SALINA","RHIANNON","JOLEEN","CRISTINE","ASHTON","ARACELY","TOMEKA","SHALONDA","MARTI","LACIE","KALA","JADA","ILSE","HAILEY","BRITTANI","ZONA","SYBLE","SHERRYL","RANDY","NIDIA","MARLO","KANDICE","KANDI","DEB","DEAN","AMERICA","ALYCIA","TOMMY","RONNA","NORENE","MERCY","JOSE","INGEBORG","GIOVANNA","GEMMA","CHRISTEL","AUDRY","ZORA","VITA","VAN","TRISH","STEPHAINE","SHIRLEE","SHANIKA","MELONIE","MAZIE","JAZMIN","INGA","HOA","HETTIE","GERALYN","FONDA","ESTRELLA","ADELLA","SU","SARITA","RINA","MILISSA","MARIBETH","GOLDA","EVON","ETHELYN","ENEDINA","CHERISE","CHANA","VELVA","TAWANNA","SADE","MIRTA","LI","KARIE","JACINTA","ELNA","DAVINA","CIERRA","ASHLIE","ALBERTHA","TANESHA","STEPHANI","NELLE","MINDI","LU","LORINDA","LARUE","FLORENE","DEMETRA","DEDRA","CIARA","CHANTELLE","ASHLY","SUZY","ROSALVA","NOELIA","LYDA","LEATHA","KRYSTYNA","KRISTAN","KARRI","DARLINE","DARCIE","CINDA","CHEYENNE","CHERRIE","AWILDA","ALMEDA","ROLANDA","LANETTE","JERILYN","GISELE","EVALYN","CYNDI","CLETA","CARIN","ZINA","ZENA","VELIA","TANIKA","PAUL","CHARISSA","THOMAS","TALIA","MARGARETE","LAVONDA","KAYLEE","KATHLENE","JONNA","IRENA","ILONA","IDALIA","CANDIS","CANDANCE","BRANDEE","ANITRA","ALIDA","SIGRID","NICOLETTE","MARYJO","LINETTE","HEDWIG","CHRISTIANA","CASSIDY","ALEXIA","TRESSIE","MODESTA","LUPITA","LITA","GLADIS","EVELIA","DAVIDA","CHERRI","CECILY","ASHELY","ANNABEL","AGUSTINA","WANITA","SHIRLY","ROSAURA","HULDA","EUN","BAILEY","YETTA","VERONA","THOMASINA","SIBYL","SHANNAN","MECHELLE","LUE","LEANDRA","LANI","KYLEE","KANDY","JOLYNN","FERNE","EBONI","CORENE","ALYSIA","ZULA","NADA","MOIRA","LYNDSAY","LORRETTA","JUAN","JAMMIE","HORTENSIA","GAYNELL","CAMERON","ADRIA","VINA","VICENTA","TANGELA","STEPHINE","NORINE","NELLA","LIANA","LESLEE","KIMBERELY","ILIANA","GLORY","FELICA","EMOGENE","ELFRIEDE","EDEN","EARTHA","CARMA","BEA","OCIE","MARRY","LENNIE","KIARA","JACALYN","CARLOTA","ARIELLE","YU","STAR","OTILIA","KIRSTIN","KACEY","JOHNETTA","JOEY","JOETTA","JERALDINE","JAUNITA","ELANA","DORTHEA","CAMI","AMADA","ADELIA","VERNITA","TAMAR","SIOBHAN","RENEA","RASHIDA","OUIDA","ODELL","NILSA","MERYL","KRISTYN","JULIETA","DANICA","BREANNE","AUREA","ANGLEA","SHERRON","ODETTE","MALIA","LORELEI","LIN","LEESA","KENNA","KATHLYN","FIONA","CHARLETTE","SUZIE","SHANTELL","SABRA","RACQUEL","MYONG","MIRA","MARTINE","LUCIENNE","LAVADA","JULIANN","JOHNIE","ELVERA","DELPHIA","CLAIR","CHRISTIANE","CHAROLETTE","CARRI","AUGUSTINE","ASHA","ANGELLA","PAOLA","NINFA","LEDA","LAI","EDA","SUNSHINE","STEFANI","SHANELL","PALMA","MACHELLE","LISSA","KECIA","KATHRYNE","KARLENE","JULISSA","JETTIE","JENNIFFER","HUI","CORRINA","CHRISTOPHER","CAROLANN","ALENA","TESS","ROSARIA","MYRTICE","MARYLEE","LIANE","KENYATTA","JUDIE","JANEY","IN","ELMIRA","ELDORA","DENNA","CRISTI","CATHI","ZAIDA","VONNIE","VIVA","VERNIE","ROSALINE","MARIELA","LUCIANA","LESLI","KARAN","FELICE","DENEEN","ADINA","WYNONA","TARSHA","SHERON","SHASTA","SHANITA","SHANI","SHANDRA","RANDA","PINKIE","PARIS","NELIDA","MARILOU","LYLA","LAURENE","LACI","JOI","JANENE","DOROTHA","DANIELE","DANI","CAROLYNN","CARLYN","BERENICE","AYESHA","ANNELIESE","ALETHEA","THERSA","TAMIKO","RUFINA","OLIVA","MOZELL","MARYLYN","MADISON","KRISTIAN","KATHYRN","KASANDRA","KANDACE","JANAE","GABRIEL","DOMENICA","DEBBRA","DANNIELLE","CHUN","BUFFY","BARBIE","ARCELIA","AJA","ZENOBIA","SHAREN","SHAREE","PATRICK","PAGE","MY","LAVINIA","KUM","KACIE","JACKELINE","HUONG","FELISA","EMELIA","ELEANORA","CYTHIA","CRISTIN","CLYDE","CLARIBEL","CARON","ANASTACIA","ZULMA","ZANDRA","YOKO","TENISHA","SUSANN","SHERILYN","SHAY","SHAWANDA","SABINE","ROMANA","MATHILDA","LINSEY","KEIKO","JOANA","ISELA","GRETTA","GEORGETTA","EUGENIE","DUSTY","DESIRAE","DELORA","CORAZON","ANTONINA","ANIKA","WILLENE","TRACEE","TAMATHA","REGAN","NICHELLE","MICKIE","MAEGAN","LUANA","LANITA","KELSIE","EDELMIRA","BREE","AFTON","TEODORA","TAMIE","SHENA","MEG","LINH","KELI","KACI","DANYELLE","BRITT","ARLETTE","ALBERTINE","ADELLE","TIFFINY","STORMY","SIMONA","NUMBERS","NICOLASA","NICHOL","NIA","NAKISHA","MEE","MAIRA","LOREEN","KIZZY","JOHNNY","JAY","FALLON","CHRISTENE","BOBBYE","ANTHONY","YING","VINCENZA","TANJA","RUBIE","RONI","QUEENIE","MARGARETT","KIMBERLI","IRMGARD","IDELL","HILMA","EVELINA","ESTA","EMILEE","DENNISE","DANIA","CARL","CARIE","ANTONIO","WAI","SANG","RISA","RIKKI","PARTICIA","MUI","MASAKO","MARIO","LUVENIA","LOREE","LONI","LIEN","KEVIN","GIGI","FLORENCIA","DORIAN","DENITA","DALLAS","CHI","BILLYE","ALEXANDER","TOMIKA","SHARITA","RANA","NIKOLE","NEOMA","MARGARITE","MADALYN","LUCINA","LAILA","KALI","JENETTE","GABRIELE","EVELYNE","ELENORA","CLEMENTINA","ALEJANDRINA","ZULEMA","VIOLETTE","VANNESSA","THRESA","RETTA","PIA","PATIENCE","NOELLA","NICKIE","JONELL","DELTA","CHUNG","CHAYA","CAMELIA","BETHEL","ANYA","ANDREW","THANH","SUZANN","SPRING","SHU","MILA","LILLA","LAVERNA","KEESHA","KATTIE","GIA","GEORGENE","EVELINE","ESTELL","ELIZBETH","VIVIENNE","VALLIE","TRUDIE","STEPHANE","MICHEL","MAGALY","MADIE","KENYETTA","KARREN","JANETTA","HERMINE","HARMONY","DRUCILLA","DEBBI","CELESTINA","CANDIE","BRITNI","BECKIE","AMINA","ZITA","YUN","YOLANDE","VIVIEN","VERNETTA","TRUDI","SOMMER","PEARLE","PATRINA","OSSIE","NICOLLE","LOYCE","LETTY","LARISA","KATHARINA","JOSELYN","JONELLE","JENELL","IESHA","HEIDE","FLORINDA","FLORENTINA","FLO","ELODIA","DORINE","BRUNILDA","BRIGID","ASHLI","ARDELLA","TWANA","THU","TARAH","SUNG","SHEA","SHAVON","SHANE","SERINA","RAYNA","RAMONITA","NGA","MARGURITE","LUCRECIA","KOURTNEY","KATI","JESUS","JESENIA","DIAMOND","CRISTA","AYANA","ALICA","ALIA","VINNIE","SUELLEN","ROMELIA","RACHELL","PIPER","OLYMPIA","MICHIKO","KATHALEEN","JOLIE","JESSI","JANESSA","HANA","HA","ELEASE","CARLETTA","BRITANY","SHONA","SALOME","ROSAMOND","REGENA","RAINA","NGOC","NELIA","LOUVENIA","LESIA","LATRINA","LATICIA","LARHONDA","JINA","JACKI","HOLLIS","HOLLEY","EMMY","DEEANN","CORETTA","ARNETTA","VELVET","THALIA","SHANICE","NETA","MIKKI","MICKI","LONNA","LEANA","LASHUNDA","KILEY","JOYE","JACQULYN","IGNACIA","HYUN","HIROKO","HENRY","HENRIETTE","ELAYNE","DELINDA","DARNELL","DAHLIA","COREEN","CONSUELA","CONCHITA","CELINE","BABETTE","AYANNA","ANETTE","ALBERTINA","SKYE","SHAWNEE","SHANEKA","QUIANA","PAMELIA","MIN","MERRI","MERLENE","MARGIT","KIESHA","KIERA","KAYLENE","JODEE","JENISE","ERLENE","EMMIE","ELSE","DARYL","DALILA","DAISEY","CODY","CASIE","BELIA","BABARA","VERSIE","VANESA","SHELBA","SHAWNDA","SAM","NORMAN","NIKIA","NAOMA","MARNA","MARGERET","MADALINE","LAWANA","KINDRA","JUTTA","JAZMINE","JANETT","HANNELORE","GLENDORA","GERTRUD","GARNETT","FREEDA","FREDERICA","FLORANCE","FLAVIA","DENNIS","CARLINE","BEVERLEE","ANJANETTE","VALDA","TRINITY","TAMALA","STEVIE","SHONNA","SHA","SARINA","ONEIDA","MICAH","MERILYN","MARLEEN","LURLINE","LENNA","KATHERIN","JIN","JENI","HAE","GRACIA","GLADY","FARAH","ERIC","ENOLA","EMA","DOMINQUE","DEVONA","DELANA","CECILA","CAPRICE","ALYSHA","ALI","ALETHIA","VENA","THERESIA","TAWNY","SONG","SHAKIRA","SAMARA","SACHIKO","RACHELE","PAMELLA","NICKY","MARNI","MARIEL","MAREN","MALISA","LIGIA","LERA","LATORIA","LARAE","KIMBER","KATHERN","KAREY","JENNEFER","JANETH","HALINA","FREDIA","DELISA","DEBROAH","CIERA","CHIN","ANGELIKA","ANDREE","ALTHA","YEN","VIVAN","TERRESA","TANNA","SUK","SUDIE","SOO","SIGNE","SALENA","RONNI","REBBECCA","MYRTIE","MCKENZIE","MALIKA","MAIDA","LOAN","LEONARDA","KAYLEIGH","FRANCE","ETHYL","ELLYN","DAYLE","CAMMIE","BRITTNI","BIRGIT","AVELINA","ASUNCION","ARIANNA","AKIKO","VENICE","TYESHA","TONIE","TIESHA","TAKISHA","STEFFANIE","SINDY","SANTANA","MEGHANN","MANDA","MACIE","LADY","KELLYE","KELLEE","JOSLYN","JASON","INGER","INDIRA","GLINDA","GLENNIS","FERNANDA","FAUSTINA","ENEIDA","ELICIA","DOT","DIGNA","DELL","ARLETTA","ANDRE","WILLIA","TAMMARA","TABETHA","SHERRELL","SARI","REFUGIO","REBBECA","PAULETTA","NIEVES","NATOSHA","NAKITA","MAMMIE","KENISHA","KAZUKO","KASSIE","GARY","EARLEAN","DAPHINE","CORLISS","CLOTILDE","CAROLYNE","BERNETTA","AUGUSTINA","AUDREA","ANNIS","ANNABELL","YAN","TENNILLE","TAMICA","SELENE","SEAN","ROSANA","REGENIA","QIANA","MARKITA","MACY","LEEANNE","LAURINE","KYM","JESSENIA","JANITA","GEORGINE","GENIE","EMIKO","ELVIE","DEANDRA","DAGMAR","CORIE","COLLEN","CHERISH","ROMAINE","PORSHA","PEARLENE","MICHELINE","MERNA","MARGORIE","MARGARETTA","LORE","KENNETH","JENINE","HERMINA","FREDERICKA","ELKE","DRUSILLA","DORATHY","DIONE","DESIRE","CELENA","BRIGIDA","ANGELES","ALLEGRA","THEO","TAMEKIA","SYNTHIA","STEPHEN","SOOK","SLYVIA","ROSANN","REATHA","RAYE","MARQUETTA","MARGART","LING","LAYLA","KYMBERLY","KIANA","KAYLEEN","KATLYN","KARMEN","JOELLA","IRINA","EMELDA","ELENI","DETRA","CLEMMIE","CHERYLL","CHANTELL","CATHEY","ARNITA","ARLA","ANGLE","ANGELIC","ALYSE","ZOFIA","THOMASINE","TENNIE","SON","SHERLY","SHERLEY","SHARYL","REMEDIOS","PETRINA","NICKOLE","MYUNG","MYRLE","MOZELLA","LOUANNE","LISHA","LATIA","LANE","KRYSTA","JULIENNE","JOEL","JEANENE","JACQUALINE","ISAURA","GWENDA","EARLEEN","DONALD","CLEOPATRA","CARLIE","AUDIE","ANTONIETTA","ALISE","ALEX","VERDELL","VAL","TYLER","TOMOKO","THAO","TALISHA","STEVEN","SO","SHEMIKA","SHAUN","SCARLET","SAVANNA","SANTINA","ROSIA","RAEANN","ODILIA","NANA","MINNA","MAGAN","LYNELLE","LE","KARMA","JOEANN","IVANA","INELL","ILANA","HYE","HONEY","HEE","GUDRUN","FRANK","DREAMA","CRISSY","CHANTE","CARMELINA","ARVILLA","ARTHUR","ANNAMAE","ALVERA","ALEIDA","AARON","YEE","YANIRA","VANDA","TIANNA","TAM","STEFANIA","SHIRA","PERRY","NICOL","NANCIE","MONSERRATE","MINH","MELYNDA","MELANY","MATTHEW","LOVELLA","LAURE","KIRBY","KACY","JACQUELYNN","HYON","GERTHA","FRANCISCO","ELIANA","CHRISTENA","CHRISTEEN","CHARISE","CATERINA","CARLEY","CANDYCE","ARLENA","AMMIE","YANG","WILLETTE","VANITA","TUYET","TINY","SYREETA","SILVA","SCOTT","RONALD","PENNEY","NYLA","MICHAL","MAURICE","MARYAM","MARYA","MAGEN","LUDIE","LOMA","LIVIA","LANELL","KIMBERLIE","JULEE","DONETTA","DIEDRA","DENISHA","DEANE","DAWNE","CLARINE","CHERRYL","BRONWYN","BRANDON","ALLA","VALERY","TONDA","SUEANN","SORAYA","SHOSHANA","SHELA","SHARLEEN","SHANELLE","NERISSA","MICHEAL","MERIDITH","MELLIE","MAYE","MAPLE","MAGARET","LUIS","LILI","LEONILA","LEONIE","LEEANNA","LAVONIA","LAVERA","KRISTEL","KATHEY","KATHE","JUSTIN","JULIAN","JIMMY","JANN","ILDA","HILDRED","HILDEGARDE","GENIA","FUMIKO","EVELIN","ERMELINDA","ELLY","DUNG","DOLORIS","DIONNA","DANAE","BERNEICE","ANNICE","ALIX","VERENA","VERDIE","TRISTAN","SHAWNNA","SHAWANA","SHAUNNA","ROZELLA","RANDEE","RANAE","MILAGRO","LYNELL","LUISE","LOUIE","LOIDA","LISBETH","KARLEEN","JUNITA","JONA","ISIS","HYACINTH","HEDY","GWENN","ETHELENE","ERLINE","EDWARD","DONYA","DOMONIQUE","DELICIA","DANNETTE","CICELY","BRANDA","BLYTHE","BETHANN","ASHLYN","ANNALEE","ALLINE","YUKO","VELLA","TRANG","TOWANDA","TESHA","SHERLYN","NARCISA","MIGUELINA","MERI","MAYBELL","MARLANA","MARGUERITA","MADLYN","LUNA","LORY","LORIANN","LIBERTY","LEONORE","LEIGHANN","LAURICE","LATESHA","LARONDA","KATRICE","KASIE","KARL","KALEY","JADWIGA","GLENNIE","GEARLDINE","FRANCINA","EPIFANIA","DYAN","DORIE","DIEDRE","DENESE","DEMETRICE","DELENA","DARBY","CRISTIE","CLEORA","CATARINA","CARISA","BERNIE","BARBERA","ALMETA","TRULA","TEREASA","SOLANGE","SHEILAH","SHAVONNE","SANORA","ROCHELL","MATHILDE","MARGARETA","MAIA","LYNSEY","LAWANNA","LAUNA","KENA","KEENA","KATIA","JAMEY","GLYNDA","GAYLENE","ELVINA","ELANOR","DANUTA","DANIKA","CRISTEN","CORDIE","COLETTA","CLARITA","CARMON","BRYNN","AZUCENA","AUNDREA","ANGELE","YI","WALTER","VERLIE","VERLENE","TAMESHA","SILVANA","SEBRINA","SAMIRA","REDA","RAYLENE","PENNI","PANDORA","NORAH","NOMA","MIREILLE","MELISSIA","MARYALICE","LARAINE","KIMBERY","KARYL","KARINE","KAM","JOLANDA","JOHANA","JESUSA","JALEESA","JAE","JACQUELYNE","IRISH","ILUMINADA","HILARIA","HANH","GENNIE","FRANCIE","FLORETTA","EXIE","EDDA","DREMA","DELPHA","BEV","BARBAR","ASSUNTA","ARDELL","ANNALISA","ALISIA","YUKIKO","YOLANDO","WONDA","WEI","WALTRAUD","VETA","TEQUILA","TEMEKA","TAMEIKA","SHIRLEEN","SHENITA","PIEDAD","OZELLA","MIRTHA","MARILU","KIMIKO","JULIANE","JENICE","JEN","JANAY","JACQUILINE","HILDE","FE","FAE","EVAN","EUGENE","ELOIS","ECHO","DEVORAH","CHAU","BRINDA","BETSEY","ARMINDA","ARACELIS","APRYL","ANNETT","ALISHIA","VEOLA","USHA","TOSHIKO","THEOLA","TASHIA","TALITHA","SHERY","RUDY","RENETTA","REIKO","RASHEEDA","OMEGA","OBDULIA","MIKA","MELAINE","MEGGAN","MARTIN","MARLEN","MARGET","MARCELINE","MANA","MAGDALEN","LIBRADA","LEZLIE","LEXIE","LATASHIA","LASANDRA","KELLE","ISIDRA","ISA","INOCENCIA","GWYN","FRANCOISE","ERMINIA","ERINN","DIMPLE","DEVORA","CRISELDA","ARMANDA","ARIE","ARIANE","ANGELO","ANGELENA","ALLEN","ALIZA","ADRIENE","ADALINE","XOCHITL","TWANNA","TRAN","TOMIKO","TAMISHA","TAISHA","SUSY","SIU","RUTHA","ROXY","RHONA","RAYMOND","OTHA","NORIKO","NATASHIA","MERRIE","MELVIN","MARINDA","MARIKO","MARGERT","LORIS","LIZZETTE","LEISHA","KAILA","KA","JOANNIE","JERRICA","JENE","JANNET","JANEE","JACINDA","HERTA","ELENORE","DORETTA","DELAINE","DANIELL","CLAUDIE","CHINA","BRITTA","APOLONIA","AMBERLY","ALEASE","YURI","YUK","WEN","WANETA","UTE","TOMI","SHARRI","SANDIE","ROSELLE","REYNALDA","RAGUEL","PHYLICIA","PATRIA","OLIMPIA","ODELIA","MITZIE","MITCHELL","MISS","MINDA","MIGNON","MICA","MENDY","MARIVEL","MAILE","LYNETTA","LAVETTE","LAURYN","LATRISHA","LAKIESHA","KIERSTEN","KARY","JOSPHINE","JOLYN","JETTA","JANISE","JACQUIE","IVELISSE","GLYNIS","GIANNA","GAYNELLE","EMERALD","DEMETRIUS","DANYELL","DANILLE","DACIA","CORALEE","CHER","CEOLA","BRETT","BELL","ARIANNE","ALESHIA","YUNG","WILLIEMAE","TROY","TRINH","THORA","TAI","SVETLANA","SHERIKA","SHEMEKA","SHAUNDA","ROSELINE","RICKI","MELDA","MALLIE","LAVONNA","LATINA","LARRY","LAQUANDA","LALA","LACHELLE","KLARA","KANDIS","JOHNA","JEANMARIE","JAYE","HANG","GRAYCE","GERTUDE","EMERITA","EBONIE","CLORINDA","CHING","CHERY","CAROLA","BREANN","BLOSSOM","BERNARDINE","BECKI","ARLETHA","ARGELIA","ARA","ALITA","YULANDA","YON","YESSENIA","TOBI","TASIA","SYLVIE","SHIRL","SHIRELY","SHERIDAN","SHELLA","SHANTELLE","SACHA","ROYCE","REBECKA","REAGAN","PROVIDENCIA","PAULENE","MISHA","MIKI","MARLINE","MARICA","LORITA","LATOYIA","LASONYA","KERSTIN","KENDA","KEITHA","KATHRIN","JAYMIE","JACK","GRICELDA","GINETTE","ERYN","ELINA","ELFRIEDA","DANYEL","CHEREE","CHANELLE","BARRIE","AVERY","AURORE","ANNAMARIA","ALLEEN","AILENE","AIDE","YASMINE","VASHTI","VALENTINE","TREASA","TORY","TIFFANEY","SHERYLL","SHARIE","SHANAE","SAU","RAISA","PA","NEDA","MITSUKO","MIRELLA","MILDA","MARYANNA","MARAGRET","MABELLE","LUETTA","LORINA","LETISHA","LATARSHA","LANELLE","LAJUANA","KRISSY","KARLY","KARENA","JON","JESSIKA","JERICA","JEANELLE","JANUARY","JALISA","JACELYN","IZOLA","IVEY","GREGORY","EUNA","ETHA","DREW","DOMITILA","DOMINICA","DAINA","CREOLA","CARLI","CAMIE","BUNNY","BRITTNY","ASHANTI","ANISHA","ALEEN","ADAH","YASUKO","WINTER","VIKI","VALRIE","TONA","TINISHA","THI","TERISA","TATUM","TANEKA","SIMONNE","SHALANDA","SERITA","RESSIE","REFUGIA","PAZ","OLENE","NA","MERRILL","MARGHERITA","MANDIE","MAN","MAIRE","LYNDIA","LUCI","LORRIANE","LORETA","LEONIA","LAVONA","LASHAWNDA","LAKIA","KYOKO","KRYSTINA","KRYSTEN","KENIA","KELSI","JUDE","JEANICE","ISOBEL","GEORGIANN","GENNY","FELICIDAD","EILENE","DEON","DELOISE","DEEDEE","DANNIE","CONCEPTION","CLORA","CHERILYN","CHANG","CALANDRA","BERRY","ARMANDINA","ANISA","ULA","TIMOTHY","TIERA","THERESSA","STEPHANIA","SIMA","SHYLA","SHONTA","SHERA","SHAQUITA","SHALA","SAMMY","ROSSANA","NOHEMI","NERY","MORIAH","MELITA","MELIDA","MELANI","MARYLYNN","MARISHA","MARIETTE","MALORIE","MADELENE","LUDIVINA","LORIA","LORETTE","LORALEE","LIANNE","LEON","LAVENIA","LAURINDA","LASHON","KIT","KIMI","KEILA","KATELYNN","KAI","JONE","JOANE","JI","JAYNA","JANELLA","JA","HUE","HERTHA","FRANCENE","ELINORE","DESPINA","DELSIE","DEEDRA","CLEMENCIA","CARRY","CAROLIN","CARLOS","BULAH","BRITTANIE","BOK","BLONDELL","BIBI","BEAULAH","BEATA","ANNITA","AGRIPINA","VIRGEN","VALENE","UN","TWANDA","TOMMYE","TOI","TARRA","TARI","TAMMERA","SHAKIA","SADYE","RUTHANNE","ROCHEL","RIVKA","PURA","NENITA","NATISHA","MING","MERRILEE","MELODEE","MARVIS","LUCILLA","LEENA","LAVETA","LARITA","LANIE","KEREN","ILEEN","GEORGEANN","GENNA","GENESIS","FRIDA","EWA","EUFEMIA","EMELY","ELA","EDYTH","DEONNA","DEADRA","DARLENA","CHANELL","CHAN","CATHERN","CASSONDRA","CASSAUNDRA","BERNARDA","BERNA","ARLINDA","ANAMARIA","ALBERT","WESLEY","VERTIE","VALERI","TORRI","TATYANA","STASIA","SHERISE","SHERILL","SEASON","SCOTTIE","SANDA","RUTHE","ROSY","ROBERTO","ROBBI","RANEE","QUYEN","PEARLY","PALMIRA","ONITA","NISHA","NIESHA","NIDA","NEVADA","NAM","MERLYN","MAYOLA","MARYLOUISE","MARYLAND","MARX","MARTH","MARGENE","MADELAINE","LONDA","LEONTINE","LEOMA","LEIA","LAWRENCE","LAURALEE","LANORA","LAKITA","KIYOKO","KETURAH","KATELIN","KAREEN","JONIE","JOHNETTE","JENEE","JEANETT","IZETTA","HIEDI","HEIKE","HASSIE","HAROLD","GIUSEPPINA","GEORGANN","FIDELA","FERNANDE","ELWANDA","ELLAMAE","ELIZ","DUSTI","DOTTY","CYNDY","CORALIE","CELESTA","ARGENTINA","ALVERTA","XENIA","WAVA","VANETTA","TORRIE","TASHINA","TANDY","TAMBRA","TAMA","STEPANIE","SHILA","SHAUNTA","SHARAN","SHANIQUA","SHAE","SETSUKO","SERAFINA","SANDEE","ROSAMARIA","PRISCILA","OLINDA","NADENE","MUOI","MICHELINA","MERCEDEZ","MARYROSE","MARIN","MARCENE","MAO","MAGALI","MAFALDA","LOGAN","LINN","LANNIE","KAYCE","KAROLINE","KAMILAH","KAMALA","JUSTA","JOLINE","JENNINE","JACQUETTA","IRAIDA","GERALD","GEORGEANNA","FRANCHESCA","FAIRY","EMELINE","ELANE","EHTEL","EARLIE","DULCIE","DALENE","CRIS","CLASSIE","CHERE","CHARIS","CAROYLN","CARMINA","CARITA","BRIAN","BETHANIE","AYAKO","ARICA","AN","ALYSA","ALESSANDRA","AKILAH","ADRIEN","ZETTA","YOULANDA","YELENA","YAHAIRA","XUAN","WENDOLYN","VICTOR","TIJUANA","TERRELL","TERINA","TERESIA","SUZI","SUNDAY","SHERELL","SHAVONDA","SHAUNTE","SHARDA","SHAKITA","SENA","RYANN","RUBI","RIVA","REGINIA","REA","RACHAL","PARTHENIA","PAMULA","MONNIE","MONET","MICHAELE","MELIA","MARINE","MALKA","MAISHA","LISANDRA","LEO","LEKISHA","LEAN","LAURENCE","LAKENDRA","KRYSTIN","KORTNEY","KIZZIE","KITTIE","KERA","KENDAL","KEMBERLY","KANISHA","JULENE","JULE","JOSHUA","JOHANNE","JEFFREY","JAMEE","HAN","HALLEY","GIDGET","GALINA","FREDRICKA","FLETA","FATIMAH","EUSEBIA","ELZA","ELEONORE","DORTHEY","DORIA","DONELLA","DINORAH","DELORSE","CLARETHA","CHRISTINIA","CHARLYN","BONG","BELKIS","AZZIE","ANDERA","AIKO","ADENA","YER","YAJAIRA","WAN","VANIA","ULRIKE","TOSHIA","TIFANY","STEFANY","SHIZUE","SHENIKA","SHAWANNA","SHAROLYN","SHARILYN","SHAQUANA","SHANTAY","SEE","ROZANNE","ROSELEE","RICKIE","REMONA","REANNA","RAELENE","QUINN","PHUNG","PETRONILA","NATACHA","NANCEY","MYRL","MIYOKO","MIESHA","MERIDETH","MARVELLA","MARQUITTA","MARHTA","MARCHELLE","LIZETH","LIBBIE","LAHOMA","LADAWN","KINA","KATHELEEN","KATHARYN","KARISA","KALEIGH","JUNIE","JULIEANN","JOHNSIE","JANEAN","JAIMEE","JACKQUELINE","HISAKO","HERMA","HELAINE","GWYNETH","GLENN","GITA","EUSTOLIA","EMELINA","ELIN","EDRIS","DONNETTE","DONNETTA","DIERDRE","DENAE","DARCEL","CLAUDE","CLARISA","CINDERELLA","CHIA","CHARLESETTA","CHARITA","CELSA","CASSY","CASSI","CARLEE","BRUNA","BRITTANEY","BRANDE","BILLI","BAO","ANTONETTA","ANGLA","ANGELYN","ANALISA","ALANE","WENONA","WENDIE","VERONIQUE","VANNESA","TOBIE","TEMPIE","SUMIKO","SULEMA","SPARKLE","SOMER","SHEBA","SHAYNE","SHARICE","SHANEL","SHALON","SAGE","ROY","ROSIO","ROSELIA","RENAY","REMA","REENA","PORSCHE","PING","PEG","OZIE","ORETHA","ORALEE","ODA","NU","NGAN","NAKESHA","MILLY","MARYBELLE","MARLIN","MARIS","MARGRETT","MARAGARET","MANIE","LURLENE","LILLIA","LIESELOTTE","LAVELLE","LASHAUNDA","LAKEESHA","KEITH","KAYCEE","KALYN","JOYA","JOETTE","JENAE","JANIECE","ILLA","GRISEL","GLAYDS","GENEVIE","GALA","FREDDA","FRED","ELMER","ELEONOR","DEBERA","DEANDREA","DAN","CORRINNE","CORDIA","CONTESSA","COLENE","CLEOTILDE","CHARLOTT","CHANTAY","CECILLE","BEATRIS","AZALEE","ARLEAN","ARDATH","ANJELICA","ANJA","ALFREDIA","ALEISHA","ADAM","ZADA","YUONNE","XIAO","WILLODEAN","WHITLEY","VENNIE","VANNA","TYISHA","TOVA","TORIE","TONISHA","TILDA","TIEN","TEMPLE","SIRENA","SHERRIL","SHANTI","SHAN","SENAIDA","SAMELLA","ROBBYN","RENDA","REITA","PHEBE","PAULITA","NOBUKO","NGUYET","NEOMI","MOON","MIKAELA","MELANIA","MAXIMINA","MARG","MAISIE","LYNNA","LILLI","LAYNE","LASHAUN","LAKENYA","LAEL","KIRSTIE","KATHLINE","KASHA","KARLYN","KARIMA","JOVAN","JOSEFINE","JENNELL","JACQUI","JACKELYN","HYO","HIEN","GRAZYNA","FLORRIE","FLORIA","ELEONORA","DWANA","DORLA","DONG","DELMY","DEJA","DEDE","DANN","CRYSTA","CLELIA","CLARIS","CLARENCE","CHIEKO","CHERLYN","CHERELLE","CHARMAIN","CHARA","CAMMY","BEE","ARNETTE","ARDELLE","ANNIKA","AMIEE","AMEE","ALLENA","YVONE","YUKI","YOSHIE","YEVETTE","YAEL","WILLETTA","VONCILE","VENETTA","TULA","TONETTE","TIMIKA","TEMIKA","TELMA","TEISHA","TAREN","TA","STACEE","SHIN","SHAWNTA","SATURNINA","RICARDA","POK","PASTY","ONIE","NUBIA","MORA","MIKE","MARIELLE","MARIELLA","MARIANELA","MARDELL","MANY","LUANNA","LOISE","LISABETH","LINDSY","LILLIANA","LILLIAM","LELAH","LEIGHA","LEANORA","LANG","KRISTEEN","KHALILAH","KEELEY","KANDRA","JUNKO","JOAQUINA","JERLENE","JANI","JAMIKA","JAME","HSIU","HERMILA","GOLDEN","GENEVIVE","EVIA","EUGENA","EMMALINE","ELFREDA","ELENE","DONETTE","DELCIE","DEEANNA","DARCEY","CUC","CLARINDA","CIRA","CHAE","CELINDA","CATHERYN","CATHERIN","CASIMIRA","CARMELIA","CAMELLIA","BREANA","BOBETTE","BERNARDINA","BEBE","BASILIA","ARLYNE","AMAL","ALAYNA","ZONIA","ZENIA","YURIKO","YAEKO","WYNELL","WILLOW","WILLENA","VERNIA","TU","TRAVIS","TORA","TERRILYN","TERICA","TENESHA","TAWNA","TAJUANA","TAINA","STEPHNIE","SONA","SOL","SINA","SHONDRA","SHIZUKO","SHERLENE","SHERICE","SHARIKA","ROSSIE","ROSENA","RORY","RIMA","RIA","RHEBA","RENNA","PETER","NATALYA","NANCEE","MELODI","MEDA","MAXIMA","MATHA","MARKETTA","MARICRUZ","MARCELENE","MALVINA","LUBA","LOUETTA","LEIDA","LECIA","LAURAN","LASHAWNA","LAINE","KHADIJAH","KATERINE","KASI","KALLIE","JULIETTA","JESUSITA","JESTINE","JESSIA","JEREMY","JEFFIE","JANYCE","ISADORA","GEORGIANNE","FIDELIA","EVITA","EURA","EULAH","ESTEFANA","ELSY","ELIZABET","ELADIA","DODIE","DION","DIA","DENISSE","DELORAS","DELILA","DAYSI","DAKOTA","CURTIS","CRYSTLE","CONCHA","COLBY","CLARETTA","CHU","CHRISTIA","CHARLSIE","CHARLENA","CARYLON","BETTYANN","ASLEY","ASHLEA","AMIRA","AI","AGUEDA","AGNUS","YUETTE","VINITA","VICTORINA","TYNISHA","TREENA","TOCCARA","TISH","THOMASENA","TEGAN","SOILA","SHILOH","SHENNA","SHARMAINE","SHANTAE","SHANDI","SEPTEMBER","SARAN","SARAI","SANA","SAMUEL","SALLEY","ROSETTE","ROLANDE","REGINE","OTELIA","OSCAR","OLEVIA","NICHOLLE","NECOLE","NAIDA","MYRTA","MYESHA","MITSUE","MINTA","MERTIE","MARGY","MAHALIA","MADALENE","LOVE","LOURA","LOREAN","LEWIS","LESHA","LEONIDA","LENITA","LAVONE","LASHELL","LASHANDRA","LAMONICA","KIMBRA","KATHERINA","KARRY","KANESHA","JULIO","JONG","JENEVA","JAQUELYN","HWA","GILMA","GHISLAINE","GERTRUDIS","FRANSISCA","FERMINA","ETTIE","ETSUKO","ELLIS","ELLAN","ELIDIA","EDRA","DORETHEA","DOREATHA","DENYSE","DENNY","DEETTA","DAINE","CYRSTAL","CORRIN","CAYLA","CARLITA","CAMILA","BURMA","BULA","BUENA","BLAKE","BARABARA","AVRIL","AUSTIN","ALAINE","ZANA","WILHEMINA","WANETTA","VIRGIL","VI","VERONIKA","VERNON","VERLINE","VASILIKI","TONITA","TISA","TEOFILA","TAYNA","TAUNYA","TANDRA","TAKAKO","SUNNI","SUANNE","SIXTA","SHARELL","SEEMA","RUSSELL","ROSENDA","ROBENA","RAYMONDE","PEI","PAMILA","OZELL","NEIDA","NEELY","MISTIE","MICHA","MERISSA","MAURITA","MARYLN","MARYETTA","MARSHALL","MARCELL","MALENA","MAKEDA","MADDIE","LOVETTA","LOURIE","LORRINE","LORILEE","LESTER","LAURENA","LASHAY","LARRAINE","LAREE","LACRESHA","KRISTLE","KRISHNA","KEVA","KEIRA","KAROLE","JOIE","JINNY","JEANNETTA","JAMA","HEIDY","GILBERTE","GEMA","FAVIOLA","EVELYNN","ENDA","ELLI","ELLENA","DIVINA","DAGNY","COLLENE","CODI","CINDIE","CHASSIDY","CHASIDY","CATRICE","CATHERINA","CASSEY","CAROLL","CARLENA","CANDRA","CALISTA","BRYANNA","BRITTENY","BEULA","BARI","AUDRIE","AUDRIA","ARDELIA","ANNELLE","ANGILA","ALONA","ALLYN","DOUGLAS","ROGER","JONATHAN","RALPH","NICHOLAS","BENJAMIN","BRUCE","HARRY","WAYNE","STEVE","HOWARD","ERNEST","PHILLIP","TODD","CRAIG","ALAN","PHILIP","EARL","DANNY","BRYAN","STANLEY","LEONARD","NATHAN","MANUEL","RODNEY","MARVIN","VINCENT","JEFFERY","JEFF","CHAD","JACOB","ALFRED","BRADLEY","HERBERT","FREDERICK","EDWIN","DON","RICKY","RANDALL","BARRY","BERNARD","LEROY","MARCUS","THEODORE","CLIFFORD","MIGUEL","JIM","TOM","CALVIN","BILL","LLOYD","DEREK","WARREN","DARRELL","JEROME","FLOYD","ALVIN","TIM","GORDON","GREG","JORGE","DUSTIN","PEDRO","DERRICK","ZACHARY","HERMAN","GLEN","HECTOR","RICARDO","RICK","BRENT","RAMON","GILBERT","MARC","REGINALD","RUBEN","NATHANIEL","RAFAEL","EDGAR","MILTON","RAUL","BEN","CHESTER","DUANE","FRANKLIN","BRAD","RON","ROLAND","ARNOLD","HARVEY","JARED","ERIK","DARRYL","NEIL","JAVIER","FERNANDO","CLINTON","TED","MATHEW","TYRONE","DARREN","LANCE","KURT","ALLAN","NELSON","GUY","CLAYTON","HUGH","MAX","DWAYNE","DWIGHT","ARMANDO","FELIX","EVERETT","IAN","WALLACE","KEN","BOB","ALFREDO","ALBERTO","DAVE","IVAN","BYRON","ISAAC","MORRIS","CLIFTON","WILLARD","ROSS","ANDY","SALVADOR","KIRK","SERGIO","SETH","KENT","TERRANCE","EDUARDO","TERRENCE","ENRIQUE","WADE","STUART","FREDRICK","ARTURO","ALEJANDRO","NICK","LUTHER","WENDELL","JEREMIAH","JULIUS","OTIS","TREVOR","OLIVER","LUKE","HOMER","GERARD","DOUG","KENNY","HUBERT","LYLE","MATT","ALFONSO","ORLANDO","REX","CARLTON","ERNESTO","NEAL","PABLO","LORENZO","OMAR","WILBUR","GRANT","HORACE","RODERICK","ABRAHAM","WILLIS","RICKEY","ANDRES","CESAR","JOHNATHAN","MALCOLM","RUDOLPH","DAMON","KELVIN","PRESTON","ALTON","ARCHIE","MARCO","WM","PETE","RANDOLPH","GARRY","GEOFFREY","JONATHON","FELIPE","GERARDO","ED","DOMINIC","DELBERT","COLIN","GUILLERMO","EARNEST","LUCAS","BENNY","SPENCER","RODOLFO","MYRON","EDMUND","GARRETT","SALVATORE","CEDRIC","LOWELL","GREGG","SHERMAN","WILSON","SYLVESTER","ROOSEVELT","ISRAEL","JERMAINE","FORREST","WILBERT","LELAND","SIMON","CLARK","IRVING","BRYANT","OWEN","RUFUS","WOODROW","KRISTOPHER","MACK","LEVI","MARCOS","GUSTAVO","JAKE","LIONEL","GILBERTO","CLINT","NICOLAS","ISMAEL","ORVILLE","ERVIN","DEWEY","AL","WILFRED","JOSH","HUGO","IGNACIO","CALEB","TOMAS","SHELDON","ERICK","STEWART","DOYLE","DARREL","ROGELIO","TERENCE","SANTIAGO","ALONZO","ELIAS","BERT","ELBERT","RAMIRO","CONRAD","NOAH","GRADY","PHIL","CORNELIUS","LAMAR","ROLANDO","CLAY","PERCY","DEXTER","BRADFORD","DARIN","AMOS","MOSES","IRVIN","SAUL","ROMAN","RANDAL","TIMMY","DARRIN","WINSTON","BRENDAN","ABEL","DOMINICK","BOYD","EMILIO","ELIJAH","DOMINGO","EMMETT","MARLON","EMANUEL","JERALD","EDMOND","EMIL","DEWAYNE","WILL","OTTO","TEDDY","REYNALDO","BRET","JESS","TRENT","HUMBERTO","EMMANUEL","STEPHAN","VICENTE","LAMONT","GARLAND","MILES","EFRAIN","HEATH","RODGER","HARLEY","ETHAN","ELDON","ROCKY","PIERRE","JUNIOR","FREDDY","ELI","BRYCE","ANTOINE","STERLING","CHASE","GROVER","ELTON","CLEVELAND","DYLAN","CHUCK","DAMIAN","REUBEN","STAN","AUGUST","LEONARDO","JASPER","RUSSEL","ERWIN","BENITO","HANS","MONTE","BLAINE","ERNIE","CURT","QUENTIN","AGUSTIN","MURRAY","JAMAL","ADOLFO","HARRISON","TYSON","BURTON","BRADY","ELLIOTT","WILFREDO","BART","JARROD","VANCE","DENIS","DAMIEN","JOAQUIN","HARLAN","DESMOND","ELLIOT","DARWIN","GREGORIO","BUDDY","XAVIER","KERMIT","ROSCOE","ESTEBAN","ANTON","SOLOMON","SCOTTY","NORBERT","ELVIN","WILLIAMS","NOLAN","ROD","QUINTON","HAL","BRAIN","ROB","ELWOOD","KENDRICK","DARIUS","MOISES","FIDEL","THADDEUS","CLIFF","MARCEL","JACKSON","RAPHAEL","BRYON","ARMAND","ALVARO","JEFFRY","DANE","JOESPH","THURMAN","NED","RUSTY","MONTY","FABIAN","REGGIE","MASON","GRAHAM","ISAIAH","VAUGHN","GUS","LOYD","DIEGO","ADOLPH","NORRIS","MILLARD","ROCCO","GONZALO","DERICK","RODRIGO","WILEY","RIGOBERTO","ALPHONSO","TY","NOE","VERN","REED","JEFFERSON","ELVIS","BERNARDO","MAURICIO","HIRAM","DONOVAN","BASIL","RILEY","NICKOLAS","MAYNARD","SCOT","VINCE","QUINCY","EDDY","SEBASTIAN","FEDERICO","ULYSSES","HERIBERTO","DONNELL","COLE","DAVIS","GAVIN","EMERY","WARD","ROMEO","JAYSON","DANTE","CLEMENT","COY","MAXWELL","JARVIS","BRUNO","ISSAC","DUDLEY","BROCK","SANFORD","CARMELO","BARNEY","NESTOR","STEFAN","DONNY","ART","LINWOOD","BEAU","WELDON","GALEN","ISIDRO","TRUMAN","DELMAR","JOHNATHON","SILAS","FREDERIC","DICK","IRWIN","MERLIN","CHARLEY","MARCELINO","HARRIS","CARLO","TRENTON","KURTIS","HUNTER","AURELIO","WINFRED","VITO","COLLIN","DENVER","CARTER","LEONEL","EMORY","PASQUALE","MOHAMMAD","MARIANO","DANIAL","LANDON","DIRK","BRANDEN","ADAN","BUFORD","GERMAN","WILMER","EMERSON","ZACHERY","FLETCHER","JACQUES","ERROL","DALTON","MONROE","JOSUE","EDWARDO","BOOKER","WILFORD","SONNY","SHELTON","CARSON","THERON","RAYMUNDO","DAREN","HOUSTON","ROBBY","LINCOLN","GENARO","BENNETT","OCTAVIO","CORNELL","HUNG","ARRON","ANTONY","HERSCHEL","GIOVANNI","GARTH","CYRUS","CYRIL","RONNY","LON","FREEMAN","DUNCAN","KENNITH","CARMINE","ERICH","CHADWICK","WILBURN","RUSS","REID","MYLES","ANDERSON","MORTON","JONAS","FOREST","MITCHEL","MERVIN","ZANE","RICH","JAMEL","LAZARO","ALPHONSE","RANDELL","MAJOR","JARRETT","BROOKS","ABDUL","LUCIANO","SEYMOUR","EUGENIO","MOHAMMED","VALENTIN","CHANCE","ARNULFO","LUCIEN","FERDINAND","THAD","EZRA","ALDO","RUBIN","ROYAL","MITCH","EARLE","ABE","WYATT","MARQUIS","LANNY","KAREEM","JAMAR","BORIS","ISIAH","EMILE","ELMO","ARON","LEOPOLDO","EVERETTE","JOSEF","ELOY","RODRICK","REINALDO","LUCIO","JERROD","WESTON","HERSHEL","BARTON","PARKER","LEMUEL","BURT","JULES","GIL","ELISEO","AHMAD","NIGEL","EFREN","ANTWAN","ALDEN","MARGARITO","COLEMAN","DINO","OSVALDO","LES","DEANDRE","NORMAND","KIETH","TREY","NORBERTO","NAPOLEON","JEROLD","FRITZ","ROSENDO","MILFORD","CHRISTOPER","ALFONZO","LYMAN","JOSIAH","BRANT","WILTON","RICO","JAMAAL","DEWITT","BRENTON","OLIN","FOSTER","FAUSTINO","CLAUDIO","JUDSON","GINO","EDGARDO","ALEC","TANNER","JARRED","DONN","TAD","PRINCE","PORFIRIO","ODIS","LENARD","CHAUNCEY","TOD","MEL","MARCELO","KORY","AUGUSTUS","KEVEN","HILARIO","BUD","SAL","ORVAL","MAURO","ZACHARIAH","OLEN","ANIBAL","MILO","JED","DILLON","AMADO","NEWTON","LENNY","RICHIE","HORACIO","BRICE","MOHAMED","DELMER","DARIO","REYES","MAC","JONAH","JERROLD","ROBT","HANK","RUPERT","ROLLAND","KENTON","DAMION","ANTONE","WALDO","FREDRIC","BRADLY","KIP","BURL","WALKER","TYREE","JEFFEREY","AHMED","WILLY","STANFORD","OREN","NOBLE","MOSHE","MIKEL","ENOCH","BRENDON","QUINTIN","JAMISON","FLORENCIO","DARRICK","TOBIAS","HASSAN","GIUSEPPE","DEMARCUS","CLETUS","TYRELL","LYNDON","KEENAN","WERNER","GERALDO","COLUMBUS","CHET","BERTRAM","MARKUS","HUEY","HILTON","DWAIN","DONTE","TYRON","OMER","ISAIAS","HIPOLITO","FERMIN","ADALBERTO","BO","BARRETT","TEODORO","MCKINLEY","MAXIMO","GARFIELD","RALEIGH","LAWERENCE","ABRAM","RASHAD","KING","EMMITT","DARON","SAMUAL","MIQUEL","EUSEBIO","DOMENIC","DARRON","BUSTER","WILBER","RENATO","JC","HOYT","HAYWOOD","EZEKIEL","CHAS","FLORENTINO","ELROY","CLEMENTE","ARDEN","NEVILLE","EDISON","DESHAWN","NATHANIAL","JORDON","DANILO","CLAUD","SHERWOOD","RAYMON","RAYFORD","CRISTOBAL","AMBROSE","TITUS","HYMAN","FELTON","EZEQUIEL","ERASMO","STANTON","LONNY","LEN","IKE","MILAN","LINO","JAROD","HERB","ANDREAS","WALTON","RHETT","PALMER","DOUGLASS","CORDELL","OSWALDO","ELLSWORTH","VIRGILIO","TONEY","NATHANAEL","DEL","BENEDICT","MOSE","JOHNSON","ISREAL","GARRET","FAUSTO","ASA","ARLEN","ZACK","WARNER","MODESTO","FRANCESCO","MANUAL","GAYLORD","GASTON","FILIBERTO","DEANGELO","MICHALE","GRANVILLE","WES","MALIK","ZACKARY","TUAN","ELDRIDGE","CRISTOPHER","CORTEZ","ANTIONE","MALCOM","LONG","KOREY","JOSPEH","COLTON","WAYLON","VON","HOSEA","SHAD","SANTO","RUDOLF","ROLF","REY","RENALDO","MARCELLUS","LUCIUS","KRISTOFER","BOYCE","BENTON","HAYDEN","HARLAND","ARNOLDO","RUEBEN","LEANDRO","KRAIG","JERRELL","JEROMY","HOBERT","CEDRICK","ARLIE","WINFORD","WALLY","LUIGI","KENETH","JACINTO","GRAIG","FRANKLYN","EDMUNDO","SID","PORTER","LEIF","JERAMY","BUCK","WILLIAN","VINCENZO","SHON","LYNWOOD","JERE","HAI","ELDEN","DORSEY","DARELL","BRODERICK","ALONSO" \ No newline at end of file diff --git a/Project Euler/Problem 22/sol1.py b/Project Euler/Problem 22/sol1.py new file mode 100644 index 000000000000..7754306583dc --- /dev/null +++ b/Project Euler/Problem 22/sol1.py @@ -0,0 +1,37 @@ +# -*- coding: latin-1 -*- +from __future__ import print_function +''' +Name scores +Problem 22 + +Using names.txt (right click and 'Save Link/Target As...'), a 46K text file containing over five-thousand first names, begin by sorting it +into alphabetical order. Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list +to obtain a name score. + +For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. +So, COLIN would obtain a score of 938 × 53 = 49714. + +What is the total of all the name scores in the file? +''' +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + +with open('p022_names.txt') as file: + names = str(file.readlines()[0]) + names = names.replace('"', '').split(',') + +names.sort() + +name_score = 0 +total_score = 0 + +for i, name in enumerate(names): + for letter in name: + name_score += ord(letter) - 64 + + total_score += (i+1)*name_score + name_score = 0 + +print(total_score) \ No newline at end of file From 1ead4e0f2d228481d1095a8bb9919a4d1500dbd6 Mon Sep 17 00:00:00 2001 From: GirijaManoj kumar reddy Kalakoti Date: Thu, 22 Mar 2018 15:50:49 +0530 Subject: [PATCH 053/105] Added Solution to Problem 2 in a simple approach --- Project Euler/Problem 02/sol3.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Project Euler/Problem 02/sol3.py diff --git a/Project Euler/Problem 02/sol3.py b/Project Euler/Problem 02/sol3.py new file mode 100644 index 000000000000..d36b741bb4f9 --- /dev/null +++ b/Project Euler/Problem 02/sol3.py @@ -0,0 +1,20 @@ +''' +Problem: +Each new term in the Fibonacci sequence is generated by adding the previous two terms. + 0,1,1,2,3,5,8,13,21,34,55,89,.. +Every third term from 0 is even So using this I have written a simple code +By considering the terms in the Fibonacci sequence whose values do not exceed n, find the sum of the even-valued terms. +e.g. for n=10, we have {2,8}, sum is 10. +''' +"""Python 3""" +n = int(input()) +a=0 +b=2 +count=0 +while 4*b+a Date: Thu, 22 Mar 2018 09:33:54 -0400 Subject: [PATCH 054/105] Counting integer partitions --- dynamic_programming/integer_partition.py | 45 ++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 dynamic_programming/integer_partition.py diff --git a/dynamic_programming/integer_partition.py b/dynamic_programming/integer_partition.py new file mode 100644 index 000000000000..7b27afebaa6c --- /dev/null +++ b/dynamic_programming/integer_partition.py @@ -0,0 +1,45 @@ +from __future__ import print_function + +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + +try: + raw_input #Python 2 +except NameError: + raw_input = input #Python 3 + +''' +The number of partitions of a number n into at least k parts equals the number of partitions into exactly k parts +plus the number of partitions into at least k-1 parts. Subtracting 1 from each part of a partition of n into k parts +gives a partition of n-k into k parts. These two facts together are used for this algorithm. +''' +def partition(m): + memo = [[0 for _ in xrange(m)] for _ in xrange(m+1)] + for i in xrange(m+1): + memo[i][0] = 1 + + for n in xrange(m+1): + for k in xrange(1, m): + memo[n][k] += memo[n][k-1] + if n-k > 0: + memo[n][k] += memo[n-k-1][k] + + return memo[m][m-1] + +if __name__ == '__main__': + import sys + + if len(sys.argv) == 1: + try: + n = int(raw_input('Enter a number: ')) + print(partition(n)) + except ValueError: + print('Please enter a number.') + else: + try: + n = int(sys.argv[1]) + print(partition(n)) + except ValueError: + print('Please pass a number.') \ No newline at end of file From 49a33969e6f303eaa060a74092e95bc6f49f456c Mon Sep 17 00:00:00 2001 From: girijamanojkumarreddy Date: Thu, 22 Mar 2018 19:29:44 +0530 Subject: [PATCH 055/105] Added a Solution using Euclidean Algo --- Project Euler/Problem 05/sol2.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Project Euler/Problem 05/sol2.py diff --git a/Project Euler/Problem 05/sol2.py b/Project Euler/Problem 05/sol2.py new file mode 100644 index 000000000000..cd11437f30db --- /dev/null +++ b/Project Euler/Problem 05/sol2.py @@ -0,0 +1,20 @@ +#!/bin/python3 +''' +Problem: +2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder. +What is the smallest positive number that is evenly divisible(divisible with no remainder) by all of the numbers from 1 to N? +''' + +""" Euclidean GCD Algorithm """ +def gcd(x,y): + return x if y==0 else gcd(y,x%y) + +""" Using the property lcm*gcd of two numbers = product of them """ +def lcm(x,y): + return (x*y)//gcd(x,y) + +n = int(input()) +g=1 +for i in range(1,n+1): + g=lcm(g,i) +print(g) From 570c27cfdd892cdde15d8167a6d261c54581dde4 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Thu, 22 Mar 2018 11:27:50 -0400 Subject: [PATCH 056/105] Solution to Problem 21 --- Project Euler/Problem 21/sol1.py | 42 ++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 Project Euler/Problem 21/sol1.py diff --git a/Project Euler/Problem 21/sol1.py b/Project Euler/Problem 21/sol1.py new file mode 100644 index 000000000000..6d137a7d4332 --- /dev/null +++ b/Project Euler/Problem 21/sol1.py @@ -0,0 +1,42 @@ +#-.- coding: latin-1 -.- +from __future__ import print_function +from math import sqrt +''' +Amicable Numbers +Problem 21 + +Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n). +If d(a) = b and d(b) = a, where a ≠ b, then a and b are an amicable pair and each of a and b are called amicable numbers. + +For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220. + +Evaluate the sum of all the amicable numbers under 10000. +''' +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + +def sum_of_divisors(n): + total = 0 + for i in xrange(1, int(sqrt(n)+1)): + if n%i == 0 and i != sqrt(n): + total += i + n//i + elif i == sqrt(n): + total += i + + return total-n + +sums = [] +total = 0 + +for i in xrange(1, 10000): + n = sum_of_divisors(i) + + if n < len(sums): + if sums[n-1] == i: + total += n + i + + sums.append(n) + +print(total) \ No newline at end of file From 68e5bb48041252ce72f35de35892de1d2934b1d1 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Thu, 22 Mar 2018 12:09:45 -0400 Subject: [PATCH 057/105] Solution to Problem 76 --- Project Euler/Problem 76/sol1.py | 35 ++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Project Euler/Problem 76/sol1.py diff --git a/Project Euler/Problem 76/sol1.py b/Project Euler/Problem 76/sol1.py new file mode 100644 index 000000000000..2832f6d7afb6 --- /dev/null +++ b/Project Euler/Problem 76/sol1.py @@ -0,0 +1,35 @@ +from __future__ import print_function +''' +Counting Summations +Problem 76 + +It is possible to write five as a sum in exactly six different ways: + +4 + 1 +3 + 2 +3 + 1 + 1 +2 + 2 + 1 +2 + 1 + 1 + 1 +1 + 1 + 1 + 1 + 1 + +How many different ways can one hundred be written as a sum of at least two positive integers? +''' +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + +def partition(m): + memo = [[0 for _ in xrange(m)] for _ in xrange(m+1)] + for i in xrange(m+1): + memo[i][0] = 1 + + for n in xrange(m+1): + for k in xrange(1, m): + memo[n][k] += memo[n][k-1] + if n > k: + memo[n][k] += memo[n-k-1][k] + + return (memo[m][m-1] - 1) + +print(partition(100)) \ No newline at end of file From f538ea51dc78a12fd2205940a6fed9572c87e6c3 Mon Sep 17 00:00:00 2001 From: girijamanojkumarreddy Date: Fri, 23 Mar 2018 16:27:25 +0530 Subject: [PATCH 058/105] Added General solution for Problem 9 --- Project Euler/Problem 9/sol2.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Project Euler/Problem 9/sol2.py diff --git a/Project Euler/Problem 9/sol2.py b/Project Euler/Problem 9/sol2.py new file mode 100644 index 000000000000..13674d25875e --- /dev/null +++ b/Project Euler/Problem 9/sol2.py @@ -0,0 +1,19 @@ +"""A Pythagorean triplet is a set of three natural numbers, for which, +a^2+b^2=c^2 +Given N, Check if there exists any Pythagorean triplet for which a+b+c=N +Find maximum possible value of product of a,b,c among all such Pythagorean triplets, If there is no such Pythagorean triplet print -1.""" +#!/bin/python3 +import sys + +product=-1 +d=0 +N = int(input()) +for a in range(1,N//3): + """Solving the two equations a**2+b**2=c**2 and a+b+c=N eliminating c """ + b=(N*N-2*a*N)//(2*N-2*a) + c=N-a-b + if c*c==(a*a+b*b): + d=(a*b*c) + if d>=product: + product=d +print(product) From eb40f43650409e534c69b3d8e1d5bf8e39f23bd8 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Sat, 24 Mar 2018 21:48:48 -0400 Subject: [PATCH 059/105] Solution to Problem 53 --- Project Euler/Problem 53/sol1.py | 36 ++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Project Euler/Problem 53/sol1.py diff --git a/Project Euler/Problem 53/sol1.py b/Project Euler/Problem 53/sol1.py new file mode 100644 index 000000000000..ed6d5329eb4e --- /dev/null +++ b/Project Euler/Problem 53/sol1.py @@ -0,0 +1,36 @@ +#-.- coding: latin-1 -.- +from __future__ import print_function +from math import factorial +''' +Combinatoric selections +Problem 53 + +There are exactly ten ways of selecting three from five, 12345: + +123, 124, 125, 134, 135, 145, 234, 235, 245, and 345 + +In combinatorics, we use the notation, 5C3 = 10. + +In general, + +nCr = n!/(r!(n−r)!),where r ≤ n, n! = n×(n−1)×...×3×2×1, and 0! = 1. +It is not until n = 23, that a value exceeds one-million: 23C10 = 1144066. + +How many, not necessarily distinct, values of nCr, for 1 ≤ n ≤ 100, are greater than one-million? +''' +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + +def combinations(n, r): + return factorial(n)/(factorial(r)*factorial(n-r)) + +total = 0 + +for i in xrange(1, 101): + for j in xrange(1, i+1): + if combinations(i, j) > 1e6: + total += 1 + +print(total) \ No newline at end of file From 7b1b33a60a0289949851f0a3405f1dd74e573fb0 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Sun, 25 Mar 2018 23:14:59 -0400 Subject: [PATCH 060/105] Solution to Problem 19 --- Project Euler/Problem 19/sol1.py | 51 ++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 Project Euler/Problem 19/sol1.py diff --git a/Project Euler/Problem 19/sol1.py b/Project Euler/Problem 19/sol1.py new file mode 100644 index 000000000000..94cf117026a4 --- /dev/null +++ b/Project Euler/Problem 19/sol1.py @@ -0,0 +1,51 @@ +from __future__ import print_function +''' +Counting Sundays +Problem 19 + +You are given the following information, but you may prefer to do some research for yourself. + +1 Jan 1900 was a Monday. +Thirty days has September, +April, June and November. +All the rest have thirty-one, +Saving February alone, +Which has twenty-eight, rain or shine. +And on leap years, twenty-nine. + +A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400. + +How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)? +''' + +days_per_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] + +day = 6 +month = 1 +year = 1901 + +sundays = 0 + +while year < 2001: + day += 7 + + if (year%4 == 0 and not year%100 == 0) or (year%400 == 0): + if day > days_per_month[month-1] and month is not 2: + month += 1 + day = day-days_per_month[month-2] + elif day > 29 and month is 2: + month += 1 + day = day-29 + else: + if day > days_per_month[month-1]: + month += 1 + day = day-days_per_month[month-2] + + if month > 12: + year += 1 + month = 1 + + if year < 2001 and day is 1: + sundays += 1 + +print(sundays) \ No newline at end of file From 53d9989b13a14d16bff9bbe023f29d081ce7b041 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Wed, 28 Mar 2018 19:11:14 -0400 Subject: [PATCH 061/105] Solution to Problem 12 --- Project Euler/Problem 12/sol1.py | 46 ++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Project Euler/Problem 12/sol1.py diff --git a/Project Euler/Problem 12/sol1.py b/Project Euler/Problem 12/sol1.py new file mode 100644 index 000000000000..9c4483fd62e5 --- /dev/null +++ b/Project Euler/Problem 12/sol1.py @@ -0,0 +1,46 @@ +from __future__ import print_function +from math import sqrt +''' +Highly divisible triangular numbers +Problem 12 +The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be: + +1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ... + +Let us list the factors of the first seven triangle numbers: + + 1: 1 + 3: 1,3 + 6: 1,2,3,6 +10: 1,2,5,10 +15: 1,3,5,15 +21: 1,3,7,21 +28: 1,2,4,7,14,28 +We can see that 28 is the first triangle number to have over five divisors. + +What is the value of the first triangle number to have over five hundred divisors? +''' +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + +def count_divisors(n): + nDivisors = 0 + for i in xrange(1, int(sqrt(n))+1): + if n%i == 0: + nDivisors += 2 + + return nDivisors + +tNum = 1 +i = 1 + +while True: + i += 1 + tNum += i + + if count_divisors(tNum) > 500: + break + +print(tNum) \ No newline at end of file From 9ed60ba882c7b6a07b7b951447558710fcbdcc4b Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Mon, 2 Apr 2018 12:20:53 -0400 Subject: [PATCH 062/105] Solution to Problem 36 --- Project Euler/Problem 36/sol1.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Project Euler/Problem 36/sol1.py diff --git a/Project Euler/Problem 36/sol1.py b/Project Euler/Problem 36/sol1.py new file mode 100644 index 000000000000..d78e7e59f210 --- /dev/null +++ b/Project Euler/Problem 36/sol1.py @@ -0,0 +1,30 @@ +from __future__ import print_function +''' +Double-base palindromes +Problem 36 +The decimal number, 585 = 10010010012 (binary), is palindromic in both bases. + +Find the sum of all numbers, less than one million, which are palindromic in base 10 and base 2. + +(Please note that the palindromic number, in either base, may not include leading zeros.) +''' +try: + xrange #Python 2 +except NameError: + xrange = range #Python 3 + +def is_palindrome(n): + n = str(n) + + if n == n[::-1]: + return True + else: + return False + +total = 0 + +for i in xrange(1, 1000000): + if is_palindrome(i) and is_palindrome(bin(i).split('b')[1]): + total += i + +print(total) \ No newline at end of file From 6a8f1cf2325253f7643bd23d1e91cb410b3cbb00 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Mon, 2 Apr 2018 23:46:28 -0400 Subject: [PATCH 063/105] Solution to Problem 40 --- Project Euler/Problem 40/sol1.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Project Euler/Problem 40/sol1.py diff --git a/Project Euler/Problem 40/sol1.py b/Project Euler/Problem 40/sol1.py new file mode 100644 index 000000000000..ab4017512a1a --- /dev/null +++ b/Project Euler/Problem 40/sol1.py @@ -0,0 +1,26 @@ +#-.- coding: latin-1 -.- +from __future__ import print_function +''' +Champernowne's constant +Problem 40 +An irrational decimal fraction is created by concatenating the positive integers: + +0.123456789101112131415161718192021... + +It can be seen that the 12th digit of the fractional part is 1. + +If dn represents the nth digit of the fractional part, find the value of the following expression. + +d1 × d10 × d100 × d1000 × d10000 × d100000 × d1000000 +''' + +constant = [] +i = 1 + +while len(constant) < 1e6: + constant.append(str(i)) + i += 1 + +constant = ''.join(constant) + +print(int(constant[0])*int(constant[9])*int(constant[99])*int(constant[999])*int(constant[9999])*int(constant[99999])*int(constant[999999])) \ No newline at end of file From b172ec38418044cefaaa6aafcf56eee172308de2 Mon Sep 17 00:00:00 2001 From: Daniel Ingram Date: Tue, 3 Apr 2018 00:04:38 -0400 Subject: [PATCH 064/105] Solution to Problem 52 --- Project Euler/Problem 52/sol1.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Project Euler/Problem 52/sol1.py diff --git a/Project Euler/Problem 52/sol1.py b/Project Euler/Problem 52/sol1.py new file mode 100644 index 000000000000..376b4cfa1d63 --- /dev/null +++ b/Project Euler/Problem 52/sol1.py @@ -0,0 +1,23 @@ +from __future__ import print_function +''' +Permuted multiples +Problem 52 + +It can be seen that the number, 125874, and its double, 251748, contain exactly the same digits, but in a different order. + +Find the smallest positive integer, x, such that 2x, 3x, 4x, 5x, and 6x, contain the same digits. +''' +i = 1 + +while True: + if sorted(list(str(i))) == \ + sorted(list(str(2*i))) == \ + sorted(list(str(3*i))) == \ + sorted(list(str(4*i))) == \ + sorted(list(str(5*i))) == \ + sorted(list(str(6*i))): + break + + i += 1 + +print(i) \ No newline at end of file From 18907e4a072077108f33cc0b724ac273724631bd Mon Sep 17 00:00:00 2001 From: douly Date: Fri, 13 Apr 2018 09:56:40 +0800 Subject: [PATCH 065/105] fix type error (except an int) in jumpmp_search line 7. --- searches/jump_search.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/searches/jump_search.py b/searches/jump_search.py index 4cff92bb585c..10cb933f2f35 100644 --- a/searches/jump_search.py +++ b/searches/jump_search.py @@ -2,11 +2,11 @@ import math def jump_search(arr, x): n = len(arr) - step = math.floor(math.sqrt(n)) + step = int(math.floor(math.sqrt(n))) prev = 0 while arr[min(step, n)-1] < x: prev = step - step += math.floor(math.sqrt(n)) + step += int(math.floor(math.sqrt(n))) if prev >= n: return -1 @@ -23,4 +23,4 @@ def jump_search(arr, x): arr = [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610] x = 55 index = jump_search(arr, x) -print("\nNumber " + str(x) +" is at index " + str(index)); \ No newline at end of file +print("\nNumber " + str(x) +" is at index " + str(index)); From 3a0555bdd7d9cfb4cfcf165249bb95b67cab3877 Mon Sep 17 00:00:00 2001 From: Syed Haseeb Shah Date: Fri, 13 Apr 2018 20:25:47 +0500 Subject: [PATCH 066/105] Create NewtonRaphsonMethod.py Newton-Raphson method is non bracketing iterative algorithm to find the nearest root of an equation from point 'a'. It's much faster because convergence to the real root is very much faster than any other methods. --- ArithmeticAnalysis/NewtonRaphsonMethod.py | 38 +++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 ArithmeticAnalysis/NewtonRaphsonMethod.py diff --git a/ArithmeticAnalysis/NewtonRaphsonMethod.py b/ArithmeticAnalysis/NewtonRaphsonMethod.py new file mode 100644 index 000000000000..40501134e28a --- /dev/null +++ b/ArithmeticAnalysis/NewtonRaphsonMethod.py @@ -0,0 +1,38 @@ +# Implementing Newton Raphson method in python +# Author: Haseeb + +from sympy import diff +from decimal import Decimal +from math import sin, cos, exp + +def NewtonRaphson(func, a): + ''' Finds root from the point 'a' onwards by Newton-Raphson method ''' + while True: + x = a + c = Decimal(a) - ( Decimal(eval(func)) / Decimal(eval(str(diff(func)))) ) + + x = c + a = c + # This number dictates the accuracy of the answer + if abs(eval(func)) < 10**-15: + return c + + +# Let's Execute +if __name__ == '__main__': + # Find root of trignometric fucntion + # Find value of pi + print ('sin(x) = 0', NewtonRaphson('sin(x)', 2)) + + # Find root of polynomial + print ('x**2 - 5*x +2 = 0', NewtonRaphson('x**2 - 5*x +2', 0.4)) + + # Find Square Root of 5 + print ('x**2 - 5 = 0', NewtonRaphson('x**2 - 5', 0.1)) + + # Exponential Roots + print ('exp(x) - 1 = 0', NewtonRaphson('exp(x) - 1', 0)) + + + + From 0fdd2d369ea5b6b4b50b1ed18c5d6c61bf073e79 Mon Sep 17 00:00:00 2001 From: Syed Haseeb Shah Date: Fri, 13 Apr 2018 20:49:38 +0500 Subject: [PATCH 067/105] Create Onepad_Cipher.py In one pad algorithm length of key and length of message are equal which results in endless possibilities of false messages on bruteforce. --- ciphers/Onepad_Cipher.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 ciphers/Onepad_Cipher.py diff --git a/ciphers/Onepad_Cipher.py b/ciphers/Onepad_Cipher.py new file mode 100644 index 000000000000..4365924920f6 --- /dev/null +++ b/ciphers/Onepad_Cipher.py @@ -0,0 +1,28 @@ +class Onepad: + def encrypt(self, text): + '''Function to encrypt text using psedo-random numbers''' + plain = [] + key = [] + cipher = [] + for i in text: + plain.append(ord(i)) + for i in plain: + k = random.randint(1, 300) + c = (i+k)*k + cipher.append(c) + key.append(k) + return cipher, key + + def decrypt(self, cipher, key): + '''Function to decrypt text using psedo-random numbers.''' + plain = [] + for i in range(len(key)): + p = (cipher[i]-(key[i])**2)/key[i] + plain.append(chr(p)) + plain = ''.join([i for i in plain]) + return plain + +if __name__ == '__main__': + c,k = Onepad().encrypt('Hello') + print c, k + print Onepad().decrypt(c, k) From 13ebdc35fda3e4b5d7c36f382f32f702af2ceed5 Mon Sep 17 00:00:00 2001 From: Christian Bender Date: Sun, 15 Apr 2018 23:29:21 +0200 Subject: [PATCH 068/105] I fixed the sol3.py of problem 1 --- Project Euler/Problem 01/sol3.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Project Euler/Problem 01/sol3.py b/Project Euler/Problem 01/sol3.py index 78b4d0e93519..f4f3aefcc5de 100644 --- a/Project Euler/Problem 01/sol3.py +++ b/Project Euler/Problem 01/sol3.py @@ -1,3 +1,5 @@ +from __future__ import print_function + ''' Problem Statement: If we list all the natural numbers below 10 that are multiples of 3 or 5, @@ -7,7 +9,7 @@ ''' This solution is based on the pattern that the successive numbers in the series follow: 0+3,+2,+1,+3,+1,+2,+3. ''' -from __future__ import print_function + try: raw_input # Python 2 except NameError: From 10b0a40b2eae2e986cffd6d4760ada01a6ee99b1 Mon Sep 17 00:00:00 2001 From: Christian Bender Date: Sun, 15 Apr 2018 23:52:45 +0200 Subject: [PATCH 069/105] fixed solution 4 of problem 1 --- Project Euler/Problem 01/sol4.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/Project Euler/Problem 01/sol4.py b/Project Euler/Problem 01/sol4.py index 0f5dc370b441..7941f5fcd3fe 100644 --- a/Project Euler/Problem 01/sol4.py +++ b/Project Euler/Problem 01/sol4.py @@ -9,7 +9,6 @@ def mulitples(limit): if (result < limit): zmulti.append(result) temp += 1 - continue else: temp = 1 break @@ -18,15 +17,14 @@ def mulitples(limit): if (result < limit): xmulti.append(result) temp += 1 - continue else: - temp = 1 break - return (sum(zmulti) + sum(xmulti)) + collection = list(set(xmulti+zmulti)) + return (sum(collection)) -print (mulitples(100)) +print (mulitples(1000)) From 621192998e2aef51b5ba188490b8f2d044beff9a Mon Sep 17 00:00:00 2001 From: Harshil Date: Mon, 16 Apr 2018 06:56:53 +0200 Subject: [PATCH 070/105] basic client-server implementation --- server.py | 43 ---------------------------------- simple-client-server/README.md | 6 +++++ simple-client-server/client.py | 14 +++++++++++ simple-client-server/server.py | 21 +++++++++++++++++ 4 files changed, 41 insertions(+), 43 deletions(-) delete mode 100644 server.py create mode 100644 simple-client-server/README.md create mode 100644 simple-client-server/client.py create mode 100644 simple-client-server/server.py diff --git a/server.py b/server.py deleted file mode 100644 index 578c24285bfb..000000000000 --- a/server.py +++ /dev/null @@ -1,43 +0,0 @@ -# all imports - including #s -import socket -#import os -#import sys -#import subprocess -# end of imports -# the below classes will clarify what information is for the attacker and client -class Termrequire: - host = socket.gethostname() - port = 3333 # fake numeral for the moment -class Clientrequire: - host = socket.gethostname() - port = 2222 # fake numeral for the moment -#CORE REQUIREMENTS OF PROGRAM: -### host ip = server ip -### potential connection hosts info (host, port) -### user.config -### user.config -# using SERVER for connections and linux meterpreter sessions -# SERVER DETAILS: - #5 client availability for pivoting #although that is not yet available in a regular form of - #exploitation - we have to go with what we have. - -# #learnmore - USER_CONFIG -# server ip will be displayed every connection at version 2.0 -# terminal attacker socket object creation -t = socket.socket(socket.AF_INET, socket.SOCK_STREAM) -# terminal attacker socket binding -t.bind() -# terminal attacker socket listen -t.listen() -# client socket object creation -s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) -# binding information with s.bind method -s.bind() -#listening for connections with s.listen method -s.listen(1) -# server_functionality waits for terminal shell and then gets client information connectivity -def func4client(): - s.accept() -# terminal functionality for attacker - I will definitely customize it soon. Maybe tkinter? -def func4term(): - t.accept() \ No newline at end of file diff --git a/simple-client-server/README.md b/simple-client-server/README.md new file mode 100644 index 000000000000..f51947f2105a --- /dev/null +++ b/simple-client-server/README.md @@ -0,0 +1,6 @@ +# simple client server + +#### Note: +- Run **`server.py`** first. +- Now, run **`client.py`**. +- verify the output. diff --git a/simple-client-server/client.py b/simple-client-server/client.py new file mode 100644 index 000000000000..c91e6233ad16 --- /dev/null +++ b/simple-client-server/client.py @@ -0,0 +1,14 @@ +# client.py + +import socket + +HOST, PORT = '127.0.0.1', 1400 + +s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) +s.connect((HOST, PORT)) + +s.send(b'Hello World') +data = s.recv(1024) + +s.close() +print(repr(data.decode('ascii'))) diff --git a/simple-client-server/server.py b/simple-client-server/server.py new file mode 100644 index 000000000000..c6b661d99044 --- /dev/null +++ b/simple-client-server/server.py @@ -0,0 +1,21 @@ +# server.py + +import socket + +HOST, PORT = '127.0.0.1', 1400 + +s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) +s.bind((HOST, PORT)) +s.listen(1) + +conn, addr = s.accept() + +print('connected to:', addr) + +while 1: + data = conn.recv(1024) + if not data: + break + conn.send(data + b' [ addition by server ]') + +conn.close() From 3a7e75f329d14bad68043896b856fed36e7bc2ef Mon Sep 17 00:00:00 2001 From: Christian Bender Date: Mon, 16 Apr 2018 13:37:04 +0200 Subject: [PATCH 071/105] added a option for termination the program --- hashes/chaos_machine.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/hashes/chaos_machine.py b/hashes/chaos_machine.py index 8b6c004380aa..59d0d7ffdd3f 100644 --- a/hashes/chaos_machine.py +++ b/hashes/chaos_machine.py @@ -1,6 +1,12 @@ """example of simple chaos machine""" from __future__ import print_function +try: + raw_input + input = raw_input +except: + pass + # Chaos Machine (K, t, m) K = [0.33, 0.44, 0.55, 0.44, 0.33]; t = 3; m = 5 @@ -91,7 +97,11 @@ def reset(): for chunk in message: push(chunk) +# for controlling +inp = "" + # Pulling Data (Output) -while True: +while inp != "e" and inp != "E": print("%s" % format(pull(), '#04x')) print(buffer_space); print(params_space) + inp = input("(e)exit? ") From c1422ec99c754e542223979a5bdc882f67ac9ac5 Mon Sep 17 00:00:00 2001 From: Christian Bender Date: Mon, 16 Apr 2018 13:42:44 +0200 Subject: [PATCH 072/105] fixed the assert statments --- hashes/chaos_machine.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/hashes/chaos_machine.py b/hashes/chaos_machine.py index 59d0d7ffdd3f..766dbba3c5c9 100644 --- a/hashes/chaos_machine.py +++ b/hashes/chaos_machine.py @@ -38,8 +38,8 @@ def push(seed): r # Saving to Parameters Space # Logistic Map - assert(max(buffer_space) < 1) - assert(max(params_space) < 4) + assert max(buffer_space) < 1 + assert max(params_space) < 4 # Machine Time machine_time += 1 From cfae621f46d6f2ae956820522e88af1bbb20475a Mon Sep 17 00:00:00 2001 From: Christian Bender Date: Mon, 16 Apr 2018 14:13:49 +0200 Subject: [PATCH 073/105] I documented the md5 hash --- hashes/md5.py | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/hashes/md5.py b/hashes/md5.py index c336b5fe49ee..3ae13089d019 100644 --- a/hashes/md5.py +++ b/hashes/md5.py @@ -10,6 +10,13 @@ def rearrange(bitString32): return newString def reformatHex(i): + """[summary] + Converts the given integer into 8-digit hex number. + + Arguments: + i {[int]} -- [integer] + """ + hexrep = format(i,'08x') thing = "" for i in [3,2,1,0]: @@ -17,6 +24,16 @@ def reformatHex(i): return thing def pad(bitString): + """[summary] + Fills up the binary string to a 512 bit binary string + + Arguments: + bitString {[string]} -- [binary string] + + Returns: + [string] -- [binary string] + """ + startLength = len(bitString) bitString += '1' while len(bitString) % 512 != 448: @@ -26,6 +43,15 @@ def pad(bitString): return bitString def getBlock(bitString): + """[summary] + Iterator: + Returns by each call a list of length 16 with the 32 bit + integer blocks. + + Arguments: + bitString {[string]} -- [binary string >= 512] + """ + currPos = 0 while currPos < len(bitString): currPart = bitString[currPos:currPos+512] @@ -34,6 +60,7 @@ def getBlock(bitString): mySplits.append(int(rearrange(currPart[32*i:32*i+32]),2)) yield mySplits currPos += 512 + def not32(i): i_str = format(i,'032b') new_str = '' @@ -48,6 +75,13 @@ def leftrot32(i,s): return (i << s) ^ (i >> (32-s)) def md5me(testString): + """[summary] + Returns a 32-bit hash code of the string 'testString' + + Arguments: + testString {[string]} -- [message] + """ + bs ='' for i in testString: bs += format(ord(i),'08b') From 0494d48f84f74145d6eec5e4dab3daad21c490aa Mon Sep 17 00:00:00 2001 From: Christian Bender Date: Mon, 16 Apr 2018 14:18:23 +0200 Subject: [PATCH 074/105] added a docstring --- hashes/md5.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/hashes/md5.py b/hashes/md5.py index 3ae13089d019..d3f15510874e 100644 --- a/hashes/md5.py +++ b/hashes/md5.py @@ -2,6 +2,19 @@ import math def rearrange(bitString32): + """[summary] + Regroups the given binary string. + + Arguments: + bitString32 {[string]} -- [32 bit binary] + + Raises: + ValueError -- [if the given string not are 32 bit binary string] + + Returns: + [string] -- [32 bit binary string] + """ + if len(bitString32) != 32: raise ValueError("Need length 32") newString = "" From 356218254263f45536bd1b053f8cb9e30450087a Mon Sep 17 00:00:00 2001 From: Bhaavik Pratyush Date: Mon, 16 Apr 2018 19:17:28 +0530 Subject: [PATCH 075/105] Update sol2.py --- Project Euler/Problem 01/sol2.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Project Euler/Problem 01/sol2.py b/Project Euler/Problem 01/sol2.py index d330387e98ab..2b7760e0bfff 100644 --- a/Project Euler/Problem 01/sol2.py +++ b/Project Euler/Problem 01/sol2.py @@ -11,10 +11,10 @@ raw_input = input # Python 3 n = int(raw_input().strip()) sum = 0 -terms = (n-1)/3 -sum+= ((terms)*(6+(terms-1)*3))/2 #sum of an A.P. -terms = (n-1)/5 -sum+= ((terms)*(10+(terms-1)*5))/2 -terms = (n-1)/15 -sum-= ((terms)*(30+(terms-1)*15))/2 +terms = (n-1)//3 +sum+= ((terms)*(6+(terms-1)*3))//2 #sum of an A.P. +terms = (n-1)//5 +sum+= ((terms)*(10+(terms-1)*5))//2 +terms = (n-1)//15 +sum-= ((terms)*(30+(terms-1)*15))//2 print(sum) From 4b58a887324ce6c5fc9b36766be9b3b742c44d3c Mon Sep 17 00:00:00 2001 From: shivg7706 Date: Thu, 26 Apr 2018 08:49:55 +0530 Subject: [PATCH 076/105] another sol for 11 --- Project Euler/Problem 11/sol2.py | 39 ++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 Project Euler/Problem 11/sol2.py diff --git a/Project Euler/Problem 11/sol2.py b/Project Euler/Problem 11/sol2.py new file mode 100644 index 000000000000..b03395f01697 --- /dev/null +++ b/Project Euler/Problem 11/sol2.py @@ -0,0 +1,39 @@ +def main(): + with open ("grid.txt", "r") as f: + l = [] + for i in range(20): + l.append([int(x) for x in f.readline().split()]) + + maximum = 0 + + # right + for i in range(20): + for j in range(17): + temp = l[i][j] * l[i][j+1] * l[i][j+2] * l[i][j+3] + if temp > maximum: + maximum = temp + + # down + for i in range(17): + for j in range(20): + temp = l[i][j] * l[i+1][j] * l[i+2][j] * l[i+3][j] + if temp > maximum: + maximum = temp + + #diagonal 1 + for i in range(17): + for j in range(17): + temp = l[i][j] * l[i+1][j+1] * l[i+2][j+2] * l[i+3][j+3] + if temp > maximum: + maximum = temp + + #diagonal 2 + for i in range(17): + for j in range(3, 20): + temp = l[i][j] * l[i+1][j-1] * l[i+2][j-2] * l[i+3][j-3] + if temp > maximum: + maximum = temp + print(maximum) + +if __name__ == '__main__': + main() \ No newline at end of file From ab9ee4064eb4a6ab7f1cab25116cc1ace996a116 Mon Sep 17 00:00:00 2001 From: shivg7706 Date: Thu, 26 Apr 2018 08:53:17 +0530 Subject: [PATCH 077/105] adding 22 and 24 --- Project Euler/Problem 24/sol1.py | 7 + Project Euler/Problem 24/sol2.py | 533 +++++++++++++++++++++++++++++++ 2 files changed, 540 insertions(+) create mode 100644 Project Euler/Problem 24/sol1.py create mode 100644 Project Euler/Problem 24/sol2.py diff --git a/Project Euler/Problem 24/sol1.py b/Project Euler/Problem 24/sol1.py new file mode 100644 index 000000000000..b20493cb03af --- /dev/null +++ b/Project Euler/Problem 24/sol1.py @@ -0,0 +1,7 @@ +from itertools import permutations +def main(): + result=list(map("".join, permutations('0123456789'))) + print(result[999999]) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/Project Euler/Problem 24/sol2.py b/Project Euler/Problem 24/sol2.py new file mode 100644 index 000000000000..d7f9abf09d49 --- /dev/null +++ b/Project Euler/Problem 24/sol2.py @@ -0,0 +1,533 @@ +def main(): + name = [ + "MARY", "PATRICIA", "LINDA", "BARBARA", "ELIZABETH", "JENNIFER", "MARIA", "SUSAN", "MARGARET", "DOROTHY", + "LISA", "NANCY", "KAREN", "BETTY", "HELEN", "SANDRA", "DONNA", "CAROL", "RUTH", "SHARON", + "MICHELLE", "LAURA", "SARAH", "KIMBERLY", "DEBORAH", "JESSICA", "SHIRLEY", "CYNTHIA", "ANGELA", "MELISSA", + "BRENDA", "AMY", "ANNA", "REBECCA", "VIRGINIA", "KATHLEEN", "PAMELA", "MARTHA", "DEBRA", "AMANDA", + "STEPHANIE", "CAROLYN", "CHRISTINE", "MARIE", "JANET", "CATHERINE", "FRANCES", "ANN", "JOYCE", "DIANE", + "ALICE", "JULIE", "HEATHER", "TERESA", "DORIS", "GLORIA", "EVELYN", "JEAN", "CHERYL", "MILDRED", + "KATHERINE", "JOAN", "ASHLEY", "JUDITH", "ROSE", "JANICE", "KELLY", "NICOLE", "JUDY", "CHRISTINA", + "KATHY", "THERESA", "BEVERLY", "DENISE", "TAMMY", "IRENE", "JANE", "LORI", "RACHEL", "MARILYN", + "ANDREA", "KATHRYN", "LOUISE", "SARA", "ANNE", "JACQUELINE", "WANDA", "BONNIE", "JULIA", "RUBY", + "LOIS", "TINA", "PHYLLIS", "NORMA", "PAULA", "DIANA", "ANNIE", "LILLIAN", "EMILY", "ROBIN", + "PEGGY", "CRYSTAL", "GLADYS", "RITA", "DAWN", "CONNIE", "FLORENCE", "TRACY", "EDNA", "TIFFANY", + "CARMEN", "ROSA", "CINDY", "GRACE", "WENDY", "VICTORIA", "EDITH", "KIM", "SHERRY", "SYLVIA", + "JOSEPHINE", "THELMA", "SHANNON", "SHEILA", "ETHEL", "ELLEN", "ELAINE", "MARJORIE", "CARRIE", "CHARLOTTE", + "MONICA", "ESTHER", "PAULINE", "EMMA", "JUANITA", "ANITA", "RHONDA", "HAZEL", "AMBER", "EVA", + "DEBBIE", "APRIL", "LESLIE", "CLARA", "LUCILLE", "JAMIE", "JOANNE", "ELEANOR", "VALERIE", "DANIELLE", + "MEGAN", "ALICIA", "SUZANNE", "MICHELE", "GAIL", "BERTHA", "DARLENE", "VERONICA", "JILL", "ERIN", + "GERALDINE", "LAUREN", "CATHY", "JOANN", "LORRAINE", "LYNN", "SALLY", "REGINA", "ERICA", "BEATRICE", + "DOLORES", "BERNICE", "AUDREY", "YVONNE", "ANNETTE", "JUNE", "SAMANTHA", "MARION", "DANA", "STACY", + "ANA", "RENEE", "IDA", "VIVIAN", "ROBERTA", "HOLLY", "BRITTANY", "MELANIE", "LORETTA", "YOLANDA", + "JEANETTE", "LAURIE", "KATIE", "KRISTEN", "VANESSA", "ALMA", "SUE", "ELSIE", "BETH", "JEANNE", + "VICKI", "CARLA", "TARA", "ROSEMARY", "EILEEN", "TERRI", "GERTRUDE", "LUCY", "TONYA", "ELLA", + "STACEY", "WILMA", "GINA", "KRISTIN", "JESSIE", "NATALIE", "AGNES", "VERA", "WILLIE", "CHARLENE", + "BESSIE", "DELORES", "MELINDA", "PEARL", "ARLENE", "MAUREEN", "COLLEEN", "ALLISON", "TAMARA", "JOY", + "GEORGIA", "CONSTANCE", "LILLIE", "CLAUDIA", "JACKIE", "MARCIA", "TANYA", "NELLIE", "MINNIE", "MARLENE", + "HEIDI", "GLENDA", "LYDIA", "VIOLA", "COURTNEY", "MARIAN", "STELLA", "CAROLINE", "DORA", "JO", + "VICKIE", "MATTIE", "TERRY", "MAXINE", "IRMA", "MABEL", "MARSHA", "MYRTLE", "LENA", "CHRISTY", + "DEANNA", "PATSY", "HILDA", "GWENDOLYN", "JENNIE", "NORA", "MARGIE", "NINA", "CASSANDRA", "LEAH", + "PENNY", "KAY", "PRISCILLA", "NAOMI", "CAROLE", "BRANDY", "OLGA", "BILLIE", "DIANNE", "TRACEY", + "LEONA", "JENNY", "FELICIA", "SONIA", "MIRIAM", "VELMA", "BECKY", "BOBBIE", "VIOLET", "KRISTINA", + "TONI", "MISTY", "MAE", "SHELLY", "DAISY", "RAMONA", "SHERRI", "ERIKA", "KATRINA", "CLAIRE", + "LINDSEY", "LINDSAY", "GENEVA", "GUADALUPE", "BELINDA", "MARGARITA", "SHERYL", "CORA", "FAYE", "ADA", + "NATASHA", "SABRINA", "ISABEL", "MARGUERITE", "HATTIE", "HARRIET", "MOLLY", "CECILIA", "KRISTI", "BRANDI", + "BLANCHE", "SANDY", "ROSIE", "JOANNA", "IRIS", "EUNICE", "ANGIE", "INEZ", "LYNDA", "MADELINE", + "AMELIA", "ALBERTA", "GENEVIEVE", "MONIQUE", "JODI", "JANIE", "MAGGIE", "KAYLA", "SONYA", "JAN", + "LEE", "KRISTINE", "CANDACE", "FANNIE", "MARYANN", "OPAL", "ALISON", "YVETTE", "MELODY", "LUZ", + "SUSIE", "OLIVIA", "FLORA", "SHELLEY", "KRISTY", "MAMIE", "LULA", "LOLA", "VERNA", "BEULAH", + "ANTOINETTE", "CANDICE", "JUANA", "JEANNETTE", "PAM", "KELLI", "HANNAH", "WHITNEY", "BRIDGET", "KARLA", + "CELIA", "LATOYA", "PATTY", "SHELIA", "GAYLE", "DELLA", "VICKY", "LYNNE", "SHERI", "MARIANNE", + "KARA", "JACQUELYN", "ERMA", "BLANCA", "MYRA", "LETICIA", "PAT", "KRISTA", "ROXANNE", "ANGELICA", + "JOHNNIE", "ROBYN", "FRANCIS", "ADRIENNE", "ROSALIE", "ALEXANDRA", "BROOKE", "BETHANY", "SADIE", "BERNADETTE", + "TRACI", "JODY", "KENDRA", "JASMINE", "NICHOLE", "RACHAEL", "CHELSEA", "MABLE", "ERNESTINE", "MURIEL", + "MARCELLA", "ELENA", "KRYSTAL", "ANGELINA", "NADINE", "KARI", "ESTELLE", "DIANNA", "PAULETTE", "LORA", + "MONA", "DOREEN", "ROSEMARIE", "ANGEL", "DESIREE", "ANTONIA", "HOPE", "GINGER", "JANIS", "BETSY", + "CHRISTIE", "FREDA", "MERCEDES", "MEREDITH", "LYNETTE", "TERI", "CRISTINA", "EULA", "LEIGH", "MEGHAN", + "SOPHIA", "ELOISE", "ROCHELLE", "GRETCHEN", "CECELIA", "RAQUEL", "HENRIETTA", "ALYSSA", "JANA", "KELLEY", + "GWEN", "KERRY", "JENNA", "TRICIA", "LAVERNE", "OLIVE", "ALEXIS", "TASHA", "SILVIA", "ELVIRA", + "CASEY", "DELIA", "SOPHIE", "KATE", "PATTI", "LORENA", "KELLIE", "SONJA", "LILA", "LANA", + "DARLA", "MAY", "MINDY", "ESSIE", "MANDY", "LORENE", "ELSA", "JOSEFINA", "JEANNIE", "MIRANDA", + "DIXIE", "LUCIA", "MARTA", "FAITH", "LELA", "JOHANNA", "SHARI", "CAMILLE", "TAMI", "SHAWNA", + "ELISA", "EBONY", "MELBA", "ORA", "NETTIE", "TABITHA", "OLLIE", "JAIME", "WINIFRED", "KRISTIE", + "MARINA", "ALISHA", "AIMEE", "RENA", "MYRNA", "MARLA", "TAMMIE", "LATASHA", "BONITA", "PATRICE", + "RONDA", "SHERRIE", "ADDIE", "FRANCINE", "DELORIS", "STACIE", "ADRIANA", "CHERI", "SHELBY", "ABIGAIL", + "CELESTE", "JEWEL", "CARA", "ADELE", "REBEKAH", "LUCINDA", "DORTHY", "CHRIS", "EFFIE", "TRINA", + "REBA", "SHAWN", "SALLIE", "AURORA", "LENORA", "ETTA", "LOTTIE", "KERRI", "TRISHA", "NIKKI", + "ESTELLA", "FRANCISCA", "JOSIE", "TRACIE", "MARISSA", "KARIN", "BRITTNEY", "JANELLE", "LOURDES", "LAUREL", + "HELENE", "FERN", "ELVA", "CORINNE", "KELSEY", "INA", "BETTIE", "ELISABETH", "AIDA", "CAITLIN", + "INGRID", "IVA", "EUGENIA", "CHRISTA", "GOLDIE", "CASSIE", "MAUDE", "JENIFER", "THERESE", "FRANKIE", + "DENA", "LORNA", "JANETTE", "LATONYA", "CANDY", "MORGAN", "CONSUELO", "TAMIKA", "ROSETTA", "DEBORA", + "CHERIE", "POLLY", "DINA", "JEWELL", "FAY", "JILLIAN", "DOROTHEA", "NELL", "TRUDY", "ESPERANZA", + "PATRICA", "KIMBERLEY", "SHANNA", "HELENA", "CAROLINA", "CLEO", "STEFANIE", "ROSARIO", "OLA", "JANINE", + "MOLLIE", "LUPE", "ALISA", "LOU", "MARIBEL", "SUSANNE", "BETTE", "SUSANA", "ELISE", "CECILE", + "ISABELLE", "LESLEY", "JOCELYN", "PAIGE", "JONI", "RACHELLE", "LEOLA", "DAPHNE", "ALTA", "ESTER", + "PETRA", "GRACIELA", "IMOGENE", "JOLENE", "KEISHA", "LACEY", "GLENNA", "GABRIELA", "KERI", "URSULA", + "LIZZIE", "KIRSTEN", "SHANA", "ADELINE", "MAYRA", "JAYNE", "JACLYN", "GRACIE", "SONDRA", "CARMELA", + "MARISA", "ROSALIND", "CHARITY", "TONIA", "BEATRIZ", "MARISOL", "CLARICE", "JEANINE", "SHEENA", "ANGELINE", + "FRIEDA", "LILY", "ROBBIE", "SHAUNA", "MILLIE", "CLAUDETTE", "CATHLEEN", "ANGELIA", "GABRIELLE", "AUTUMN", + "KATHARINE", "SUMMER", "JODIE", "STACI", "LEA", "CHRISTI", "JIMMIE", "JUSTINE", "ELMA", "LUELLA", + "MARGRET", "DOMINIQUE", "SOCORRO", "RENE", "MARTINA", "MARGO", "MAVIS", "CALLIE", "BOBBI", "MARITZA", + "LUCILE", "LEANNE", "JEANNINE", "DEANA", "AILEEN", "LORIE", "LADONNA", "WILLA", "MANUELA", "GALE", + "SELMA", "DOLLY", "SYBIL", "ABBY", "LARA", "DALE", "IVY", "DEE", "WINNIE", "MARCY", + "LUISA", "JERI", "MAGDALENA", "OFELIA", "MEAGAN", "AUDRA", "MATILDA", "LEILA", "CORNELIA", "BIANCA", + "SIMONE", "BETTYE", "RANDI", "VIRGIE", "LATISHA", "BARBRA", "GEORGINA", "ELIZA", "LEANN", "BRIDGETTE", + "RHODA", "HALEY", "ADELA", "NOLA", "BERNADINE", "FLOSSIE", "ILA", "GRETA", "RUTHIE", "NELDA", + "MINERVA", "LILLY", "TERRIE", "LETHA", "HILARY", "ESTELA", "VALARIE", "BRIANNA", "ROSALYN", "EARLINE", + "CATALINA", "AVA", "MIA", "CLARISSA", "LIDIA", "CORRINE", "ALEXANDRIA", "CONCEPCION", "TIA", "SHARRON", + "RAE", "DONA", "ERICKA", "JAMI", "ELNORA", "CHANDRA", "LENORE", "NEVA", "MARYLOU", "MELISA", + "TABATHA", "SERENA", "AVIS", "ALLIE", "SOFIA", "JEANIE", "ODESSA", "NANNIE", "HARRIETT", "LORAINE", + "PENELOPE", "MILAGROS", "EMILIA", "BENITA", "ALLYSON", "ASHLEE", "TANIA", "TOMMIE", "ESMERALDA", "KARINA", + "EVE", "PEARLIE", "ZELMA", "MALINDA", "NOREEN", "TAMEKA", "SAUNDRA", "HILLARY", "AMIE", "ALTHEA", + "ROSALINDA", "JORDAN", "LILIA", "ALANA", "GAY", "CLARE", "ALEJANDRA", "ELINOR", "MICHAEL", "LORRIE", + "JERRI", "DARCY", "EARNESTINE", "CARMELLA", "TAYLOR", "NOEMI", "MARCIE", "LIZA", "ANNABELLE", "LOUISA", + "EARLENE", "MALLORY", "CARLENE", "NITA", "SELENA", "TANISHA", "KATY", "JULIANNE", "JOHN", "LAKISHA", + "EDWINA", "MARICELA", "MARGERY", "KENYA", "DOLLIE", "ROXIE", "ROSLYN", "KATHRINE", "NANETTE", "CHARMAINE", + "LAVONNE", "ILENE", "KRIS", "TAMMI", "SUZETTE", "CORINE", "KAYE", "JERRY", "MERLE", "CHRYSTAL", + "LINA", "DEANNE", "LILIAN", "JULIANA", "ALINE", "LUANN", "KASEY", "MARYANNE", "EVANGELINE", "COLETTE", + "MELVA", "LAWANDA", "YESENIA", "NADIA", "MADGE", "KATHIE", "EDDIE", "OPHELIA", "VALERIA", "NONA", + "MITZI", "MARI", "GEORGETTE", "CLAUDINE", "FRAN", "ALISSA", "ROSEANN", "LAKEISHA", "SUSANNA", "REVA", + "DEIDRE", "CHASITY", "SHEREE", "CARLY", "JAMES", "ELVIA", "ALYCE", "DEIRDRE", "GENA", "BRIANA", + "ARACELI", "KATELYN", "ROSANNE", "WENDI", "TESSA", "BERTA", "MARVA", "IMELDA", "MARIETTA", "MARCI", + "LEONOR", "ARLINE", "SASHA", "MADELYN", "JANNA", "JULIETTE", "DEENA", "AURELIA", "JOSEFA", "AUGUSTA", + "LILIANA", "YOUNG", "CHRISTIAN", "LESSIE", "AMALIA", "SAVANNAH", "ANASTASIA", "VILMA", "NATALIA", "ROSELLA", + "LYNNETTE", "CORINA", "ALFREDA", "LEANNA", "CAREY", "AMPARO", "COLEEN", "TAMRA", "AISHA", "WILDA", + "KARYN", "CHERRY", "QUEEN", "MAURA", "MAI", "EVANGELINA", "ROSANNA", "HALLIE", "ERNA", "ENID", + "MARIANA", "LACY", "JULIET", "JACKLYN", "FREIDA", "MADELEINE", "MARA", "HESTER", "CATHRYN", "LELIA", + "CASANDRA", "BRIDGETT", "ANGELITA", "JANNIE", "DIONNE", "ANNMARIE", "KATINA", "BERYL", "PHOEBE", "MILLICENT", + "KATHERYN", "DIANN", "CARISSA", "MARYELLEN", "LIZ", "LAURI", "HELGA", "GILDA", "ADRIAN", "RHEA", + "MARQUITA", "HOLLIE", "TISHA", "TAMERA", "ANGELIQUE", "FRANCESCA", "BRITNEY", "KAITLIN", "LOLITA", "FLORINE", + "ROWENA", "REYNA", "TWILA", "FANNY", "JANELL", "INES", "CONCETTA", "BERTIE", "ALBA", "BRIGITTE", + "ALYSON", "VONDA", "PANSY", "ELBA", "NOELLE", "LETITIA", "KITTY", "DEANN", "BRANDIE", "LOUELLA", + "LETA", "FELECIA", "SHARLENE", "LESA", "BEVERLEY", "ROBERT", "ISABELLA", "HERMINIA", "TERRA", "CELINA", + "TORI", "OCTAVIA", "JADE", "DENICE", "GERMAINE", "SIERRA", "MICHELL", "CORTNEY", "NELLY", "DORETHA", + "SYDNEY", "DEIDRA", "MONIKA", "LASHONDA", "JUDI", "CHELSEY", "ANTIONETTE", "MARGOT", "BOBBY", "ADELAIDE", + "NAN", "LEEANN", "ELISHA", "DESSIE", "LIBBY", "KATHI", "GAYLA", "LATANYA", "MINA", "MELLISA", + "KIMBERLEE", "JASMIN", "RENAE", "ZELDA", "ELDA", "MA", "JUSTINA", "GUSSIE", "EMILIE", "CAMILLA", + "ABBIE", "ROCIO", "KAITLYN", "JESSE", "EDYTHE", "ASHLEIGH", "SELINA", "LAKESHA", "GERI", "ALLENE", + "PAMALA", "MICHAELA", "DAYNA", "CARYN", "ROSALIA", "SUN", "JACQULINE", "REBECA", "MARYBETH", "KRYSTLE", + "IOLA", "DOTTIE", "BENNIE", "BELLE", "AUBREY", "GRISELDA", "ERNESTINA", "ELIDA", "ADRIANNE", "DEMETRIA", + "DELMA", "CHONG", "JAQUELINE", "DESTINY", "ARLEEN", "VIRGINA", "RETHA", "FATIMA", "TILLIE", "ELEANORE", + "CARI", "TREVA", "BIRDIE", "WILHELMINA", "ROSALEE", "MAURINE", "LATRICE", "YONG", "JENA", "TARYN", + "ELIA", "DEBBY", "MAUDIE", "JEANNA", "DELILAH", "CATRINA", "SHONDA", "HORTENCIA", "THEODORA", "TERESITA", + "ROBBIN", "DANETTE", "MARYJANE", "FREDDIE", "DELPHINE", "BRIANNE", "NILDA", "DANNA", "CINDI", "BESS", + "IONA", "HANNA", "ARIEL", "WINONA", "VIDA", "ROSITA", "MARIANNA", "WILLIAM", "RACHEAL", "GUILLERMINA", + "ELOISA", "CELESTINE", "CAREN", "MALISSA", "LONA", "CHANTEL", "SHELLIE", "MARISELA", "LEORA", "AGATHA", + "SOLEDAD", "MIGDALIA", "IVETTE", "CHRISTEN", "ATHENA", "JANEL", "CHLOE", "VEDA", "PATTIE", "TESSIE", + "TERA", "MARILYNN", "LUCRETIA", "KARRIE", "DINAH", "DANIELA", "ALECIA", "ADELINA", "VERNICE", "SHIELA", + "PORTIA", "MERRY", "LASHAWN", "DEVON", "DARA", "TAWANA", "OMA", "VERDA", "CHRISTIN", "ALENE", + "ZELLA", "SANDI", "RAFAELA", "MAYA", "KIRA", "CANDIDA", "ALVINA", "SUZAN", "SHAYLA", "LYN", + "LETTIE", "ALVA", "SAMATHA", "ORALIA", "MATILDE", "MADONNA", "LARISSA", "VESTA", "RENITA", "INDIA", + "DELOIS", "SHANDA", "PHILLIS", "LORRI", "ERLINDA", "CRUZ", "CATHRINE", "BARB", "ZOE", "ISABELL", + "IONE", "GISELA", "CHARLIE", "VALENCIA", "ROXANNA", "MAYME", "KISHA", "ELLIE", "MELLISSA", "DORRIS", + "DALIA", "BELLA", "ANNETTA", "ZOILA", "RETA", "REINA", "LAURETTA", "KYLIE", "CHRISTAL", "PILAR", + "CHARLA", "ELISSA", "TIFFANI", "TANA", "PAULINA", "LEOTA", "BREANNA", "JAYME", "CARMEL", "VERNELL", + "TOMASA", "MANDI", "DOMINGA", "SANTA", "MELODIE", "LURA", "ALEXA", "TAMELA", "RYAN", "MIRNA", + "KERRIE", "VENUS", "NOEL", "FELICITA", "CRISTY", "CARMELITA", "BERNIECE", "ANNEMARIE", "TIARA", "ROSEANNE", + "MISSY", "CORI", "ROXANA", "PRICILLA", "KRISTAL", "JUNG", "ELYSE", "HAYDEE", "ALETHA", "BETTINA", + "MARGE", "GILLIAN", "FILOMENA", "CHARLES", "ZENAIDA", "HARRIETTE", "CARIDAD", "VADA", "UNA", "ARETHA", + "PEARLINE", "MARJORY", "MARCELA", "FLOR", "EVETTE", "ELOUISE", "ALINA", "TRINIDAD", "DAVID", "DAMARIS", + "CATHARINE", "CARROLL", "BELVA", "NAKIA", "MARLENA", "LUANNE", "LORINE", "KARON", "DORENE", "DANITA", + "BRENNA", "TATIANA", "SAMMIE", "LOUANN", "LOREN", "JULIANNA", "ANDRIA", "PHILOMENA", "LUCILA", "LEONORA", + "DOVIE", "ROMONA", "MIMI", "JACQUELIN", "GAYE", "TONJA", "MISTI", "JOE", "GENE", "CHASTITY", + "STACIA", "ROXANN", "MICAELA", "NIKITA", "MEI", "VELDA", "MARLYS", "JOHNNA", "AURA", "LAVERN", + "IVONNE", "HAYLEY", "NICKI", "MAJORIE", "HERLINDA", "GEORGE", "ALPHA", "YADIRA", "PERLA", "GREGORIA", + "DANIEL", "ANTONETTE", "SHELLI", "MOZELLE", "MARIAH", "JOELLE", "CORDELIA", "JOSETTE", "CHIQUITA", "TRISTA", + "LOUIS", "LAQUITA", "GEORGIANA", "CANDI", "SHANON", "LONNIE", "HILDEGARD", "CECIL", "VALENTINA", "STEPHANY", + "MAGDA", "KAROL", "GERRY", "GABRIELLA", "TIANA", "ROMA", "RICHELLE", "RAY", "PRINCESS", "OLETA", + "JACQUE", "IDELLA", "ALAINA", "SUZANNA", "JOVITA", "BLAIR", "TOSHA", "RAVEN", "NEREIDA", "MARLYN", + "KYLA", "JOSEPH", "DELFINA", "TENA", "STEPHENIE", "SABINA", "NATHALIE", "MARCELLE", "GERTIE", "DARLEEN", + "THEA", "SHARONDA", "SHANTEL", "BELEN", "VENESSA", "ROSALINA", "ONA", "GENOVEVA", "COREY", "CLEMENTINE", + "ROSALBA", "RENATE", "RENATA", "MI", "IVORY", "GEORGIANNA", "FLOY", "DORCAS", "ARIANA", "TYRA", + "THEDA", "MARIAM", "JULI", "JESICA", "DONNIE", "VIKKI", "VERLA", "ROSELYN", "MELVINA", "JANNETTE", + "GINNY", "DEBRAH", "CORRIE", "ASIA", "VIOLETA", "MYRTIS", "LATRICIA", "COLLETTE", "CHARLEEN", "ANISSA", + "VIVIANA", "TWYLA", "PRECIOUS", "NEDRA", "LATONIA", "LAN", "HELLEN", "FABIOLA", "ANNAMARIE", "ADELL", + "SHARYN", "CHANTAL", "NIKI", "MAUD", "LIZETTE", "LINDY", "KIA", "KESHA", "JEANA", "DANELLE", + "CHARLINE", "CHANEL", "CARROL", "VALORIE", "LIA", "DORTHA", "CRISTAL", "SUNNY", "LEONE", "LEILANI", + "GERRI", "DEBI", "ANDRA", "KESHIA", "IMA", "EULALIA", "EASTER", "DULCE", "NATIVIDAD", "LINNIE", + "KAMI", "GEORGIE", "CATINA", "BROOK", "ALDA", "WINNIFRED", "SHARLA", "RUTHANN", "MEAGHAN", "MAGDALENE", + "LISSETTE", "ADELAIDA", "VENITA", "TRENA", "SHIRLENE", "SHAMEKA", "ELIZEBETH", "DIAN", "SHANTA", "MICKEY", + "LATOSHA", "CARLOTTA", "WINDY", "SOON", "ROSINA", "MARIANN", "LEISA", "JONNIE", "DAWNA", "CATHIE", + "BILLY", "ASTRID", "SIDNEY", "LAUREEN", "JANEEN", "HOLLI", "FAWN", "VICKEY", "TERESSA", "SHANTE", + "RUBYE", "MARCELINA", "CHANDA", "CARY", "TERESE", "SCARLETT", "MARTY", "MARNIE", "LULU", "LISETTE", + "JENIFFER", "ELENOR", "DORINDA", "DONITA", "CARMAN", "BERNITA", "ALTAGRACIA", "ALETA", "ADRIANNA", "ZORAIDA", + "RONNIE", "NICOLA", "LYNDSEY", "KENDALL", "JANINA", "CHRISSY", "AMI", "STARLA", "PHYLIS", "PHUONG", + "KYRA", "CHARISSE", "BLANCH", "SANJUANITA", "RONA", "NANCI", "MARILEE", "MARANDA", "CORY", "BRIGETTE", + "SANJUANA", "MARITA", "KASSANDRA", "JOYCELYN", "IRA", "FELIPA", "CHELSIE", "BONNY", "MIREYA", "LORENZA", + "KYONG", "ILEANA", "CANDELARIA", "TONY", "TOBY", "SHERIE", "OK", "MARK", "LUCIE", "LEATRICE", + "LAKESHIA", "GERDA", "EDIE", "BAMBI", "MARYLIN", "LAVON", "HORTENSE", "GARNET", "EVIE", "TRESSA", + "SHAYNA", "LAVINA", "KYUNG", "JEANETTA", "SHERRILL", "SHARA", "PHYLISS", "MITTIE", "ANABEL", "ALESIA", + "THUY", "TAWANDA", "RICHARD", "JOANIE", "TIFFANIE", "LASHANDA", "KARISSA", "ENRIQUETA", "DARIA", "DANIELLA", + "CORINNA", "ALANNA", "ABBEY", "ROXANE", "ROSEANNA", "MAGNOLIA", "LIDA", "KYLE", "JOELLEN", "ERA", + "CORAL", "CARLEEN", "TRESA", "PEGGIE", "NOVELLA", "NILA", "MAYBELLE", "JENELLE", "CARINA", "NOVA", + "MELINA", "MARQUERITE", "MARGARETTE", "JOSEPHINA", "EVONNE", "DEVIN", "CINTHIA", "ALBINA", "TOYA", "TAWNYA", + "SHERITA", "SANTOS", "MYRIAM", "LIZABETH", "LISE", "KEELY", "JENNI", "GISELLE", "CHERYLE", "ARDITH", + "ARDIS", "ALESHA", "ADRIANE", "SHAINA", "LINNEA", "KAROLYN", "HONG", "FLORIDA", "FELISHA", "DORI", + "DARCI", "ARTIE", "ARMIDA", "ZOLA", "XIOMARA", "VERGIE", "SHAMIKA", "NENA", "NANNETTE", "MAXIE", + "LOVIE", "JEANE", "JAIMIE", "INGE", "FARRAH", "ELAINA", "CAITLYN", "STARR", "FELICITAS", "CHERLY", + "CARYL", "YOLONDA", "YASMIN", "TEENA", "PRUDENCE", "PENNIE", "NYDIA", "MACKENZIE", "ORPHA", "MARVEL", + "LIZBETH", "LAURETTE", "JERRIE", "HERMELINDA", "CAROLEE", "TIERRA", "MIRIAN", "META", "MELONY", "KORI", + "JENNETTE", "JAMILA", "ENA", "ANH", "YOSHIKO", "SUSANNAH", "SALINA", "RHIANNON", "JOLEEN", "CRISTINE", + "ASHTON", "ARACELY", "TOMEKA", "SHALONDA", "MARTI", "LACIE", "KALA", "JADA", "ILSE", "HAILEY", + "BRITTANI", "ZONA", "SYBLE", "SHERRYL", "RANDY", "NIDIA", "MARLO", "KANDICE", "KANDI", "DEB", + "DEAN", "AMERICA", "ALYCIA", "TOMMY", "RONNA", "NORENE", "MERCY", "JOSE", "INGEBORG", "GIOVANNA", + "GEMMA", "CHRISTEL", "AUDRY", "ZORA", "VITA", "VAN", "TRISH", "STEPHAINE", "SHIRLEE", "SHANIKA", + "MELONIE", "MAZIE", "JAZMIN", "INGA", "HOA", "HETTIE", "GERALYN", "FONDA", "ESTRELLA", "ADELLA", + "SU", "SARITA", "RINA", "MILISSA", "MARIBETH", "GOLDA", "EVON", "ETHELYN", "ENEDINA", "CHERISE", + "CHANA", "VELVA", "TAWANNA", "SADE", "MIRTA", "LI", "KARIE", "JACINTA", "ELNA", "DAVINA", + "CIERRA", "ASHLIE", "ALBERTHA", "TANESHA", "STEPHANI", "NELLE", "MINDI", "LU", "LORINDA", "LARUE", + "FLORENE", "DEMETRA", "DEDRA", "CIARA", "CHANTELLE", "ASHLY", "SUZY", "ROSALVA", "NOELIA", "LYDA", + "LEATHA", "KRYSTYNA", "KRISTAN", "KARRI", "DARLINE", "DARCIE", "CINDA", "CHEYENNE", "CHERRIE", "AWILDA", + "ALMEDA", "ROLANDA", "LANETTE", "JERILYN", "GISELE", "EVALYN", "CYNDI", "CLETA", "CARIN", "ZINA", + "ZENA", "VELIA", "TANIKA", "PAUL", "CHARISSA", "THOMAS", "TALIA", "MARGARETE", "LAVONDA", "KAYLEE", + "KATHLENE", "JONNA", "IRENA", "ILONA", "IDALIA", "CANDIS", "CANDANCE", "BRANDEE", "ANITRA", "ALIDA", + "SIGRID", "NICOLETTE", "MARYJO", "LINETTE", "HEDWIG", "CHRISTIANA", "CASSIDY", "ALEXIA", "TRESSIE", "MODESTA", + "LUPITA", "LITA", "GLADIS", "EVELIA", "DAVIDA", "CHERRI", "CECILY", "ASHELY", "ANNABEL", "AGUSTINA", + "WANITA", "SHIRLY", "ROSAURA", "HULDA", "EUN", "BAILEY", "YETTA", "VERONA", "THOMASINA", "SIBYL", + "SHANNAN", "MECHELLE", "LUE", "LEANDRA", "LANI", "KYLEE", "KANDY", "JOLYNN", "FERNE", "EBONI", + "CORENE", "ALYSIA", "ZULA", "NADA", "MOIRA", "LYNDSAY", "LORRETTA", "JUAN", "JAMMIE", "HORTENSIA", + "GAYNELL", "CAMERON", "ADRIA", "VINA", "VICENTA", "TANGELA", "STEPHINE", "NORINE", "NELLA", "LIANA", + "LESLEE", "KIMBERELY", "ILIANA", "GLORY", "FELICA", "EMOGENE", "ELFRIEDE", "EDEN", "EARTHA", "CARMA", + "BEA", "OCIE", "MARRY", "LENNIE", "KIARA", "JACALYN", "CARLOTA", "ARIELLE", "YU", "STAR", + "OTILIA", "KIRSTIN", "KACEY", "JOHNETTA", "JOEY", "JOETTA", "JERALDINE", "JAUNITA", "ELANA", "DORTHEA", + "CAMI", "AMADA", "ADELIA", "VERNITA", "TAMAR", "SIOBHAN", "RENEA", "RASHIDA", "OUIDA", "ODELL", + "NILSA", "MERYL", "KRISTYN", "JULIETA", "DANICA", "BREANNE", "AUREA", "ANGLEA", "SHERRON", "ODETTE", + "MALIA", "LORELEI", "LIN", "LEESA", "KENNA", "KATHLYN", "FIONA", "CHARLETTE", "SUZIE", "SHANTELL", + "SABRA", "RACQUEL", "MYONG", "MIRA", "MARTINE", "LUCIENNE", "LAVADA", "JULIANN", "JOHNIE", "ELVERA", + "DELPHIA", "CLAIR", "CHRISTIANE", "CHAROLETTE", "CARRI", "AUGUSTINE", "ASHA", "ANGELLA", "PAOLA", "NINFA", + "LEDA", "LAI", "EDA", "SUNSHINE", "STEFANI", "SHANELL", "PALMA", "MACHELLE", "LISSA", "KECIA", + "KATHRYNE", "KARLENE", "JULISSA", "JETTIE", "JENNIFFER", "HUI", "CORRINA", "CHRISTOPHER", "CAROLANN", "ALENA", + "TESS", "ROSARIA", "MYRTICE", "MARYLEE", "LIANE", "KENYATTA", "JUDIE", "JANEY", "IN", "ELMIRA", + "ELDORA", "DENNA", "CRISTI", "CATHI", "ZAIDA", "VONNIE", "VIVA", "VERNIE", "ROSALINE", "MARIELA", + "LUCIANA", "LESLI", "KARAN", "FELICE", "DENEEN", "ADINA", "WYNONA", "TARSHA", "SHERON", "SHASTA", + "SHANITA", "SHANI", "SHANDRA", "RANDA", "PINKIE", "PARIS", "NELIDA", "MARILOU", "LYLA", "LAURENE", + "LACI", "JOI", "JANENE", "DOROTHA", "DANIELE", "DANI", "CAROLYNN", "CARLYN", "BERENICE", "AYESHA", + "ANNELIESE", "ALETHEA", "THERSA", "TAMIKO", "RUFINA", "OLIVA", "MOZELL", "MARYLYN", "MADISON", "KRISTIAN", + "KATHYRN", "KASANDRA", "KANDACE", "JANAE", "GABRIEL", "DOMENICA", "DEBBRA", "DANNIELLE", "CHUN", "BUFFY", + "BARBIE", "ARCELIA", "AJA", "ZENOBIA", "SHAREN", "SHAREE", "PATRICK", "PAGE", "MY", "LAVINIA", + "KUM", "KACIE", "JACKELINE", "HUONG", "FELISA", "EMELIA", "ELEANORA", "CYTHIA", "CRISTIN", "CLYDE", + "CLARIBEL", "CARON", "ANASTACIA", "ZULMA", "ZANDRA", "YOKO", "TENISHA", "SUSANN", "SHERILYN", "SHAY", + "SHAWANDA", "SABINE", "ROMANA", "MATHILDA", "LINSEY", "KEIKO", "JOANA", "ISELA", "GRETTA", "GEORGETTA", + "EUGENIE", "DUSTY", "DESIRAE", "DELORA", "CORAZON", "ANTONINA", "ANIKA", "WILLENE", "TRACEE", "TAMATHA", + "REGAN", "NICHELLE", "MICKIE", "MAEGAN", "LUANA", "LANITA", "KELSIE", "EDELMIRA", "BREE", "AFTON", + "TEODORA", "TAMIE", "SHENA", "MEG", "LINH", "KELI", "KACI", "DANYELLE", "BRITT", "ARLETTE", + "ALBERTINE", "ADELLE", "TIFFINY", "STORMY", "SIMONA", "NUMBERS", "NICOLASA", "NICHOL", "NIA", "NAKISHA", + "MEE", "MAIRA", "LOREEN", "KIZZY", "JOHNNY", "JAY", "FALLON", "CHRISTENE", "BOBBYE", "ANTHONY", + "YING", "VINCENZA", "TANJA", "RUBIE", "RONI", "QUEENIE", "MARGARETT", "KIMBERLI", "IRMGARD", "IDELL", + "HILMA", "EVELINA", "ESTA", "EMILEE", "DENNISE", "DANIA", "CARL", "CARIE", "ANTONIO", "WAI", + "SANG", "RISA", "RIKKI", "PARTICIA", "MUI", "MASAKO", "MARIO", "LUVENIA", "LOREE", "LONI", + "LIEN", "KEVIN", "GIGI", "FLORENCIA", "DORIAN", "DENITA", "DALLAS", "CHI", "BILLYE", "ALEXANDER", + "TOMIKA", "SHARITA", "RANA", "NIKOLE", "NEOMA", "MARGARITE", "MADALYN", "LUCINA", "LAILA", "KALI", + "JENETTE", "GABRIELE", "EVELYNE", "ELENORA", "CLEMENTINA", "ALEJANDRINA", "ZULEMA", "VIOLETTE", "VANNESSA", "THRESA", + "RETTA", "PIA", "PATIENCE", "NOELLA", "NICKIE", "JONELL", "DELTA", "CHUNG", "CHAYA", "CAMELIA", + "BETHEL", "ANYA", "ANDREW", "THANH", "SUZANN", "SPRING", "SHU", "MILA", "LILLA", "LAVERNA", + "KEESHA", "KATTIE", "GIA", "GEORGENE", "EVELINE", "ESTELL", "ELIZBETH", "VIVIENNE", "VALLIE", "TRUDIE", + "STEPHANE", "MICHEL", "MAGALY", "MADIE", "KENYETTA", "KARREN", "JANETTA", "HERMINE", "HARMONY", "DRUCILLA", + "DEBBI", "CELESTINA", "CANDIE", "BRITNI", "BECKIE", "AMINA", "ZITA", "YUN", "YOLANDE", "VIVIEN", + "VERNETTA", "TRUDI", "SOMMER", "PEARLE", "PATRINA", "OSSIE", "NICOLLE", "LOYCE", "LETTY", "LARISA", + "KATHARINA", "JOSELYN", "JONELLE", "JENELL", "IESHA", "HEIDE", "FLORINDA", "FLORENTINA", "FLO", "ELODIA", + "DORINE", "BRUNILDA", "BRIGID", "ASHLI", "ARDELLA", "TWANA", "THU", "TARAH", "SUNG", "SHEA", + "SHAVON", "SHANE", "SERINA", "RAYNA", "RAMONITA", "NGA", "MARGURITE", "LUCRECIA", "KOURTNEY", "KATI", + "JESUS", "JESENIA", "DIAMOND", "CRISTA", "AYANA", "ALICA", "ALIA", "VINNIE", "SUELLEN", "ROMELIA", + "RACHELL", "PIPER", "OLYMPIA", "MICHIKO", "KATHALEEN", "JOLIE", "JESSI", "JANESSA", "HANA", "HA", + "ELEASE", "CARLETTA", "BRITANY", "SHONA", "SALOME", "ROSAMOND", "REGENA", "RAINA", "NGOC", "NELIA", + "LOUVENIA", "LESIA", "LATRINA", "LATICIA", "LARHONDA", "JINA", "JACKI", "HOLLIS", "HOLLEY", "EMMY", + "DEEANN", "CORETTA", "ARNETTA", "VELVET", "THALIA", "SHANICE", "NETA", "MIKKI", "MICKI", "LONNA", + "LEANA", "LASHUNDA", "KILEY", "JOYE", "JACQULYN", "IGNACIA", "HYUN", "HIROKO", "HENRY", "HENRIETTE", + "ELAYNE", "DELINDA", "DARNELL", "DAHLIA", "COREEN", "CONSUELA", "CONCHITA", "CELINE", "BABETTE", "AYANNA", + "ANETTE", "ALBERTINA", "SKYE", "SHAWNEE", "SHANEKA", "QUIANA", "PAMELIA", "MIN", "MERRI", "MERLENE", + "MARGIT", "KIESHA", "KIERA", "KAYLENE", "JODEE", "JENISE", "ERLENE", "EMMIE", "ELSE", "DARYL", + "DALILA", "DAISEY", "CODY", "CASIE", "BELIA", "BABARA", "VERSIE", "VANESA", "SHELBA", "SHAWNDA", + "SAM", "NORMAN", "NIKIA", "NAOMA", "MARNA", "MARGERET", "MADALINE", "LAWANA", "KINDRA", "JUTTA", + "JAZMINE", "JANETT", "HANNELORE", "GLENDORA", "GERTRUD", "GARNETT", "FREEDA", "FREDERICA", "FLORANCE", "FLAVIA", + "DENNIS", "CARLINE", "BEVERLEE", "ANJANETTE", "VALDA", "TRINITY", "TAMALA", "STEVIE", "SHONNA", "SHA", + "SARINA", "ONEIDA", "MICAH", "MERILYN", "MARLEEN", "LURLINE", "LENNA", "KATHERIN", "JIN", "JENI", + "HAE", "GRACIA", "GLADY", "FARAH", "ERIC", "ENOLA", "EMA", "DOMINQUE", "DEVONA", "DELANA", + "CECILA", "CAPRICE", "ALYSHA", "ALI", "ALETHIA", "VENA", "THERESIA", "TAWNY", "SONG", "SHAKIRA", + "SAMARA", "SACHIKO", "RACHELE", "PAMELLA", "NICKY", "MARNI", "MARIEL", "MAREN", "MALISA", "LIGIA", + "LERA", "LATORIA", "LARAE", "KIMBER", "KATHERN", "KAREY", "JENNEFER", "JANETH", "HALINA", "FREDIA", + "DELISA", "DEBROAH", "CIERA", "CHIN", "ANGELIKA", "ANDREE", "ALTHA", "YEN", "VIVAN", "TERRESA", + "TANNA", "SUK", "SUDIE", "SOO", "SIGNE", "SALENA", "RONNI", "REBBECCA", "MYRTIE", "MCKENZIE", + "MALIKA", "MAIDA", "LOAN", "LEONARDA", "KAYLEIGH", "FRANCE", "ETHYL", "ELLYN", "DAYLE", "CAMMIE", + "BRITTNI", "BIRGIT", "AVELINA", "ASUNCION", "ARIANNA", "AKIKO", "VENICE", "TYESHA", "TONIE", "TIESHA", + "TAKISHA", "STEFFANIE", "SINDY", "SANTANA", "MEGHANN", "MANDA", "MACIE", "LADY", "KELLYE", "KELLEE", + "JOSLYN", "JASON", "INGER", "INDIRA", "GLINDA", "GLENNIS", "FERNANDA", "FAUSTINA", "ENEIDA", "ELICIA", + "DOT", "DIGNA", "DELL", "ARLETTA", "ANDRE", "WILLIA", "TAMMARA", "TABETHA", "SHERRELL", "SARI", + "REFUGIO", "REBBECA", "PAULETTA", "NIEVES", "NATOSHA", "NAKITA", "MAMMIE", "KENISHA", "KAZUKO", "KASSIE", + "GARY", "EARLEAN", "DAPHINE", "CORLISS", "CLOTILDE", "CAROLYNE", "BERNETTA", "AUGUSTINA", "AUDREA", "ANNIS", + "ANNABELL", "YAN", "TENNILLE", "TAMICA", "SELENE", "SEAN", "ROSANA", "REGENIA", "QIANA", "MARKITA", + "MACY", "LEEANNE", "LAURINE", "KYM", "JESSENIA", "JANITA", "GEORGINE", "GENIE", "EMIKO", "ELVIE", + "DEANDRA", "DAGMAR", "CORIE", "COLLEN", "CHERISH", "ROMAINE", "PORSHA", "PEARLENE", "MICHELINE", "MERNA", + "MARGORIE", "MARGARETTA", "LORE", "KENNETH", "JENINE", "HERMINA", "FREDERICKA", "ELKE", "DRUSILLA", "DORATHY", + "DIONE", "DESIRE", "CELENA", "BRIGIDA", "ANGELES", "ALLEGRA", "THEO", "TAMEKIA", "SYNTHIA", "STEPHEN", + "SOOK", "SLYVIA", "ROSANN", "REATHA", "RAYE", "MARQUETTA", "MARGART", "LING", "LAYLA", "KYMBERLY", + "KIANA", "KAYLEEN", "KATLYN", "KARMEN", "JOELLA", "IRINA", "EMELDA", "ELENI", "DETRA", "CLEMMIE", + "CHERYLL", "CHANTELL", "CATHEY", "ARNITA", "ARLA", "ANGLE", "ANGELIC", "ALYSE", "ZOFIA", "THOMASINE", + "TENNIE", "SON", "SHERLY", "SHERLEY", "SHARYL", "REMEDIOS", "PETRINA", "NICKOLE", "MYUNG", "MYRLE", + "MOZELLA", "LOUANNE", "LISHA", "LATIA", "LANE", "KRYSTA", "JULIENNE", "JOEL", "JEANENE", "JACQUALINE", + "ISAURA", "GWENDA", "EARLEEN", "DONALD", "CLEOPATRA", "CARLIE", "AUDIE", "ANTONIETTA", "ALISE", "ALEX", + "VERDELL", "VAL", "TYLER", "TOMOKO", "THAO", "TALISHA", "STEVEN", "SO", "SHEMIKA", "SHAUN", + "SCARLET", "SAVANNA", "SANTINA", "ROSIA", "RAEANN", "ODILIA", "NANA", "MINNA", "MAGAN", "LYNELLE", + "LE", "KARMA", "JOEANN", "IVANA", "INELL", "ILANA", "HYE", "HONEY", "HEE", "GUDRUN", + "FRANK", "DREAMA", "CRISSY", "CHANTE", "CARMELINA", "ARVILLA", "ARTHUR", "ANNAMAE", "ALVERA", "ALEIDA", + "AARON", "YEE", "YANIRA", "VANDA", "TIANNA", "TAM", "STEFANIA", "SHIRA", "PERRY", "NICOL", + "NANCIE", "MONSERRATE", "MINH", "MELYNDA", "MELANY", "MATTHEW", "LOVELLA", "LAURE", "KIRBY", "KACY", + "JACQUELYNN", "HYON", "GERTHA", "FRANCISCO", "ELIANA", "CHRISTENA", "CHRISTEEN", "CHARISE", "CATERINA", "CARLEY", + "CANDYCE", "ARLENA", "AMMIE", "YANG", "WILLETTE", "VANITA", "TUYET", "TINY", "SYREETA", "SILVA", + "SCOTT", "RONALD", "PENNEY", "NYLA", "MICHAL", "MAURICE", "MARYAM", "MARYA", "MAGEN", "LUDIE", + "LOMA", "LIVIA", "LANELL", "KIMBERLIE", "JULEE", "DONETTA", "DIEDRA", "DENISHA", "DEANE", "DAWNE", + "CLARINE", "CHERRYL", "BRONWYN", "BRANDON", "ALLA", "VALERY", "TONDA", "SUEANN", "SORAYA", "SHOSHANA", + "SHELA", "SHARLEEN", "SHANELLE", "NERISSA", "MICHEAL", "MERIDITH", "MELLIE", "MAYE", "MAPLE", "MAGARET", + "LUIS", "LILI", "LEONILA", "LEONIE", "LEEANNA", "LAVONIA", "LAVERA", "KRISTEL", "KATHEY", "KATHE", + "JUSTIN", "JULIAN", "JIMMY", "JANN", "ILDA", "HILDRED", "HILDEGARDE", "GENIA", "FUMIKO", "EVELIN", + "ERMELINDA", "ELLY", "DUNG", "DOLORIS", "DIONNA", "DANAE", "BERNEICE", "ANNICE", "ALIX", "VERENA", + "VERDIE", "TRISTAN", "SHAWNNA", "SHAWANA", "SHAUNNA", "ROZELLA", "RANDEE", "RANAE", "MILAGRO", "LYNELL", + "LUISE", "LOUIE", "LOIDA", "LISBETH", "KARLEEN", "JUNITA", "JONA", "ISIS", "HYACINTH", "HEDY", + "GWENN", "ETHELENE", "ERLINE", "EDWARD", "DONYA", "DOMONIQUE", "DELICIA", "DANNETTE", "CICELY", "BRANDA", + "BLYTHE", "BETHANN", "ASHLYN", "ANNALEE", "ALLINE", "YUKO", "VELLA", "TRANG", "TOWANDA", "TESHA", + "SHERLYN", "NARCISA", "MIGUELINA", "MERI", "MAYBELL", "MARLANA", "MARGUERITA", "MADLYN", "LUNA", "LORY", + "LORIANN", "LIBERTY", "LEONORE", "LEIGHANN", "LAURICE", "LATESHA", "LARONDA", "KATRICE", "KASIE", "KARL", + "KALEY", "JADWIGA", "GLENNIE", "GEARLDINE", "FRANCINA", "EPIFANIA", "DYAN", "DORIE", "DIEDRE", "DENESE", + "DEMETRICE", "DELENA", "DARBY", "CRISTIE", "CLEORA", "CATARINA", "CARISA", "BERNIE", "BARBERA", "ALMETA", + "TRULA", "TEREASA", "SOLANGE", "SHEILAH", "SHAVONNE", "SANORA", "ROCHELL", "MATHILDE", "MARGARETA", "MAIA", + "LYNSEY", "LAWANNA", "LAUNA", "KENA", "KEENA", "KATIA", "JAMEY", "GLYNDA", "GAYLENE", "ELVINA", + "ELANOR", "DANUTA", "DANIKA", "CRISTEN", "CORDIE", "COLETTA", "CLARITA", "CARMON", "BRYNN", "AZUCENA", + "AUNDREA", "ANGELE", "YI", "WALTER", "VERLIE", "VERLENE", "TAMESHA", "SILVANA", "SEBRINA", "SAMIRA", + "REDA", "RAYLENE", "PENNI", "PANDORA", "NORAH", "NOMA", "MIREILLE", "MELISSIA", "MARYALICE", "LARAINE", + "KIMBERY", "KARYL", "KARINE", "KAM", "JOLANDA", "JOHANA", "JESUSA", "JALEESA", "JAE", "JACQUELYNE", + "IRISH", "ILUMINADA", "HILARIA", "HANH", "GENNIE", "FRANCIE", "FLORETTA", "EXIE", "EDDA", "DREMA", + "DELPHA", "BEV", "BARBAR", "ASSUNTA", "ARDELL", "ANNALISA", "ALISIA", "YUKIKO", "YOLANDO", "WONDA", + "WEI", "WALTRAUD", "VETA", "TEQUILA", "TEMEKA", "TAMEIKA", "SHIRLEEN", "SHENITA", "PIEDAD", "OZELLA", + "MIRTHA", "MARILU", "KIMIKO", "JULIANE", "JENICE", "JEN", "JANAY", "JACQUILINE", "HILDE", "FE", + "FAE", "EVAN", "EUGENE", "ELOIS", "ECHO", "DEVORAH", "CHAU", "BRINDA", "BETSEY", "ARMINDA", + "ARACELIS", "APRYL", "ANNETT", "ALISHIA", "VEOLA", "USHA", "TOSHIKO", "THEOLA", "TASHIA", "TALITHA", + "SHERY", "RUDY", "RENETTA", "REIKO", "RASHEEDA", "OMEGA", "OBDULIA", "MIKA", "MELAINE", "MEGGAN", + "MARTIN", "MARLEN", "MARGET", "MARCELINE", "MANA", "MAGDALEN", "LIBRADA", "LEZLIE", "LEXIE", "LATASHIA", + "LASANDRA", "KELLE", "ISIDRA", "ISA", "INOCENCIA", "GWYN", "FRANCOISE", "ERMINIA", "ERINN", "DIMPLE", + "DEVORA", "CRISELDA", "ARMANDA", "ARIE", "ARIANE", "ANGELO", "ANGELENA", "ALLEN", "ALIZA", "ADRIENE", + "ADALINE", "XOCHITL", "TWANNA", "TRAN", "TOMIKO", "TAMISHA", "TAISHA", "SUSY", "SIU", "RUTHA", + "ROXY", "RHONA", "RAYMOND", "OTHA", "NORIKO", "NATASHIA", "MERRIE", "MELVIN", "MARINDA", "MARIKO", + "MARGERT", "LORIS", "LIZZETTE", "LEISHA", "KAILA", "KA", "JOANNIE", "JERRICA", "JENE", "JANNET", + "JANEE", "JACINDA", "HERTA", "ELENORE", "DORETTA", "DELAINE", "DANIELL", "CLAUDIE", "CHINA", "BRITTA", + "APOLONIA", "AMBERLY", "ALEASE", "YURI", "YUK", "WEN", "WANETA", "UTE", "TOMI", "SHARRI", + "SANDIE", "ROSELLE", "REYNALDA", "RAGUEL", "PHYLICIA", "PATRIA", "OLIMPIA", "ODELIA", "MITZIE", "MITCHELL", + "MISS", "MINDA", "MIGNON", "MICA", "MENDY", "MARIVEL", "MAILE", "LYNETTA", "LAVETTE", "LAURYN", + "LATRISHA", "LAKIESHA", "KIERSTEN", "KARY", "JOSPHINE", "JOLYN", "JETTA", "JANISE", "JACQUIE", "IVELISSE", + "GLYNIS", "GIANNA", "GAYNELLE", "EMERALD", "DEMETRIUS", "DANYELL", "DANILLE", "DACIA", "CORALEE", "CHER", + "CEOLA", "BRETT", "BELL", "ARIANNE", "ALESHIA", "YUNG", "WILLIEMAE", "TROY", "TRINH", "THORA", + "TAI", "SVETLANA", "SHERIKA", "SHEMEKA", "SHAUNDA", "ROSELINE", "RICKI", "MELDA", "MALLIE", "LAVONNA", + "LATINA", "LARRY", "LAQUANDA", "LALA", "LACHELLE", "KLARA", "KANDIS", "JOHNA", "JEANMARIE", "JAYE", + "HANG", "GRAYCE", "GERTUDE", "EMERITA", "EBONIE", "CLORINDA", "CHING", "CHERY", "CAROLA", "BREANN", + "BLOSSOM", "BERNARDINE", "BECKI", "ARLETHA", "ARGELIA", "ARA", "ALITA", "YULANDA", "YON", "YESSENIA", + "TOBI", "TASIA", "SYLVIE", "SHIRL", "SHIRELY", "SHERIDAN", "SHELLA", "SHANTELLE", "SACHA", "ROYCE", + "REBECKA", "REAGAN", "PROVIDENCIA", "PAULENE", "MISHA", "MIKI", "MARLINE", "MARICA", "LORITA", "LATOYIA", + "LASONYA", "KERSTIN", "KENDA", "KEITHA", "KATHRIN", "JAYMIE", "JACK", "GRICELDA", "GINETTE", "ERYN", + "ELINA", "ELFRIEDA", "DANYEL", "CHEREE", "CHANELLE", "BARRIE", "AVERY", "AURORE", "ANNAMARIA", "ALLEEN", + "AILENE", "AIDE", "YASMINE", "VASHTI", "VALENTINE", "TREASA", "TORY", "TIFFANEY", "SHERYLL", "SHARIE", + "SHANAE", "SAU", "RAISA", "PA", "NEDA", "MITSUKO", "MIRELLA", "MILDA", "MARYANNA", "MARAGRET", + "MABELLE", "LUETTA", "LORINA", "LETISHA", "LATARSHA", "LANELLE", "LAJUANA", "KRISSY", "KARLY", "KARENA", + "JON", "JESSIKA", "JERICA", "JEANELLE", "JANUARY", "JALISA", "JACELYN", "IZOLA", "IVEY", "GREGORY", + "EUNA", "ETHA", "DREW", "DOMITILA", "DOMINICA", "DAINA", "CREOLA", "CARLI", "CAMIE", "BUNNY", + "BRITTNY", "ASHANTI", "ANISHA", "ALEEN", "ADAH", "YASUKO", "WINTER", "VIKI", "VALRIE", "TONA", + "TINISHA", "THI", "TERISA", "TATUM", "TANEKA", "SIMONNE", "SHALANDA", "SERITA", "RESSIE", "REFUGIA", + "PAZ", "OLENE", "NA", "MERRILL", "MARGHERITA", "MANDIE", "MAN", "MAIRE", "LYNDIA", "LUCI", + "LORRIANE", "LORETA", "LEONIA", "LAVONA", "LASHAWNDA", "LAKIA", "KYOKO", "KRYSTINA", "KRYSTEN", "KENIA", + "KELSI", "JUDE", "JEANICE", "ISOBEL", "GEORGIANN", "GENNY", "FELICIDAD", "EILENE", "DEON", "DELOISE", + "DEEDEE", "DANNIE", "CONCEPTION", "CLORA", "CHERILYN", "CHANG", "CALANDRA", "BERRY", "ARMANDINA", "ANISA", + "ULA", "TIMOTHY", "TIERA", "THERESSA", "STEPHANIA", "SIMA", "SHYLA", "SHONTA", "SHERA", "SHAQUITA", + "SHALA", "SAMMY", "ROSSANA", "NOHEMI", "NERY", "MORIAH", "MELITA", "MELIDA", "MELANI", "MARYLYNN", + "MARISHA", "MARIETTE", "MALORIE", "MADELENE", "LUDIVINA", "LORIA", "LORETTE", "LORALEE", "LIANNE", "LEON", + "LAVENIA", "LAURINDA", "LASHON", "KIT", "KIMI", "KEILA", "KATELYNN", "KAI", "JONE", "JOANE", + "JI", "JAYNA", "JANELLA", "JA", "HUE", "HERTHA", "FRANCENE", "ELINORE", "DESPINA", "DELSIE", + "DEEDRA", "CLEMENCIA", "CARRY", "CAROLIN", "CARLOS", "BULAH", "BRITTANIE", "BOK", "BLONDELL", "BIBI", + "BEAULAH", "BEATA", "ANNITA", "AGRIPINA", "VIRGEN", "VALENE", "UN", "TWANDA", "TOMMYE", "TOI", + "TARRA", "TARI", "TAMMERA", "SHAKIA", "SADYE", "RUTHANNE", "ROCHEL", "RIVKA", "PURA", "NENITA", + "NATISHA", "MING", "MERRILEE", "MELODEE", "MARVIS", "LUCILLA", "LEENA", "LAVETA", "LARITA", "LANIE", + "KEREN", "ILEEN", "GEORGEANN", "GENNA", "GENESIS", "FRIDA", "EWA", "EUFEMIA", "EMELY", "ELA", + "EDYTH", "DEONNA", "DEADRA", "DARLENA", "CHANELL", "CHAN", "CATHERN", "CASSONDRA", "CASSAUNDRA", "BERNARDA", + "BERNA", "ARLINDA", "ANAMARIA", "ALBERT", "WESLEY", "VERTIE", "VALERI", "TORRI", "TATYANA", "STASIA", + "SHERISE", "SHERILL", "SEASON", "SCOTTIE", "SANDA", "RUTHE", "ROSY", "ROBERTO", "ROBBI", "RANEE", + "QUYEN", "PEARLY", "PALMIRA", "ONITA", "NISHA", "NIESHA", "NIDA", "NEVADA", "NAM", "MERLYN", + "MAYOLA", "MARYLOUISE", "MARYLAND", "MARX", "MARTH", "MARGENE", "MADELAINE", "LONDA", "LEONTINE", "LEOMA", + "LEIA", "LAWRENCE", "LAURALEE", "LANORA", "LAKITA", "KIYOKO", "KETURAH", "KATELIN", "KAREEN", "JONIE", + "JOHNETTE", "JENEE", "JEANETT", "IZETTA", "HIEDI", "HEIKE", "HASSIE", "HAROLD", "GIUSEPPINA", "GEORGANN", + "FIDELA", "FERNANDE", "ELWANDA", "ELLAMAE", "ELIZ", "DUSTI", "DOTTY", "CYNDY", "CORALIE", "CELESTA", + "ARGENTINA", "ALVERTA", "XENIA", "WAVA", "VANETTA", "TORRIE", "TASHINA", "TANDY", "TAMBRA", "TAMA", + "STEPANIE", "SHILA", "SHAUNTA", "SHARAN", "SHANIQUA", "SHAE", "SETSUKO", "SERAFINA", "SANDEE", "ROSAMARIA", + "PRISCILA", "OLINDA", "NADENE", "MUOI", "MICHELINA", "MERCEDEZ", "MARYROSE", "MARIN", "MARCENE", "MAO", + "MAGALI", "MAFALDA", "LOGAN", "LINN", "LANNIE", "KAYCE", "KAROLINE", "KAMILAH", "KAMALA", "JUSTA", + "JOLINE", "JENNINE", "JACQUETTA", "IRAIDA", "GERALD", "GEORGEANNA", "FRANCHESCA", "FAIRY", "EMELINE", "ELANE", + "EHTEL", "EARLIE", "DULCIE", "DALENE", "CRIS", "CLASSIE", "CHERE", "CHARIS", "CAROYLN", "CARMINA", + "CARITA", "BRIAN", "BETHANIE", "AYAKO", "ARICA", "AN", "ALYSA", "ALESSANDRA", "AKILAH", "ADRIEN", + "ZETTA", "YOULANDA", "YELENA", "YAHAIRA", "XUAN", "WENDOLYN", "VICTOR", "TIJUANA", "TERRELL", "TERINA", + "TERESIA", "SUZI", "SUNDAY", "SHERELL", "SHAVONDA", "SHAUNTE", "SHARDA", "SHAKITA", "SENA", "RYANN", + "RUBI", "RIVA", "REGINIA", "REA", "RACHAL", "PARTHENIA", "PAMULA", "MONNIE", "MONET", "MICHAELE", + "MELIA", "MARINE", "MALKA", "MAISHA", "LISANDRA", "LEO", "LEKISHA", "LEAN", "LAURENCE", "LAKENDRA", + "KRYSTIN", "KORTNEY", "KIZZIE", "KITTIE", "KERA", "KENDAL", "KEMBERLY", "KANISHA", "JULENE", "JULE", + "JOSHUA", "JOHANNE", "JEFFREY", "JAMEE", "HAN", "HALLEY", "GIDGET", "GALINA", "FREDRICKA", "FLETA", + "FATIMAH", "EUSEBIA", "ELZA", "ELEONORE", "DORTHEY", "DORIA", "DONELLA", "DINORAH", "DELORSE", "CLARETHA", + "CHRISTINIA", "CHARLYN", "BONG", "BELKIS", "AZZIE", "ANDERA", "AIKO", "ADENA", "YER", "YAJAIRA", + "WAN", "VANIA", "ULRIKE", "TOSHIA", "TIFANY", "STEFANY", "SHIZUE", "SHENIKA", "SHAWANNA", "SHAROLYN", + "SHARILYN", "SHAQUANA", "SHANTAY", "SEE", "ROZANNE", "ROSELEE", "RICKIE", "REMONA", "REANNA", "RAELENE", + "QUINN", "PHUNG", "PETRONILA", "NATACHA", "NANCEY", "MYRL", "MIYOKO", "MIESHA", "MERIDETH", "MARVELLA", + "MARQUITTA", "MARHTA", "MARCHELLE", "LIZETH", "LIBBIE", "LAHOMA", "LADAWN", "KINA", "KATHELEEN", "KATHARYN", + "KARISA", "KALEIGH", "JUNIE", "JULIEANN", "JOHNSIE", "JANEAN", "JAIMEE", "JACKQUELINE", "HISAKO", "HERMA", + "HELAINE", "GWYNETH", "GLENN", "GITA", "EUSTOLIA", "EMELINA", "ELIN", "EDRIS", "DONNETTE", "DONNETTA", + "DIERDRE", "DENAE", "DARCEL", "CLAUDE", "CLARISA", "CINDERELLA", "CHIA", "CHARLESETTA", "CHARITA", "CELSA", + "CASSY", "CASSI", "CARLEE", "BRUNA", "BRITTANEY", "BRANDE", "BILLI", "BAO", "ANTONETTA", "ANGLA", + "ANGELYN", "ANALISA", "ALANE", "WENONA", "WENDIE", "VERONIQUE", "VANNESA", "TOBIE", "TEMPIE", "SUMIKO", + "SULEMA", "SPARKLE", "SOMER", "SHEBA", "SHAYNE", "SHARICE", "SHANEL", "SHALON", "SAGE", "ROY", + "ROSIO", "ROSELIA", "RENAY", "REMA", "REENA", "PORSCHE", "PING", "PEG", "OZIE", "ORETHA", + "ORALEE", "ODA", "NU", "NGAN", "NAKESHA", "MILLY", "MARYBELLE", "MARLIN", "MARIS", "MARGRETT", + "MARAGARET", "MANIE", "LURLENE", "LILLIA", "LIESELOTTE", "LAVELLE", "LASHAUNDA", "LAKEESHA", "KEITH", "KAYCEE", + "KALYN", "JOYA", "JOETTE", "JENAE", "JANIECE", "ILLA", "GRISEL", "GLAYDS", "GENEVIE", "GALA", + "FREDDA", "FRED", "ELMER", "ELEONOR", "DEBERA", "DEANDREA", "DAN", "CORRINNE", "CORDIA", "CONTESSA", + "COLENE", "CLEOTILDE", "CHARLOTT", "CHANTAY", "CECILLE", "BEATRIS", "AZALEE", "ARLEAN", "ARDATH", "ANJELICA", + "ANJA", "ALFREDIA", "ALEISHA", "ADAM", "ZADA", "YUONNE", "XIAO", "WILLODEAN", "WHITLEY", "VENNIE", + "VANNA", "TYISHA", "TOVA", "TORIE", "TONISHA", "TILDA", "TIEN", "TEMPLE", "SIRENA", "SHERRIL", + "SHANTI", "SHAN", "SENAIDA", "SAMELLA", "ROBBYN", "RENDA", "REITA", "PHEBE", "PAULITA", "NOBUKO", + "NGUYET", "NEOMI", "MOON", "MIKAELA", "MELANIA", "MAXIMINA", "MARG", "MAISIE", "LYNNA", "LILLI", + "LAYNE", "LASHAUN", "LAKENYA", "LAEL", "KIRSTIE", "KATHLINE", "KASHA", "KARLYN", "KARIMA", "JOVAN", + "JOSEFINE", "JENNELL", "JACQUI", "JACKELYN", "HYO", "HIEN", "GRAZYNA", "FLORRIE", "FLORIA", "ELEONORA", + "DWANA", "DORLA", "DONG", "DELMY", "DEJA", "DEDE", "DANN", "CRYSTA", "CLELIA", "CLARIS", + "CLARENCE", "CHIEKO", "CHERLYN", "CHERELLE", "CHARMAIN", "CHARA", "CAMMY", "BEE", "ARNETTE", "ARDELLE", + "ANNIKA", "AMIEE", "AMEE", "ALLENA", "YVONE", "YUKI", "YOSHIE", "YEVETTE", "YAEL", "WILLETTA", + "VONCILE", "VENETTA", "TULA", "TONETTE", "TIMIKA", "TEMIKA", "TELMA", "TEISHA", "TAREN", "TA", + "STACEE", "SHIN", "SHAWNTA", "SATURNINA", "RICARDA", "POK", "PASTY", "ONIE", "NUBIA", "MORA", + "MIKE", "MARIELLE", "MARIELLA", "MARIANELA", "MARDELL", "MANY", "LUANNA", "LOISE", "LISABETH", "LINDSY", + "LILLIANA", "LILLIAM", "LELAH", "LEIGHA", "LEANORA", "LANG", "KRISTEEN", "KHALILAH", "KEELEY", "KANDRA", + "JUNKO", "JOAQUINA", "JERLENE", "JANI", "JAMIKA", "JAME", "HSIU", "HERMILA", "GOLDEN", "GENEVIVE", + "EVIA", "EUGENA", "EMMALINE", "ELFREDA", "ELENE", "DONETTE", "DELCIE", "DEEANNA", "DARCEY", "CUC", + "CLARINDA", "CIRA", "CHAE", "CELINDA", "CATHERYN", "CATHERIN", "CASIMIRA", "CARMELIA", "CAMELLIA", "BREANA", + "BOBETTE", "BERNARDINA", "BEBE", "BASILIA", "ARLYNE", "AMAL", "ALAYNA", "ZONIA", "ZENIA", "YURIKO", + "YAEKO", "WYNELL", "WILLOW", "WILLENA", "VERNIA", "TU", "TRAVIS", "TORA", "TERRILYN", "TERICA", + "TENESHA", "TAWNA", "TAJUANA", "TAINA", "STEPHNIE", "SONA", "SOL", "SINA", "SHONDRA", "SHIZUKO", + "SHERLENE", "SHERICE", "SHARIKA", "ROSSIE", "ROSENA", "RORY", "RIMA", "RIA", "RHEBA", "RENNA", + "PETER", "NATALYA", "NANCEE", "MELODI", "MEDA", "MAXIMA", "MATHA", "MARKETTA", "MARICRUZ", "MARCELENE", + "MALVINA", "LUBA", "LOUETTA", "LEIDA", "LECIA", "LAURAN", "LASHAWNA", "LAINE", "KHADIJAH", "KATERINE", + "KASI", "KALLIE", "JULIETTA", "JESUSITA", "JESTINE", "JESSIA", "JEREMY", "JEFFIE", "JANYCE", "ISADORA", + "GEORGIANNE", "FIDELIA", "EVITA", "EURA", "EULAH", "ESTEFANA", "ELSY", "ELIZABET", "ELADIA", "DODIE", + "DION", "DIA", "DENISSE", "DELORAS", "DELILA", "DAYSI", "DAKOTA", "CURTIS", "CRYSTLE", "CONCHA", + "COLBY", "CLARETTA", "CHU", "CHRISTIA", "CHARLSIE", "CHARLENA", "CARYLON", "BETTYANN", "ASLEY", "ASHLEA", + "AMIRA", "AI", "AGUEDA", "AGNUS", "YUETTE", "VINITA", "VICTORINA", "TYNISHA", "TREENA", "TOCCARA", + "TISH", "THOMASENA", "TEGAN", "SOILA", "SHILOH", "SHENNA", "SHARMAINE", "SHANTAE", "SHANDI", "SEPTEMBER", + "SARAN", "SARAI", "SANA", "SAMUEL", "SALLEY", "ROSETTE", "ROLANDE", "REGINE", "OTELIA", "OSCAR", + "OLEVIA", "NICHOLLE", "NECOLE", "NAIDA", "MYRTA", "MYESHA", "MITSUE", "MINTA", "MERTIE", "MARGY", + "MAHALIA", "MADALENE", "LOVE", "LOURA", "LOREAN", "LEWIS", "LESHA", "LEONIDA", "LENITA", "LAVONE", + "LASHELL", "LASHANDRA", "LAMONICA", "KIMBRA", "KATHERINA", "KARRY", "KANESHA", "JULIO", "JONG", "JENEVA", + "JAQUELYN", "HWA", "GILMA", "GHISLAINE", "GERTRUDIS", "FRANSISCA", "FERMINA", "ETTIE", "ETSUKO", "ELLIS", + "ELLAN", "ELIDIA", "EDRA", "DORETHEA", "DOREATHA", "DENYSE", "DENNY", "DEETTA", "DAINE", "CYRSTAL", + "CORRIN", "CAYLA", "CARLITA", "CAMILA", "BURMA", "BULA", "BUENA", "BLAKE", "BARABARA", "AVRIL", + "AUSTIN", "ALAINE", "ZANA", "WILHEMINA", "WANETTA", "VIRGIL", "VI", "VERONIKA", "VERNON", "VERLINE", + "VASILIKI", "TONITA", "TISA", "TEOFILA", "TAYNA", "TAUNYA", "TANDRA", "TAKAKO", "SUNNI", "SUANNE", + "SIXTA", "SHARELL", "SEEMA", "RUSSELL", "ROSENDA", "ROBENA", "RAYMONDE", "PEI", "PAMILA", "OZELL", + "NEIDA", "NEELY", "MISTIE", "MICHA", "MERISSA", "MAURITA", "MARYLN", "MARYETTA", "MARSHALL", "MARCELL", + "MALENA", "MAKEDA", "MADDIE", "LOVETTA", "LOURIE", "LORRINE", "LORILEE", "LESTER", "LAURENA", "LASHAY", + "LARRAINE", "LAREE", "LACRESHA", "KRISTLE", "KRISHNA", "KEVA", "KEIRA", "KAROLE", "JOIE", "JINNY", + "JEANNETTA", "JAMA", "HEIDY", "GILBERTE", "GEMA", "FAVIOLA", "EVELYNN", "ENDA", "ELLI", "ELLENA", + "DIVINA", "DAGNY", "COLLENE", "CODI", "CINDIE", "CHASSIDY", "CHASIDY", "CATRICE", "CATHERINA", "CASSEY", + "CAROLL", "CARLENA", "CANDRA", "CALISTA", "BRYANNA", "BRITTENY", "BEULA", "BARI", "AUDRIE", "AUDRIA", + "ARDELIA", "ANNELLE", "ANGILA", "ALONA", "ALLYN", "DOUGLAS", "ROGER", "JONATHAN", "RALPH", "NICHOLAS", + "BENJAMIN", "BRUCE", "HARRY", "WAYNE", "STEVE", "HOWARD", "ERNEST", "PHILLIP", "TODD", "CRAIG", + "ALAN", "PHILIP", "EARL", "DANNY", "BRYAN", "STANLEY", "LEONARD", "NATHAN", "MANUEL", "RODNEY", + "MARVIN", "VINCENT", "JEFFERY", "JEFF", "CHAD", "JACOB", "ALFRED", "BRADLEY", "HERBERT", "FREDERICK", + "EDWIN", "DON", "RICKY", "RANDALL", "BARRY", "BERNARD", "LEROY", "MARCUS", "THEODORE", "CLIFFORD", + "MIGUEL", "JIM", "TOM", "CALVIN", "BILL", "LLOYD", "DEREK", "WARREN", "DARRELL", "JEROME", + "FLOYD", "ALVIN", "TIM", "GORDON", "GREG", "JORGE", "DUSTIN", "PEDRO", "DERRICK", "ZACHARY", + "HERMAN", "GLEN", "HECTOR", "RICARDO", "RICK", "BRENT", "RAMON", "GILBERT", "MARC", "REGINALD", + "RUBEN", "NATHANIEL", "RAFAEL", "EDGAR", "MILTON", "RAUL", "BEN", "CHESTER", "DUANE", "FRANKLIN", + "BRAD", "RON", "ROLAND", "ARNOLD", "HARVEY", "JARED", "ERIK", "DARRYL", "NEIL", "JAVIER", + "FERNANDO", "CLINTON", "TED", "MATHEW", "TYRONE", "DARREN", "LANCE", "KURT", "ALLAN", "NELSON", + "GUY", "CLAYTON", "HUGH", "MAX", "DWAYNE", "DWIGHT", "ARMANDO", "FELIX", "EVERETT", "IAN", + "WALLACE", "KEN", "BOB", "ALFREDO", "ALBERTO", "DAVE", "IVAN", "BYRON", "ISAAC", "MORRIS", + "CLIFTON", "WILLARD", "ROSS", "ANDY", "SALVADOR", "KIRK", "SERGIO", "SETH", "KENT", "TERRANCE", + "EDUARDO", "TERRENCE", "ENRIQUE", "WADE", "STUART", "FREDRICK", "ARTURO", "ALEJANDRO", "NICK", "LUTHER", + "WENDELL", "JEREMIAH", "JULIUS", "OTIS", "TREVOR", "OLIVER", "LUKE", "HOMER", "GERARD", "DOUG", + "KENNY", "HUBERT", "LYLE", "MATT", "ALFONSO", "ORLANDO", "REX", "CARLTON", "ERNESTO", "NEAL", + "PABLO", "LORENZO", "OMAR", "WILBUR", "GRANT", "HORACE", "RODERICK", "ABRAHAM", "WILLIS", "RICKEY", + "ANDRES", "CESAR", "JOHNATHAN", "MALCOLM", "RUDOLPH", "DAMON", "KELVIN", "PRESTON", "ALTON", "ARCHIE", + "MARCO", "WM", "PETE", "RANDOLPH", "GARRY", "GEOFFREY", "JONATHON", "FELIPE", "GERARDO", "ED", + "DOMINIC", "DELBERT", "COLIN", "GUILLERMO", "EARNEST", "LUCAS", "BENNY", "SPENCER", "RODOLFO", "MYRON", + "EDMUND", "GARRETT", "SALVATORE", "CEDRIC", "LOWELL", "GREGG", "SHERMAN", "WILSON", "SYLVESTER", "ROOSEVELT", + "ISRAEL", "JERMAINE", "FORREST", "WILBERT", "LELAND", "SIMON", "CLARK", "IRVING", "BRYANT", "OWEN", + "RUFUS", "WOODROW", "KRISTOPHER", "MACK", "LEVI", "MARCOS", "GUSTAVO", "JAKE", "LIONEL", "GILBERTO", + "CLINT", "NICOLAS", "ISMAEL", "ORVILLE", "ERVIN", "DEWEY", "AL", "WILFRED", "JOSH", "HUGO", + "IGNACIO", "CALEB", "TOMAS", "SHELDON", "ERICK", "STEWART", "DOYLE", "DARREL", "ROGELIO", "TERENCE", + "SANTIAGO", "ALONZO", "ELIAS", "BERT", "ELBERT", "RAMIRO", "CONRAD", "NOAH", "GRADY", "PHIL", + "CORNELIUS", "LAMAR", "ROLANDO", "CLAY", "PERCY", "DEXTER", "BRADFORD", "DARIN", "AMOS", "MOSES", + "IRVIN", "SAUL", "ROMAN", "RANDAL", "TIMMY", "DARRIN", "WINSTON", "BRENDAN", "ABEL", "DOMINICK", + "BOYD", "EMILIO", "ELIJAH", "DOMINGO", "EMMETT", "MARLON", "EMANUEL", "JERALD", "EDMOND", "EMIL", + "DEWAYNE", "WILL", "OTTO", "TEDDY", "REYNALDO", "BRET", "JESS", "TRENT", "HUMBERTO", "EMMANUEL", + "STEPHAN", "VICENTE", "LAMONT", "GARLAND", "MILES", "EFRAIN", "HEATH", "RODGER", "HARLEY", "ETHAN", + "ELDON", "ROCKY", "PIERRE", "JUNIOR", "FREDDY", "ELI", "BRYCE", "ANTOINE", "STERLING", "CHASE", + "GROVER", "ELTON", "CLEVELAND", "DYLAN", "CHUCK", "DAMIAN", "REUBEN", "STAN", "AUGUST", "LEONARDO", + "JASPER", "RUSSEL", "ERWIN", "BENITO", "HANS", "MONTE", "BLAINE", "ERNIE", "CURT", "QUENTIN", + "AGUSTIN", "MURRAY", "JAMAL", "ADOLFO", "HARRISON", "TYSON", "BURTON", "BRADY", "ELLIOTT", "WILFREDO", + "BART", "JARROD", "VANCE", "DENIS", "DAMIEN", "JOAQUIN", "HARLAN", "DESMOND", "ELLIOT", "DARWIN", + "GREGORIO", "BUDDY", "XAVIER", "KERMIT", "ROSCOE", "ESTEBAN", "ANTON", "SOLOMON", "SCOTTY", "NORBERT", + "ELVIN", "WILLIAMS", "NOLAN", "ROD", "QUINTON", "HAL", "BRAIN", "ROB", "ELWOOD", "KENDRICK", + "DARIUS", "MOISES", "FIDEL", "THADDEUS", "CLIFF", "MARCEL", "JACKSON", "RAPHAEL", "BRYON", "ARMAND", + "ALVARO", "JEFFRY", "DANE", "JOESPH", "THURMAN", "NED", "RUSTY", "MONTY", "FABIAN", "REGGIE", + "MASON", "GRAHAM", "ISAIAH", "VAUGHN", "GUS", "LOYD", "DIEGO", "ADOLPH", "NORRIS", "MILLARD", + "ROCCO", "GONZALO", "DERICK", "RODRIGO", "WILEY", "RIGOBERTO", "ALPHONSO", "TY", "NOE", "VERN", + "REED", "JEFFERSON", "ELVIS", "BERNARDO", "MAURICIO", "HIRAM", "DONOVAN", "BASIL", "RILEY", "NICKOLAS", + "MAYNARD", "SCOT", "VINCE", "QUINCY", "EDDY", "SEBASTIAN", "FEDERICO", "ULYSSES", "HERIBERTO", "DONNELL", + "COLE", "DAVIS", "GAVIN", "EMERY", "WARD", "ROMEO", "JAYSON", "DANTE", "CLEMENT", "COY", + "MAXWELL", "JARVIS", "BRUNO", "ISSAC", "DUDLEY", "BROCK", "SANFORD", "CARMELO", "BARNEY", "NESTOR", + "STEFAN", "DONNY", "ART", "LINWOOD", "BEAU", "WELDON", "GALEN", "ISIDRO", "TRUMAN", "DELMAR", + "JOHNATHON", "SILAS", "FREDERIC", "DICK", "IRWIN", "MERLIN", "CHARLEY", "MARCELINO", "HARRIS", "CARLO", + "TRENTON", "KURTIS", "HUNTER", "AURELIO", "WINFRED", "VITO", "COLLIN", "DENVER", "CARTER", "LEONEL", + "EMORY", "PASQUALE", "MOHAMMAD", "MARIANO", "DANIAL", "LANDON", "DIRK", "BRANDEN", "ADAN", "BUFORD", + "GERMAN", "WILMER", "EMERSON", "ZACHERY", "FLETCHER", "JACQUES", "ERROL", "DALTON", "MONROE", "JOSUE", + "EDWARDO", "BOOKER", "WILFORD", "SONNY", "SHELTON", "CARSON", "THERON", "RAYMUNDO", "DAREN", "HOUSTON", + "ROBBY", "LINCOLN", "GENARO", "BENNETT", "OCTAVIO", "CORNELL", "HUNG", "ARRON", "ANTONY", "HERSCHEL", + "GIOVANNI", "GARTH", "CYRUS", "CYRIL", "RONNY", "LON", "FREEMAN", "DUNCAN", "KENNITH", "CARMINE", + "ERICH", "CHADWICK", "WILBURN", "RUSS", "REID", "MYLES", "ANDERSON", "MORTON", "JONAS", "FOREST", + "MITCHEL", "MERVIN", "ZANE", "RICH", "JAMEL", "LAZARO", "ALPHONSE", "RANDELL", "MAJOR", "JARRETT", + "BROOKS", "ABDUL", "LUCIANO", "SEYMOUR", "EUGENIO", "MOHAMMED", "VALENTIN", "CHANCE", "ARNULFO", "LUCIEN", + "FERDINAND", "THAD", "EZRA", "ALDO", "RUBIN", "ROYAL", "MITCH", "EARLE", "ABE", "WYATT", + "MARQUIS", "LANNY", "KAREEM", "JAMAR", "BORIS", "ISIAH", "EMILE", "ELMO", "ARON", "LEOPOLDO", + "EVERETTE", "JOSEF", "ELOY", "RODRICK", "REINALDO", "LUCIO", "JERROD", "WESTON", "HERSHEL", "BARTON", + "PARKER", "LEMUEL", "BURT", "JULES", "GIL", "ELISEO", "AHMAD", "NIGEL", "EFREN", "ANTWAN", + "ALDEN", "MARGARITO", "COLEMAN", "DINO", "OSVALDO", "LES", "DEANDRE", "NORMAND", "KIETH", "TREY", + "NORBERTO", "NAPOLEON", "JEROLD", "FRITZ", "ROSENDO", "MILFORD", "CHRISTOPER", "ALFONZO", "LYMAN", "JOSIAH", + "BRANT", "WILTON", "RICO", "JAMAAL", "DEWITT", "BRENTON", "OLIN", "FOSTER", "FAUSTINO", "CLAUDIO", + "JUDSON", "GINO", "EDGARDO", "ALEC", "TANNER", "JARRED", "DONN", "TAD", "PRINCE", "PORFIRIO", + "ODIS", "LENARD", "CHAUNCEY", "TOD", "MEL", "MARCELO", "KORY", "AUGUSTUS", "KEVEN", "HILARIO", + "BUD", "SAL", "ORVAL", "MAURO", "ZACHARIAH", "OLEN", "ANIBAL", "MILO", "JED", "DILLON", + "AMADO", "NEWTON", "LENNY", "RICHIE", "HORACIO", "BRICE", "MOHAMED", "DELMER", "DARIO", "REYES", + "MAC", "JONAH", "JERROLD", "ROBT", "HANK", "RUPERT", "ROLLAND", "KENTON", "DAMION", "ANTONE", + "WALDO", "FREDRIC", "BRADLY", "KIP", "BURL", "WALKER", "TYREE", "JEFFEREY", "AHMED", "WILLY", + "STANFORD", "OREN", "NOBLE", "MOSHE", "MIKEL", "ENOCH", "BRENDON", "QUINTIN", "JAMISON", "FLORENCIO", + "DARRICK", "TOBIAS", "HASSAN", "GIUSEPPE", "DEMARCUS", "CLETUS", "TYRELL", "LYNDON", "KEENAN", "WERNER", + "GERALDO", "COLUMBUS", "CHET", "BERTRAM", "MARKUS", "HUEY", "HILTON", "DWAIN", "DONTE", "TYRON", + "OMER", "ISAIAS", "HIPOLITO", "FERMIN", "ADALBERTO", "BO", "BARRETT", "TEODORO", "MCKINLEY", "MAXIMO", + "GARFIELD", "RALEIGH", "LAWERENCE", "ABRAM", "RASHAD", "KING", "EMMITT", "DARON", "SAMUAL", "MIQUEL", + "EUSEBIO", "DOMENIC", "DARRON", "BUSTER", "WILBER", "RENATO", "JC", "HOYT", "HAYWOOD", "EZEKIEL", + "CHAS", "FLORENTINO", "ELROY", "CLEMENTE", "ARDEN", "NEVILLE", "EDISON", "DESHAWN", "NATHANIAL", "JORDON", + "DANILO", "CLAUD", "SHERWOOD", "RAYMON", "RAYFORD", "CRISTOBAL", "AMBROSE", "TITUS", "HYMAN", "FELTON", + "EZEQUIEL", "ERASMO", "STANTON", "LONNY", "LEN", "IKE", "MILAN", "LINO", "JAROD", "HERB", + "ANDREAS", "WALTON", "RHETT", "PALMER", "DOUGLASS", "CORDELL", "OSWALDO", "ELLSWORTH", "VIRGILIO", "TONEY", + "NATHANAEL", "DEL", "BENEDICT", "MOSE", "JOHNSON", "ISREAL", "GARRET", "FAUSTO", "ASA", "ARLEN", + "ZACK", "WARNER", "MODESTO", "FRANCESCO", "MANUAL", "GAYLORD", "GASTON", "FILIBERTO", "DEANGELO", "MICHALE", + "GRANVILLE", "WES", "MALIK", "ZACKARY", "TUAN", "ELDRIDGE", "CRISTOPHER", "CORTEZ", "ANTIONE", "MALCOM", + "LONG", "KOREY", "JOSPEH", "COLTON", "WAYLON", "VON", "HOSEA", "SHAD", "SANTO", "RUDOLF", + "ROLF", "REY", "RENALDO", "MARCELLUS", "LUCIUS", "KRISTOFER", "BOYCE", "BENTON", "HAYDEN", "HARLAND", + "ARNOLDO", "RUEBEN", "LEANDRO", "KRAIG", "JERRELL", "JEROMY", "HOBERT", "CEDRICK", "ARLIE", "WINFORD", + "WALLY", "LUIGI", "KENETH", "JACINTO", "GRAIG", "FRANKLYN", "EDMUNDO", "SID", "PORTER", "LEIF", + "JERAMY", "BUCK", "WILLIAN", "VINCENZO", "SHON", "LYNWOOD", "JERE", "HAI", "ELDEN", "DORSEY", + "DARELL", "BRODERICK", "ALONSO" + ] + total_sum = 0 + temp_sum = 0 + name.sort() + for i in range(len(name)): + for j in name[i]: + temp_sum += ord(j) - ord('A') + 1 + total_sum += (i + 1) * temp_sum + temp_sum = 0 + print(total_sum) + + +if __name__ == '__main__': + main() From 515cf2e81a181348f4968b1944ce34af414a1f5d Mon Sep 17 00:00:00 2001 From: shivg7706 Date: Thu, 26 Apr 2018 08:54:44 +0530 Subject: [PATCH 078/105] changes --- Project Euler/{Problem 24 => Problem 22}/sol2.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Project Euler/{Problem 24 => Problem 22}/sol2.py (100%) diff --git a/Project Euler/Problem 24/sol2.py b/Project Euler/Problem 22/sol2.py similarity index 100% rename from Project Euler/Problem 24/sol2.py rename to Project Euler/Problem 22/sol2.py From 09088cd8351729cfa093d46c03e35e5b222d5d90 Mon Sep 17 00:00:00 2001 From: Syed Haseeb Shah Date: Sat, 19 May 2018 16:07:24 +0500 Subject: [PATCH 079/105] Create Fischer-Yates_Shuffle.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Fisher–Yates shuffle is an algorithm for generating a random permutation of a finite sequence. For more details visit wikipedia/Fischer-Yates-Shuffle --- other/Fischer-Yates_Shuffle.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 other/Fischer-Yates_Shuffle.py diff --git a/other/Fischer-Yates_Shuffle.py b/other/Fischer-Yates_Shuffle.py new file mode 100644 index 000000000000..28cdff75ab85 --- /dev/null +++ b/other/Fischer-Yates_Shuffle.py @@ -0,0 +1,20 @@ +''' +The Fisher–Yates shuffle is an algorithm for generating a random permutation of a finite sequence. +For more details visit +wikipedia/Fischer-Yates-Shuffle. +''' +import random + +def FYshuffle(LIST): + for i in range(len(LIST)): + a = random.randint(0, len(LIST)-1) + b = random.randint(0, len(LIST)-1) + LIST[a], LIST[b] = LIST[b], LIST[a] + return LIST + +if __name__ == '__main__': + integers = [0,1,2,3,4,5,6,7] + strings = ['python', 'says', 'hello', '!'] + print ('Fisher-Yates Shuffle:') + print ('List',integers, strings) + print ('FY Shuffle',FYshuffle(integers), FYshuffle(strings)) From 35110b6e44cbe5b83878cd5d64a85466723a153a Mon Sep 17 00:00:00 2001 From: irokafetzaki Date: Sun, 20 May 2018 02:27:01 +0300 Subject: [PATCH 080/105] Tabu Search --- searches/tabuTestData.txt | 10 ++ searches/tabu_search.py | 313 +++++++++++++++++++++++++++++++++++ searches/test_tabu_search.py | 46 +++++ 3 files changed, 369 insertions(+) create mode 100644 searches/tabuTestData.txt create mode 100644 searches/tabu_search.py create mode 100644 searches/test_tabu_search.py diff --git a/searches/tabuTestData.txt b/searches/tabuTestData.txt new file mode 100644 index 000000000000..f797ff1c627a --- /dev/null +++ b/searches/tabuTestData.txt @@ -0,0 +1,10 @@ +a b 20 +a c 18 +a d 22 +a e 26 +b c 10 +b d 11 +b e 12 +c d 23 +c e 24 +d e 40 diff --git a/searches/tabu_search.py b/searches/tabu_search.py new file mode 100644 index 000000000000..b93b3202bce7 --- /dev/null +++ b/searches/tabu_search.py @@ -0,0 +1,313 @@ +""" +This is pure python implementation of Tabu search algorithm for a Travelling Salesman Problem, that the distances +between the cities are symmetric (the distance between city 'a' and city 'b' is the same between city 'b' and city 'a'). +The TSP can be represented into a graph. The cities are represented by nodes and the distance between them is +represented by the weight of the ark between the nodes. + +The .txt file with the graph has the form: + +node1 node2 distance_between_node1_and_node2 +node1 node3 distance_between_node1_and_node3 +... + +Be careful node1, node2 and the distance between them, must exist only once. This means in the .txt file +should not exist: +node1 node2 distance_between_node1_and_node2 +node2 node1 distance_between_node2_and_node1 + +For pytests run following command: +pytest + +For manual testing run: +python tabu_search.py -f your_file_name.txt -number_of_iterations_of_tabu_search -s size_of_tabu_search +e.g. python tabu_search.py -f tabudata2.txt -i 4 -s 3 +""" + +import copy +import argparse +import sys + + +def generate_neighbours(path): + """ + Pure implementation of generating a dictionary of neighbors and the cost with each + neighbor, given a path file that includes a graph. + + :param path: The path to the .txt file that includes the graph (e.g.tabudata2.txt) + :return dict_of_neighbours: Dictionary with key each node and value a list of lists with the neighbors of the node + and the cost (distance) for each neighbor. + + Example of dict_of_neighbours: + >>> dict_of_neighbours[a] + [[b,20],[c,18],[d,22],[e,26]] + + This indicates the neighbors of node (city) 'a', which has neighbor the node 'b' with distance 20, + the node 'c' with distance 18, the node 'd' with distance 22 and the node 'e' with distance 26. + + """ + f = open(path, "r") + + dict_of_neighbours = {} + + for line in f: + if line.split()[0] not in dict_of_neighbours: + _list = list() + _list.append([line.split()[1], line.split()[2]]) + dict_of_neighbours[line.split()[0]] = _list + else: + dict_of_neighbours[line.split()[0]].append([line.split()[1], line.split()[2]]) + if line.split()[1] not in dict_of_neighbours: + _list = list() + _list.append([line.split()[0], line.split()[2]]) + dict_of_neighbours[line.split()[1]] = _list + else: + dict_of_neighbours[line.split()[1]].append([line.split()[0], line.split()[2]]) + f.close() + + return dict_of_neighbours + + +def generate_first_solution(path, dict_of_neighbours): + """ + Pure implementation of generating the first solution for the Tabu search to start, with the redundant resolution + strategy. That means that we start from the starting node (e.g. node 'a'), then we go to the city nearest (lowest + distance) to this node (let's assume is node 'c'), then we go to the nearest city of the node 'c', etc + till we have visited all cities and return to the starting node. + + :param path: The path to the .txt file that includes the graph (e.g.tabudata2.txt) + :param dict_of_neighbours: Dictionary with key each node and value a list of lists with the neighbors of the node + and the cost (distance) for each neighbor. + :return first_solution: The solution for the first iteration of Tabu search using the redundant resolution strategy + in a list. + :return distance_of_first_solution: The total distance that Travelling Salesman will travel, if he follows the path + in first_solution. + + """ + + f = open(path, "r") + start_node = f.read(1) + end_node = start_node + + first_solution = [] + + visiting = start_node + + distance_of_first_solution = 0 + f.close() + while visiting not in first_solution: + minim = 10000 + for k in dict_of_neighbours[visiting]: + if int(k[1]) < int(minim) and k[0] not in first_solution: + minim = k[1] + best_node = k[0] + + first_solution.append(visiting) + distance_of_first_solution = distance_of_first_solution + int(minim) + visiting = best_node + + first_solution.append(end_node) + + position = 0 + for k in dict_of_neighbours[first_solution[-2]]: + if k[0] == start_node: + break + position += 1 + + distance_of_first_solution = distance_of_first_solution + int( + dict_of_neighbours[first_solution[-2]][position][1]) - 10000 + return first_solution, distance_of_first_solution + + +def find_neighborhood(solution, dict_of_neighbours): + """ + Pure implementation of generating the neighborhood (sorted by total distance of each solution from + lowest to highest) of a solution with 1-1 exchange method, that means we exchange each node in a solution with each + other node and generating a number of solution named neighborhood. + + :param solution: The solution in which we want to find the neighborhood. + :param dict_of_neighbours: Dictionary with key each node and value a list of lists with the neighbors of the node + and the cost (distance) for each neighbor. + :return neighborhood_of_solution: A list that includes the solutions and the total distance of each solution + (in form of list) that are produced with 1-1 exchange from the solution that the method took as an input + + + Example: + >>> find_neighborhood(['a','c','b','d','e','a']) + [['a','e','b','d','c','a',90], [['a','c','d','b','e','a',90],['a','d','b','c','e','a',93], + ['a','c','b','e','d','a',102], ['a','c','e','d','b','a',113], ['a','b','c','d','e','a',93]] + + """ + + neighborhood_of_solution = [] + + for n in solution[1:-1]: + idx1 = solution.index(n) + for kn in solution[1:-1]: + idx2 = solution.index(kn) + if n == kn: + continue + + _tmp = copy.deepcopy(solution) + _tmp[idx1] = kn + _tmp[idx2] = n + + distance = 0 + + for k in _tmp[:-1]: + next_node = _tmp[_tmp.index(k) + 1] + for i in dict_of_neighbours[k]: + if i[0] == next_node: + distance = distance + int(i[1]) + _tmp.append(distance) + + if _tmp not in neighborhood_of_solution: + neighborhood_of_solution.append(_tmp) + + indexOfLastItemInTheList = len(neighborhood_of_solution[0]) - 1 + + neighborhood_of_solution.sort(key=lambda x: x[indexOfLastItemInTheList]) + return neighborhood_of_solution + + +def tabu_search(first_solution, distance_of_first_solution, dict_of_neighbours, iters, size): + """ + Pure implementation of Tabu search algorithm for a Travelling Salesman Problem in Python. + + :param first_solution: The solution for the first iteration of Tabu search using the redundant resolution strategy + in a list. + :param distance_of_first_solution: The total distance that Travelling Salesman will travel, if he follows the path + in first_solution. + :param dict_of_neighbours: Dictionary with key each node and value a list of lists with the neighbors of the node + and the cost (distance) for each neighbor. + :param iters: The number of iterations that Tabu search will execute. + :param size: The size of Tabu List. + :return best_solution_ever: The solution with the lowest distance that occured during the execution of Tabu search. + :return best_cost: The total distance that Travelling Salesman will travel, if he follows the path in best_solution + ever. + + """ + count = 1 + solution = first_solution + tabu_list = list() + best_cost = distance_of_first_solution + best_solution_ever = solution + + while count <= iters: + neighborhood = find_neighborhood(solution, dict_of_neighbours) + index_of_best_solution = 0 + best_solution = neighborhood[index_of_best_solution] + best_cost_index = len(best_solution) - 1 + + found = False + while found is False: + i = 0 + while i < len(best_solution): + + if best_solution[i] != solution[i]: + first_exchange_node = best_solution[i] + second_exchange_node = solution[i] + break + i = i + 1 + + if [first_exchange_node, second_exchange_node] not in tabu_list and [second_exchange_node, + first_exchange_node] not in tabu_list: + tabu_list.append([first_exchange_node, second_exchange_node]) + found = True + solution = best_solution[:-1] + cost = neighborhood[index_of_best_solution][best_cost_index] + if cost < best_cost: + best_cost = cost + best_solution_ever = solution + else: + index_of_best_solution = index_of_best_solution + 1 + best_solution = neighborhood[index_of_best_solution] + + if len(tabu_list) >= size: + tabu_list.pop(0) + + count = count + 1 + + return best_solution_ever, best_cost + + +def main(args=None): + dict_of_neighbours = generate_neighbours(args.File) + + first_solution, distance_of_first_solution = generate_first_solution(args.File, dict_of_neighbours) + + best_sol, best_cost = tabu_search(first_solution, distance_of_first_solution, dict_of_neighbours, args.Iterations, + args.Size) + + print("Best solution: {0}, with total distance: {1}.".format(best_sol, best_cost)) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Tabu Search") + parser.add_argument( + "-f", "--File", type=str, help="Path to the file containing the data", required=True) + parser.add_argument( + "-i", "--Iterations", type=int, help="How many iterations the algorithm should perform", required=True) + parser.add_argument( + "-s", "--Size", type=int, help="Size of the tabu list", required=True) + + # Pass the arguments to main method + sys.exit(main(parser.parse_args())) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/searches/test_tabu_search.py b/searches/test_tabu_search.py new file mode 100644 index 000000000000..1bc2d33612ff --- /dev/null +++ b/searches/test_tabu_search.py @@ -0,0 +1,46 @@ +import unittest +import os +from tabu_search import generate_neighbours, generate_first_solution, find_neighborhood, tabu_search + +TEST_FILE = os.path.join(os.path.dirname(__file__), './tabuTestData.txt') + +NEIGHBOURS_DICT = {'a': [['b', '20'], ['c', '18'], ['d', '22'], ['e', '26']], + 'c': [['a', '18'], ['b', '10'], ['d', '23'], ['e', '24']], + 'b': [['a', '20'], ['c', '10'], ['d', '11'], ['e', '12']], + 'e': [['a', '26'], ['b', '12'], ['c', '24'], ['d', '40']], + 'd': [['a', '22'], ['b', '11'], ['c', '23'], ['e', '40']]} + +FIRST_SOLUTION = ['a', 'c', 'b', 'd', 'e', 'a'] + +DISTANCE = 105 + +NEIGHBOURHOOD_OF_SOLUTIONS = [['a', 'e', 'b', 'd', 'c', 'a', 90], + ['a', 'c', 'd', 'b', 'e', 'a', 90], + ['a', 'd', 'b', 'c', 'e', 'a', 93], + ['a', 'c', 'b', 'e', 'd', 'a', 102], + ['a', 'c', 'e', 'd', 'b', 'a', 113], + ['a', 'b', 'c', 'd', 'e', 'a', 119]] + + +class TestClass(unittest.TestCase): + def test_generate_neighbours(self): + neighbours = generate_neighbours(TEST_FILE) + + self.assertEquals(NEIGHBOURS_DICT, neighbours) + + def test_generate_first_solutions(self): + first_solution, distance = generate_first_solution(TEST_FILE, NEIGHBOURS_DICT) + + self.assertEquals(FIRST_SOLUTION, first_solution) + self.assertEquals(DISTANCE, distance) + + def test_find_neighbours(self): + neighbour_of_solutions = find_neighborhood(FIRST_SOLUTION, NEIGHBOURS_DICT) + + self.assertEquals(NEIGHBOURHOOD_OF_SOLUTIONS, neighbour_of_solutions) + + def test_tabu_search(self): + best_sol, best_cost = tabu_search(FIRST_SOLUTION, DISTANCE, NEIGHBOURS_DICT, 4, 3) + + self.assertEquals(['a', 'd', 'b', 'e', 'c', 'a'], best_sol) + self.assertEquals(87, best_cost) \ No newline at end of file From 237df47a31240ebf35a5de304bcc6c73e8f921b9 Mon Sep 17 00:00:00 2001 From: Syed Haseeb Shah Date: Sun, 20 May 2018 23:00:17 +0500 Subject: [PATCH 081/105] Create merge_sort_fastest.py Python implementation of merge sort algorithm. Takes an average of 0.6 microseconds to sort a list of length 1000 items. Best Case Scenario : O(n) Worst Case Scenario : O(n) --- sorts/merge_sort_fastest.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 sorts/merge_sort_fastest.py diff --git a/sorts/merge_sort_fastest.py b/sorts/merge_sort_fastest.py new file mode 100644 index 000000000000..cb7359ce2e40 --- /dev/null +++ b/sorts/merge_sort_fastest.py @@ -0,0 +1,20 @@ +''' +Python implementation of merge sort algorithm. +Takes an average of 0.6 microseconds to sort a list of length 1000 items. +Best Case Scenario : O(n) +Worst Case Scenario : O(n) +''' +def merge_sort(LIST): + start = [] + end = [] + a = LIST[0] + b = LIST[-1] + while (LIST.index(a) == LIST.index(b) and len(LIST) <=2): + a = min(LIST) + b = max(LIST) + start.append(a) + end.append(b) + LIST.remove(a) + LIST.remove(b) + end.reverse() +return start + end From 8957cf7ea8873206c355f513a79a185f9888c438 Mon Sep 17 00:00:00 2001 From: Harshil Date: Mon, 21 May 2018 10:01:44 +0200 Subject: [PATCH 082/105] Removed empty lines (255-313) Lines 255 to 313 were just empty, so removed those lines! --- searches/tabu_search.py | 59 ----------------------------------------- 1 file changed, 59 deletions(-) diff --git a/searches/tabu_search.py b/searches/tabu_search.py index b93b3202bce7..74c23f8b8cf1 100644 --- a/searches/tabu_search.py +++ b/searches/tabu_search.py @@ -252,62 +252,3 @@ def main(args=None): # Pass the arguments to main method sys.exit(main(parser.parse_args())) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - From 7f4b240d1a9092f8e04257f26965b7bc3a4dac07 Mon Sep 17 00:00:00 2001 From: Harshil Date: Mon, 21 May 2018 10:21:33 +0200 Subject: [PATCH 083/105] Update merge_sort_fastest.py I have modified the code a little to make it work as expected! --- sorts/merge_sort_fastest.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/sorts/merge_sort_fastest.py b/sorts/merge_sort_fastest.py index cb7359ce2e40..2e6249778d78 100644 --- a/sorts/merge_sort_fastest.py +++ b/sorts/merge_sort_fastest.py @@ -7,14 +7,15 @@ def merge_sort(LIST): start = [] end = [] - a = LIST[0] - b = LIST[-1] - while (LIST.index(a) == LIST.index(b) and len(LIST) <=2): + while LIST: a = min(LIST) b = max(LIST) start.append(a) end.append(b) - LIST.remove(a) - LIST.remove(b) + try: + LIST.remove(a) + LIST.remove(b) + except ValueError: + continue end.reverse() -return start + end + return (start + end) From 71fd719ab77329721f7b8caf50c16a145fd2c9e9 Mon Sep 17 00:00:00 2001 From: Harshil Date: Mon, 21 May 2018 10:28:37 +0200 Subject: [PATCH 084/105] Update merge_sort_fastest.py --- sorts/merge_sort_fastest.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/sorts/merge_sort_fastest.py b/sorts/merge_sort_fastest.py index 2e6249778d78..9fc9275aacba 100644 --- a/sorts/merge_sort_fastest.py +++ b/sorts/merge_sort_fastest.py @@ -7,15 +7,13 @@ def merge_sort(LIST): start = [] end = [] - while LIST: + while len(LIST) > 1: a = min(LIST) b = max(LIST) start.append(a) end.append(b) - try: - LIST.remove(a) - LIST.remove(b) - except ValueError: - continue + LIST.remove(a) + LIST.remove(b) + if LIST: start.append(LIST[0]) end.reverse() return (start + end) From ca7eb46756f230c2c089f3b83ecaf6c596df4ff0 Mon Sep 17 00:00:00 2001 From: Hyuntae Date: Mon, 28 May 2018 19:19:15 +0900 Subject: [PATCH 085/105] quicksort_3_partition --- sorts/quick_sort_3partition.py | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 sorts/quick_sort_3partition.py diff --git a/sorts/quick_sort_3partition.py b/sorts/quick_sort_3partition.py new file mode 100644 index 000000000000..5e4e080a84bf --- /dev/null +++ b/sorts/quick_sort_3partition.py @@ -0,0 +1,33 @@ +from __future__ import print_function + +def quick_sort_3partition(sorting, left, right): + + if right <= left: + return + a = left + b = right + pivot = sorting[left] + i = left + while i <= b: + if sorting[i] < pivot: + sorting[a], sorting[i] = sorting[i], sorting[a] + a += 1 + i += 1 + elif sorting[i] > pivot: + sorting[b], sorting[i] = sorting[i], sorting[b] + b -= 1 + else: + i += 1 + quick_sort_3partition(sorting, left, a - 1) + quick_sort_3partition(sorting, b + 1, right) + +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(',') ] + quick_sort_3partition(unsorted,0,len(unsorted)-1) + print(unsorted) \ No newline at end of file From f1fe4583562a1840af9b1128f33114272d7f1ed8 Mon Sep 17 00:00:00 2001 From: PyDevthon <34104945+PyDevthon@users.noreply.github.com> Date: Mon, 28 May 2018 19:16:02 +0530 Subject: [PATCH 086/105] Updated_caesar_cipher.py Updated --- ciphers/caesar_cipher.py | 110 ++++++++++++++++++++++++--------------- 1 file changed, 67 insertions(+), 43 deletions(-) diff --git a/ciphers/caesar_cipher.py b/ciphers/caesar_cipher.py index a53dc5857fca..4560db03b6f9 100644 --- a/ciphers/caesar_cipher.py +++ b/ciphers/caesar_cipher.py @@ -1,45 +1,69 @@ -from __future__ import print_function -# The Caesar Cipher Algorithm +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 != 96: + for x in strng: + indx = (ord(x) - key) % 256 + if indx < 32: + indx = indx + 95 + decrypted = decrypted + chr(indx) + print(decrypted) + decrypted = '' + key += 1 + return None + def main(): - message = input("Enter message: ") - key = int(input("Key [1-26]: ")) - mode = input("Encrypt or Decrypt [e/d]: ") - - if mode.lower().startswith('e'): - mode = "encrypt" - elif mode.lower().startswith('d'): - mode = "decrypt" - - translated = encdec(message, key, mode) - if mode == "encrypt": - print(("Encryption:", translated)) - elif mode == "decrypt": - print(("Decryption:", translated)) - -def encdec(message, key, mode): - message = message.upper() - translated = "" - LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - for symbol in message: - if symbol in LETTERS: - num = LETTERS.find(symbol) - if mode == "encrypt": - num = num + key - elif mode == "decrypt": - num = num - key - - if num >= len(LETTERS): - num -= len(LETTERS) - elif num < 0: - num += len(LETTERS) - - translated += LETTERS[num] - else: - translated += symbol - return translated - -if __name__ == '__main__': - import doctest - doctest.testmod() - main() + print("**Menu**") + 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 > 0 and key <= 94: + 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.") + break + +main() + + From 13617225cafdec85cb067c5c7badca28d408eb92 Mon Sep 17 00:00:00 2001 From: Harshil Date: Mon, 28 May 2018 23:25:48 +0200 Subject: [PATCH 087/105] small improvements! --- ciphers/caesar_cipher.py | 27 +++++++++++++-------------- 1 file changed, 13 insertions(+), 14 deletions(-) diff --git a/ciphers/caesar_cipher.py b/ciphers/caesar_cipher.py index 4560db03b6f9..6cd35e73db0d 100644 --- a/ciphers/caesar_cipher.py +++ b/ciphers/caesar_cipher.py @@ -1,3 +1,4 @@ +import sys def encrypt(strng, key): encrypted = '' for x in strng: @@ -20,50 +21,48 @@ def decrypt(strng, key): def brute_force(strng): key = 1 decrypted = '' - while key != 96: + while key <= 94: for x in strng: indx = (ord(x) - key) % 256 if indx < 32: indx = indx + 95 decrypted = decrypted + chr(indx) - print(decrypted) + print("Key: {}\t| Message: {}".format(key, decrypted)) decrypted = '' key += 1 return None def main(): - print("**Menu**") + 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") + 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:") + strng = input("Please enter the string to be ecrypted: ") while True: - key = int(input("Please enter off-set between 1-94")) - if key > 0 and key <= 94: + 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:") + strng = input("Please enter the string to be decrypted: ") while True: - key = int(input("Please enter off-set between 1-94")) + 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:") + strng = input("Please enter the string to be decrypted: ") brute_force(strng) main() elif choice == '4': - print ("GoodBye.") - break + print ("Goodbye.") + sys.exit() main() - - From 31f968f589db99f41bffaf6a255c4bd3211dca95 Mon Sep 17 00:00:00 2001 From: Harshil Date: Mon, 28 May 2018 23:34:21 +0200 Subject: [PATCH 088/105] small change! --- sorts/quick_sort_3partition.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/sorts/quick_sort_3partition.py b/sorts/quick_sort_3partition.py index 5e4e080a84bf..def646cdbc50 100644 --- a/sorts/quick_sort_3partition.py +++ b/sorts/quick_sort_3partition.py @@ -1,13 +1,11 @@ from __future__ import print_function def quick_sort_3partition(sorting, left, right): - if right <= left: return - a = left + a = i = left b = right pivot = sorting[left] - i = left while i <= b: if sorting[i] < pivot: sorting[a], sorting[i] = sorting[i], sorting[a] @@ -30,4 +28,4 @@ def quick_sort_3partition(sorting, left, right): user_input = raw_input('Enter numbers separated by a comma:\n').strip() unsorted = [ int(item) for item in user_input.split(',') ] quick_sort_3partition(unsorted,0,len(unsorted)-1) - print(unsorted) \ No newline at end of file + print(unsorted) From 16cd42c26c37a3666c7cd011e7fa436cf0eedbe3 Mon Sep 17 00:00:00 2001 From: Harshil Date: Sun, 3 Jun 2018 12:47:36 +0200 Subject: [PATCH 089/105] Updated sol2.py to make it work as expected --- Project Euler/Problem 02/sol2.py | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/Project Euler/Problem 02/sol2.py b/Project Euler/Problem 02/sol2.py index f0502a389707..9bbd0c535d63 100644 --- a/Project Euler/Problem 02/sol2.py +++ b/Project Euler/Problem 02/sol2.py @@ -1,13 +1,12 @@ def fib(n): - ls = [] - a,b = 0,1 - n += 1 - for i in range(n): - if (b % 2 == 0): - ls.append(b) - else: - pass - a,b = b, a+b - print (sum(ls)) - return None -fib(10) + a, b, s = 0, 1, 0 + while b < n: + if b % 2 == 0 and b < n: s += b + a, b = b, a+b + ls.append(s) + +T = int(input().strip()) +ls = [] +for _ in range(T): + fib(int(input().strip())) +print(*ls, sep = '\n') From 0d19edbcb3baa4b2a21362977246a848aabce1ee Mon Sep 17 00:00:00 2001 From: Anshul Malik Date: Tue, 5 Jun 2018 21:39:16 +0530 Subject: [PATCH 090/105] refactor-segment-tree --- data_structures/Binary Tree/SegmentTree.py | 62 ++++++++++++---------- 1 file changed, 34 insertions(+), 28 deletions(-) diff --git a/data_structures/Binary Tree/SegmentTree.py b/data_structures/Binary Tree/SegmentTree.py index a3b128c9d8b9..001bf999f391 100644 --- a/data_structures/Binary Tree/SegmentTree.py +++ b/data_structures/Binary Tree/SegmentTree.py @@ -3,63 +3,69 @@ class SegmentTree: - def __init__(self, N): - self.N = N - self.st = [0 for i in range(0,4*N)] # approximate the overall size of segment tree with array N + def __init__(self, A): + self.N = len(A) + self.st = [0] * (4 * self.N) # approximate the overall size of segment tree with array N + self.build(1, 0, self.N - 1) def left(self, idx): - return idx*2 + return idx * 2 def right(self, idx): - return idx*2 + 1 + return idx * 2 + 1 - def build(self, idx, l, r, A): - if l==r: - self.st[idx] = A[l-1] - else : - mid = (l+r)//2 - self.build(self.left(idx),l,mid, A) - self.build(self.right(idx),mid+1,r, A) + def build(self, idx, l, r): + if l == r: + self.st[idx] = A[l] + else: + mid = (l + r) // 2 + self.build(self.left(idx), l, mid) + self.build(self.right(idx), mid + 1, r) self.st[idx] = max(self.st[self.left(idx)] , self.st[self.right(idx)]) - def update(self, idx, l, r, a, b, val): # update(1, 1, N, a, b, v) for update val v to [a,b] + def update(self, a, b, val): + return self.update_recursive(1, 0, self.N - 1, a - 1, b - 1, val) + + def update_recursive(self, idx, l, r, a, b, val): # update(1, 1, N, a, b, v) for update val v to [a,b] if r < a or l > b: return True if l == r : self.st[idx] = val return True mid = (l+r)//2 - self.update(self.left(idx),l,mid,a,b,val) - self.update(self.right(idx),mid+1,r,a,b,val) + self.update_recursive(self.left(idx), l, mid, a, b, val) + self.update_recursive(self.right(idx), mid+1, r, a, b, val) self.st[idx] = max(self.st[self.left(idx)] , self.st[self.right(idx)]) return True - def query(self, idx, l, r, a, b): #query(1, 1, N, a, b) for query max of [a,b] + def query(self, a, b): + return self.query_recursive(1, 0, self.N - 1, a - 1, b - 1) + + def query_recursive(self, idx, l, r, a, b): #query(1, 1, N, a, b) for query max of [a,b] if r < a or l > b: return -math.inf if l >= a and r <= b: return self.st[idx] mid = (l+r)//2 - q1 = self.query(self.left(idx),l,mid,a,b) - q2 = self.query(self.right(idx),mid+1,r,a,b) - return max(q1,q2) + q1 = self.query_recursive(self.left(idx), l, mid, a, b) + q2 = self.query_recursive(self.right(idx), mid + 1, r, a, b) + return max(q1, q2) def showData(self): showList = [] for i in range(1,N+1): - showList += [self.query(1, 1, self.N, i, i)] + showList += [self.query(i, i)] print (showList) if __name__ == '__main__': A = [1,2,-4,7,3,-5,6,11,-20,9,14,15,5,2,-8] N = 15 - segt = SegmentTree(N) - segt.build(1,1,N,A) - print (segt.query(1,1,N,4,6)) - print (segt.query(1,1,N,7,11)) - print (segt.query(1,1,N,7,12)) - segt.update(1,1,N,1,3,111) - print (segt.query(1,1,N,1,15)) - segt.update(1,1,N,7,8,235) + segt = SegmentTree(A) + print (segt.query(4, 6)) + print (segt.query(7, 11)) + print (segt.query(7, 12)) + segt.update(1,3,111) + print (segt.query(1, 15)) + segt.update(7,8,235) segt.showData() From cc51a667e1e932e7fa4403e62642755fad480452 Mon Sep 17 00:00:00 2001 From: psyas Date: Tue, 12 Jun 2018 14:58:06 +0900 Subject: [PATCH 091/105] modify README.md by psyas for just test --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 9b394e001d66..199fe52d48f4 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ ### All algorithms implemented in Python (for education) These are for demonstration purposes only. There are many implementations of sorts in the Python standard library that are much better for performance reasons. - +test ## Sort Algorithms From 602eae756ebc3a1fe1b8fc04f20073ddcb32fee7 Mon Sep 17 00:00:00 2001 From: psyas Date: Tue, 12 Jun 2018 21:18:50 +0900 Subject: [PATCH 092/105] Elgamal cipher key generator code - (initial) --- README.md | 2 +- ciphers/elgamal_key_generator.py | 62 ++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 ciphers/elgamal_key_generator.py diff --git a/README.md b/README.md index 199fe52d48f4..9b394e001d66 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ ### All algorithms implemented in Python (for education) These are for demonstration purposes only. There are many implementations of sorts in the Python standard library that are much better for performance reasons. -test + ## Sort Algorithms diff --git a/ciphers/elgamal_key_generator.py b/ciphers/elgamal_key_generator.py new file mode 100644 index 000000000000..0524980d64a2 --- /dev/null +++ b/ciphers/elgamal_key_generator.py @@ -0,0 +1,62 @@ +import os +import random +import sys +import rabin_miller as rabinMiller, cryptomath_module as cryptoMath + +min_primitive_root = 3 + + +def main(): + print('Making key files...') + makeKeyFiles('elgamal', 2048) + print('Key files generation successful') + + +# I have written my code naively same as definition of primitive root +# however every time I run this program, memory exceeded... +# so I used 4.80 Algorithm in Handbook of Applied Cryptography(CRC Press, ISBN : 0-8493-8523-7, October 1996) +# and it seems to run nicely! +def primitiveRoot(p_val): + print("Generating primitive root of p") + while True: + g = random.randrange(3,p_val) + if pow(g, 2, p_val) == 1: + continue + if pow(g, p_val, p_val) == 1: + continue + return g + + +def generateKey(keySize): + print('Generating prime p...') + p = rabinMiller.generateLargePrime(keySize) # select large prime number. + e_1 = primitiveRoot(p) # one primitive root on modulo p. + d = random.randrange(3, p) # private_key -> have to be greater than 2 for safety. + e_2 = cryptoMath.findModInverse(pow(e_1, d, p), p) + + publicKey = (keySize, e_1, e_2, p) + privateKey = (keySize, d) + + return publicKey, privateKey + + +def makeKeyFiles(name, keySize): + if os.path.exists('%s_pubkey.txt' % name) or os.path.exists('%s_privkey.txt' % name): + print('\nWARNING:') + print('"%s_pubkey.txt" or "%s_privkey.txt" already exists. \n' + 'Use a different name or delete these files and re-run this program.' % + (name, name)) + sys.exit() + + publicKey, privateKey = generateKey(keySize) + print('\nWriting public key to file %s_pubkey.txt...' % name) + with open('%s_pubkey.txt' % name, 'w') as fo: + fo.write('%d,%d,%d,%d' % (publicKey[0], publicKey[1], publicKey[2], publicKey[3])) + + print('Writing private key to file %s_privkey.txt...' % name) + with open('%s_privkey.txt' % name, 'w') as fo: + fo.write('%d,%d' % (privateKey[0], privateKey[1])) + + +if __name__ == '__main__': + main() \ No newline at end of file From 0c8707d11ca70fc3ccae5ff2d3cb11cca1573199 Mon Sep 17 00:00:00 2001 From: psyas Date: Tue, 12 Jun 2018 21:21:38 +0900 Subject: [PATCH 093/105] Elgamal cipher key generator code - (initial) --- ciphers/elgamal_key_generator.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ciphers/elgamal_key_generator.py b/ciphers/elgamal_key_generator.py index 0524980d64a2..6a8751f69524 100644 --- a/ciphers/elgamal_key_generator.py +++ b/ciphers/elgamal_key_generator.py @@ -59,4 +59,5 @@ def makeKeyFiles(name, keySize): if __name__ == '__main__': - main() \ No newline at end of file + main() + \ No newline at end of file From 9489e8512df9e073ac019c75f827c03fe64242dd Mon Sep 17 00:00:00 2001 From: Hossam Al-Dokkani Date: Sat, 23 Jun 2018 17:01:06 +0200 Subject: [PATCH 094/105] Break if the collection is sorted --- sorts/bubble_sort.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/sorts/bubble_sort.py b/sorts/bubble_sort.py index e1bdf318911d..e28e7aa4fbe2 100644 --- a/sorts/bubble_sort.py +++ b/sorts/bubble_sort.py @@ -32,10 +32,12 @@ def bubble_sort(collection): """ length = len(collection) for i in range(length): + swapped = False for j in range(length-1): if collection[j] > collection[j+1]: + swapped = True collection[j], collection[j+1] = collection[j+1], collection[j] - + if not swapped: break # Stop iteration if the collection is sorted. return collection From ac30a97e99a8243378837ab735e93034b8c8ccc6 Mon Sep 17 00:00:00 2001 From: PandllCom Date: Tue, 26 Jun 2018 10:55:21 +0800 Subject: [PATCH 095/105] typo: strip --- sorts/bogosort.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sorts/bogosort.py b/sorts/bogosort.py index 2a3d320b00f0..33eac66bf21c 100644 --- a/sorts/bogosort.py +++ b/sorts/bogosort.py @@ -44,6 +44,6 @@ def isSorted(collection): except NameError: raw_input = input # Python 3 - user_input = raw_input('Enter numbers separated by a comma:\n').stript() + user_input = raw_input('Enter numbers separated by a comma:\n').strip() unsorted = [int(item) for item in user_input.split(',')] print(bogosort(unsorted)) From d4594da5327267aebfc484d67a61bd0752765c2c Mon Sep 17 00:00:00 2001 From: cclauss Date: Mon, 2 Jul 2018 10:07:25 +0200 Subject: [PATCH 096/105] print() is a function in Python 3 --- ciphers/Onepad_Cipher.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/ciphers/Onepad_Cipher.py b/ciphers/Onepad_Cipher.py index 4365924920f6..5536285efc17 100644 --- a/ciphers/Onepad_Cipher.py +++ b/ciphers/Onepad_Cipher.py @@ -1,11 +1,12 @@ +from __future__ import print_function + + class Onepad: def encrypt(self, text): '''Function to encrypt text using psedo-random numbers''' - plain = [] + plain = [ord(i) for i in text] key = [] cipher = [] - for i in text: - plain.append(ord(i)) for i in plain: k = random.randint(1, 300) c = (i+k)*k @@ -21,8 +22,9 @@ def decrypt(self, cipher, key): plain.append(chr(p)) plain = ''.join([i for i in plain]) return plain - + + if __name__ == '__main__': - c,k = Onepad().encrypt('Hello') - print c, k - print Onepad().decrypt(c, k) + c, k = Onepad().encrypt('Hello') + print(c, k) + print(Onepad().decrypt(c, k)) From ee3b0f2e50b78f3a8a2ca1b4937502da68d3db35 Mon Sep 17 00:00:00 2001 From: cclauss Date: Mon, 2 Jul 2018 10:11:28 +0200 Subject: [PATCH 097/105] Properly define raw_input)( in Python 3 __raw_input()__ was removed in Python 3 in favor of __input()__. This change ensure similar functioning in both Python 2 and Python 3. --- hashes/chaos_machine.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/hashes/chaos_machine.py b/hashes/chaos_machine.py index 766dbba3c5c9..4b30f631af5b 100644 --- a/hashes/chaos_machine.py +++ b/hashes/chaos_machine.py @@ -2,10 +2,9 @@ from __future__ import print_function try: - raw_input - input = raw_input -except: - pass + raw_input # Python 2 +except NameError: + input = raw_input # Python 3 # Chaos Machine (K, t, m) K = [0.33, 0.44, 0.55, 0.44, 0.33]; t = 3; m = 5 From bec160c6dc651442a37edafe85245a7856a2a142 Mon Sep 17 00:00:00 2001 From: cclauss Date: Tue, 3 Jul 2018 08:33:38 +0200 Subject: [PATCH 098/105] Use strip() to deal with leading or trailing whitespace --- hashes/chaos_machine.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/hashes/chaos_machine.py b/hashes/chaos_machine.py index 4b30f631af5b..f0a305bfeade 100644 --- a/hashes/chaos_machine.py +++ b/hashes/chaos_machine.py @@ -2,9 +2,9 @@ from __future__ import print_function try: - raw_input # Python 2 + input = raw_input # Python 2 except NameError: - input = raw_input # Python 3 + pass # Python 3 # Chaos Machine (K, t, m) K = [0.33, 0.44, 0.55, 0.44, 0.33]; t = 3; m = 5 @@ -100,7 +100,7 @@ def reset(): inp = "" # Pulling Data (Output) -while inp != "e" and inp != "E": +while inp in ("e", "E"): print("%s" % format(pull(), '#04x')) print(buffer_space); print(params_space) - inp = input("(e)exit? ") + inp = input("(e)exit? ").strip() From 2f22ea1acd72087bbb08d6f3c17c1331a21c8561 Mon Sep 17 00:00:00 2001 From: bharath-123 Date: Mon, 23 Jul 2018 00:18:58 +0530 Subject: [PATCH 099/105] Added test case Added a test case check knapsack.py --- dynamic_programming/knapsack.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/dynamic_programming/knapsack.py b/dynamic_programming/knapsack.py index a1e4f0d80daf..3823b5503417 100644 --- a/dynamic_programming/knapsack.py +++ b/dynamic_programming/knapsack.py @@ -12,3 +12,13 @@ def knapsack(W, wt, val, n): dp[i][w] = dp[i-1][w] return dp[n][w] +if name == "__main__": + val = [3,2,4,4] + wt = [4,3,2,3] + W = 6 + n = 4 + ''' + Should give 8 + ''' + print(knapsack(W,wt,val,n)) + From d96048a7df8ee833e6f025490c17c5050f77eace Mon Sep 17 00:00:00 2001 From: bharath-123 Date: Mon, 23 Jul 2018 00:29:40 +0530 Subject: [PATCH 100/105] Updated test case Made a typo writing name instead of __name__ --- dynamic_programming/knapsack.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dynamic_programming/knapsack.py b/dynamic_programming/knapsack.py index 3823b5503417..6c9789c972f2 100644 --- a/dynamic_programming/knapsack.py +++ b/dynamic_programming/knapsack.py @@ -12,7 +12,7 @@ def knapsack(W, wt, val, n): dp[i][w] = dp[i-1][w] return dp[n][w] -if name == "__main__": +if __name__ == "__main__": val = [3,2,4,4] wt = [4,3,2,3] W = 6 From a9f906208016817c05f9daf660f7bd4823951c0d Mon Sep 17 00:00:00 2001 From: bharath-123 Date: Mon, 23 Jul 2018 00:36:53 +0530 Subject: [PATCH 101/105] Added code for memory function implementation Added a function which implements knapsack using memory functions. Also I updated the test cases to include test cases for the memory function implementation. --- dynamic_programming/knapsack.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/dynamic_programming/knapsack.py b/dynamic_programming/knapsack.py index a1e4f0d80daf..a0b006a58710 100644 --- a/dynamic_programming/knapsack.py +++ b/dynamic_programming/knapsack.py @@ -1,6 +1,21 @@ """ Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the knapsack. """ +def MF_knapsack(i,wt,val,j): + ''' + This code involves the concept of memory functions. Here we solve the subproblems which are needed + unlike the below example + F is a 2D array with -1s filled up + ''' + global F # a global dp table for knapsack + if F[i][j] < 0: + if j < wt[i - 1]: + val = MF_knapsack(i - 1,wt,val,j) + else: + val = max(MF_knapsack(i - 1,wt,val,j),MF_knapsack(i - 1,wt,val,j - wt[i - 1]) + val[i - 1]) + F[i][j] = val + return F[i][j] + def knapsack(W, wt, val, n): dp = [[0 for i in range(W+1)]for j in range(n+1)] @@ -12,3 +27,16 @@ def knapsack(W, wt, val, n): dp[i][w] = dp[i-1][w] return dp[n][w] + +if name == '__main__': + ''' + Adding test case for knapsack + ''' + val = [3,2,4,4] + wt = [4,3,2,3] + n = 4 + w = 6 + F = [[0]*(w + 1)] + [[0] + [-1 for i in range(w + 1)] for j in range(n + 1)] + print(knapsack(w,wt,val,n)) + print(MF_knapsack(n,wt,val,w)) # switched the n and w + From bd7054ace9404dec5116cd858b72eb3d1cad2b16 Mon Sep 17 00:00:00 2001 From: bharath-123 Date: Mon, 23 Jul 2018 13:01:02 +0530 Subject: [PATCH 102/105] updated testcase Changed name to __name__. Sorry for the typo! --- dynamic_programming/knapsack.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dynamic_programming/knapsack.py b/dynamic_programming/knapsack.py index a0b006a58710..27d1cfed799b 100644 --- a/dynamic_programming/knapsack.py +++ b/dynamic_programming/knapsack.py @@ -28,7 +28,7 @@ def knapsack(W, wt, val, n): return dp[n][w] -if name == '__main__': +if __name__ == '__main__': ''' Adding test case for knapsack ''' From ce3e6787f4df7fa198881b1dfa80c58a5c7afbb5 Mon Sep 17 00:00:00 2001 From: HasanGokdag Date: Thu, 13 Sep 2018 13:17:36 +0200 Subject: [PATCH 103/105] merge sort average&worst case scenarios changed --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 9b394e001d66..bc31d5389dfd 100644 --- a/README.md +++ b/README.md @@ -41,8 +41,8 @@ From [Wikipedia][merge-wiki]: In computer science, merge sort (also commonly spe __Properties__ * Worst case performance O(n log n) -* Best case performance O(n) -* Average case performance O(n) +* Best case performance O(n log n) +* Average case performance O(n log n) ###### View the algorithm in [action][merge-toptal] From b62a258f8ab870ff7077a5ddde3fc9e58801c333 Mon Sep 17 00:00:00 2001 From: Anton Helm Date: Tue, 25 Sep 2018 15:12:16 +0100 Subject: [PATCH 104/105] renamed `NeutonMethod.py` to `NewtonMethod.py` --- ArithmeticAnalysis/{NeutonMethod.py => NewtonMethod.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename ArithmeticAnalysis/{NeutonMethod.py => NewtonMethod.py} (100%) diff --git a/ArithmeticAnalysis/NeutonMethod.py b/ArithmeticAnalysis/NewtonMethod.py similarity index 100% rename from ArithmeticAnalysis/NeutonMethod.py rename to ArithmeticAnalysis/NewtonMethod.py From 3a77380ed33b497648dd9beca5e9aa72615bb6e6 Mon Sep 17 00:00:00 2001 From: cclauss Date: Fri, 28 Sep 2018 06:17:28 +0200 Subject: [PATCH 105/105] Undefined name: import random in Onepad_Cipher.py (#339) --- ciphers/Onepad_Cipher.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ciphers/Onepad_Cipher.py b/ciphers/Onepad_Cipher.py index 5536285efc17..7e1be5fdc077 100644 --- a/ciphers/Onepad_Cipher.py +++ b/ciphers/Onepad_Cipher.py @@ -1,5 +1,7 @@ from __future__ import print_function +import random + class Onepad: def encrypt(self, text):