def category_picking(self):
print(
f'''Hello {self.username}, lets play a game. To start, you need to pick a category.''',
end="\n\n")
ll = SingleLinkedList()
for i in self.game['categories'].keys():
ll.insert_last(i)
ll.print_list()
print()
self.category = input("Please pick a category: ")
print()
while True:
if ll.find(self.category) is None:
self.category = input(
"There is no such category. Please pick again: ")
print()
else:
word_ll = SingleLinkedList()
for i in self.list_of_categories[self.category]:
word_ll.insert_last(i)
self.word = word_ll.pick_random()
self.list_of_players[
self.username]["categories_picked"].append(
self.category.lower())
self.list_of_players[self.username]["favorite_category"] = max(
set(self.list_of_players[self.username]
["categories_picked"]),
key=self.list_of_players[
self.username]["categories_picked"].count)
break
def test_front():
l = SingleLinkedList()
for i in range(10):
l.push_back(i)
assert 0 == l.front()
l = SingleLinkedList()
for i in range(10):
l.push_front(i)
assert i == l.front()
def test_value_n_from_end():
l = SingleLinkedList()
for i in range(10):
l.push_back(i)
assert l.value_n_from_end(0) == 9
assert l.value_n_from_end(3) == 6
def topo_sort_by_dfs(dg: DirectedGraph):
adj = dg.adj
vertex_nums = len(adj)
visited = [False] * vertex_nums
reverse_adj = [SingleLinkedList() for _ in range(vertex_nums)]
# 构造逆邻接表
for i in range(vertex_nums):
v = adj[i].head
while v:
if v.val is None: break
id_ = v.val[0]
reverse_adj[id_].append((i, 1))
v = v._next
def dfs(i):
v = reverse_adj[i].head
while v:
if v.val is None or visited[v.val[0]]: break
id_ = v.val[0]
visited[id_] = True
dfs(id_)
v = v._next
print(i)
# 遍历
for i in range(vertex_nums):
if visited[i]: continue
visited[i] = True
dfs(i)
def test_seq_constructor():
l = SingleLinkedList([0, 1, 2, 3, 4])
assert l.length == 5
for i in range(5):
assert i == l.pop_front()
def test_push_back_second():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
assert l.tail.data == 4
assert l.head.data == 0
def test_erase_head():
l = SingleLinkedList()
l.push_front(1)
assert l.head.data == 1
l.erase(0)
assert l.head == None
def test_remove_value_front():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
l.remove_value(0)
assert l.head.data == 1
def test_remove_value_middle():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
l.remove_value(2)
assert l.head.next.next.data == 3
def test_remove_value_back():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
l.remove_value(4)
assert l.tail.data == 3
def test_value_at():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
assert l.value_at(0) == 0
assert l.value_at(2) == 2
assert l.value_at(4) == 4
def test_insert_tail():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
l.insert(4, 33)
assert l.tail.data == 33
assert l.length == 6
def test_erase_middle():
l = SingleLinkedList()
l.push_back(1)
l.push_back(2)
l.push_back(3)
assert l.head.next.data == 2
l.erase(1)
assert l.head.next.data == 3
def add(self, key, value):
index = self._get_hash_key(key)
if (self._hash_table[index]):
# Need to check for duplicate keys
# Overwrite value for existing key
self._hash_table[index].add_rear(key, value)
else:
hash_bucket = SingleLinkedList()
hash_bucket.add_rear(key, value)
self._hash_table[index] = hash_bucket
def test_insert_middle():
l = SingleLinkedList()
for i in range(10):
l.push_back(i)
l.insert(3, 99)
assert l.head.next.next.next.data == 99
assert l.head.next.next.next.next.data == 3
def test_instert_head():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
assert l.head.data == 0
assert l.tail.data == 4
l.insert(0, 33)
assert l.head.data == 33
def test_reverse():
l = SingleLinkedList()
for i in range(5):
l.push_front(i)
l.reverse()
assert l.head.data == 0
assert l.tail.data == 4
assert l.tail.next == None
for i in range(5):
assert l.pop_front() == i
def test_push_front():
l = SingleLinkedList()
l.push_front(1)
assert l.head.data == 1
assert l.tail.data == 1
l.push_front(2)
assert l.head.data == 2
assert l.tail.data == 1
assert l.head.next.data, l.tail.data
l.push_front(3)
assert l.head.data == 3
assert l.head.next.data == 2
def test_erase_tail():
l = SingleLinkedList()
l.push_back(1)
assert l.tail.data == 1
l.push_back(2)
assert l.tail.data == 2
l.push_back(3)
assert l.tail.data == 3
l.erase(2)
assert l.tail.data == 2
def test_push_back():
l = SingleLinkedList()
l.push_back(1)
assert l.tail.data == 1
assert l.head.data == 1
l.push_back(2)
assert l.tail.data == 2
assert l.head.data == 1
assert l.head.next.data == l.tail.data
l.push_back(3)
assert l.tail.data == 3
assert l.head.next.next.data == 3
def is_palindrome1(single_linked):
# 如果回文串长度为 0 或 1 则为回文串
if single_linked.length in [0, 1]:
return True
fast, slow = single_linked.head, single_linked.head
# 寻找中间节点
while fast._next and fast._next._next:
slow = slow._next
fast = fast._next._next
# 后半部分逆序
prev = slow._next
if not prev._next:
second_part = SingleLinkedList(prev)
else:
current = prev._next
after = prev._next._next
prev._next = None
while True:
current._next = prev
prev = current
current = after
if not current:
second_part = SingleLinkedList(prev)
break
else:
after = current._next
# 判断是否是回文串
node1 = single_linked.head
node2 = second_part.head
while node2:
if node1.val != node2.val:
return False
else:
node1 = node1._next
node2 = node2._next
return True
def test_pop_front():
l = SingleLinkedList()
for i in range(5):
l.push_back(i)
for i in range(4):
assert l.pop_front() == i
assert l.head.data == i + 1
assert l.head.data == l.tail.data
assert l.tail.data == 4
l.pop_front()
assert l.head == None
assert l.tail == None
def information_getting(self):
info = input(
"If you want to know your statistics, insert info, otherwise GAME OVER: "
)
print()
if info.lower() == "info":
print()
print(f"* {self.ranking()} * {self.username}")
ll = SingleLinkedList()
for key, value in self.game["players"][self.username].items():
if type(value) != list:
ll.insert_last(f"{key}: {value}")
ll.print_list()
print()
print("Thanks for playing. See you next time!")
exit()
def test_pop_back():
l = SingleLinkedList()
l.push_back(1)
assert l.head.data == 1
assert l.tail.data == 1
l.push_back(2)
assert l.head.data == 1
assert l.tail.data == 2
l.push_back(3)
assert l.head.data == 1
assert l.tail.data == 3
assert l.pop_back(), 3
assert l.pop_back(), 2
assert l.pop_back(), 1
def __init__(self, n: int):
"""
:param n: 顶点数
"""
self.adj = [SingleLinkedList() for _ in range(n)]
def __init__(self, n: int):
self.vertex_nums = n
self.adjacency_list = [SingleLinkedList() for _ in range(n)]
def test_iteration():
l = SingleLinkedList([0, 1, 2, 3, 4, 5])
i = 0
for element in l:
assert element == i
i += 1
fast = single_linked.head
slow = single_linked.head
# 慢指针前进过程中前半部分逆序
while fast and fast._next:
fast = fast._next._next
next_ = slow._next
slow._next = prev
prev = slow
slow = next_
# 针对奇数情况
if fast:
slow = slow._next
# 对比
while slow:
if slow.val != prev.val:
return False
else:
slow = slow._next
prev = prev._next
return True
if __name__ == "__main__":
test = SingleLinkedList()
for i in ['a', 'b']:
test.append(i)
print(is_palindrome2(test))
def test_back():
l = SingleLinkedList()
for i in range(10):
l.push_back(i)
assert 9 == l.tail.data
def __init__(self):
self.items = SingleLinkedList()
self.length = 0