2. Priebežný test z Programovania (1) 2021¶

Vo všetkých úlohách odovzdávaš funkciu alebo triedu, ktorá ju rieši. V odovzdanom riešení nepoužívaj import ani niektoré iné príkazy.

Napíš funkciu pascal(n), ktorá zostrojí dvojrozmernú tabuľku (zoznam zoznamov) prvých n riadkov Pascalovho trojuholníka. Táto dvojrozmerná tabuľka bude obsahovať Pascalov trojuholník otočený, tak že 0-riadok bude v ľavom hornom rohu. Každý ďalší riadok sa nachadza šikmo pod predchádzajúcim. Napríklad:
```
>>> print(*pascal(5), sep='\n')
    [1, 1, 1, 1, 1, 1]
    [1, 2, 3, 4, 5]
    [1, 3, 6, 10]
    [1, 4, 10]
    [1, 5]
    [1]
```
Zadefinuj:
```
def pascal(n):
    ...
```

Prepíš funkciu urob tak, aby namiesto kreslenia čiar vrátila množinu súradníc (tuple dvoch čísel) červených nakreslených krížikov. Samozrejme, že pritom nepoužiješ tkinter a nebude tu fungovať ani enumerate:

def urob(x, y, d, u=0):
    if d < 10:
        canvas.create_text(x, y, text='+', fill='red')
    else:
        dxy = (((d, 0), (0, -d), (-d, 0), (0, d)) * 2)[u:u+4]
        x0, y0 = x, y
        for i, (dx, dy) in enumerate(dxy, u):
            urob(x0, y0, d * .4, i % 4)
            canvas.create_line(x0, y0, x0 + dx, y0 + dy)
            x0, y0 = x0 + dx, y0 + dy

Napríklad, by to malo fungovať takto:

>>> m = urob(20, 120, 100)
>>> print(len(m))
    64
>>> m = urob(20, 70, 50)
>>> print(len(m))
    16

Uvedom si, že program by mal správne fungovať aj pre viac spustení.

Máme danú dvojrozmernú tabuľku, ktorá môže mať rôzne dlhé riadky. Pre dĺžku riadkov v tabuľke platí, že každý ďalší nie je kratší ako predchádzajúci. Napíš funkciu otoc(tab), ktorá otočí túto tabuľku o 90 stupňov (v smere otáčania hodinových ručičiek). Napríklad:
```
>>> c = [[1], [2, 3], [4, 5, 6]]
>>> print(*c, sep='\n')
    [1]
    [2, 3]
    [4, 5, 6]
>>> print(*otoc(c), sep='\n')
    [4, 2, 1]
    [5, 3]
    [6]
```
Zadefinuj:
```
def otoc(tab):
    ...
```

V textovom súbore sú slová oddelené medzerami, prípadne koncami riadkov. Napíš funkciu subor(meno_suboru, typ), ktorá spracuje tieto slová a z niektorých z nich vytvorí výsledný zoznam (funkcia vráti tento zoznam ako výsledok):
- ak je parameter typ znakový reťazec, do výsledného zoznamu pridá všetky slová začínajúce týmto reťazcom
- inak, je tento parameter pythonovským typom (napríklad int), do výsledného zoznamu vtedy pridá všetky prekonvertované slová týmto typom (ak sa to dá), napríklad všetky celé čísla
Zadefinuj:
```
def subor(meno_suboru, typ):
    ...
```

Napíš funkciu pocitaj(*post) s nepárnym počtom parametrov: každý parameter na nepárnom mieste je celé číslo, každý párny parameter je celočíselná funkcia (jej referencia) definovaná s dvoma parametrami. Funkcia postupne vyhodnotí takto zadanú postupnosť: postupne zoberie najprv prvé tri hodnoty (teda číslo, funkcia, číslo), vypočíta ich hodnotu (volaním funkcia(číslo, číslo)) a ďalej pokračuje s touto vypočítanou hodnotou a ďalšími dvoma parametrami, … Napríklad:
```
>>> pocitaj(7)
    7
>>> f = lambda a, b: 3*a-2*b
>>> pocitaj(7, f, 6)
    9
>>> pocitaj(7, f, 6, int.__add__, 5)
    14
```
Zadefinuj:
```
def pocitaj(*post):
    ...
```

Dodefinuj metódy triedy:

class Cisla:
    ...

tak, aby fungovalo:

>>> Cisla(5, 3, 4)    # parametrami je ľubovoľný nenulovy počet celých čísel
    12
>>> c = Cisla(5, 3, 4, 2)
>>> c.max()
    5
>>> c.sucin()
    120
>>> c                 # __repr__ vráti súčet
    14
>>> type(c)
    <class '__main__.Cisla'>

Zadefinuj dvojicu funkcii: prvá funkcia slovnik_pismen(slovo) pre dané slovo (ľubovoľný reťazec) vráti slovník s frekvenciou jednotlivých písmen v slove. Druhá funkcia rovnake_pismena(slovo1, slovo2) pomocou prvej pre dané dve slová zistí, či sú zložené z rovnakých písmen (možno v inom poradí). Napríklad:
```
>>> slovnik_pismen('kabat')
    {'k': 1, 'a': 2, 'b': 1, 't': 1}
>>> rovnake_pismena('atbak', 'kabat')
    True
>>> rovnake_pismena('abkt', 'abakt')
    False
```
Zadefinuj:
```
def slovnik_pismen(slovo):
    ...

def rovnake_pismena(slovo1, slovo2):
    ...
```

Vygeneruj všetky výrazy s tromi celočíselnými členmi v tvare 'a # b # c', kde a, b, c sú z intervalu <od, do> a operácie # sú buď + alebo *, napríklad '3 + 2 * 1' alebo '2 * 2 * 3'. Napíš funkciu zoznam(od, do), ktorá vráti utriedený zoznam dvojíc (výraz, hodnota) všetkých vygenerovaných výrazov, pričom výraz (znakový reťazec) je vygenerovaný výraz a hodnota je hodnota tohto výrazu. Výsledný zoznam je utriedený podľa týchto hodnôt. Napríklad:
```
>>> zoznam(3, 3)
    [('3+3+3', 9), ('3*3+3', 12), ('3+3*3', 12), ('3*3*3', 27)]
```
Zadefinuj:
```
def zoznam(od, do):
    ...
```

Predpokladaj, že máme niekoľko rovnakociferných celých čísel. Napíš funkciu po_cifrach(*cisla), ktorá vráti zoznam súčtov cifier: prvý súčet všetkých prvých cifier, druhý súčet druhých, … Napriklad:
```
>>> po_cifrach(12, 34, 56)
    [9, 12]
>>> po_cifrach(1234, 5678)
    [6, 8, 10, 12]
```
Zadefinuj:
```
def po_cifrach(*cisla):
    ...
```

Vygeneruj program pre Turingov stroj, ktorý prejde vstupnú pásku zľava doprava a vymení symboly na páske za nami zadané symboly. Napíš funkciu program(*dvoj), ktorá dostáva postupnosť dvojznakových reťazcov. Tieto reťazce popisujú dvojice znakov pre generovaný program: každý výskyt na páske prvého znaku z dvojice sa má nahradiť druhým znakom. Program na konci reťazca skončí v stave 'stop'. Mal by byť spustiteľný v Turingovom stroji z prednášky. Napriklad takéto volanie:
```
>>> program('aA', 'bB')
    ...
```
Zadefinuj:
```
def program(*dvoj):
    ...
```

Riešenie odovzdaj v súbore test.py (môžeš si ho stiahnuť z L.I.S.T.u), pričom prvé tri riadky súboru budú obsahovať:

# 2. priebezny test 2021
# student: Janko Hrasko
# datum: 13.12.2022

zrejme ako študenta uvedieš svoje meno.