From 0cb0f3684c1f2bd01375797cdda26fe946f38815 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Wed, 5 Jul 2017 16:17:48 -0700 Subject: [PATCH 01/25] check that balance! and then do it --- .DS_Store | Bin 6148 -> 6148 bytes src/BST.py | 14 +++++++++----- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/.DS_Store b/.DS_Store index 66b24885e514fb7f1a547a3827f0fca280383d6e..e39baeee102948d53a1db96a61c965f90e599b88 100644 GIT binary patch delta 79 zcmZoMXfc=|#>CJ*u~2NHo}wr-0|Nsi1A_nqgC9dMgR5swesWUI#6opO=FJw2=h-H2 jU|h4Aor9kPsAKa&#_!CN`9%yF87ABCNNB`mu~2NHo}wrV0|Nsi1A_nqLn=e6XHI@{Qcix-WJbp2x*!=gh9rh! zh7yJ%WLcm%P&tD&5NrGg0|thTJ?Ggrvvcrs08QS^$oQRkGQWr+2hd=K1|Z(-A+m=V E0Mthvng9R* diff --git a/src/BST.py b/src/BST.py index 502cace..0c64442 100644 --- a/src/BST.py +++ b/src/BST.py @@ -149,11 +149,8 @@ def check_that_balance(self, target=None): """check the balance of your treeeee""" if self.size == 0: return 0 - if not target: - target = self.root - else: - target = self.search(target) - return self.depth_first(target.right) - self.depth_first(target.left) + if target is not None: + return self.depth_first(target.right) - self.depth_first(target.left) def find_min_depth(self, target): curr = target @@ -215,6 +212,13 @@ def deletion(self, target): max_val.left.parent = None max_val.left = None + def rotate_left(self): + self.check_that_balance() + if + def rotate_right(self): + + + if __name__ == '__main__': # pragma: no cover b = BinarySearchTree([5, 3, 7, 2, 8, 4, 9, 1]) gen = b.in_order() From dec4d8d9b03db38e91e9348a0af3a9bf3aba6e86 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Wed, 5 Jul 2017 17:34:52 -0700 Subject: [PATCH 02/25] more balance --- src/BST.py | 42 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 38 insertions(+), 4 deletions(-) diff --git a/src/BST.py b/src/BST.py index 0c64442..4bde62f 100644 --- a/src/BST.py +++ b/src/BST.py @@ -212,11 +212,45 @@ def deletion(self, target): max_val.left.parent = None max_val.left = None - def rotate_left(self): - self.check_that_balance() - if - def rotate_right(self): + def rotate_left(self, node=None): + if not node: + node = self.root + while node.left: + node = self.find_max_depth(node.left) + if node > node.parent: + node.left = node.parent.parent + node.parent = node.left.parent + node.right = node.left.right + node.right.parent = node + node.left.parent = node + node.parent.right = node + else: + node.right = self.root + node.left = self.root.left + self.root.left = None + self.root = node + self.root.parent.right = None + self.root.parent = None + def rotate_right(self, node=None): + if not node: + node = self.root + while node.right: + node = self.find_min_depth(node.right) + if node > node.parent: + node.right = node.parent.parent + node.parent = node.right.parent + node.left = node.right.left + node.left.parent = node + node.right.parent = node + node.parent.left = node + else: + node.left = self.root + node.right = self.root.right + self.root.right = None + self.root = node + self.root.parent.left = None + self.root.parent = None if __name__ == '__main__': # pragma: no cover From 9c3cff4537790b589ff7294297de8a37b88b444f Mon Sep 17 00:00:00 2001 From: Woojgh Date: Wed, 5 Jul 2017 17:53:24 -0700 Subject: [PATCH 03/25] more balance --- src/BST.py | 47 +++++++++++++++++++++++++++++++++++------------ 1 file changed, 35 insertions(+), 12 deletions(-) diff --git a/src/BST.py b/src/BST.py index 4bde62f..a7a7956 100644 --- a/src/BST.py +++ b/src/BST.py @@ -212,9 +212,24 @@ def deletion(self, target): max_val.left.parent = None max_val.left = None + def balance_that_thang(self, node): + if not node: + node = self.root + if self.size % 2 == 0: + while self.check_that_balance() > 1: + self.rotate_right() + while self.check_that_balance() < -1: + self.rotate_left() + else: + while self.check_that_balance() > 0: + self.rotate_right() + while self.check_that_balance() < 0: + self.rotate_left() + def rotate_left(self, node=None): if not node: node = self.root + origin = node while node.left: node = self.find_max_depth(node.left) if node > node.parent: @@ -225,16 +240,17 @@ def rotate_left(self, node=None): node.left.parent = node node.parent.right = node else: - node.right = self.root - node.left = self.root.left - self.root.left = None - self.root = node - self.root.parent.right = None - self.root.parent = None + node.right = origin + node.left = origin.left + origin.left = None + origin = node + origin.parent.right = None + origin.parent = None def rotate_right(self, node=None): if not node: node = self.root + origin = node while node.right: node = self.find_min_depth(node.right) if node > node.parent: @@ -245,12 +261,19 @@ def rotate_right(self, node=None): node.right.parent = node node.parent.left = node else: - node.left = self.root - node.right = self.root.right - self.root.right = None - self.root = node - self.root.parent.left = None - self.root.parent = None + node.left = origin + node.right = origin.right + origin.right = None + origin = node + origin.parent.left = None + origin.parent = None + + def balance_manager(self, node=None): + if not node: + node = self.root + gen = self.breadth_first() + for i in [i for i in gen]: + self.balance_that_thang(i) if __name__ == '__main__': # pragma: no cover From 9f51d8065f3b8ade9080642f311dfdab4b17c12a Mon Sep 17 00:00:00 2001 From: Woojgh Date: Wed, 5 Jul 2017 18:32:36 -0700 Subject: [PATCH 04/25] balance things --- src/BST.py | 86 +++++++++++++++++++++++++++++++----------------------- 1 file changed, 50 insertions(+), 36 deletions(-) diff --git a/src/BST.py b/src/BST.py index a7a7956..4344f4f 100644 --- a/src/BST.py +++ b/src/BST.py @@ -212,63 +212,77 @@ def deletion(self, target): max_val.left.parent = None max_val.left = None - def balance_that_thang(self, node): - if not node: + def balance_that_thang(self, node=None): + import pdb; pdb.set_trace() + if node is None: node = self.root if self.size % 2 == 0: - while self.check_that_balance() > 1: + while self.check_that_balance(node) > 1: self.rotate_right() - while self.check_that_balance() < -1: + while self.check_that_balance(node) < -1: self.rotate_left() else: - while self.check_that_balance() > 0: + while self.check_that_balance(node) > 0: self.rotate_right() - while self.check_that_balance() < 0: + while self.check_that_balance(node) < 0: self.rotate_left() def rotate_left(self, node=None): if not node: node = self.root origin = node - while node.left: - node = self.find_max_depth(node.left) - if node > node.parent: - node.left = node.parent.parent - node.parent = node.left.parent - node.right = node.left.right - node.right.parent = node - node.left.parent = node - node.parent.right = node - else: + node = self.find_max_depth(node.left) + if node.val > node.parent.val: + if node.parent.parent is None: node.right = origin - node.left = origin.left - origin.left = None - origin = node - origin.parent.right = None - origin.parent = None + node.right.parent = node + node.right.left = None + node.parent = None + node = self.root + return + node.left = node.parent.parent + node.parent = node.left.parent + node.right = node.left.right + node.right.parent = node + node.left.parent = node + node.parent.right = node + else: + node.right = origin + node.left = origin.left + origin.left = None + origin = node + origin.parent.right = None + origin.parent = None def rotate_right(self, node=None): if not node: node = self.root origin = node - while node.right: - node = self.find_min_depth(node.right) - if node > node.parent: - node.right = node.parent.parent - node.parent = node.right.parent - node.left = node.right.left - node.left.parent = node - node.right.parent = node - node.parent.left = node - else: + node = self.find_min_depth(node.right) + if node.val > node.parent.val: + if node.parent.parent is None: node.left = origin - node.right = origin.right - origin.right = None - origin = node - origin.parent.left = None - origin.parent = None + node.left.parent = node + node.left.right = None + node.parent = None + node = self.root + return + node.right = node.parent.parent + node.parent = node.right.parent + node.left = node.right.left + node.left.parent = node + node.right.parent = node + node.parent.left = node + else: + node.left = origin + node.right = origin.right + origin.right = None + origin = node + origin.parent.left = None + origin.parent = None def balance_manager(self, node=None): + import pdb; pdb.set_trace() if not node: node = self.root gen = self.breadth_first() From 88135ad89ac777f6dacf972f71814b4202bacb44 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Wed, 5 Jul 2017 22:18:01 -0700 Subject: [PATCH 05/25] push --- src/BST.py | 49 ++++++++++++++++++++++++++----------------------- 1 file changed, 26 insertions(+), 23 deletions(-) diff --git a/src/BST.py b/src/BST.py index 4344f4f..621cf44 100644 --- a/src/BST.py +++ b/src/BST.py @@ -153,16 +153,18 @@ def check_that_balance(self, target=None): return self.depth_first(target.right) - self.depth_first(target.left) def find_min_depth(self, target): - curr = target - while curr.left is not None: - curr = curr.left - return curr + if target.left is None: + return target + if target.left is not None: + target = target.left + return target def find_max_depth(self, target): - curr = target - while curr.right is not None: - curr = curr.right - return curr + if target.right is None: + return target + if target.right is not None: + target = target.right + return target def deletion(self, target): """nope""" @@ -212,26 +214,26 @@ def deletion(self, target): max_val.left.parent = None max_val.left = None - def balance_that_thang(self, node=None): - import pdb; pdb.set_trace() + def balance_manager(self, node=None): + # import pdb; pdb.set_trace() if node is None: node = self.root if self.size % 2 == 0: - while self.check_that_balance(node) > 1: + if self.check_that_balance(node) > 1: self.rotate_right() - while self.check_that_balance(node) < -1: + if self.check_that_balance(node) < -1: self.rotate_left() else: - while self.check_that_balance(node) > 0: + if self.check_that_balance(node) > 0: self.rotate_right() - while self.check_that_balance(node) < 0: + if self.check_that_balance(node) < 0: self.rotate_left() def rotate_left(self, node=None): - if not node: + if node is None: node = self.root origin = node - node = self.find_max_depth(node.left) + node = self.find_max_depth(origin.left) if node.val > node.parent.val: if node.parent.parent is None: node.right = origin @@ -244,7 +246,7 @@ def rotate_left(self, node=None): node.parent = node.left.parent node.right = node.left.right node.right.parent = node - node.left.parent = node + node.left.parent = node.left node.parent.right = node else: node.right = origin @@ -255,10 +257,11 @@ def rotate_left(self, node=None): origin.parent = None def rotate_right(self, node=None): - if not node: + # import pdb; pdb.set_trace() + if node is None: node = self.root origin = node - node = self.find_min_depth(node.right) + node = self.find_min_depth(origin.right) if node.val > node.parent.val: if node.parent.parent is None: node.left = origin @@ -271,7 +274,7 @@ def rotate_right(self, node=None): node.parent = node.right.parent node.left = node.right.left node.left.parent = node - node.right.parent = node + node.right.parent = node.right node.parent.left = node else: node.left = origin @@ -281,13 +284,13 @@ def rotate_right(self, node=None): origin.parent.left = None origin.parent = None - def balance_manager(self, node=None): - import pdb; pdb.set_trace() + def balance_that_thang(self, node=None): + # import pdb; pdb.set_trace() if not node: node = self.root gen = self.breadth_first() for i in [i for i in gen]: - self.balance_that_thang(i) + self.balance_manager(i) if __name__ == '__main__': # pragma: no cover From ed4661c9c7f2d9ce3e64070f16a2689620bebbe6 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Wed, 5 Jul 2017 22:50:36 -0700 Subject: [PATCH 06/25] ugh --- src/BST.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/BST.py b/src/BST.py index 621cf44..0e9d0b8 100644 --- a/src/BST.py +++ b/src/BST.py @@ -44,6 +44,7 @@ def insert(self, entry): curr.right = Node(entry) self.size += 1 curr.right.parent = curr + self.balance_manager(curr) elif entry < curr.val: if curr.left: curr = curr.left @@ -51,6 +52,7 @@ def insert(self, entry): else: curr.left = Node(entry) self.size += 1 + self.balance_manager(curr) curr.left.parent = curr else: return @@ -284,13 +286,13 @@ def rotate_right(self, node=None): origin.parent.left = None origin.parent = None - def balance_that_thang(self, node=None): - # import pdb; pdb.set_trace() - if not node: - node = self.root - gen = self.breadth_first() - for i in [i for i in gen]: - self.balance_manager(i) + # def balance_that_thang(self, node=None): + # # import pdb; pdb.set_trace() + # if not node: + # node = self.root + # gen = self.breadth_first() + # for i in [i for i in gen]: + # self.balance_manager(i) if __name__ == '__main__': # pragma: no cover From 3b0ae87a5744fb73084e72796e23c238efb58df0 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Fri, 7 Jul 2017 16:56:36 -0700 Subject: [PATCH 07/25] adding trie stuff --- src/.DS_Store | Bin 6148 -> 6148 bytes src/bag_o_words.txt | 150 ++++++++++++++++++++++++++++++++++++++++++++ src/test_trie.py | 0 src/trie.py | 38 +++++++++++ 4 files changed, 188 insertions(+) create mode 100644 src/bag_o_words.txt create mode 100644 src/test_trie.py create mode 100644 src/trie.py diff --git a/src/.DS_Store b/src/.DS_Store index 38734ca2de71d90578b12a191d5ff30a57f26d5c..a1d6b9e6785359e9122af98ade7af9548b39a034 100644 GIT binary patch delta 313 zcmZoMXfc=|#>B)qu~2NHo+2aL!~pA!2O1cGj2sIs;%I8QfhMK`O)df21J~t+p{*578#_=#5kn?WD>h3$BUEqPc#UN&bVgm~RUUO8v delta 76 zcmZoMXfc=|#>CJzu~2NHo+2aT!~knX#>qTPQj=qtcs83dUt-zpz}(EVnVo~51E_4X eA@g_U$^0U^oQw<%3 Date: Sat, 8 Jul 2017 14:28:30 -0700 Subject: [PATCH 08/25] adding more trie --- .DS_Store | Bin 6148 -> 6148 bytes bag_o_words.txt | 150 ++++++++++++++++++++++++++++++++++++++++++++++++ src/trie.py | 17 +++--- 3 files changed, 160 insertions(+), 7 deletions(-) create mode 100644 bag_o_words.txt diff --git a/.DS_Store b/.DS_Store index e39baeee102948d53a1db96a61c965f90e599b88..486420a8c7bed0960ac182c0f9c5048d8c63c1bd 100644 GIT binary patch delta 441 zcmZoMXfc=|#>B)qu~2NHo+2a1!~pBf0*noeKvs`oFegJ0gDZn0gA0Q%kk(_!Wk~VN z$xlwo$xmWnU=UznU~C1_8vnrn$YNmNU?^rtWhh}NWheluFJP!dQ~!D5I-B~W^5O!h z8OM_fax#lc3=FO_GBLBTvaxe;a&mC;a>NE_^vFd6= zQym3EgIXPhYIAb~9R(9(v)Wn?4slgOThD~t%Bt#`+Pdjr-!U*ULTCnlC=H`#One|_ z&kXc@5kqoWa8X`PeqK6I4y2qN7##Tw6~N%gWXNO4L=6xIYoLl{kO17w$SBORnVo~5 e0~jGd&Ufa?{33<|ATt_(7)XO{-y9&ag&6?M^K*9q delta 72 zcmZoMXfc=|#>CJ*u~2NHo+2aj!~knX=E*!vhLh(r=}unB%(Gd9Lzrc=0Lwq7&Fmcf c96+U;8CkwFPv#dfWMr6Z!y~;pMq~vu0J@(Np8x;= diff --git a/bag_o_words.txt b/bag_o_words.txt new file mode 100644 index 0000000..23e6ccd --- /dev/null +++ b/bag_o_words.txt @@ -0,0 +1,150 @@ +the +of +and +to +a +in +that +is +was +he +for +it +with +as +his +on +be +at +by +i +this +had +not +are +but +from +or +have +an +they +which +one +you +were +her +all +she +there +would +their +we +him +been +has +when +who +will +more +no +if +out +so +said +what +up +its +about +into +than +them +can +only +other +new +some +could +time +these +two +may +then +do +first +any +my +now +such +like +our +over +man +me +even +most +made +after +also +did +many +before +must +through +back +years +where +much +your +way +well +down +should +because +each +just +those +people +mr +how +too +little +state +good +very +make +world +still +own +see +men +work +long +get +here +between +both +life +being +under +never +day +same +another +know +while +last +might +us +great +old +year +off +come +since +against +go +came +right +used +take +three diff --git a/src/trie.py b/src/trie.py index 9ca01e9..bc971c0 100644 --- a/src/trie.py +++ b/src/trie.py @@ -1,27 +1,30 @@ +end = '$' + + class TrieTree(object): - def __init__(self, iterable=None): + def __init__(self): # import pdb; pdb.set_trace() """This will sety what wwe will be iterating through.""" self.size = 0 + self.letters = 0 self.roots = [] - _end = '$' def make_tree(self, *words): root = dict() for word in words: + self.size + 1 current_word = root for letter in word: + self.letters + 1 current_word = current_word.setdefault(letter, {}) - current_word[_end] = _end + current_word[end] = end return root def insert(self, word): word_root = word[0] if word_root not in self.roots: self.roots.append(word_root) - else: - def search(self, word): """.""" @@ -30,9 +33,9 @@ def search(self, word): if letter in current_word_dict: current_word_dict = current_word_dict[letter] else: - reutnr False + return False else: - if _end in current_word_dict: + if end in current_word_dict: return True else: return False From a3af6758e5814de95a798cabe0da98a139526190 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Sat, 8 Jul 2017 21:30:07 -0700 Subject: [PATCH 09/25] adding more trie stuff --- src/trie.py | 82 ++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 68 insertions(+), 14 deletions(-) diff --git a/src/trie.py b/src/trie.py index bc971c0..6e023b4 100644 --- a/src/trie.py +++ b/src/trie.py @@ -7,24 +7,78 @@ def __init__(self): # import pdb; pdb.set_trace() """This will sety what wwe will be iterating through.""" self.size = 0 - self.letters = 0 - self.roots = [] + self.letter_count = 0 + self.root_set = [] + self.letter_sets = [] def make_tree(self, *words): - root = dict() + # new_dict = dict() for word in words: - self.size + 1 - current_word = root - for letter in word: - self.letters + 1 - current_word = current_word.setdefault(letter, {}) - current_word[end] = end - return root + current_letter_set = [] + self.size = self.size + 1 + # word_dict = new_dict + if self.letter_sets == []: + self.letter_sets = [word] + self.root_set = self.letter_sets + return self.letter_sets + break + else: + letter_check = '' + for letter in word: + self.letter_count = self.letter_count + 1 + letter_check = letter_check + letter + for lset in self.letter_sets: + if letter_check in lset: + good_group = letter_check + continue + else: + import pdb; pdb.set_trace() + current_letter_set = good_group + new_letter_set = [] + old_letter_set = [] + [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] + new_group_set = ''.join(new_letter_set) + [old_letter_set.append(old) for old in self.letter_sets[0] if old not in good_group] + old_group_set = ''.join(old_letter_set) + self.letter_sets = [current_letter_set] + self.letter_sets.append(old_group_set) + self.letter_sets.append(new_group_set) + return self.letter_sets + + # word_dict = word_dict.setdefault(letter, {}) + # word_dict[end] = end + # self.root_dict.append(new_dict) - def insert(self, word): - word_root = word[0] - if word_root not in self.roots: - self.roots.append(word_root) + def insert(self, words): + for word in words: + current_letter_set = [] + self.size = self.size + 1 + letter_check = '' + for letter in word: + self.letter_count = self.letter_count + 1 + letter_check = letter_check + letter + for lset in self.letter_sets: + if letter_check in lset: + good_group = letter_check + elif good_group == lset: + new_letter_set = [] + [new_letter_set.append(letter) for letter in word if letter not in good_group] + new_group_set = ''.join(new_letter_set) + self.letter_sets.append() + continue + else: + import pdb; pdb.set_trace() + current_letter_set = good_group + new_letter_set = [] + old_letter_set = [] + [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] + new_group_set = ''.join(new_letter_set) + [old_letter_set.append(old) for old in self.letter_sets[0] if old not in good_group] + old_group_set = ''.join(old_letter_set) + self.letter_sets = [current_letter_set] + self.letter_sets.append(old_group_set) + self.letter_sets.append(new_group_set) + return self.letter_sets def search(self, word): """.""" From b082458d0a82c09e548774e25a32c48c43a26e25 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Sun, 9 Jul 2017 20:29:34 -0700 Subject: [PATCH 10/25] got tree doing tree --- src/simple_trie.py | 89 +++++++++++++++++++++++++++++ src/trie.py | 136 ++++++++++++++++++++++++--------------------- 2 files changed, 162 insertions(+), 63 deletions(-) create mode 100644 src/simple_trie.py diff --git a/src/simple_trie.py b/src/simple_trie.py new file mode 100644 index 0000000..0cd2d24 --- /dev/null +++ b/src/simple_trie.py @@ -0,0 +1,89 @@ +test_list = ['mon', 'ta', 'read'] + + +def compare(input_word, index=0, word_set=test_list): + #if check_if_word_in_set(input_word, word_set): + #return test_list + while True: + temp_list = list(filter(lambda x: input_word[0:index] == x[0:index], word_set)) + if temp_list: + new_list = [] + for letter in input_word: + new_list.append(letter) + if new_list == temp_list: + [new_list.append(letter) for letter in input_word if letter not in temp_list] + index += 1 + import pdb; pdb.set_trace() + if index > len(input_word): + word_set.remove(temp_list[0]) + word_set.append(input_word) + word_set.append(temp_list[0][index-1:]) + return word_set + else: + word_set.append(input_word) + return word_set + +_end = '$' + + +def make_trie(*words): + root = dict() + for word in words: + current_dict = root + for letter in word: + current_dict = current_dict.setdefault(letter, {}) + current_dict[_end] = _end + import pdb; pdb.set_trace() + return root + +# test_list = ['mon', 'ta', 'read'] + + +# class Node(object): +# def __init__(self, entry, root=None, child=None, parent=None): +# """Node for tree.""" +# self.val = entry +# self.root = root +# self.child = child +# self.parent = parent + + +# class TrieTree(object): + +# def __init__(self, Node=None, iterable=None): +# self.node = Node +# self.itertable = iterable + +# def compare(self, input_word, index=0, word_set=test_list): +# if self.check_if_word_in_set(input_word, word_set): +# return test_list +# while True: +# temp_list = list(filter(lambda x: input_word[0:index] == x[0:index], word_set)) +# if temp_list: +# index += 1 +# if index > len(input_word): +# word_set.remove(temp_list[0]) +# word_set.append(input_word) +# word_set.append(temp_list[0][index-1:]) +# return word_set +# else: +# word_set.append(input_word) +# return word_set + +# def check_if_word_in_set(self, input_word, word_set=test_list): +# if input_word in self.concat_words_in_set(word_set): +# return True +# return False + +# def concat_words_in_set(self, word_set): +# """Will create a list of concatenated words based on the current set of words.""" +# concat_words = [] +# for word in word_set: +# if word.parent: +# temp_word = word.parent + word +# while word.parent: +# temp_word = word.parent + temp_word +# concat_words.append(temp_word) +# else: +# concat_words.append(word) +# return concat_words diff --git a/src/trie.py b/src/trie.py index 6e023b4..9663553 100644 --- a/src/trie.py +++ b/src/trie.py @@ -7,7 +7,6 @@ def __init__(self): # import pdb; pdb.set_trace() """This will sety what wwe will be iterating through.""" self.size = 0 - self.letter_count = 0 self.root_set = [] self.letter_sets = [] @@ -18,78 +17,89 @@ def make_tree(self, *words): self.size = self.size + 1 # word_dict = new_dict if self.letter_sets == []: - self.letter_sets = [word] - self.root_set = self.letter_sets + self.letter_sets.append(word) + self.root_set = self.letter_sets[0] return self.letter_sets break else: + import pdb; pdb.set_trace() letter_check = '' - for letter in word: - self.letter_count = self.letter_count + 1 - letter_check = letter_check + letter - for lset in self.letter_sets: - if letter_check in lset: - good_group = letter_check + for curr_set in self.letter_sets: + for letter in word: + letter_check = letter_check + letter + if letter_check in curr_set: continue - else: - import pdb; pdb.set_trace() - current_letter_set = good_group + elif : + current_letter_set = letter_check[:-1] new_letter_set = [] old_letter_set = [] [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] new_group_set = ''.join(new_letter_set) - [old_letter_set.append(old) for old in self.letter_sets[0] if old not in good_group] + [old_letter_set.append(old) for old in self.letter_sets[0] if old not in current_letter_set] old_group_set = ''.join(old_letter_set) - self.letter_sets = [current_letter_set] - self.letter_sets.append(old_group_set) - self.letter_sets.append(new_group_set) + if current_letter_set in self.letter_sets and current_letter_set != '': + if current_letter_set == curr_set: + tmp = [] + [tmp.append(letter) for letter in word if letter not in current_letter_set] + tmp = ''.join(tmp) + self.letter_sets.append(tmp) + else: + self.letter_sets.append(current_letter_set) + if new_group_set or old_group_set != '': + if self.root_set in self.letter_sets: + self.letter_sets.remove(self.root_set) + self.root_set = self.letter_sets + if old_group_set not in self.letter_sets: + self.letter_sets.append(old_group_set) + if new_group_set not in self.letter_sets: + self.letter_sets.append(new_group_set) + if '' in self.letter_sets: + self.letter_sets.remove('') return self.letter_sets - # word_dict = word_dict.setdefault(letter, {}) - # word_dict[end] = end - # self.root_dict.append(new_dict) + # def insert(self, word): + # for word in words: + # current_letter_set = [] + # self.size = self.size + 1 + # # word_dict = new_dict + # if self.letter_sets == []: + # self.letter_sets = [word] + # self.root_set = self.letter_sets + # return self.letter_sets + # break + # else: + # letter_check = '' + # for letter in word: + # self.letters = self.letters + 1 + # letter_check = letter_check + letter + # for lset in self.letter_sets: + # if letter_check in lset: + # good_group = letter_check + # continue + # else: + # import pdb; pdb.set_trace() + # current_letter_set = good_group + # new_letter_set = [] + # old_letter_set = [] + # [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] + # new_group_set = ''.join(new_letter_set) + # [old_letter_set.append(old) for old in self.letter_sets[0] if old not in good_group] + # old_group_set = ''.join(old_letter_set) + # self.letter_sets = [current_letter_set] + # self.letter_sets.append(old_group_set) + # self.letter_sets.append(new_group_set) + # return self.letter_sets - def insert(self, words): - for word in words: - current_letter_set = [] - self.size = self.size + 1 - letter_check = '' - for letter in word: - self.letter_count = self.letter_count + 1 - letter_check = letter_check + letter - for lset in self.letter_sets: - if letter_check in lset: - good_group = letter_check - elif good_group == lset: - new_letter_set = [] - [new_letter_set.append(letter) for letter in word if letter not in good_group] - new_group_set = ''.join(new_letter_set) - self.letter_sets.append() - continue - else: - import pdb; pdb.set_trace() - current_letter_set = good_group - new_letter_set = [] - old_letter_set = [] - [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] - new_group_set = ''.join(new_letter_set) - [old_letter_set.append(old) for old in self.letter_sets[0] if old not in good_group] - old_group_set = ''.join(old_letter_set) - self.letter_sets = [current_letter_set] - self.letter_sets.append(old_group_set) - self.letter_sets.append(new_group_set) - return self.letter_sets - - def search(self, word): - """.""" - current_word_dict = self - for letter in word: - if letter in current_word_dict: - current_word_dict = current_word_dict[letter] - else: - return False - else: - if end in current_word_dict: - return True - else: - return False + # def search(self, word): + # """.""" + # current_word_dict = self + # for letter in word: + # if letter in current_word_dict: + # current_word_dict = current_word_dict[letter] + # else: + # return False + # else: + # if end in current_word_dict: + # return True + # else: + # return False From c68f80fc0806e804b6cadf601313ae51d33c2285 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Sun, 9 Jul 2017 22:04:10 -0700 Subject: [PATCH 11/25] starting hashingtons --- bag_o_words.txt | 150 ----------------------------------------------- requirements.txt | 22 +++++++ setup.py | 2 +- src/hash.py | 23 ++++++++ src/test_trie.py | 18 ++++++ src/trie.py | 2 +- tox.ini | 2 +- 7 files changed, 66 insertions(+), 153 deletions(-) delete mode 100644 bag_o_words.txt create mode 100644 requirements.txt create mode 100644 src/hash.py diff --git a/bag_o_words.txt b/bag_o_words.txt deleted file mode 100644 index 23e6ccd..0000000 --- a/bag_o_words.txt +++ /dev/null @@ -1,150 +0,0 @@ -the -of -and -to -a -in -that -is -was -he -for -it -with -as -his -on -be -at -by -i -this -had -not -are -but -from -or -have -an -they -which -one -you -were -her -all -she -there -would -their -we -him -been -has -when -who -will -more -no -if -out -so -said -what -up -its -about -into -than -them -can -only -other -new -some -could -time -these -two -may -then -do -first -any -my -now -such -like -our -over -man -me -even -most -made -after -also -did -many -before -must -through -back -years -where -much -your -way -well -down -should -because -each -just -those -people -mr -how -too -little -state -good -very -make -world -still -own -see -men -work -long -get -here -between -both -life -being -under -never -day -same -another -know -while -last -might -us -great -old -year -off -come -since -against -go -came -right -used -take -three diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..a67df26 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,22 @@ +appnope==0.1.0 +coverage==4.4.1 +-e git+https://github.com/Woojgh/data-structure.git@b082458d0a82c09e548774e25a32c48c43a26e25#egg=data_structures +decorator==4.0.11 +ipython==6.1.0 +ipython-genutils==0.2.0 +jedi==0.10.2 +pexpect==4.2.1 +pickleshare==0.7.4 +pluggy==0.4.0 +prompt-toolkit==1.0.14 +ptyprocess==0.5.2 +py==1.4.34 +Pygments==2.2.0 +pytest==3.1.3 +pytest-cov==2.5.1 +simplegeneric==0.8.1 +six==1.10.0 +tox==2.7.0 +traitlets==4.3.2 +virtualenv==15.1.0 +wcwidth==0.1.7 diff --git a/setup.py b/setup.py index 30846ee..e1bfe71 100644 --- a/setup.py +++ b/setup.py @@ -1,7 +1,7 @@ from setuptools import setup extra_packages = { - 'testing': ['ipython', 'pytest', 'pytest-cov', 'tox'] + 'testing': ['ipython', 'pytest', 'tox'] } setup( diff --git a/src/hash.py b/src/hash.py new file mode 100644 index 0000000..36b3061 --- /dev/null +++ b/src/hash.py @@ -0,0 +1,23 @@ +class HashTable: + + def __init__(self): + self.size = 753 + self.slots = [None] * self.size + self.data = [None] * self.size + + def hashingtons(self, key, size): + return key % size + + def hashemagain(self, oldcountrystylehash, size): + return (oldcountrystylehash+1) % size + + def set(self, key, val): + hash_val = self.hashingtons(key, len(self.slots)) + + def get(self, key): + startingslot = self.hashingtons(key, len(self.slots)) + + val = None + stop = False + start = False + position = startingslot diff --git a/src/test_trie.py b/src/test_trie.py index e69de29..3c84f1f 100644 --- a/src/test_trie.py +++ b/src/test_trie.py @@ -0,0 +1,18 @@ +import pytest +from trie import TrieTree + +@pytest.fixture +def trie(): + tree = TrieTree() + return tree + + +def test_tree_empty(): + t = trie() + assert t.size == 0 + + +def test_tree_insert(): + t = trie() + t.insert('monkey') + assert t.letter_sets == ['monkey'] diff --git a/src/trie.py b/src/trie.py index 9663553..f834e2e 100644 --- a/src/trie.py +++ b/src/trie.py @@ -10,7 +10,7 @@ def __init__(self): self.root_set = [] self.letter_sets = [] - def make_tree(self, *words): + def insert(self, *words): # new_dict = dict() for word in words: current_letter_set = [] diff --git a/tox.ini b/tox.ini index 36db6d0..c17d845 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,5 @@ [tox] -envlist = py27, py36 +envlist = py27 py36 [testenv] commands = py.test src --cov=src --cov-report term-missing From 03a071d8d9b50f252a7a1cb319420c7968818c8b Mon Sep 17 00:00:00 2001 From: Woojgh Date: Mon, 10 Jul 2017 10:49:08 -0700 Subject: [PATCH 12/25] got trie working --- src/trie.py | 124 ++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 90 insertions(+), 34 deletions(-) diff --git a/src/trie.py b/src/trie.py index f834e2e..0a1a07b 100644 --- a/src/trie.py +++ b/src/trie.py @@ -4,18 +4,15 @@ class TrieTree(object): def __init__(self): - # import pdb; pdb.set_trace() - """This will sety what wwe will be iterating through.""" + """This will implement our Trie tree funciton.""" self.size = 0 self.root_set = [] self.letter_sets = [] def insert(self, *words): - # new_dict = dict() for word in words: current_letter_set = [] self.size = self.size + 1 - # word_dict = new_dict if self.letter_sets == []: self.letter_sets.append(word) self.root_set = self.letter_sets[0] @@ -25,38 +22,97 @@ def insert(self, *words): import pdb; pdb.set_trace() letter_check = '' for curr_set in self.letter_sets: - for letter in word: - letter_check = letter_check + letter - if letter_check in curr_set: - continue - elif : - current_letter_set = letter_check[:-1] - new_letter_set = [] - old_letter_set = [] - [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] - new_group_set = ''.join(new_letter_set) - [old_letter_set.append(old) for old in self.letter_sets[0] if old not in current_letter_set] - old_group_set = ''.join(old_letter_set) - if current_letter_set in self.letter_sets and current_letter_set != '': - if current_letter_set == curr_set: - tmp = [] - [tmp.append(letter) for letter in word if letter not in current_letter_set] - tmp = ''.join(tmp) - self.letter_sets.append(tmp) + if type(curr_set) == dict: + for item in curr_set.keys(): + if type(item) == str: + for letter in word: + letter_check = letter_check + letter + if letter_check == item: + new_level = list(curr_set.values()) + current_letter_set = letter_check + new_letter_set = [] + old_letter_set = [] + [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] + new_group_set = ''.join(new_letter_set) + [old_letter_set.append(old) for old in self.letter_sets[0] if old not in current_letter_set] + old_group_set = ''.join(old_letter_set) + if current_letter_set != '': + if current_letter_set == item: + tmp = [] + [tmp.append(letter) for letter in word if letter not in current_letter_set] + tmp = ''.join(tmp) + for item in curr_set.values(): + if tmp == item: + continue + else: + new_level[0].append(tmp) + # self.letter_sets.append(tmp) + + else: + # self.letter_sets.append(current_letter_set) + if new_group_set or old_group_set != '': + if self.root_set in self.letter_sets: + self.letter_sets.remove(self.root_set) + self.root_set = self.letter_sets + if old_group_set not in self.letter_sets: + new_level.append(old_group_set) + # self.letter_sets.append(old_group_set) + if new_group_set not in self.letter_sets: + new_level.append(new_group_set) + # self.letter_sets.append(new_group_set) + if '' in self.letter_sets: + self.letter_sets.remove('') + # self.letter_sets.append({current_letter_set: new_level}) + return self.letter_sets + break + + else: + if letter_check in item: + continue + else: + for letter in word: + letter_check = letter_check + letter + if letter_check in curr_set: + continue else: - self.letter_sets.append(current_letter_set) - if new_group_set or old_group_set != '': - if self.root_set in self.letter_sets: - self.letter_sets.remove(self.root_set) - self.root_set = self.letter_sets - if old_group_set not in self.letter_sets: - self.letter_sets.append(old_group_set) - if new_group_set not in self.letter_sets: - self.letter_sets.append(new_group_set) - if '' in self.letter_sets: - self.letter_sets.remove('') - return self.letter_sets + new_level = [] + current_letter_set = letter_check[:-1] + new_letter_set = [] + old_letter_set = [] + [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] + new_group_set = ''.join(new_letter_set) + [old_letter_set.append(old) for old in self.letter_sets[0] if old not in current_letter_set] + old_group_set = ''.join(old_letter_set) + if current_letter_set in self.letter_sets and current_letter_set != '': + if current_letter_set == curr_set: + tmp = [] + [tmp.append(letter) for letter in word if letter not in current_letter_set] + tmp = ''.join(tmp) + new_level.append([tmp]) + # self.letter_sets.append(tmp) + + # else: + # self.letter_sets.append(current_letter_set) + if new_group_set or old_group_set != '': + if self.root_set in self.letter_sets: + self.letter_sets.remove(self.root_set) + self.root_set = self.letter_sets + if old_group_set not in self.letter_sets: + new_level.append(old_group_set) + # self.letter_sets.append(old_group_set) + if new_group_set not in self.letter_sets: + new_level.append(new_group_set) + # self.letter_sets.append(new_group_set) + if '' in self.letter_sets: + self.letter_sets.remove('') + self.letter_sets.append({current_letter_set: new_level}) + return self.letter_sets + def print_tree(self): + count = 0 + for item in self.letter_sets: + count += 1 + return 'Set ' + str(count) + ' ' + str(item) # def insert(self, word): # for word in words: # current_letter_set = [] From 0b735fb37c494348d0b6825fa52e92f5a3f36182 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Mon, 10 Jul 2017 11:19:40 -0700 Subject: [PATCH 13/25] adding more trier --- src/trie.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/trie.py b/src/trie.py index 0a1a07b..c13e4c7 100644 --- a/src/trie.py +++ b/src/trie.py @@ -18,6 +18,7 @@ def insert(self, *words): self.root_set = self.letter_sets[0] return self.letter_sets break + else: import pdb; pdb.set_trace() letter_check = '' @@ -25,6 +26,9 @@ def insert(self, *words): if type(curr_set) == dict: for item in curr_set.keys(): if type(item) == str: + if word[0] not in item: + self.letter_sets.append({word: word}) + return self.letter_sets for letter in word: letter_check = letter_check + letter if letter_check == item: From 718ad46685e6ff25b817c393d02a01284af0b3a1 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Mon, 10 Jul 2017 14:57:48 -0700 Subject: [PATCH 14/25] trie working better --- src/trie.py | 101 ++++++++++++++++++++++++++++------------------------ 1 file changed, 55 insertions(+), 46 deletions(-) diff --git a/src/trie.py b/src/trie.py index c13e4c7..86ed367 100644 --- a/src/trie.py +++ b/src/trie.py @@ -21,17 +21,23 @@ def insert(self, *words): else: import pdb; pdb.set_trace() + dict_check = [] + for i in self.letter_sets: + dict_check.append(i) + list_check = [] letter_check = '' for curr_set in self.letter_sets: + if type(curr_set) == str: + list_check = curr_set if type(curr_set) == dict: - for item in curr_set.keys(): + for item in list(curr_set.keys()): if type(item) == str: - if word[0] not in item: - self.letter_sets.append({word: word}) - return self.letter_sets + list_check.append(item) + for thing in list_check: + if word[0] in thing: for letter in word: letter_check = letter_check + letter - if letter_check == item: + if letter_check == thing: new_level = list(curr_set.values()) current_letter_set = letter_check new_letter_set = [] @@ -45,11 +51,10 @@ def insert(self, *words): tmp = [] [tmp.append(letter) for letter in word if letter not in current_letter_set] tmp = ''.join(tmp) - for item in curr_set.values(): - if tmp == item: - continue - else: - new_level[0].append(tmp) + if tmp == item: + continue + else: + new_level[0].append(tmp) # self.letter_sets.append(tmp) else: @@ -73,45 +78,49 @@ def insert(self, *words): else: if letter_check in item: continue - else: - for letter in word: - letter_check = letter_check + letter - if letter_check in curr_set: - continue else: - new_level = [] - current_letter_set = letter_check[:-1] - new_letter_set = [] - old_letter_set = [] - [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] - new_group_set = ''.join(new_letter_set) - [old_letter_set.append(old) for old in self.letter_sets[0] if old not in current_letter_set] - old_group_set = ''.join(old_letter_set) - if current_letter_set in self.letter_sets and current_letter_set != '': - if current_letter_set == curr_set: - tmp = [] - [tmp.append(letter) for letter in word if letter not in current_letter_set] - tmp = ''.join(tmp) - new_level.append([tmp]) - # self.letter_sets.append(tmp) - - # else: - # self.letter_sets.append(current_letter_set) - if new_group_set or old_group_set != '': - if self.root_set in self.letter_sets: - self.letter_sets.remove(self.root_set) - self.root_set = self.letter_sets - if old_group_set not in self.letter_sets: - new_level.append(old_group_set) - # self.letter_sets.append(old_group_set) - if new_group_set not in self.letter_sets: - new_level.append(new_group_set) - # self.letter_sets.append(new_group_set) - if '' in self.letter_sets: - self.letter_sets.remove('') - self.letter_sets.append({current_letter_set: new_level}) + self.letter_sets.append({word: ''}) return self.letter_sets + else: + for letter in word: + letter_check = letter_check + letter + if letter_check in curr_set: + continue + else: + new_level = [] + current_letter_set = letter_check[:-1] + new_letter_set = [] + old_letter_set = [] + [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] + new_group_set = ''.join(new_letter_set) + [old_letter_set.append(old) for old in self.letter_sets[0] if old not in current_letter_set] + old_group_set = ''.join(old_letter_set) + if current_letter_set in self.letter_sets and current_letter_set != '': + if current_letter_set == curr_set: + tmp = [] + [tmp.append(letter) for letter in word if letter not in current_letter_set] + tmp = ''.join(tmp) + new_level.append([tmp]) + # self.letter_sets.append(tmp) + + # else: + # self.letter_sets.append(current_letter_set) + if new_group_set or old_group_set != '': + if self.root_set in self.letter_sets: + self.letter_sets.remove(self.root_set) + self.root_set = self.letter_sets + if old_group_set not in self.letter_sets: + new_level.append(old_group_set) + # self.letter_sets.append(old_group_set) + if new_group_set not in self.letter_sets: + new_level.append(new_group_set) + # self.letter_sets.append(new_group_set) + if '' in self.letter_sets: + self.letter_sets.remove('') + self.letter_sets.append({current_letter_set: new_level}) + return self.letter_sets + def print_tree(self): count = 0 for item in self.letter_sets: From 944be5ba98e81021c53d30d489025485df5b1b6f Mon Sep 17 00:00:00 2001 From: Woojgh Date: Mon, 10 Jul 2017 16:58:13 -0700 Subject: [PATCH 15/25] omgomgomg --- src/trie.py | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/src/trie.py b/src/trie.py index 86ed367..31c1c5e 100644 --- a/src/trie.py +++ b/src/trie.py @@ -54,7 +54,25 @@ def insert(self, *words): if tmp == item: continue else: - new_level[0].append(tmp) + count = -1 + for group in new_level[0]: + count += 1 + if tmp[0] in group: + del_letters = '' + for tmp_letter in tmp: + del_letters = del_letters + tmp_letter + if del_letters == group: + level_3 = [] + [level_3.append(char) for char in tmp if char not in group] + level_3_group = ''.join(level_3) + new_level[0][count] = [{group: level_3_group}] + # count += 1 + if count > -1: + count = -1 + # new_level[0].append(tmp) + else: + if del_letters in group: + continue # self.letter_sets.append(tmp) else: From 9bbc58d245ced22b08d7ee87bcbda1eecd2b284b Mon Sep 17 00:00:00 2001 From: Woojgh Date: Mon, 10 Jul 2017 20:56:47 -0700 Subject: [PATCH 16/25] adding stuff --- src/trie.py | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/src/trie.py b/src/trie.py index 31c1c5e..ea507e9 100644 --- a/src/trie.py +++ b/src/trie.py @@ -20,7 +20,7 @@ def insert(self, *words): break else: - import pdb; pdb.set_trace() + # import pdb; pdb.set_trace() dict_check = [] for i in self.letter_sets: dict_check.append(i) @@ -65,31 +65,26 @@ def insert(self, *words): level_3 = [] [level_3.append(char) for char in tmp if char not in group] level_3_group = ''.join(level_3) - new_level[0][count] = [{group: level_3_group}] - # count += 1 + new_level[0][count] = {group: level_3_group} if count > -1: count = -1 - # new_level[0].append(tmp) else: if del_letters in group: continue - # self.letter_sets.append(tmp) + # if tmp[0] not in new_level[0] and tmp[0] not in new_level[0][0]: + # new_level[0].append(tmp) else: - # self.letter_sets.append(current_letter_set) if new_group_set or old_group_set != '': if self.root_set in self.letter_sets: self.letter_sets.remove(self.root_set) self.root_set = self.letter_sets if old_group_set not in self.letter_sets: new_level.append(old_group_set) - # self.letter_sets.append(old_group_set) if new_group_set not in self.letter_sets: new_level.append(new_group_set) - # self.letter_sets.append(new_group_set) if '' in self.letter_sets: self.letter_sets.remove('') - # self.letter_sets.append({current_letter_set: new_level}) return self.letter_sets break @@ -119,8 +114,7 @@ def insert(self, *words): tmp = [] [tmp.append(letter) for letter in word if letter not in current_letter_set] tmp = ''.join(tmp) - new_level.append([tmp]) - # self.letter_sets.append(tmp) + # new_level.append([tmp]) # else: # self.letter_sets.append(current_letter_set) From c67cba66f607b1069b25475d1834191904a28328 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Tue, 11 Jul 2017 08:26:28 -0700 Subject: [PATCH 17/25] got it working better --- src/trie.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/trie.py b/src/trie.py index ea507e9..9035be8 100644 --- a/src/trie.py +++ b/src/trie.py @@ -20,7 +20,7 @@ def insert(self, *words): break else: - # import pdb; pdb.set_trace() + import pdb; pdb.set_trace() dict_check = [] for i in self.letter_sets: dict_check.append(i) @@ -71,8 +71,8 @@ def insert(self, *words): else: if del_letters in group: continue - # if tmp[0] not in new_level[0] and tmp[0] not in new_level[0][0]: - # new_level[0].append(tmp) + if tmp[0] not in new_level[0]: + new_level[0].append(tmp) else: if new_group_set or old_group_set != '': From 83793dd4ba0eb326b7512d59dd10b695ddc1c17e Mon Sep 17 00:00:00 2001 From: Alex Date: Fri, 14 Jul 2017 15:53:23 -0700 Subject: [PATCH 18/25] fixing tests for bubble sort. --- requirements.txt | 22 --- setup.py | 5 +- src/BST.py | 301 ---------------------------------------- src/bag_o_words.txt | 150 -------------------- src/bubble_sort.py | 15 ++ src/hash.py | 23 --- src/simple_trie.py | 89 ------------ src/test_BST.py | 167 ---------------------- src/test_bubble_sort.py | 12 ++ src/test_trie.py | 18 --- src/trie.py | 186 ------------------------- 11 files changed, 30 insertions(+), 958 deletions(-) delete mode 100644 requirements.txt delete mode 100644 src/BST.py delete mode 100644 src/bag_o_words.txt create mode 100644 src/bubble_sort.py delete mode 100644 src/hash.py delete mode 100644 src/simple_trie.py delete mode 100644 src/test_BST.py create mode 100644 src/test_bubble_sort.py delete mode 100644 src/test_trie.py delete mode 100644 src/trie.py diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index a67df26..0000000 --- a/requirements.txt +++ /dev/null @@ -1,22 +0,0 @@ -appnope==0.1.0 -coverage==4.4.1 --e git+https://github.com/Woojgh/data-structure.git@b082458d0a82c09e548774e25a32c48c43a26e25#egg=data_structures -decorator==4.0.11 -ipython==6.1.0 -ipython-genutils==0.2.0 -jedi==0.10.2 -pexpect==4.2.1 -pickleshare==0.7.4 -pluggy==0.4.0 -prompt-toolkit==1.0.14 -ptyprocess==0.5.2 -py==1.4.34 -Pygments==2.2.0 -pytest==3.1.3 -pytest-cov==2.5.1 -simplegeneric==0.8.1 -six==1.10.0 -tox==2.7.0 -traitlets==4.3.2 -virtualenv==15.1.0 -wcwidth==0.1.7 diff --git a/setup.py b/setup.py index e1bfe71..b02ac1f 100644 --- a/setup.py +++ b/setup.py @@ -1,3 +1,4 @@ +"""Setup for data-structure package.""" from setuptools import setup extra_packages = { @@ -8,7 +9,7 @@ name='data-structures', desctription='A variety of data structures built with Python.', version='0.1', - author='James Salamonsen', + author='James Salamonsen and Alex Short', author_email='jamessalamonsen@gmail.com', license='MIT', py_modules=[], @@ -19,4 +20,4 @@ 'console_scripts': [ ] } -) \ No newline at end of file +) diff --git a/src/BST.py b/src/BST.py deleted file mode 100644 index 0e9d0b8..0000000 --- a/src/BST.py +++ /dev/null @@ -1,301 +0,0 @@ -"""Implementing a Binary Search tree with In Order Traversal.""" - - -class Node(object): - def __init__(self, entry, left=None, iterable=None, parent=None): - """Node for tree.""" - self.val = entry - self.left = left - self.right = iterable - self.parent = parent - - -class BinarySearchTree(object): - - def __init__(self, iterable=None): - # import pdb; pdb.set_trace() - """This will sety what wwe will be iterating through.""" - self.visited = [] - self.list = [] - self.size = 0 - self.root = None - self.iterable = iterable - if iterable is not None: - if type(iterable) in [list, tuple]: - for element in iterable: - self.list.append(element) - self.insert(element) - - def insert(self, entry): - # import pdb; pdb.set_trace() - if type(entry) not in [float, int]: - raise TypeError("NUMBERS!!!!! numbers...") - if not self.root: - self.root = Node(entry) - self.size += 1 - else: - curr = self.root - while curr: - if entry > curr.val: - if curr.right: - curr = curr.right - continue - else: - curr.right = Node(entry) - self.size += 1 - curr.right.parent = curr - self.balance_manager(curr) - elif entry < curr.val: - if curr.left: - curr = curr.left - continue - else: - curr.left = Node(entry) - self.size += 1 - self.balance_manager(curr) - curr.left.parent = curr - else: - return - - def search(self, entry): - """.""" - if type(entry) not in [float, int]: - raise TypeError("NUMBERS!!!!! numbers...") - else: - curr = self.root - while curr: - if entry > curr.val: - if curr.right: - curr = curr.right - continue - elif entry < curr.val: - if curr.left: - curr = curr.left - continue - else: - return curr - - def depth_first(self, entry): - if entry is None: - return 0 - left_depth = self.depth_first(entry.left) - right_depth = self.depth_first(entry.right) - if (left_depth > right_depth): - return left_depth + 1 - return right_depth + 1 - - def breadth_first(self): - self.nodes_to_visit = [] - curr = self.root - self.nodes_to_visit.append(curr) - while self.nodes_to_visit: - curr = self.nodes_to_visit.pop(0) - if curr.left: - self.nodes_to_visit.append(curr.left) - if curr.right: - self.nodes_to_visit.append(curr.right) - yield curr - - def pre_order_trav(self, entry=None): - if entry: - curr = entry - else: - curr = self.root - yield curr.val - if curr.left: - for item in self.pre_order_trav(curr.left): - yield item - if curr.right: - for item in self.pre_order_trav(curr.right): - yield item - - def pre_order(self): - for node_data in self.pre_order_trav(): - yield node_data - - def in_order_trav(self, entry=None): - if entry: - curr = entry - else: - curr = self.root - if curr.left: - for item in self.in_order_trav(curr.left): - yield item - yield curr.val - if curr.right: - for item in self.in_order_trav(curr.right): - yield item - - def in_order(self): - for node_data in self.in_order_trav(): - yield node_data - - def post_order_trav(self, entry=None): - if entry: - curr = entry - else: - curr = self.root - if curr.left: - for item in self.post_order_trav(curr.left): - yield item - if curr.right: - for item in self.post_order_trav(curr.right): - yield item - yield curr.val - - def post_order(self): - for node_data in self.post_order_trav(): - yield node_data - - def check_that_balance(self, target=None): - """check the balance of your treeeee""" - if self.size == 0: - return 0 - if target is not None: - return self.depth_first(target.right) - self.depth_first(target.left) - - def find_min_depth(self, target): - if target.left is None: - return target - if target.left is not None: - target = target.left - return target - - def find_max_depth(self, target): - if target.right is None: - return target - if target.right is not None: - target = target.right - return target - - def deletion(self, target): - """nope""" - delete_node = self.search(target) - if delete_node is None: - return 'This is the end!' - else: - self.size -= 1 - if delete_node.left is None and delete_node.right is None: - if delete_node.val > delete_node.parent.val: - delete_node.parent.right = None - else: - delete_node.parent.left = None - elif delete_node.left and not delete_node.right: - if delete_node.val > delete_node.parent.val: - delete_node.parent.right = delete_node.left - delete_node.left.parent = delete_node.parent - else: - delete_node.parent.left = delete_node.left - delete_node.left.parent = delete_node.parent - elif delete_node.right and not delete_node.left: - if delete_node.val > delete_node.parent.val: - delete_node.parent.right = delete_node.right - delete_node.right.parent = delete_node.parent - else: - delete_node.parent.left = delete_node.right - delete_node.left.parent = delete_node.parent - else: - if self.check_that_balance(target) > 0: - min_val = self.find_min_depth(delete_node.right) - delete_node.val = min_val.val - if min_val.right is None: - min_val.parent.left = None - min_val.parent = None - else: - min_val.val = min_val.right.val - min_val.right.parent = None - min_val.right = None - else: - max_val = self.find_max_depth(delete_node.left) - delete_node.val = max_val.val - if max_val.left is None: - max_val.parent.right = None - max_val.parent = None - else: - max_val.val = max_val.left.val - max_val.left.parent = None - max_val.left = None - - def balance_manager(self, node=None): - # import pdb; pdb.set_trace() - if node is None: - node = self.root - if self.size % 2 == 0: - if self.check_that_balance(node) > 1: - self.rotate_right() - if self.check_that_balance(node) < -1: - self.rotate_left() - else: - if self.check_that_balance(node) > 0: - self.rotate_right() - if self.check_that_balance(node) < 0: - self.rotate_left() - - def rotate_left(self, node=None): - if node is None: - node = self.root - origin = node - node = self.find_max_depth(origin.left) - if node.val > node.parent.val: - if node.parent.parent is None: - node.right = origin - node.right.parent = node - node.right.left = None - node.parent = None - node = self.root - return - node.left = node.parent.parent - node.parent = node.left.parent - node.right = node.left.right - node.right.parent = node - node.left.parent = node.left - node.parent.right = node - else: - node.right = origin - node.left = origin.left - origin.left = None - origin = node - origin.parent.right = None - origin.parent = None - - def rotate_right(self, node=None): - # import pdb; pdb.set_trace() - if node is None: - node = self.root - origin = node - node = self.find_min_depth(origin.right) - if node.val > node.parent.val: - if node.parent.parent is None: - node.left = origin - node.left.parent = node - node.left.right = None - node.parent = None - node = self.root - return - node.right = node.parent.parent - node.parent = node.right.parent - node.left = node.right.left - node.left.parent = node - node.right.parent = node.right - node.parent.left = node - else: - node.left = origin - node.right = origin.right - origin.right = None - origin = node - origin.parent.left = None - origin.parent = None - - # def balance_that_thang(self, node=None): - # # import pdb; pdb.set_trace() - # if not node: - # node = self.root - # gen = self.breadth_first() - # for i in [i for i in gen]: - # self.balance_manager(i) - - -if __name__ == '__main__': # pragma: no cover - b = BinarySearchTree([5, 3, 7, 2, 8, 4, 9, 1]) - gen = b.in_order() - [i for i in gen] diff --git a/src/bag_o_words.txt b/src/bag_o_words.txt deleted file mode 100644 index 23e6ccd..0000000 --- a/src/bag_o_words.txt +++ /dev/null @@ -1,150 +0,0 @@ -the -of -and -to -a -in -that -is -was -he -for -it -with -as -his -on -be -at -by -i -this -had -not -are -but -from -or -have -an -they -which -one -you -were -her -all -she -there -would -their -we -him -been -has -when -who -will -more -no -if -out -so -said -what -up -its -about -into -than -them -can -only -other -new -some -could -time -these -two -may -then -do -first -any -my -now -such -like -our -over -man -me -even -most -made -after -also -did -many -before -must -through -back -years -where -much -your -way -well -down -should -because -each -just -those -people -mr -how -too -little -state -good -very -make -world -still -own -see -men -work -long -get -here -between -both -life -being -under -never -day -same -another -know -while -last -might -us -great -old -year -off -come -since -against -go -came -right -used -take -three diff --git a/src/bubble_sort.py b/src/bubble_sort.py new file mode 100644 index 0000000..0f461bf --- /dev/null +++ b/src/bubble_sort.py @@ -0,0 +1,15 @@ +"""An example of the basic bubble sort function.""" + + +def bubble_sort(numbers): + """Basic bubble sort.""" + sorted_numbers = list(numbers) + count = 0 + while count < len(sorted_numbers) - 1: + count = 0 + for x in range(len(sorted_numbers) - 1): + if sorted_numbers[x] > sorted_numbers[(x + 1)]: + sorted_numbers[x], sorted_numbers[x + 1] = sorted_numbers[x + 1], sorted_numbers[x] + else: + count += 1 + return sorted_numbers diff --git a/src/hash.py b/src/hash.py deleted file mode 100644 index 36b3061..0000000 --- a/src/hash.py +++ /dev/null @@ -1,23 +0,0 @@ -class HashTable: - - def __init__(self): - self.size = 753 - self.slots = [None] * self.size - self.data = [None] * self.size - - def hashingtons(self, key, size): - return key % size - - def hashemagain(self, oldcountrystylehash, size): - return (oldcountrystylehash+1) % size - - def set(self, key, val): - hash_val = self.hashingtons(key, len(self.slots)) - - def get(self, key): - startingslot = self.hashingtons(key, len(self.slots)) - - val = None - stop = False - start = False - position = startingslot diff --git a/src/simple_trie.py b/src/simple_trie.py deleted file mode 100644 index 0cd2d24..0000000 --- a/src/simple_trie.py +++ /dev/null @@ -1,89 +0,0 @@ -test_list = ['mon', 'ta', 'read'] - - -def compare(input_word, index=0, word_set=test_list): - #if check_if_word_in_set(input_word, word_set): - #return test_list - while True: - temp_list = list(filter(lambda x: input_word[0:index] == x[0:index], word_set)) - if temp_list: - new_list = [] - for letter in input_word: - new_list.append(letter) - if new_list == temp_list: - [new_list.append(letter) for letter in input_word if letter not in temp_list] - index += 1 - import pdb; pdb.set_trace() - if index > len(input_word): - word_set.remove(temp_list[0]) - word_set.append(input_word) - word_set.append(temp_list[0][index-1:]) - return word_set - else: - word_set.append(input_word) - return word_set - -_end = '$' - - -def make_trie(*words): - root = dict() - for word in words: - current_dict = root - for letter in word: - current_dict = current_dict.setdefault(letter, {}) - current_dict[_end] = _end - import pdb; pdb.set_trace() - return root - -# test_list = ['mon', 'ta', 'read'] - - -# class Node(object): -# def __init__(self, entry, root=None, child=None, parent=None): -# """Node for tree.""" -# self.val = entry -# self.root = root -# self.child = child -# self.parent = parent - - -# class TrieTree(object): - -# def __init__(self, Node=None, iterable=None): -# self.node = Node -# self.itertable = iterable - -# def compare(self, input_word, index=0, word_set=test_list): -# if self.check_if_word_in_set(input_word, word_set): -# return test_list -# while True: -# temp_list = list(filter(lambda x: input_word[0:index] == x[0:index], word_set)) -# if temp_list: -# index += 1 -# if index > len(input_word): -# word_set.remove(temp_list[0]) -# word_set.append(input_word) -# word_set.append(temp_list[0][index-1:]) -# return word_set -# else: -# word_set.append(input_word) -# return word_set - -# def check_if_word_in_set(self, input_word, word_set=test_list): -# if input_word in self.concat_words_in_set(word_set): -# return True -# return False - -# def concat_words_in_set(self, word_set): -# """Will create a list of concatenated words based on the current set of words.""" -# concat_words = [] -# for word in word_set: -# if word.parent: -# temp_word = word.parent + word -# while word.parent: -# temp_word = word.parent + temp_word -# concat_words.append(temp_word) -# else: -# concat_words.append(word) -# return concat_words diff --git a/src/test_BST.py b/src/test_BST.py deleted file mode 100644 index 3c3bf66..0000000 --- a/src/test_BST.py +++ /dev/null @@ -1,167 +0,0 @@ -"""Test the tree.py module.""" -import pytest -from BST import BinarySearchTree - -a = BinarySearchTree([12, 42, 4, 87, 2, 65, 0]) - -b = BinarySearchTree([5, 3, 7, 2, 8, 4, 9, 1]) - -c = BinarySearchTree([-2, -6, 22.55, 0, -94, 2, -1]) - - -@pytest.fixture -def bitr(): # pragma: no cover - """Init a new Binary Tree.""" - tree = BinarySearchTree() - return tree - - -@pytest.fixture -def bitr_iter(): # pragma: no cover - """Init a new Binary tree from an iterable.""" - return a.iterable - return b.iterable - return c.iterable - - -def test_tree_empty(): - """Instantiate a new Binary tree, that should be an empty list.""" - b = BinarySearchTree([]) - assert b.size == 0 - - -def test_type_error_insert(): - """Test for type error in insert function""" - with pytest.raises(TypeError): - b.insert('not a number') - - -def test_type_error_search(): - """Test for type error in the search function""" - with pytest.raises(TypeError): - b.search('still not a number') - - -def test_bitr_search(): - """Test the seartch function""" - assert a.search(12).left.val == 4 - assert a.search(4).left.val == 2 - assert a.search(87).left.val == 65 - assert b.search(3).left.val == 2 - assert b.search(5).left.val == 3 - assert c.search(-2).left.val == -6 - assert c.search(0).left.val == -1 - assert c.search(-6).left.val == -94 - - -def test_bitr_iter_in_order(): - """Test the in order funciton.""" - gena = a.in_order() - a_list = [item for item in gena] - assert a_list == [0, 2, 4, 12, 42, 65, 87] - assert a_list[0] == 0 - assert a_list[1] == 2 - assert a_list[2] == 4 - assert len(a_list) == 7 - genb = b.in_order() - b_list = [item for item in genb] - assert b_list == [1, 2, 3, 4, 5, 7, 8, 9] - assert b_list[0] == 1 - assert b_list[1] == 2 - assert b_list[2] == 3 - assert len(b_list) == 8 - genc = c.in_order() - c_list = [item for item in genc] - assert c_list == [-94, -6, -2, -1, 0, 2, 22.55] - assert c_list[0] == -94 - assert c_list[1] == -6 - assert c_list[2] == -2 - assert len(c_list) == 7 - - -def test_bitr_iter_pre_order(): - """Test the pre order funciton.""" - gena = a.pre_order() - a_list = [item for item in gena] - assert a_list == [12, 4, 2, 0, 42, 87, 65] - assert a_list[0] == 12 - assert a_list[1] == 4 - assert a_list[6] == 65 - assert len(a_list) == 7 - genb = b.pre_order() - b_list = [item for item in genb] - assert b_list == [5, 3, 2, 1, 4, 7, 8, 9] - assert b_list[0] == 5 - assert b_list[1] == 3 - assert b_list[6] == 8 - assert len(b_list) == 8 - genc = c.pre_order() - c_list = [item for item in genc] - assert c_list == [-2, -6, -94, 22.55, 0, -1, 2] - assert c_list[0] == -2 - assert c_list[1] == -6 - assert c_list[6] == 2 - assert len(c_list) == 7 - - -def test_bitr_iter_post_order(): - """Test the post order funciton.""" - gena = a.post_order() - a_list = [item for item in gena] - assert a_list == [0, 2, 4, 65, 87, 42, 12] - assert a_list[0] == 0 - assert a_list[3] == 65 - assert a_list[2] == 4 - assert len(a_list) == 7 - gen = b.post_order() - b_list = [item for item in gen] - assert b_list == [1, 2, 4, 3, 9, 8, 7, 5] - assert b_list[0] == 1 - assert b_list[3] == 3 - assert b_list[2] == 4 - assert len(b_list) == 8 - genc = c.post_order() - c_list = [item for item in genc] - assert c_list == [-94, -6, -1, 2, 0, 22.55, -2] - assert c_list[0] == -94 - assert c_list[3] == 2 - assert c_list[2] == -1 - assert len(c_list) == 7 - - -def test_bitr_breadth(): - """Test the breadth first traversal.""" - abf = a.breadth_first() - assert [ab.val for ab in abf] == [12, 4, 42, 2, 87, 0, 65] - bbf = b.breadth_first() - assert [bb.val for bb in bbf] == [5, 3, 7, 2, 4, 8, 1, 9] - cbf = c.breadth_first() - assert [cb.val for cb in cbf] == [-2, -6, 22.55, -94, 0, -1, 2] - - -def test_bitr_insert(): - """Push the insert function.""" - a.insert(30) - gena = a.in_order() - a_list = [item for item in gena] - assert a_list == [0, 2, 4, 12, 30, 42, 65, 87] - a.insert(2.5) - gena = a.in_order() - a_list = [item for item in gena] - assert a_list == [0, 2, 2.5, 4, 12, 30, 42, 65, 87] - b.insert(1.1) - genb = b.in_order() - b_list = [item for item in genb] - assert b_list == [1, 1.1, 2, 3, 4, 5, 7, 8, 9] - b.insert(-90) - genb = b.in_order() - b_list = [item for item in genb] - assert b_list == [-90, 1, 1.1, 2, 3, 4, 5, 7, 8, 9] - c.insert(31) - genc = c.in_order() - c_list = [item for item in genc] - assert c_list == [-94, -6, -2, -1, 0, 2, 22.55, 31] - c.insert(22.54) - genc = c.in_order() - c_list = [item for item in genc] - assert c_list == [-94, -6, -2, -1, 0, 2, 22.54, 22.55, 31] diff --git a/src/test_bubble_sort.py b/src/test_bubble_sort.py new file mode 100644 index 0000000..aca365b --- /dev/null +++ b/src/test_bubble_sort.py @@ -0,0 +1,12 @@ +"""Will test the bubble sort for desired outputs.""" +from bubble_sort import bubble_sort +import random + + +def test_bubble_sort(): + """Test against many random outputs.""" + assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) + assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) + assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) + assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) + assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) diff --git a/src/test_trie.py b/src/test_trie.py deleted file mode 100644 index 3c84f1f..0000000 --- a/src/test_trie.py +++ /dev/null @@ -1,18 +0,0 @@ -import pytest -from trie import TrieTree - -@pytest.fixture -def trie(): - tree = TrieTree() - return tree - - -def test_tree_empty(): - t = trie() - assert t.size == 0 - - -def test_tree_insert(): - t = trie() - t.insert('monkey') - assert t.letter_sets == ['monkey'] diff --git a/src/trie.py b/src/trie.py deleted file mode 100644 index 9035be8..0000000 --- a/src/trie.py +++ /dev/null @@ -1,186 +0,0 @@ -end = '$' - - -class TrieTree(object): - - def __init__(self): - """This will implement our Trie tree funciton.""" - self.size = 0 - self.root_set = [] - self.letter_sets = [] - - def insert(self, *words): - for word in words: - current_letter_set = [] - self.size = self.size + 1 - if self.letter_sets == []: - self.letter_sets.append(word) - self.root_set = self.letter_sets[0] - return self.letter_sets - break - - else: - import pdb; pdb.set_trace() - dict_check = [] - for i in self.letter_sets: - dict_check.append(i) - list_check = [] - letter_check = '' - for curr_set in self.letter_sets: - if type(curr_set) == str: - list_check = curr_set - if type(curr_set) == dict: - for item in list(curr_set.keys()): - if type(item) == str: - list_check.append(item) - for thing in list_check: - if word[0] in thing: - for letter in word: - letter_check = letter_check + letter - if letter_check == thing: - new_level = list(curr_set.values()) - current_letter_set = letter_check - new_letter_set = [] - old_letter_set = [] - [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] - new_group_set = ''.join(new_letter_set) - [old_letter_set.append(old) for old in self.letter_sets[0] if old not in current_letter_set] - old_group_set = ''.join(old_letter_set) - if current_letter_set != '': - if current_letter_set == item: - tmp = [] - [tmp.append(letter) for letter in word if letter not in current_letter_set] - tmp = ''.join(tmp) - if tmp == item: - continue - else: - count = -1 - for group in new_level[0]: - count += 1 - if tmp[0] in group: - del_letters = '' - for tmp_letter in tmp: - del_letters = del_letters + tmp_letter - if del_letters == group: - level_3 = [] - [level_3.append(char) for char in tmp if char not in group] - level_3_group = ''.join(level_3) - new_level[0][count] = {group: level_3_group} - if count > -1: - count = -1 - else: - if del_letters in group: - continue - if tmp[0] not in new_level[0]: - new_level[0].append(tmp) - - else: - if new_group_set or old_group_set != '': - if self.root_set in self.letter_sets: - self.letter_sets.remove(self.root_set) - self.root_set = self.letter_sets - if old_group_set not in self.letter_sets: - new_level.append(old_group_set) - if new_group_set not in self.letter_sets: - new_level.append(new_group_set) - if '' in self.letter_sets: - self.letter_sets.remove('') - return self.letter_sets - break - - else: - if letter_check in item: - continue - else: - self.letter_sets.append({word: ''}) - return self.letter_sets - - else: - for letter in word: - letter_check = letter_check + letter - if letter_check in curr_set: - continue - else: - new_level = [] - current_letter_set = letter_check[:-1] - new_letter_set = [] - old_letter_set = [] - [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] - new_group_set = ''.join(new_letter_set) - [old_letter_set.append(old) for old in self.letter_sets[0] if old not in current_letter_set] - old_group_set = ''.join(old_letter_set) - if current_letter_set in self.letter_sets and current_letter_set != '': - if current_letter_set == curr_set: - tmp = [] - [tmp.append(letter) for letter in word if letter not in current_letter_set] - tmp = ''.join(tmp) - # new_level.append([tmp]) - - # else: - # self.letter_sets.append(current_letter_set) - if new_group_set or old_group_set != '': - if self.root_set in self.letter_sets: - self.letter_sets.remove(self.root_set) - self.root_set = self.letter_sets - if old_group_set not in self.letter_sets: - new_level.append(old_group_set) - # self.letter_sets.append(old_group_set) - if new_group_set not in self.letter_sets: - new_level.append(new_group_set) - # self.letter_sets.append(new_group_set) - if '' in self.letter_sets: - self.letter_sets.remove('') - self.letter_sets.append({current_letter_set: new_level}) - return self.letter_sets - - def print_tree(self): - count = 0 - for item in self.letter_sets: - count += 1 - return 'Set ' + str(count) + ' ' + str(item) - # def insert(self, word): - # for word in words: - # current_letter_set = [] - # self.size = self.size + 1 - # # word_dict = new_dict - # if self.letter_sets == []: - # self.letter_sets = [word] - # self.root_set = self.letter_sets - # return self.letter_sets - # break - # else: - # letter_check = '' - # for letter in word: - # self.letters = self.letters + 1 - # letter_check = letter_check + letter - # for lset in self.letter_sets: - # if letter_check in lset: - # good_group = letter_check - # continue - # else: - # import pdb; pdb.set_trace() - # current_letter_set = good_group - # new_letter_set = [] - # old_letter_set = [] - # [new_letter_set.append(letter) for letter in word if letter not in current_letter_set] - # new_group_set = ''.join(new_letter_set) - # [old_letter_set.append(old) for old in self.letter_sets[0] if old not in good_group] - # old_group_set = ''.join(old_letter_set) - # self.letter_sets = [current_letter_set] - # self.letter_sets.append(old_group_set) - # self.letter_sets.append(new_group_set) - # return self.letter_sets - - # def search(self, word): - # """.""" - # current_word_dict = self - # for letter in word: - # if letter in current_word_dict: - # current_word_dict = current_word_dict[letter] - # else: - # return False - # else: - # if end in current_word_dict: - # return True - # else: - # return False From 33b581ccaafd57549ad0f72b1b64cf88b4aba05d Mon Sep 17 00:00:00 2001 From: Alex Date: Sun, 16 Jul 2017 10:46:22 -0700 Subject: [PATCH 19/25] insertion sort and test is complete. --- src/bubble_sort.py | 15 --------------- src/insertion_sort.py | 22 ++++++++++++++++++++++ src/test_bubble_sort.py | 12 ------------ src/test_insertion_sort.py | 12 ++++++++++++ 4 files changed, 34 insertions(+), 27 deletions(-) delete mode 100644 src/bubble_sort.py create mode 100644 src/insertion_sort.py delete mode 100644 src/test_bubble_sort.py create mode 100644 src/test_insertion_sort.py diff --git a/src/bubble_sort.py b/src/bubble_sort.py deleted file mode 100644 index 0f461bf..0000000 --- a/src/bubble_sort.py +++ /dev/null @@ -1,15 +0,0 @@ -"""An example of the basic bubble sort function.""" - - -def bubble_sort(numbers): - """Basic bubble sort.""" - sorted_numbers = list(numbers) - count = 0 - while count < len(sorted_numbers) - 1: - count = 0 - for x in range(len(sorted_numbers) - 1): - if sorted_numbers[x] > sorted_numbers[(x + 1)]: - sorted_numbers[x], sorted_numbers[x + 1] = sorted_numbers[x + 1], sorted_numbers[x] - else: - count += 1 - return sorted_numbers diff --git a/src/insertion_sort.py b/src/insertion_sort.py new file mode 100644 index 0000000..c631cdc --- /dev/null +++ b/src/insertion_sort.py @@ -0,0 +1,22 @@ +"""An example of the insertion sort.""" + + +def insertion_sort(numbers): + """Will sort any given number iterable into a min first list.""" + new = [] + while len(new) < len(numbers): + x = 0 + for i in numbers: + while True: + try: + if new[x] >= i: + new.insert(x, i) + x = 0 + break + else: + x += 1 + except IndexError: + new.append(i) + x = 0 + break + return new diff --git a/src/test_bubble_sort.py b/src/test_bubble_sort.py deleted file mode 100644 index aca365b..0000000 --- a/src/test_bubble_sort.py +++ /dev/null @@ -1,12 +0,0 @@ -"""Will test the bubble sort for desired outputs.""" -from bubble_sort import bubble_sort -import random - - -def test_bubble_sort(): - """Test against many random outputs.""" - assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) - assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) - assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) - assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) - assert bubble_sort(random.sample(range(100), 100)) == list(range(100)) diff --git a/src/test_insertion_sort.py b/src/test_insertion_sort.py new file mode 100644 index 0000000..2afb2d5 --- /dev/null +++ b/src/test_insertion_sort.py @@ -0,0 +1,12 @@ +"""Test for the insertion sort.""" +from insertion_sort import insertion_sort +import random + + +def test_insertion_sort(): + """Test that any given numerical iterable is returned as a min first list.""" + assert insertion_sort(random.sample(range(100), 100)) == list(range(100)) + assert insertion_sort(random.sample(range(100), 100)) == list(range(100)) + assert insertion_sort(random.sample(range(100), 100)) == list(range(100)) + assert insertion_sort(random.sample(range(100), 100)) == list(range(100)) + assert insertion_sort(random.sample(range(100), 100)) == list(range(100)) From f61fbed28a280a4516094d93d01369ae931d2d2b Mon Sep 17 00:00:00 2001 From: Alex Date: Sun, 16 Jul 2017 14:13:23 -0700 Subject: [PATCH 20/25] started the merge sort --- src/merge_sort.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 src/merge_sort.py diff --git a/src/merge_sort.py b/src/merge_sort.py new file mode 100644 index 0000000..3e582e2 --- /dev/null +++ b/src/merge_sort.py @@ -0,0 +1,14 @@ +"""A merge sort function.""" + + +def merge_sort(numbers): + """Sort a iterable of numbers into min first via merge sort.""" + temp = [] + if len(numbers) % 2 == 0: + for i in range(0, len(numbers), 2): + temp.append(numbers[i: i + 2]) + for pair in temp: + if pair[0] > pair[1]: + pair[0], pair[1] = pair[1], pair[0] + + return temp From 3cfa0f5d44b49805dc38626a4278b3b7c35c3bfc Mon Sep 17 00:00:00 2001 From: Alex Date: Sun, 16 Jul 2017 18:13:18 -0700 Subject: [PATCH 21/25] maybe this works. --- src/insertion_sort.py | 24 ++++++++++++++++++++++++ src/merge_sort.py | 43 +++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 65 insertions(+), 2 deletions(-) diff --git a/src/insertion_sort.py b/src/insertion_sort.py index c631cdc..49b0f97 100644 --- a/src/insertion_sort.py +++ b/src/insertion_sort.py @@ -20,3 +20,27 @@ def insertion_sort(numbers): x = 0 break return new + + +def existing_set_insertion_sort(numbers, existing_set): + """Will sort any given number iterable into a min first list.""" + new = list(existing_set) + while len(new) < len(numbers) + len(existing_set): + x = 0 + for i in numbers: + while True: + try: + if x is 0 and new[x] >= i: + new.insert(x, i) + break + elif new[x] >= i: + new.insert(x, i) + x = 0 + break + else: + x += 1 + except IndexError: + new.append(i) + x = 0 + break + return new diff --git a/src/merge_sort.py b/src/merge_sort.py index 3e582e2..c4f3e5a 100644 --- a/src/merge_sort.py +++ b/src/merge_sort.py @@ -1,14 +1,53 @@ """A merge sort function.""" +from insertion_sort import existing_set_insertion_sort as esis def merge_sort(numbers): """Sort a iterable of numbers into min first via merge sort.""" + final = [] + compare = [] temp = [] + hold_extra = [] if len(numbers) % 2 == 0: for i in range(0, len(numbers), 2): temp.append(numbers[i: i + 2]) for pair in temp: if pair[0] > pair[1]: pair[0], pair[1] = pair[1], pair[0] - - return temp + else: + for i in range(0, len(numbers) - 1, 2): + temp.append(numbers[i: i + 2]) + for pair in temp: + if pair[0] > pair[1]: + pair[0], pair[1] = pair[1], pair[0] + hold_extra.append(numbers[len(numbers) - 1]) + while 1: + if final: + if len(final) == 1: + if hold_extra: + return esis(hold_extra, final[0]) + return final[0] + temp = list(final) + if len(temp) % 2 == 1: + hold_extra.extend(temp[len(temp) - 1]) + final = [] + for i in range(0, len(temp) - 1, 2): + t = 0 + k = 0 + while 1: + if t >= len(temp[i]) and k >= len(temp[i + 1]): + final.append(compare) + compare = [] + break + elif t >= len(temp[i]): + compare.append(temp[i + 1][k]) + k += 1 + elif k >= len(temp[i + 1]): + compare.append(temp[i][t]) + t += 1 + elif temp[i][t] >= temp[i + 1][k]: + compare.append(temp[i + 1][k]) + k += 1 + elif temp[i][t] <= temp[i + 1][k]: + compare.append(temp[i][t]) + t += 1 From fbd0e2ea2a2cf70d032d7113dc71476ff823b964 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Sun, 16 Jul 2017 18:30:57 -0700 Subject: [PATCH 22/25] got merge sort working --- src/merge_sort.py | 11 ++++++++ src/something.py | 67 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+) create mode 100644 src/something.py diff --git a/src/merge_sort.py b/src/merge_sort.py index c4f3e5a..c27284c 100644 --- a/src/merge_sort.py +++ b/src/merge_sort.py @@ -1,6 +1,8 @@ """A merge sort function.""" from insertion_sort import existing_set_insertion_sort as esis +from insertion_sort import insertion_sort + def merge_sort(numbers): """Sort a iterable of numbers into min first via merge sort.""" @@ -8,6 +10,15 @@ def merge_sort(numbers): compare = [] temp = [] hold_extra = [] + if len(numbers) == 1: + return numbers + elif len(numbers) == 2: + if numbers[0] > numbers[1]: + numbers[0], numbers[1] = numbers[1], numbers[0] + return numbers + return numbers + elif len(numbers) == 3: + return insertion_sort(numbers) if len(numbers) % 2 == 0: for i in range(0, len(numbers), 2): temp.append(numbers[i: i + 2]) diff --git a/src/something.py b/src/something.py new file mode 100644 index 0000000..f27205c --- /dev/null +++ b/src/something.py @@ -0,0 +1,67 @@ +def merge_sort(numbers): + """Sort a iterable of numbers into min first via merge sort.""" + final = [] + compare = [] + temp = [] + if len(numbers) == 1: + return numbers + elif len(numbers) == 2: + if numbers[0] > numbers[1]: + numbers[0], numbers[1] = numbers[1], numbers[0] + return numbers + elif len(numbers) == 3: + + elif len(numbers) % 2 == 0: + for i in range(0, len(numbers), 2): + temp.append(numbers[i: i + 2]) + for pair in temp: + if pair[0] > pair[1]: + pair[0], pair[1] = pair[1], pair[0] + else: + for i in range(0, len(numbers) - 1, 2): + temp.append(numbers[i: i + 2]) + for pair in temp: + if pair[0] > pair[1]: + pair[0], pair[1] = pair[1], pair[0] + temp[0].append(numbers[len(numbers) - 1]) + while 1: + if final: + if len(final) == 1: + return final[0] + temp = list(final) + print(temp) + final = [] + if len(temp) % 2 != 0: + temp[0].extend(temp[len(temp) - 1]) + for i in range(0, len(temp) - 1, 2): + t = 0 + k = 0 + while 1: + # import pdb; pdb.set_trace() + if t >= len(temp[i]) and k >= len(temp[i + 1]): + if len(temp) % 2 != 0: + num = round(len(compare) / 2) + ss = compare[:num] + for i in range(0, len(ss) - 1, 2): + if ss[i] > ss[i + 1]: + ss[i], ss[i + 1] = ss[i + 1], ss[i] + final.append(ss) + ss = compare[num:] + for i in range(0, len(ss) - 1, 2): + if ss[i] > ss[i + 1]: + ss[i], ss[i + 1] = ss[i + 1], ss[i] + final.append(ss) + compare = [] + break + elif t >= len(temp[i]): + compare.append(temp[i + 1][k]) + k += 1 + elif k >= len(temp[i + 1]): + compare.append(temp[i][t]) + t += 1 + elif temp[i][t] >= temp[i + 1][k]: + compare.append(temp[i + 1][k]) + k += 1 + elif temp[i][t] <= temp[i + 1][k]: + compare.append(temp[i][t]) + t += 1 From 9da9f4f7f079d328d98a9de8b4a1021882da3b1b Mon Sep 17 00:00:00 2001 From: Woojgh Date: Mon, 17 Jul 2017 09:51:23 -0700 Subject: [PATCH 23/25] adding merge2 and quick stuff --- src/merge_sort.py | 27 +++++++++++++++++++++++++++ src/quick_sort.py | 25 +++++++++++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 src/quick_sort.py diff --git a/src/merge_sort.py b/src/merge_sort.py index c27284c..0694bc0 100644 --- a/src/merge_sort.py +++ b/src/merge_sort.py @@ -4,6 +4,33 @@ from insertion_sort import insertion_sort +def merge2(numbers): + if len(numbers) == 1: + return numbers + if len(numbers) == 2: + if numbers[0] > numbers[1]: + numbers[0], numbers[1] = numbers[1], numbers[0] + return numbers + midpnt = len(numbers) // 2 + left = merge2(numbers[:midpnt]) + right = merge2(numbers[midpnt:]) + + output = [] + while left or right: + if left and right and left[0] < right[0]: + output.append(left.pop(0)) + elif left and right and left[0] >= right[0]: + output.append(right.pop(0)) + elif left and not right: + output.extend(left) + break + elif right and not left: + output.extend(right) + break + + return output + + def merge_sort(numbers): """Sort a iterable of numbers into min first via merge sort.""" final = [] diff --git a/src/quick_sort.py b/src/quick_sort.py new file mode 100644 index 0000000..d6ee68d --- /dev/null +++ b/src/quick_sort.py @@ -0,0 +1,25 @@ +"""This is an implemntation of quick_sort.""" + + +def quick_sort(numbers): + import pdb; pdb.set_trace() + pivot = numbers[0] + pivot_index = numbers.index(pivot) + store_index = numbers.index(pivot) + 1 + for i in numbers[1:]: + if i < pivot: + new_nums = [pivot] + bigger_nums = [] + check_list = list(numbers[store_index:]) + count = 0 + for number in check_list: + count += 1 + thing = check_list[count] + print(number) + print(thing) + if number < pivot: + number, check_list[store_index] = check_list[store_index], number + store_index += 1 + print(new_nums) + print(check_list) + # pivot, check_list[store_index - 1] = check_list[store_index - 1], pivot From 5c9274e22a91ac925fe4119f682b7f7659487e24 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Mon, 17 Jul 2017 11:01:07 -0700 Subject: [PATCH 24/25] recursive merge --- src/merge_sort.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/merge_sort.py b/src/merge_sort.py index 0694bc0..14a8e5c 100644 --- a/src/merge_sort.py +++ b/src/merge_sort.py @@ -5,6 +5,7 @@ def merge2(numbers): + """Mob Programming""" if len(numbers) == 1: return numbers if len(numbers) == 2: @@ -32,7 +33,7 @@ def merge2(numbers): def merge_sort(numbers): - """Sort a iterable of numbers into min first via merge sort.""" + """Sort a iterable of numbers into min first via merge sort non-recursively.""" final = [] compare = [] temp = [] @@ -43,7 +44,7 @@ def merge_sort(numbers): if numbers[0] > numbers[1]: numbers[0], numbers[1] = numbers[1], numbers[0] return numbers - return numbers + elif len(numbers) == 3: return insertion_sort(numbers) if len(numbers) % 2 == 0: From c5bf02bf5ee39d4cd1fd3894b0153335e1e844b8 Mon Sep 17 00:00:00 2001 From: Woojgh Date: Mon, 17 Jul 2017 20:32:47 -0700 Subject: [PATCH 25/25] got radix sort running smoothly --- src/radix_sort.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 src/radix_sort.py diff --git a/src/radix_sort.py b/src/radix_sort.py new file mode 100644 index 0000000..4279c90 --- /dev/null +++ b/src/radix_sort.py @@ -0,0 +1,15 @@ +from itertools import chain + + +def radix(set, curr_idx=0): + bucket = [[] for _ in range(10)] + place = curr_idx + for number in set: + try: + value = int(str(number)[:: - 1][place]) + bucket[value].append(number) + except: + bucket[0].append(number) + if len(bucket[0]) == len(set): + return bucket[0] + return radix(list(chain.from_iterable(bucket)), place+1)