def get_llst(lst1, lst2):
llst1 = LinkedList()
llst2 = LinkedList()
for value in lst1:
llst1.append(value)
for value in lst2:
llst2.append(value)
return llst1, llst2
def pl_true(formula, model):
# zavisi na resenem problemu
if formula == "kb":
return model == LinkedList([("p3", True), ("p2", True), ("p1", True)]) or \
model == LinkedList([("p3", True), ("p2", True), ("p1", False)])
if formula == "alpha":
return model == LinkedList([("p3", True), ("p2", True), ("p1", True)]) or \
model == LinkedList([("p3", False), ("p2", True), ("p1", True)]) or \
model == LinkedList([("p3", True), ("p2", True), ("p1", False)]) or \
model == LinkedList([("p3", False), ("p2", True), ("p1", False)])
if formula == "beta":
return model == LinkedList([("p3", True), ("p2", True), ("p1", True)]) or \
model == LinkedList([("p3", True), ("p2", False), ("p1", True)]) or \
model == LinkedList([("p3", False), ("p2", True), ("p1", True)]) or \
model == LinkedList([("p3", False), ("p2", False), ("p1", True)])
def andor(start):
heap = [(0, 0, LinkedList([(0, 0, 0, start, Nil)]), Nil)]
while True:
try:
f, g, nodes, solved = heapq.heappop(heap)
except IndexError: # fronta je prazdna
raise ValueError("Reseni neexistuje.")
if nodes == Nil: # seznam uzlu k vyreseni je prazdny
return reconstruct_search_tree(solved)
_, g1, c, node, path = nodes.head
if is_goal(node):
solved = Cons((node, Cons(node, path)), solved)
heapq.heappush(heap, (f - h(node) - c, g - c, nodes.tail, solved))
elif f <= biggest:
succ = get_successors(node)
if succ is None: # narazili jsme na necilovy uzel
continue
op, successors = succ
path1 = Cons(node, path)
if op == "and":
nodes1 = nodes.tail
for m, c in successors:
if not member(m, path1):
nodes1 = insert((g1 + c + h(m), g1 + c, c, m, path1),
nodes1)
f = g + c + h(m)
g = g + c
heapq.heappush(heap, (f, g, nodes1, solved))
if op == "or":
for m, c in successors:
if not member(m, path1):
nodes1 = insert((g1 + c + h(m), g1 + c, c, m, path1),
nodes.tail)
heapq.heappush(heap,
(g + c + h(m), g + c, nodes1, solved))
def print_bst(root):
'''
Print complete BST by level
'''
if not root:
return
queue = LinkedList()
print(root.data)
queue.add(root)
while not queue.is_empty():
# Dequeue
visiting = queue.pop(idx=0).data
if visiting.left:
print(visiting.left.data, end=', ')
queue.add(visiting.left)
if visiting.right:
print(visiting.right.data, end=', ')
queue.add(visiting.right)
if visiting.right.data > queue.peek(idx=0).data.data:
print()
print()
def air_neighbours_available(self):
'''Returns a list with neighbours with open airport'''
a_n_a = LinkedList()
for neib in self.air_neighbours:
if self.open_airport and neib.open_airport:
a_n_a.append(neib)
return a_n_a
def neighbours_available(self):
'''Returns list with neighbours with opened fronteir'''
n_a = LinkedList()
for neib in self.neighbours:
if self.open_fronteir and neib.open_fronteir:
n_a.append(neib)
return n_a
def partition(linked_list, x):
first_low = first_high = low_tail = high_tail = None
node = linked_list.head
while node != None:
next = node.next
node.next = None
if node.data < x:
if low_tail:
low_tail.next = node
else:
first_low = node
low_tail = node
else:
if high_tail:
high_tail.next = node
else:
first_high = node
high_tail = node
node = next
low_tail.next = first_high
return LinkedList(first_low)
def queens(n):
problem = Problem()
domain = range(n + 1)[1:]
variables = LinkedList(list("X%d" % i for i in range(n + 1)[1:]))
for name in variables:
problem.addVariable(name, domain)
constr_all(problem, variables)
return problem
def setUp(self) -> None:
self.linkedlist = LinkedList()
node1 = Node()
node2 = Node()
node1.next = node2
node3 = Node()
node2.next = node3
self.linkedlist.head = node1
def __init__(self, name, initial_population):
self.name = name
self.initial_population = initial_population
self.healthy_total = initial_population
self.dead_total = 0
self.infected_total = 0
self.actions_queue = LinkedList()
self.neighbours = LinkedList()
self.neighbours_names = LinkedList()
self.air_neighbours = LinkedList()
self.air_neighbours_names = LinkedList()
self.open_airport = True
self.open_fronteir = True
self.has_cure = False
self.has_mask = False
self.infected_this_day = 0
self.dead_this_day = 0
def insert(node, nodes):
if nodes == Nil:
return LinkedList([node])
f = node[0]
f1 = nodes.head[0]
if f <= f1:
return Cons(node, nodes)
return Cons(nodes.head, insert(node, nodes.tail))
def intersection(llist_1, llist_2):
llst = LinkedList()
lst_1 = llist_1.to_list()
lst_2 = llist_2.to_list()
nodes = set(lst_1).intersection(set(lst_2))
for node in nodes:
llst.append(node)
return llst
def union(llist_1, llist_2):
llst = LinkedList()
lst_1 = llist_1.to_list()
lst_2 = llist_2.to_list()
nodes = set(lst_1 + lst_2)
for node in nodes:
llst.append(node)
return llst
def hanoi(n, a, b, c):
if n == 1:
return LinkedList(["%s to %s" % (a, b)])
if n < 1:
raise ValueError("n musi byt kladne")
if (n+1, a, c, b) not in hanoi_mem:
hanoi_mem[(n-1, a, c, b)] = hanoi(n-1, a, c, b)
if (n+1, a, c, b) not in hanoi_mem:
hanoi_mem[(n-1, c, b, a)] = hanoi(n-1, c, b, a)
ms1 = hanoi_mem[(n-1, a, c, b)]
ms2 = hanoi_mem[(n-1, c, b, a)]
return append(ms1, Cons("%s to %s" % (a, b), ms2))
def test_add_to_list(self):
name = "Jose"
matric = "1234"
year = 2
node = Node(name, matric, year)
linked_list = LinkedList()
linked_list.add_to_list(node)
self.assertEqual(linked_list.get_root(), node)
def __init__(self, file_population, file_borders, file_airports,
file_ramdom_airports):
self.file_population = file_population
self.file_borders = file_borders
self.file_airports = file_airports
self.file_ramdom_airports = file_ramdom_airports
self.countries = LinkedList()
self.names = LinkedList()
self.cure_progress = 0.0
self.cure_delivered = False
self.infection_detected = False
self.infection_detection_day = 0
self.actions_queue = LinkedQueue()
self.infection = None
self.day = 0
self.closed_airports_today = ""
self.closed_fronteirs_today = ""
self.gave_masks_today = ""
# sum of the new infected every day
# It does not include the healing process
self.infected_to_this_day = 0
self.infected_per_day_list = LinkedList(1)
self.dead_per_day_list = LinkedList(0)
def test_find_in_list(self):
names = ("Jose", "1234", 2), ("Rolf", "2345", 3), ("Anna", "3456", 7)
nodes = [Node(name, matric, year) for name, matric, year in names]
linked_list = LinkedList()
for node in nodes:
linked_list.add_to_list(node)
marker = linked_list.get_root()
for i in range(len(nodes) - 1, -1, -1):
self.assertEqual(linked_list.find(marker.name), nodes[i])
marker = marker.get_next()
def get_successors(node):
if node[0] == "direct":
_, x, z = node
succ = Nil
if x in stateS and z in stateU:
for y in borders:
succ = Cons((("via", x, z, y), 0), succ)
if x in distances:
for y, d in distances[x]:
succ = Cons((("direct", y, z), d), succ)
if succ == Nil:
return None
return ("or", succ)
if node[0] == "via":
_, x, z, y = node
return ("and", LinkedList([(("direct", x, y), 0), (("direct", y, z), 0)]))
def reconstruct_search_tree(leaves):
tree = dict()
for node, path in leaves:
tree[node] = "goal"
while path != Nil and path.tail != Nil:
node = path.head
parent = path.tail.head
if parent not in tree:
op, _ = get_successors(parent)
tree[parent] = (op + "_result", LinkedList([node]))
else:
op, nodes = tree[parent]
if not member(node, nodes):
tree[parent] = (op, Cons(node, nodes))
break
path = path.tail
return tree
def setUp(self):
self.link_list = LinkedList()
self.double_link_list = DoubleLinkList()
#!/usr/bin/env python
# encoding=utf-8 (pep 0263)
from __future__ import division
from linked_lists import LinkedList, Cons, Nil
from best_search import BestSearch
biggest = 99
start = (LinkedList([("t1", 4), ("t2", 2), ("t3", 2), ("t4", 20), ("t5", 20),
("t6", 11), ("t7", 11)]),
LinkedList([("idle", 0), ("idle", 0), ("idle", 0)]), 0)
precedence = dict(t1=["t4", "t5"], t2=["t4", "t5"], t3=["t5", "t6", "t7"])
def goes_before(T1, T2):
if T1 in precedence:
if T2 in precedence[T1]:
return True
for T in precedence[T1]:
if goes_before(T, T2):
return True
return False
def is_goal(state):
# zavisi na resenem problemu
waiting, _, _ = state
return waiting == Nil
#!/usr/bin/env python
# encoding=utf-8 (pep 0263)
from linked_lists import LinkedList, Cons, Nil
from best_search import BestSearch
biggest = 99
start = LinkedList([(2, 2), (3, 1), (2, 3), (2, 1), (3, 3), (1, 2), (3, 2),
(1, 3), (1, 1)])
goal = LinkedList([(1, 3), (2, 3), (3, 3), (1, 2), (2, 2), (3, 2), (1, 1),
(2, 1), (3, 1)])
def is_goal(state):
return state == goal
def move_anyYC(numbers):
if numbers == Nil:
return
xb, yb = numbers.head
if xb > 1: # pohyb mezery doleva
xl = xb - 1
new_tail = replace((xl, yb), (xb, yb), numbers.tail)
yield (Cons((xl, yb), new_tail), 1)
if xb < 3: # pohyb mezery doprava
xr = xb + 1
new_tail = replace((xr, yb), (xb, yb), numbers.tail)
yield (Cons((xr, yb), new_tail), 1)
if yb > 1: # pohyb mezery dolu
yd = yb - 1
def member(x, xs):
if xs == Nil:
return False
if x == xs.head:
return True
return member(x, xs.tail)
def h(_):
# zavisi na resenem problemu
return 0
graph = dict(a=("or", LinkedList([("b", 1), ("c", 3)])),
b=("and", LinkedList([("d", 1), ("e", 1)])),
c=("and", LinkedList([("f", 2), ("g", 1)])),
e=("or", LinkedList([("h", 6)])),
f=("or", LinkedList([("h", 2), ("i", 3)])))
goals = dict(d=True, g=True, h=True)
def is_goal(node):
# zavisi na resenem problemu
return node in goals
# tato funkce nahrazuje prologovska fakta tvaru node ---> Op:Subtrees
# a pro zadany node navraci prislusne Op:Subtrees
def path(a, z, graph):
for cesta in path1(a, LinkedList([z]), graph, 1):
yield cesta
for a, b in member_anyX(edges):
if y == a:
yield b
if y == b:
yield a
def member(x, xs):
if xs == Nil:
return False
if x == xs.head:
return True
return member(x, xs.tail)
def member_anyX(xs):
if xs == Nil:
return
yield xs.head
for x in member_anyX(xs.tail):
yield x
_graph = (LinkedList(["a", "b", "c", "d"]),
LinkedList([("a", "b"), ("b", "d"), ("b", "c"), ("c", "d")]))
# demonstracni vypis
if __name__ == "__main__":
print('Cesta v grafu\n')
print('next(path("a", "c", _graph)) : %s' % next(path("a", "c", _graph)))
def __init__(self, element_class):
"""
:param element_class: class that this linked list will store
"""
self.element_class = element_class
self._list = LinkedList()
def linkedlist(self, e1, e2, e3):
linkedlist = LinkedList(e1)
linkedlist.append(e2)
linkedlist.append(e3)
return linkedlist
#!/usr/bin/env python
# encoding=utf-8 (pep 0263)
from linked_lists import LinkedList, Cons, Nil
graph = dict(
a=("or", LinkedList(["b", "c"])),
b=("and", LinkedList(["d", "e"])),
c=("and", LinkedList(["f", "g"])),
e=("or", LinkedList(["h"])),
f=("and", LinkedList(["h", "i"])))
goals = dict(d=True, g=True, h=True)
def is_goal(node):
# zavisi na resenem problemu
return node in goals
def solve(node):
if is_goal(node):
yield node
if node in graph:
nodes = graph[node][1]
if graph[node][0] == "or":
for node1 in member_anyX(nodes):
for tree in solve(node1):
yield (node, "--->", tree)
elif graph[node][0] == "and":
for trees in solveall(nodes):
yield (node, "--->", ("and", trees))
pos1 = poslist.head
if poslist.tail == Nil:
return minimax(pos1)
_, val1 = minimax(pos1)
pos2, val2 = best(poslist.tail)
return better_of(pos1, val1, pos2, val2)
def better_of(pos0, val0, pos1, val1):
if min_to_move(pos0) and val0 > val1 or max_to_move(pos0) and val0 < val1:
return (pos0, val0)
return (pos1, val1)
start = "root"
graph = dict(root=("max", LinkedList(["a1", "a2", "a3"])),
a1=("min", LinkedList(["b1", "b2", "b3"])),
a2=("min", LinkedList(["c1", "c2", "c3"])),
a3=("min", LinkedList(["d1", "d2", "d3"])),
b1=("max", Nil),
b2=("max", Nil),
b3=("max", Nil),
c1=("max", Nil),
c2=("max", Nil),
c3=("max", Nil),
d1=("max", Nil),
d2=("max", Nil),
d3=("max", Nil))
def moves(pos):
def __init__(self, size):
self.size = int(1.3 * size)
self.table = [LinkedList() for i in range(self.size)]