def test_contains_simple(self):
t = HashTable()
t.put('a', 1)
self.assertEqual(t.contains('a'), True)
self.assertEqual(t.contains('b'), False)
t.put('b', 1)
self.assertEqual(t.contains('b'), True)
def test_remove_simple(self):
t = HashTable()
t.put('a', 1)
self.assertEqual(t.contains('a'), True)
t.remove('a')
self.assertEqual(t.contains('a'), False)
self.assertEqual(t.remove('b'), 'key not found')
def test_boolean_contains(self):
ht = HashTable()
ht.set('A', 1)
ht.set('B', 5)
ht.set('C', 10)
assert ht.contains('A') is True
assert ht.contains('B') is True
assert ht.contains('C') is True
assert ht.contains('G') is False
def test_contains(self):
ht = HashTable()
ht.set('I', 1)
ht.set('V', 5)
ht.set('X', 10)
assert ht.contains('I') is True
assert ht.contains('V') is True
assert ht.contains('X') is True
assert ht.contains('A') is False
def test_my_contains(self):
ht = HashTable()
ht.set('G', 4)
ht.set('D', 4)
ht.set('A', 4)
assert ht.contains('G') is True
assert ht.contains('D') is True
assert ht.contains('A') is True
assert ht.contains('AA') is False
class HashSet(object):
def __init__(self, elements=None):
self.hashtable = HashTable()
self.size = 0
def contains(self, element):
return self.hashtable.contains(element)
def add(self, element):
if not self.contains(element):
self.hashtable.set(element, None)
self.size += 1
def remove(self, element):
if self.contains(element):
self.hashtable.delete(element)
self.size -= 1
def union(self, other_set):
new_set = HashSet()
for key in other_set.hashtable.keys():
new_set.add(key)
for key in self.hashtable.keys():
new_set.add(key)
return new_items
def intersection(self, other_set):
shared = HashSet()
for key in other_set.hashtable.keys():
if self.hashtable.contains(key) == True:
shared.add(key)
return shared
def difference(self, other_set):
different_items = HashSet()
for key in other_set.hashtable.keys():
if self.hashtable.contains(key) == False:
different_items.add(key)
for key in self.hashtable.keys():
if other_set.hashtable.contains(key) == False:
different_items.add(key)
return different_items
# different_items = []
# for key in other_set.hashtable.keys():
# if self.contains(key) == False:
# new_items.append(key)
# return new_items
def is_subset(self, other_set):
for key in other_set.hashtable.keys():
if self.hashtable.contains(key) == False:
return False
return True
def test_collisions(self):
t = HashTable()
t.put('rwlqyilqlt', 1)
t.put('eulvcjibif', 2)
self.assertEqual(t.contains('rwlqyilqlt'), True)
self.assertEqual(t.contains('eulvcjibif'), True)
self.assertEqual(t.get('rwlqyilqlt'), 1)
self.assertEqual(t.get('eulvcjibif'), 2)
t.remove('rwlqyilqlt')
self.assertEqual(t.contains('rwlqyilqlt'), False)
self.assertEqual(t.contains('eulvcjibif'), True)
t.remove('eulvcjibif')
self.assertEqual(t.contains('eulvcjibif'), False)
def repeated_word(text_string):
ht = HashTable()
x = text_string.split()
count = 0
for word in x:
if word[-1] in string.ascii_letters:
if ht.contains(word.lower()):
return word
ht.add(word.lower(), count)
else:
if ht.contains(word[:-1].lower()):
return word[-1]
ht.add(word[:-1], count)
count += 1
class HashSet(AbstractSet):
def __init__(self, elements=None):
"""Initialize this hash table with the given data."""
self.table = HashTable()
if elements is not None:
for element in elements:
self.add(element)
@property
def size(self):
""" Makes size an attribute """
return self.tree.size
def __repr__(self):
"""Return a string representation of this binary tree node."""
return 'Set({!r})'.format(self.table)
def contains(self, item):
return self.table.contains(item)
def add(self, item):
if not self.contains(item):
self.table.set(item)
def remove(self, item):
self.table.delete(item)
def items(self):
return self.table.items()
class Jumble(object):
@time_it
def __init__(self, words):
"""Initialize a new Hash Table and then clean up each line to get individual
words. Add the dictionary words that equal the length of the scrambled words.
"""
self.words = words
self.hash = HashTable()
lengths = []
#Determining the lengths of the scrambled words, increases speed greatly.
for scrambled_word in words:
if len(scrambled_word) not in lengths:
lengths.append(len(scrambled_word))
with open("/usr/share/dict/words", 'r') as f:
for word in f:
#Remove endline characters
word = word.strip().lower()
#Adds the word back into a hash table from the dictionary
#Also only sets the word if it equals the length of the scrambled words
if len(word) in lengths:
self.hash.set(word, word)
def get_permutations(self, scrambled_word):
"""Get every single permutation of the scrambled word."""
permutations = []
if len(scrambled_word) == 1:
return scrambled_word
else:
for char in scrambled_word:
#Replacing parts of the scrambled word until we get down to 1 letter,
#then continue to re-add strings to the character in each call
for string in self.get_permutations(
scrambled_word.replace(char, "", 1)):
#Checking to not repeat permutations
if (char + string) not in permutations:
permutations.append(char + string)
return permutations
def find_word(self, permutations):
"""Take each of the permutation of the scrambled word and look for it in the hash
table."""
#Look up the word in the hash table
for perm in permutations:
if self.hash.contains(perm):
return self.hash.get(perm)
return "Word not Found"
@time_it
def unscramble(self):
"""Unscramble each word in our list of scrambled words."""
unscrambled = []
for word in self.words:
unscrambled.append(self.find_word(self.get_permutations(word)))
return unscrambled
def test_contains_pass_with_collsion():
hashtable = HashTable()
hashtable.add('Chuck', 40)
hashtable.add('kcuhC', 33)
hashtable.add('Ckcuh', 11)
expected = hashtable.contains('kcuhC')
actual = True
assert actual == expected
class HashSet(object):
def __init__(self, elements=None):
self.ht = HashTable()
if elements is not None:
for element in elements:
self.add(element)
def __len__(self):
return self.size
@property
def size(self):
return self.ht.size
def get(self, element):
"""Get item from the Set"""
return self.ht.get(element)
def contains(self, element):
"""return a boolean indicating whether element is in this set"""
return self.ht.contains(element)
def add(self, element):
"""add element to this set, if not present already"""
if not self.contains(element):
self.ht.set(element, element)
def remove(self, element):
"""remove element from this set, if present, or else raise KeyError"""
self.ht.delete(element)
def items(self):
return self.ht.keys()
def union(self, other_set):
"""return a new set that is the union of this set and other_set"""
return HashSet(self.items() + other_set.items())
def intersection(self, other_set):
"""return a new set that is the intersection of this set and other_set"""
return HashSet([
element for element in self.items() if other_set.contains(element)
])
def difference(self, other_set):
"""return a new set that is the difference of this set and other_set"""
return HashSet([
element for element in self.items()
if not other_set.contains(element)
])
def is_subset(self, other_set):
"""return a boolean indicating whether other_set is a subset of this set"""
for item in other_set.items():
if not self.contains(item):
# An item in our set is not in the given set
return False
return True
def test_get_null():
'''Successfully returns null for a key that does not exist in the hashtable'''
hash = HashTable()
hash.add('dog', 'bark')
hash.add('Freddie', 'Nightmare')
hash.add('Jason', 'Lake')
actual = hash.contains('Frankie')
expected = False
assert expected == actual
def test_get_collision():
'''Successfully handle a collision within the hashtable'''
hash = HashTable()
hash.add('dog', 'bark')
hash.add('god', 'karb')
actual = hash.contains('dog')
actual = hash.contains('god')
expected = True
assert expected == actual
class Set(object):
def __init__(self, items=None):
"""Initialize this hash table with the given initial size."""
self.ht = HashTable()
if items is not None:
for item in items:
self.add(item)
def __repr__(self):
"""Return a string representation of this hash table."""
return 'HashTable({!r})'.format(self.ht.keys())
def __iter__(self):
for item in self.ht.keys():
yield item
def contains(self, item):
return self.ht.contains(item)
def size(self):
return self.ht.size
def add(self, item):
return self.ht.set(item)
def remove(self, item):
return self.ht.delete(item)
def union(self, set2):
union_set = Set(
set2.ht.keys()) # Initialize union set to have contain set 2
for item in self:
union_set.add(item) # add item to set
return union_set
def intersect(self, set2):
intersect_set = Set() # Initialize an empty set
for item in self: # Iterate through items in self
if set2.contains(item): # Check if item is contained in set 2
intersect_set.add(item) # Add item to intersect set
return intersect_set
def difference(self, set2):
diff_set = Set()
for item in self:
if not set2.contains(item):
diff_set.add(item)
return diff_set
def subset(self, set2):
if set2.size() > self.size():
return False
for item in set2:
if not self.contains(item):
return False
return True
class Set(object):
def __init__(self, elements=None):
"""initialize a new empty set structure, and add each element if a sequence is given"""
self.size = 0
# map is just a dictionary with Key Value Pairs
self.map = HashTable()
if elements is not None:
for element in elements:
self.add(element)
def add(self, element):
"""add element to this set, if not present already"""
if not self.contains(element):
self.size += 1
self.map.set(element, None)
def remove(self, element):
"""remove element from this set, if present, or else raise KeyError"""
self.map.delete(element)
self.size -= 1
def contains(self, element):
"""return a boolean indicating whether element is in this set"""
return self.map.contains(element)
def union(self, other_set):
"""return a new set that is the union of this set and other_set"""
new_set = Set()
for element in self.map.keys():
new_set.add(element)
for element in other_set.map.keys():
if not new_set.contains(element):
new_set.add(element)
return new_set
def intersection(self, other_set):
new_set = Set()
for element in other_set.map.keys():
if self.contains(element):
new_set.add(element)
return new_set
def difference(self, other_set):
new_set = Set()
for element in self.map.keys():
if not other_set.contains(element):
new_set.add(element)
return new_set
def is_subset(self, other_set):
for element in other_set.map.keys():
if not self.contains(element):
return False
return True
def redact(array1, array2):
result = []
hash_table = HashTable()
for word in array2:
hash_table.set(word, word)
for word in array1:
if hash_table.contains(word) is False:
result.append(word)
return result
def repeated_word(phrase):
start = 0
word_table = HashTable()
words = phrase.split(' ')
for word in words:
if not word_table.contains(word):
word_table.add(word, word_table.hash(word))
else:
return word
return 'No matching words.'
class Set(object):
def __init__(self, elems=[]):
self.size = 0
self.table = HashTable()
for i in elems:
self.table.set(i, i)
def __str__(self):
return str(self.table.keys())
def contains(self, item):
return self.table.contains(item)
def add(self, item):
if self.contains(item):
raise ValueError("item already in set")
self.size += 1
self.table.set(item, item)
def remove(self, item):
if not self.contains(item):
raise ValueError("item not in set")
self.size -= 1
self.table.delete(item)
def union(self, set2):
new = Set()
for i in self.table.keys():
new.add(i)
for val in set2.table.keys():
if not new.contains(val):
new.add(val)
return new
def difference(self, set2):
new = Set()
for i in self.table.keys():
if not set2.contains(i):
new.add(i)
return new
def intersection(self, set2):
new = Set()
for val in self.table.keys():
if set2.contains(val):
new.add(val)
return new
def is_subset(self, set2):
for val in set2.table.keys():
if not self.contains(val):
return False
return True
class Set:
def __init__(self, elements=None):
self.hashtable = HashTable()
self.size = self.hashtable.size
def contains(self, element):
return self.hashtable.contains(element)
def add(self, element):
if self.contains(element):
raise ValueError
else:
return self.hashtable.set(element, 3)
def remove(self, element):
if self.contains(element):
self.hashtable.delete(element)
else:
return KeyError
def union(self, other_set):
new_set = Set()
for key in self.hashtable.keys():
new_set.add(key)
for key in other_set.hashtable.keys():
new_set.add(key)
return new_set
def difference(self, other_set):
new_set = Set()
for key in other_set.hashtable.keys():
if not self.hashtable.contains(key):
new_set.add(key)
return new_set
def is_subset(self, other_set):
for key in other_set.hashtable.keys():
if not self.hashtable.contains(key):
return False
return True
def splitIntoHash(path):
with open(path) as file:
lines = file.read().splitlines()
theHash = HashTable()
for line in lines:
mylist = line.split(',')
if (theHash.contains(mylist[0])):
oldVal = theHash.get(mylist[0])
if (oldVal > mylist[1]):
theHash.set(mylist[0], mylist[1])
else:
theHash.set(mylist[0], mylist[1])
return theHash
class Jumble(object):
def __init__(self, words):
'''Create a hash table and gets individual words.
adds words that are
the same length of scramble'''
self.words = words
self.hash = HashTable()
length = []
for scrambled_word in words:
if len(scrambled_word) not in length:
length.append(len(scrambled_word))
with open("/usr/share/dict/words", 'r') as file:
for word in file:
word = word.strip().lower()
if len(word) in length:
self.hash.set(word, word)
def find_permutation(self, scrambled_word):
'''get all possible permutation'''
permutation = []
if len(scrambled_word) == 1:
return scrambled_word
else:
for char in scrambled_word:
# Replcaes scramvbled letters until down to a single letter
for string in self.find_permutation(scrambled_word.replace(char, "", 1)):
if (char + string) not in permutation:
permutation.append(char + string)
return permutation
def find_word(self, permutations):
for perm in permutations:
if self.hash.contains(perm):
return self.hash.get(perm)
return "word not Found"
def unscramble(self):
unscrabled = []
for word in self.words:
unscrabled.append(self.find_word(self.find_permutation(word)))
return unscrabled
def __convert_file_into_hashtable(self, file_path):
"""
Read route costs file into a dictionary and return the result.
Runtime: Θ(n) Space: Θ(m)
n = number of lines in file
m = total entries in the hash table
"""
hash_lookup = HashTable()
with open('data/' + file_path, "r") as file:
for line in file:
line = line[:-1]
route, cost = line.split(",")
if hash_lookup.contains(route):
original_cost = hash_lookup.get(route)
if cost < original_cost:
hash_lookup.set(route, cost)
else:
hash_lookup.set(route, cost)
return hash_lookup
def table_generator(corpus_text, order):
"""Make the actual markov table."""
"""It's a hashtable with tuples, list => tuples, dictionary."""
# Corpus in linkedlist form
corpus_ll = LinkedList(corpus_text)
# Window and the table
window_queue = LinkedList()
current_table = HashTable()
# Current window for iterating through corpus; order changes size
for i in range(order):
window_queue.append(corpus_text[i])
# Add above to hashtable + the word that comes after
current_table.set((window_queue.items()), [corpus_text[order + 1]])
# For the rest
for i in range(corpus_ll.length() - (order + 1)):
# Dequeue window, add next to window;
window_queue.move()
window_queue.append(corpus_text[i + order])
# Word after window
next_word = corpus_text[i + order + 1]
# Check if window exists in hash table already
# Add tuple + new word to list, or tuple and list w/ new word
if current_table.contains((window_queue.items())):
currentvalues = current_table.get(window_queue.items())
currentvalues.append(next_word)
new_value = currentvalues
current_table.set((window_queue.items()), new_value)
else:
current_table.set((window_queue.items()), [next_word])
# Turn the second element (list) into a dictionary
for key, value in current_table.items():
current_table.set(key, Dictogram(value))
return current_table
class Set(object):
def __init__(self, items=None):
self.items = HashTable() # setup Hasttable
# Insert everything
if items is not None:
for item in items:
self.add(item)
@property
def size(self):
""" Makes size an attribute """
return self.items.length()
def add(self, item):
""" Insert one item to the set if it doesn't already exist
Time complexity: O(1) since we are using hash table
"""
if not self.items.contains(item): # check if item doesn't exist
self.items.set(item, None) # add the item
def length(self):
""" Gets the length of the set
Time complexity: O(1) since we store the length in a property"""
return self.size
def is_empty(self):
""" Checks if the set is empty
Time complexity: O(1) since we store the length in a property"""
return self.size == 0
def contains(self, item):
""" Checks if item is in the set
Time Complexity: O(1) since Hash table access is constant time"""
return self.items.contains(item)
def remove(self, item):
""" Check if item exists and remove it or raise Keyerror
Time complexity: O(1) since accessing from Hashtable is constant time"""
self.items.delete(
item) # remove the item or the inner hashtable will raise error
def union(self, other_set):
""" Makes a union with the other set and returns a new set
Time complexity: O(n) since getting the keys take linear time"""
smaller = self.items
larger = other_set.items
if smaller.size > larger.size:
smaller, larger = larger, smaller
new_set = Set(larger.keys())
for item in smaller.keys():
new_set.add(item)
return new_set
def intersection(self, other_set):
""" Makes an intersection between self and other set
Time complexity: O(min(m,n)) since we iterate over the smaller set"""
smaller = self.items
larger = other_set.items
if smaller.size > larger.size:
smaller, larger = larger, smaller
new_set = Set()
for item in smaller.keys():
if larger.contains(item):
new_set.add(item)
return new_set
def difference(self, other_set):
""" Gets the difference between two sets and returns it.
Time complexity: O(n) since the keys() method takes linear time"""
return Set(x for x in self.items.keys() if not other_set.contains(x))
def is_subset(self, other_set):
""" Checks if all the items in other_set are in self
Time complexity: O(n) since we are calling the keys() method that takes linear time"""
if other_set.size > self.size:
return False
return len(other_set.difference(self).items.keys()) == 0
class Set(object):
"""Set Data Structure w/."""
def __init__(self, init_size=8):
"""Initialize this hash table with the given initial size."""
self.ht = HashTable(init_size)
@property
def size(self):
"""Return size of ht."""
return self.ht.size
def contains(self, element):
"""Check if the element is store in set (self)."""
return self.ht.contains(element)
def add(self, element):
"""Add new element to set, if unique."""
self.ht.set(element, None)
def remove(self, element):
"""Remove element from set if present. Else raise keyerror."""
self.ht.delete(element) # Key error is raised in function
def union(self, other_set):
"""Return a new set that is the union of self and other_set."""
union_set = deepcopy(self)
for item in other_set.ht.items():
union_set.add(item)
return union_set
def intersection(self, other_set):
"""Return a new set that is the intersection of self and other_set."""
intersection_set = Set()
# Use smaller set in order to iterate less items and improve runtime
if self.size < other_set.size:
for item in self.ht.items():
if other_set.contains(item):
intersection_set.add(item)
else: # If other set is smaller than self
for item in other_set.items():
if self.contains(item):
intersection_set.add(item)
return intersection_set
def difference(self, other_set):
"""Return a new set that is the difference of self and other_set."""
difference_set = Set()
for item in self.ht.items():
if not other_set.contains(item):
difference_set.add(item)
return difference_set
def is_subset(self, other_set):
"""Return a boolean indicating whether other_set is a subset of this set."""
for item in other_set.ht.items():
if not self.contains(item):
return False
return True
class Set(object):
def __init__(self, elements=None):
self.hashtable = HashTable()
self.size = 0
if elements is not None:
for element in elements:
self.add(element)
def contains(self, element):
"""Returns a boolean indicating whether element is in this set
Time Complexity: O(1) >> hashtable lookup is a const operation on average case
Space Complexity: O(n) >> n is a bucket size.
"""
if not self.hashtable:
raise ValueError('Empty Hashtable')
else:
return self.hashtable.contains(element)
def add(self, element):
"""Adds element to this set, if not present already
Time Complexity: O(1) >> set method of hastable is const time
Space Complexity: O(1) >> one new space is created for new element
"""
if self.contains(element) is True:
return
else:
self.hashtable.set(element, None)
self.size += 1
def remove(self, element):
"""Removes element from this set, if present, or else raise KeyError
Time Complexity: O(n) >> delete method of hastable is const time
Space Complexity: O(n) >>
"""
if self.contains(element) is False:
raise KeyError('Element does not exist')
else:
self.hashtable.delete(element)
self.size -= 1
def union(self, other_set):
"""Returns a new set that is the union of this set and other_set
Time Complexity: O(n+m) >> two loops >> two different hashtables and each has own length
Space Complexity: O(n+m) >> creating space for new each element one by one. n + m
"""
united_set = Set()
# adding elements of self to united_set
for element in self.hashtable.keys():
united_set.add(element)
# adding elements of other_set to united_set
for element in other_set.hashtable.keys():
united_set.add(element)
return united_set
def intersection(self, other_set):
"""Returns a new set that is the intersection of this set and other_set
Time Complexity: O(n) >> travaersing through the hashtable to collect and compare the elements
Space Complexity: O(n) >> creating space for new each element one by one
"""
inter_set = Set()
# smaller set has to be iterated and its elements should be compared to larger set
if self.size > other_set.size:
big_set = self
small_set = other_set
else:
big_set = other_set
small_set = self
for element in small_set.hashtable.keys():
if big_set.hashtable.contains(element) is True:
inter_set.add(element)
return inter_set
def difference(self, other_set):
"""Returns a new set that is the difference of this set and other_set
Time Complexity: O(n) >> travaersing through the hashtable to collect and compare the elements
Space Complexity: O(n) >> creating space for new each element one by one
"""
differ_set = Set()
for element in self.hashtable.keys():
if not other_set.hashtable.contains(element):
differ_set.add(element)
for element in other_set.hashtable.keys():
if not self.hashtable.contains(element):
differ_set.add(element)
return differ_set
def is_subset(self, other_set):
"""Returns a boolean indicating whether other_set is a subset of this set
Time Complexity: O(n) >> travaersing through the hashtable to collect and compare the elements
Space Complexity: O(n) >> creating space for new each element one by one
"""
# smaller set has to be iterated and its elements should be compared to larger set
if self.size > other_set.size:
big_set = self
small_set = other_set
else:
big_set = other_set
small_set = self
for element in small_set.hashtable.keys():
if big_set.hashtable.contains(element) is True:
return True
else:
return False
class HashSet(object):
def __init__(self, elements=None):
"""Initialize this hash set; add the given items, if any"""
self.ht = HashTable()
self.size = 0
if elements:
for element in elements:
self.add(element)
def elements(self):
"""Return all of the elements in this set"""
return self.ht.keys()
def contains(self, element):
"""Return True if the given element is in this set,
returns False otherwise.
Best case running time: Omega(?) ?
Worst case running time: O(?) ?"""
if self.size > 0 and self.ht.contains(element):
return True
return False
def add(self, element):
"""Add the given element to this set"""
if self.ht.contains(element):
raise ValueError('Element already exists')
self.ht.set(element, True)
self.size += 1
def remove(self, element):
"""Remove the given element from this set, or raise ValueError"""
if not self.contains(element):
raise ValueError('Element not found: {}'.format(element))
self.ht.delete(element)
self.size -= 1
def union(self, other_set):
"""Returns the union of other_set and this set"""
union_set = HashSet(self.elements())
for item in other_set.elements():
union_set.add(item)
return union_set
def intersection(self, other_set):
"""Returns the intersection of other_set and this set, if any elements are shared."""
intersection_set = HashSet()
for item in self.elements():
if other_set.contains(item):
intersection_set.add(item)
return intersection_set
def difference(self, other_set):
"""Returns the differemce of other_set and this set, if any elements are not shared."""
difference_set = HashSet()
for item in self.elements():
if not other_set.contains(item):
difference_set.add(item)
return difference_set
def is_subset(self, other_set):
"""Returns True if other_set is a subset of this set, returns False otherwise."""
for item in other_set.elements():
if not self.contains(item):
return False
return True
def setup():
table = HashTable(len(words) + 1)
for i in range(0, len(words)):
# Our initial implementation of Hashtable is so limited (no resize/load)
# That I might as well use a LinkedList for the innerTable, Because
# Our HashTable with an initial size of 1, is essentially a LinkedList
# The only way to improve this is recreating the HashTable with size + 1
# with each new word for a word
# I could use the table.get surrounded by a try-except instead of contains
begin = False
end = False
word = words[i]
# If the word starts a sentence
if "BEGINSENT" in word:
begin = True
word = word[(len("BEGINSENT")):]
# If the word ends a sentence
if "ENDSENT" in word:
end = True
word = word[:-(len("ENDSENT"))]
# We have to remove any beginning or ending flags for the next word (word2)
# in order to add the next word (word2) to the current word's innertable
word2 = ""
# We have to check that we're not at the end of the for-loop
if (i + 1 != len(words)):
word2 = words[i + 1]
word2.replace("\n", "")
# If the next word starts a sentence,
if "BEGINSENT" in word2:
word2 = word2[(len("BEGINSENT")):]
# If the next word ends a sentence
if "ENDSENT" in word2:
word2 = word2[:-(len("ENDSENT"))]
# I could also do a check to see if the word is an ending word, then
# proceed to add only the ending token. However, I decided to add
# both the next word and possibly the ending token because lyrics are
# are really short.
# If the table contains the word already
if table.contains(word):
lis = table.get(word)
# Increment the total number of tokens that can come after this word
lis[0] += 1
# This variable represent the total number of times the word that comes
# after this word in the for-loop appears
tup = 0
# if the the current word isn't the end of the for-loop, meaning
# that it has a word coming after the current one
# (The word at the end of the loop is automatically an ending word)
if i + 1 != len(words):
# Try to find the word, if the word isnt in there, then the
# get method throws an error so catch it
# We want to set the "tup" variable to how many times the word
# has already appeared
try:
tup = lis[1].get(word2)
except:
tup = 0
# Then we reset the next word but increment the number of times
# the next word appears after the current word
lis[1].set(word2, tup + 1)
# If the word is new to the table
else:
lis = [None, None]
lis[0] = 1
lis[1] = HashTable(1)
lis[1].set(word2, 1)
table.set(word, lis)
# Technically we could've used the same character for both beginning
# and ending since they wont live in the same space (table vs innertable)
# If the word is an end of a sentence (or if it's at the end of the
# for-loop then it's automatically the end of the sentence)
# then we need to account for how likely is it to end the sentence
# It's stored inside the innertable
if end:
lis = table.get(word)
lis[0] += 1
tup = 0
try:
tup = lis[1].get("]")
except:
# Word hasn't ended a sentence before
tup = 0
lis[1].set("]", tup + 1)
# If the word is an beginning of a sentence
# then we need to account for how likely is it to start a sentence
# We use '[' as the character to signify starting a new sentence
# It's stored in a table of it's own (not an innertable)
if begin:
# Not the first sentence starter
if table.contains("["):
lis = table.get("[")
lis[0] += 1
tup = 0
try:
tup = lis[1].get(word)
except:
# Word hasn't started a sentence before
tup = 0
lis[1].set(word, tup + 1)
# This is the first sentence starter (Happens at beginning of for-loop)
else:
lis = [None, None]
lis[0] = 1
lis[1] = HashTable(1)
lis[1].set(word, 1)
table.set("[", lis)
return table
class Set(object):
def __init__(self, elements=None):
"""Initialize this new empty set structure with the given initial size."""
self.map = HashTable()
self.size = 0 # property that tracks the number of elements in constant time
if elements is not None:
for element in elements:
self.size += 1
self.map.set(element, True)
def contains(self, element):
"""return a boolean indicating whether element is in this set."""
# return element in self.elements -> return self.elements.___contains__(element)
return self.map.contains(element)
def add(self, element):
"""add element to this set, if not present already"""
# check if its unique by
# if not self.contains(element):
if self.map.contains(element) == False:
self.map.set(element, None)
self.size += 1
return self.size
def remove(self, element):
"""remove element from this set, if present, or else raise KeyError"""
# if element in self.elements:
# if self.elements.___contains__(element):
# if self.contains(element):
self.map.delete(element)
self.size -= 1
return self.size
# else:
# raise KeyError('Element not found: {}'.format(element))
def union(self, other_set):
"""return a new set that is the union of this set and other_set"""
new_set = Set()
# for element in self.map:
# for element in self.elements.__iter__():
for element in self.map.keys():
new_set.add(element) # or new_set.add(element.data[0]) ?
for element in other_set.map.keys():
if not new_set.contains(element):
new_set.add(element)
return new_set
def intersection(self, other_set):
"""return a new set that is the intersection of this set and other_set"""
new_set = Set()
for element in other_set.map.keys():
if self.contains(element):
new_set.add(element)
return new_set
def difference(self, other_set):
"""return a new set that is the difference of this set and other_set"""
new_set = Set()
for element in self.map.keys():
if other_set.contains(element):
new_set.add(element)
return new_set
def issubset(self, other_set):
"""Return true if all the elements in a set exist in the other set, False if not."""
for item in self.map.keys():
print('item in test_set:', item)
if item not in other_set.map.keys():
return False
return True
