Commit 783478bf authored by Ing. Petr Pauš, Ph.D.'s avatar Ing. Petr Pauš, Ph.D.
Browse files

2025

parent 8a0aa1ff

2024/11/__pycache__/bintree.cpython-312.pyc

0 → 100644
+4.41 KiB

File added.

No diff preview for this file type.

View file

2024/11/rpz.py

0 → 100644
+29 −0
Original line number Diff line number Diff line 
def rpz(s:str) -> str:

    priority = {"(":0, "+":1, "-":1, "*":2, "/":2}

    q = []

    result = []

    for x in s:

        if x.isalpha():

            result.append(x)

        if x=='(':

            q.append(x)

        if x in "+-*/":

            while len(q) and priority[q[-1]]>=priority[x]:

                result.append(q.pop())

            q.append(x)

        if x==')':

            while q[-1]!='(':

                result.append(q.pop())

            q.pop()

    while len(q):

        result.append(q.pop())

    return "".join(result)



s = "A+B*C+(D+E)*F"

result = rpz(s)

print(result)



s2 = "((A+B)*(C+D) + E)-F"

result = rpz(s2)

print(result)

2024/11/soustavy.py

0 → 100644
+9 −0
Original line number Diff line number Diff line 
def convert(x, base):

    result = []

    while x > 0:

        result.append(chr(x%base+ord('0')))

        x = x // base

    result.reverse()

    return "".join(result)



print(convert(255, 16))
 
 No newline at end of file

2024/11/taylor.py

0 → 100644
+29 −0
Original line number Diff line number Diff line 
import math

from matplotlib import pyplot as plt



def factorial(n):

    result = 1

    for i in range(2,n+1):

        result *= i

    return result



def sin(x, n = 10):

    result = 0

    for i in range(0,n):

        result += ((-1)**i) * (x**(2*i+1)) / factorial(2*i+1)

    return result



step = 0.05

start = -10

end = 10

xs = []

ys = []



while start <= end:

    xs.append(start)

    ys.append(sin(start))

    start += step





plt.plot(xs, ys)

plt.show()

2024/Zapocet/ddl.py

0 → 100644
+327 −0
Original line number Diff line number Diff line 
# Testovací skript pro odevzdání zápočtového úkolu.

# Vytvoření obousměrného spojového seznamu se zarážkou.

# Doplňte všechny metody tak, aby to prošlo testy v dolní části souboru.

# Testy jsou rozděleny na osm levelů, které můžete plnit postupně



LEVEL = 8   # zde postupně měňte číslo až do 8, čímž si zpřístupníte testy k jednotlivým levelům



class Node:

    def __init__(self, data=None):

          

        self.data = data

        self.next = None  

        self.prev = None

 

class DoublyLInkedList:

 

    def __init__(self):

        self.head = None

        self.tail = None

 

    def insert_at_begin(self, data):

        new_node = Node(data)

        if self.head is None:

            self.head = new_node

            self.tail = new_node

        else:

            self.head.prev = new_node

            new_node.next = self.head

            self.head = new_node

     

    def delete_at_begin(self):

        if self.head is None:

            return None

        elif self.head.next is None:

            data = self.head.data

            self.head = None

            self.tail = None

            return data

        else:

            data = self.head.data

            self.head = self.head.next

            self.head.prev = None

            return data

 

    def __str__(self):

        result = '['

        curr = self.head

        while(curr != None):

            if curr!=self.head:

                result += ", "

            result += str(curr.data)

            curr = curr.next

        result += ']'

        return result

    

    def str_reverse(self):

        result = '['

        curr = self.tail

        while(curr != None):

            if curr!=self.tail:

                result += ", "

            result += str(curr.data)

            curr = curr.prev

        result += ']'

        return result



    def delete_data(self, data):

        curr = self.head

        while curr and curr.data!=data:

            curr = curr.next

        

        if curr == self.head:

            self.delete_at_begin()

            return

        elif not curr:

            return

        else:

            curr.prev.next = curr.next

            if curr.next:

                curr.next.prev = curr.prev

            else:

                self.tail = curr.prev



    def empty(self):

        return self.head == None

    

    def clear(self):

        self.head = None

        self.tail = None



    def contains(self, data):

        curr = self.head

        while curr and curr.data!=data:

            curr = curr.next

        

        return curr != None



    def sort(self, asc = True):

        if not self.head:

            return



        start = self.head



        while start.next:

            curr = start

            min = start

            while curr:

                if asc:

                    if curr.data < min.data:

                        min = curr

                else:

                    if curr.data > min.data:

                        min = curr

                curr = curr.next



            start.data, min.data = min.data, start.data

            start = start.next



    def insert_at_end(self, data):

        if self.empty():

            self.insert_at_begin(data)

            return

        new_node = Node(data)

        new_node.prev = self.tail

        self.tail.next = new_node

        self.tail = new_node



    def delete_at_end(self):

        if self.empty():

            return None

        elif not self.head.next:

            return self.delete_at_begin()

        else:

            data = self.tail.data

            self.tail = self.tail.prev

            self.tail.next = None

            return data





if LEVEL >= 1:

# Testy, level 1

# převod na string a vkládání na začátek



    dll = DoublyLInkedList()

    assert str(dll) == '[]'



    dll.insert_at_begin(10)

    assert str(dll) == '[10]'



    dll.insert_at_begin(12)

    dll.insert_at_begin(13)

    assert str(dll) == '[13, 12, 10]'



    print("Level 1: OK")



if LEVEL >= 2:

# Testy, level 2

# mazání na začátku



    assert dll.delete_at_begin()==13

    assert str(dll) == '[12, 10]'



    assert dll.delete_at_begin()==12

    assert str(dll) == '[10]'



    assert dll.delete_at_begin()==10

    assert str(dll) == '[]'



    assert dll.delete_at_begin()==None

    assert str(dll) == '[]'



    print("Level 2: OK")



if LEVEL >= 3:

# Testy, level 3

# vkládání na konec a výpis pozadu



    cars = DoublyLInkedList()

    assert cars.str_reverse() == '[]'

    cars.insert_at_end("trabant")

    assert str(cars) == '[trabant]'

    assert cars.str_reverse() == '[trabant]'

    cars.insert_at_end("mazda")

    assert str(cars) == '[trabant, mazda]'

    assert cars.str_reverse() == '[mazda, trabant]'

    cars.insert_at_end("tesla")

    assert str(cars) == '[trabant, mazda, tesla]'

    assert cars.str_reverse() == '[tesla, mazda, trabant]'

    cars.insert_at_begin("skoda")

    assert str(cars) == '[skoda, trabant, mazda, tesla]'

    assert cars.str_reverse() == '[tesla, mazda, trabant, skoda]'

    cars.insert_at_begin("toyota")

    assert str(cars) == '[toyota, skoda, trabant, mazda, tesla]'

    assert cars.str_reverse() == '[tesla, mazda, trabant, skoda, toyota]'



    print("Level 3: OK")



if LEVEL >= 4:

# Testy, level 4

# mazání na konci seznamu



    assert cars.delete_at_end() == 'tesla'

    assert str(cars) == '[toyota, skoda, trabant, mazda]'

    assert cars.str_reverse() == '[mazda, trabant, skoda, toyota]'



    assert cars.delete_at_end() == 'mazda'

    assert str(cars) == '[toyota, skoda, trabant]'

    assert cars.str_reverse() == '[trabant, skoda, toyota]'



    assert cars.delete_at_begin() == 'toyota'

    assert str(cars) == '[skoda, trabant]'

    assert cars.str_reverse() == '[trabant, skoda]'



    assert cars.delete_at_end() == 'trabant'

    assert str(cars) == '[skoda]'

    assert cars.str_reverse() == '[skoda]'



    assert cars.delete_at_end() == 'skoda'

    assert str(cars) == '[]'

    assert cars.str_reverse() == '[]'



    print("Level 4: OK")



if LEVEL >= 5:

# Testy, level 5

# mazání uprostřed seznamu pomocí delete_data(data)



    drinks = DoublyLInkedList()

    drinks.insert_at_begin('limo')

    drinks.insert_at_begin('pivo')

    drinks.insert_at_begin('voda')

    drinks.insert_at_begin('dzus')

    drinks.insert_at_begin('limo')



    assert str(drinks) == '[limo, dzus, voda, pivo, limo]'

    drinks.delete_data('caj')

    assert str(drinks) == '[limo, dzus, voda, pivo, limo]'

    drinks.delete_data('limo')

    assert str(drinks) == '[dzus, voda, pivo, limo]'

    assert drinks.str_reverse() == '[limo, pivo, voda, dzus]'

    drinks.delete_data('pivo')

    assert str(drinks) == '[dzus, voda, limo]'

    assert drinks.str_reverse() == '[limo, voda, dzus]'

    drinks.delete_data('dzus')

    assert str(drinks) == '[voda, limo]'

    assert drinks.str_reverse() == '[limo, voda]'

    drinks.delete_data('limo')

    assert str(drinks) == '[voda]'

    assert drinks.str_reverse() == '[voda]'

    drinks.delete_data('voda')

    assert str(drinks) == '[]'

    assert drinks.str_reverse() == '[]'

    drinks.delete_data('voda')

    assert str(drinks) == '[]'

    assert drinks.str_reverse() == '[]'



    print("Level 5: OK")



if LEVEL >= 6:

# Testy, level 6

# metoda empty() a clear()



    odd = DoublyLInkedList()

    even = DoublyLInkedList()



    assert odd.empty() == True

    assert even.empty() == True



    for i in range(5):

        odd.insert_at_begin(2*i+1)

        even.insert_at_begin(2*i + 2)

    assert str(odd) == '[9, 7, 5, 3, 1]'

    assert str(even) == '[10, 8, 6, 4, 2]'



    assert odd.empty() == False

    assert even.empty() == False



    while not odd.empty():

        odd.delete_at_begin()



    even.clear()

    assert odd.empty() == True

    assert even.empty() == True



    assert odd.str_reverse() == '[]'

    assert even.str_reverse() == '[]'



    print("Level 6: OK")



if LEVEL >= 7:

# Testy, level 7

# metoda contains(data)



    animals = DoublyLInkedList()

    animals.insert_at_begin('pes')

    animals.insert_at_begin('kocka')

    animals.insert_at_begin('jezevec')

    animals.insert_at_begin('meduza')



    assert animals.contains('pes') == True

    assert animals.contains('meduza') == True

    assert animals.contains('slon') == False



    print("Level 7: OK")



if LEVEL >= 8:

# Testy, level 8

# metoda sort(asc)



    assert str(animals) == '[meduza, jezevec, kocka, pes]'

    animals.sort()

    assert str(animals) == '[jezevec, kocka, meduza, pes]'

    assert animals.str_reverse() == '[pes, meduza, kocka, jezevec]'



    animals.sort(False)

    assert str(animals) == '[pes, meduza, kocka, jezevec]'

    assert animals.str_reverse() == '[jezevec, kocka, meduza, pes]'



    test = DoublyLInkedList()

    test.sort()

    assert str(test) == '[]'



    test.insert_at_begin(1)

    test.sort()

    assert str(test) == '[1]'



    print("Level 8: OK")
 
 No newline at end of file