update zdrojaku (302ff660) · Commits · Petr Pauš / ZALG-Paus

2025/10/list_select_1.py

0 → 100644

+114 −0

Original line number	Diff line number	Diff line
		class Node:
		def __init__(self, next, data):
		self.next = next
		self.data = data

		def __str__(self):
		return str(self.data)


		class LinkedList:
		def __init__(self):
		self.head = Node(None, None)
		self.tail = self.head
		self.size = 0

		def add_at_begin(self, d):
		tmp = self.head
		self.head = Node(tmp, d)
		self.size += 1

		def __str__(self):
		tmp = self.head
		result = "["
		while tmp != self.tail:
		result += str(tmp)
		tmp = tmp.next
		if tmp != self.tail:
		result += ", "
		return result + "]"

		def append(self, d):
		self.tail.data = d
		self.tail.next = Node(None, None)
		self.tail = self.tail.next
		self.size += 1

		def find(self, d) -> Node:
		tmp = self.head
		self.tail.data = d
		while tmp.data != d:
		tmp = tmp.next
		if tmp==self.tail:
		return None
		else:
		return tmp

		def add(self, node:Node, d):
		if node==self.tail:
		raise Exception("Vlozeni za zarazku")
		node.next = Node(node.next, d)
		self.size += 1

		def delete(self, node:Node):
		if node==self.tail:
		raise Exception("Mazani zarazky")
		if node.next == self.tail:
		self.tail = node
		node.next = None
		else:
		node.data = node.next.data
		node.next = node.next.next
		self.size -= 1

		def delete_index(self, index:int):
		tmp = self.head
		k = 0
		if index>=self.size:
		raise Exception("Spatny index")
		while k<index:
		tmp = tmp.next
		k += 1

		self.delete(tmp)

		def sort(self):
		current = self.head
		while current.next!=None:
		tmp = current
		min = current

		while tmp!=None:
		if min.data > tmp.data:
		min = tmp
		tmp = tmp.next

		current.data, min.data = min.data, current.data
		current = current.next


		seznam = LinkedList()
		print(seznam)

		seznam.add_at_begin(5)
		seznam.add_at_begin(2)
		seznam.add_at_begin(6)
		seznam.add_at_begin(-100)
		print(seznam)

		seznam.append(0)
		seznam.append(-1)

		print(seznam)

		seznam2 = LinkedList()
		seznam2.append(5)

		print(seznam2)

		prvek = seznam.find(2)
		seznam.add(prvek, -100)
		print(seznam)

		seznam.sort()
		print(seznam)
		No newline at end of file

2025/10/topo.py

0 → 100644

+97 −0

Original line number	Diff line number	Diff line
		class MainNode:
		def __init__(self, data = None, next = None):
		self.data = data
		self.num_predecessors = 0
		self.next = next
		self.successor_list_head = None

		def __str__(self):
		result = f"{self.data}: num_pred: {self.num_predecessors}, succ_list: ["

		tmp = self.successor_list_head
		while tmp!=None:
		result += str(tmp.successor.data) + ","
		tmp = tmp.next
		return result + ']'

		class SuccessorNode:
		def __init__(self):
		self.successor = None
		self.next = None


		class TopoSort:
		def __init__(self):
		self.head = None
		self.size = 0

		def find_or_add(self, data) -> MainNode:
		tmp = self.head
		while tmp and tmp.data != data:
		tmp = tmp.next
		if tmp==None:
		tmp = MainNode(data, self.head)
		self.size += 1
		self.head = tmp
		return tmp

		def add_relation(self, pred, succ):
		p = self.find_or_add(pred)
		s = self.find_or_add(succ)
		succ_node = SuccessorNode()
		succ_node.successor = s
		succ_node.next = p.successor_list_head
		p.successor_list_head = succ_node
		s.num_predecessors += 1

		def __str__(self):
		result = ""
		tmp = self.head
		while tmp:
		result += f"{tmp}\n"
		tmp = tmp.next
		return result

		def find_zero_pred(self):
		tmp = self.head
		self.head = None
		while tmp!=None:
		x = tmp
		tmp = tmp.next
		if x.num_predecessors == 0:
		x.next = self.head
		self.head = x


		def get_sorted(self):
		result = []
		tmp = self.head
		while tmp != None:
		result.append(tmp.data)
		self.size -= 1
		succ_tmp = tmp.successor_list_head
		tmp = tmp.next
		while succ_tmp != None:
		p = succ_tmp.successor
		p.num_predecessors -= 1
		if p.num_predecessors == 0:
		p.next = tmp
		tmp = p
		succ_tmp = succ_tmp.next
		if self.size != 0:
		return "Not sortable"
		return result

		relations = [(1, 5),(1, 3), (3, 2), (3, 4), (5, 2), (6, 3), (2, 4)]

		T = TopoSort()
		for pair in relations:
		T.add_relation(*pair)
		print(T)
		T.find_zero_pred()
		print(T)
		result = T.get_sorted()
		print(result)

2025/10/topo2.py

0 → 100644

+87 −0

Original line number	Diff line number	Diff line
		class MainNode:
		def __init__(self, data = None):
		self.data = data
		self.num_predecessors = 0
		self.successor_list = []

		def __str__(self):
		result = f"{self.data}: num_pred: {self.num_predecessors}, succ_list: ["

		for tmp in self.successor_list:
		result += str(tmp.data) + " "
		return result + ']'

		class TopoSort:
		def __init__(self):
		self.main_list = []
		self.zero_predecessor_list = []
		self.relations = []

		def set_relations(self, rel):
		self.relations = rel

		def build_graph(self):
		for pair in self.relations:
		self.add_relation(*pair)
		print(self)

		def find_or_add(self, data) -> MainNode:
		for x in self.main_list:
		if x.data == data:
		return x
		tmp = MainNode(data)
		self.main_list.append(tmp)
		return tmp

		def add_relation(self, pred, succ):
		p = self.find_or_add(pred)
		s = self.find_or_add(succ)
		for x in self.main_list:
		print(x.data, sep = " ", end="")
		print()
		p.successor_list.append(s)
		s.num_predecessors += 1

		def __str__(self):
		result = ""
		for tmp in self.main_list:
		result += f"{tmp}\n"
		return result

		def find_zero_pred(self):
		for tmp in self.main_list:
		if tmp.num_predecessors==0:
		self.zero_predecessor_list.append(tmp)

		def get_sorted(self):
		self.build_graph()
		self.find_zero_pred()
		result = []
		size = len(self.main_list)
		for tmp in self.zero_predecessor_list:
		result.append(tmp.data)
		size -= 1
		for succ_temp in tmp.successor_list:
		succ_temp.num_predecessors -= 1
		if succ_temp.num_predecessors == 0:
		self.zero_predecessor_list.append(succ_temp)

		if size != 0:
		return "Not sortable"
		return result

		relations = [(1, 5),(1, 3), (3, 2), (3, 4), (5, 2), (6, 3), (2, 4), (2, 7), (6,5)]

		drinks = [("voda", "cola"), ("džus", "pivo"), ("rum","whisky"), ("cola","pivo"),
		("voda","rum"), ("whisky","pivo")]

		T = TopoSort()
		T.set_relations(relations)
		result = T.get_sorted()
		print(result)

		T2 = TopoSort()
		T2.set_relations(drinks)
		print(T2.get_sorted())

2025/10/topo_1.py

0 → 100644

+76 −0

Original line number	Diff line number	Diff line
		class Node:
		def __init__(self, data):
		self.data = data
		self.num_predecessors = 0
		self.successor_list = []

		def __str__(self):
		result = f"{self.data}: pred={self.num_predecessors}, list=["
		for n in self.successor_list:
		result += str(n.data) + " "
		return result + "]"

		class TopoSort:
		def __init__(self):
		self.node_list = []
		self.zero_list = []

		def find_or_add(self, data):
		for x in self.node_list:
		if x.data == data:
		return x
		new = Node(data)
		self.node_list.append(new)
		return new

		def add_relation(self, pred, succ):
		p = self.find_or_add(pred)
		s = self.find_or_add(succ)
		p.successor_list.append(s)
		s.num_predecessors += 1

		def __str__(self):
		result = ""
		for x in self.node_list:
		result += str(x) + "\n"
		return result

		def find_zero_pred(self):
		for x in self.node_list:
		if x.num_predecessors == 0:
		self.zero_list.append(x)

		def sort(self) -> list:
		self.find_zero_pred()
		result = []
		size = len(self.node_list)
		for x in self.zero_list:
		result.append(x.data)
		size -= 1
		for s in x.successor_list:
		s.num_predecessors -= 1
		if s.num_predecessors == 0:
		self.zero_list.append(s)

		if size!=0:
		return "Not sortable"
		return result

		topo = TopoSort()
		topo.add_relation(1,2)
		topo.add_relation(3,5)
		topo.add_relation(3,1)
		topo.add_relation(4,5)
		topo.add_relation(1,4)
		print(topo)
		result = topo.sort()
		print(result)

		drinks = [("voda", "cola"), ("džus", "pivo"), ("rum","whisky"), ("cola","pivo"),
		("voda","rum"), ("whisky","pivo")]

		topodrink = TopoSort()
		for d in drinks:
		topodrink.add_relation(*d)
		result = topodrink.sort()
		print(result)
		No newline at end of file

2025/10/topo_2.py

0 → 100644

+86 −0

Original line number	Diff line number	Diff line
		class Node:
		def __init__(self, data = None):
		self.data = data
		self.pred = 0
		self.succ = []

		def __str__(self):
		result = f"{self.data}: pred: {self.pred}, succ: ["
		for x in self.succ:
		result += str(x.data) + " "
		return result + ']'

		class TopoSort:
		def __init__(self):
		self.list = []
		self.zero_list = []
		self.relations = []

		def find_or_add(self, data) -> Node:
		for x in self.list:
		if x.data == data:
		return x
		tmp = Node(data)
		self.list.append(tmp)
		return tmp

		def add_relation(self, pred, succ):
		p = self.find_or_add(pred)
		s = self.find_or_add(succ)
		p.succ.append(s)
		s.pred += 1

		def find_zero_pred(self):
		for x in self.list:
		if x.pred==0:
		self.zero_list.append(x)

		def sort(self):
		self.find_zero_pred()
		result = []
		size = len(self.list)

		for x in self.zero_list:
		result.append(x.data)
		size -= 1

		for s in x.succ:
		s.pred -= 1
		if s.pred==0:
		self.zero_list.append(s)

		if size!=0:
		return "No solution"
		return result

		def __str__(self):
		result = ""
		for x in self.list:
		result += f"{x}\n"
		return result



		topo = TopoSort()
		topo.add_relation(1,2)
		topo.add_relation(1,3)
		topo.add_relation(1,4)
		topo.add_relation(4,2)
		topo.add_relation(3,5)
		topo.add_relation(5,4)
		#topo.add_relation(5,1)
		print(topo)

		result = topo.sort()
		print(result)
		print(topo)


		drinks = [("voda", "cola"), ("džus", "pivo"), ("rum","whisky"), ("cola","pivo"),
		("voda","rum"), ("whisky","pivo")]

		topo2 = TopoSort()
		for x in drinks:
		topo2.add_relation(x[0], x[1])
		print(topo2)
		print(topo2.sort())
		No newline at end of file