cviko 1 a 2

%% Cell type:markdown id: tags:

# Úvodní cvičení

## Algoritmus

Algoritmus je v podstatě návod, jak provést určitou  činnost, a má následjící vlastnosti:

1. Je elementární.

2. Je determinovaný.

3. Je konečný.

4. Je rezultativní.

5. Je hromadný.

## Tvorba algoritmu

1. Metoda shora dolů.

2. Metoda zdola nahoru.

*Příklad: Kvadratická rovnice*

![Kvadr](kvadr.png "Kvadr")

## Vlastnosti algoritmu

* Časová náročnost

* Paměťová náročnost

* Přesnost

## Popis algoritmu

* PDL - Program Description Language

* Zjednodušený programovací jazyk

* Strukturogramy (prehistoric)

* Vývojové diagramy (dnes spíš UML a další)

*Příklad: Vývojový diagram kvadr. rovnice*

TODO

*Příklad:*

![Diagram](diagram.png "Diagram")

%% Cell type:markdown id: tags:

## Rekurentní vztahy

*Faktoriál

$n!$

*Fibonacciho posloupnost*

$F(n) = F(n-1) + F(n-2)$

$F(0) = 0, F(1) = 1$

%% Cell type:code id: tags:

``` python

calls = 0

def fib(n):

    global calls

    calls += 1

    if n==0:

        return 0

    elif n==1:

        return 1

    else:

        return fib(n-1) + fib(n-2)

def fib_o1(n):

    phi = (1.0+5.0**(1/2))/2

    return (phi**n) / (5.0**(1/2)) - ((1-phi)**n) / (5.0**(1/2))

def fib_on(n):

    if n<2:

        return n

    f0 = 0

    f1 = 1

    fn = 0

    for i in range(1,n):

        fn = f1 + f0

        f0 = f1

        f1 = fn

    return fn

n = 8

print(f"Recursive: {fib(n)}, o(1): {fib_o1(n)}, o(n): {fib_on(n)}")

print(f"Lower: {2**(n/2)}, real: {calls}, upper: {2**n}, calls2: {2*fib_on(n+1)-1}")

```

%% Output

    Recursive: 21, o(1): 21.000000000000004, o(n): 21

    Lower: 16.0, real: 67, upper: 256, calls2: 67

%% Cell type:markdown id: tags:

*Výpočet počtu volání funkce v rekurzi*

Zkusíme, jestli počet volání nějak závisí na $F(n)$. Nejprve třeba lineárně. $X(n)$ označíme počet volání fce pro $F(n)$.

$X(n) = a F(n+1) + b$

Pro $n = 1$ víme, že $X(1)=1$ a $F(2) = 1$, tedy $X(1) = a + b = 1$.

Platí, že $X(n) = X(n-1) + X(n-2) + 1$.

$a F(n+1) + b = a F(n) + b + a F(n-1) + b +1$

$a (F(n)+F(n-1)) + b = a F(n) + b + a F(n-1) + b +1$

$b = -1$, tzn. $a = 2$

Počet volání fce pro $F(n)$ je tedy $2F(n+1)-1$.

%% Cell type:markdown id: tags:

class Vehicle:

    def __init__(self, id, brand):

        self.id = id

        self.brand = brand

    def __str__(self):

        return f"{self.brand} ({self.id})"

class Bus(Vehicle):

    def __init__(self, id, brand, capacity):

        super().__init__(id, brand)

        self.capacity = capacity

    def __str__(self):

        return super().__str__() + f', Capacity: {self.capacity}'

car1 = Vehicle('ABC123', 'Ford')

car2 = Vehicle('BBBAAA', 'BMW')

bus1 = Bus('BUS1','Volvo', 30)

print(car1, car2, bus1)