Hetedik házi feladat

paranthesis_depth (1 pont)

Írjunk egy parenthesis_depth nevű függvényt, aminek

bemenete: egy string, ami jól van zárójelezve és zárójeleken kívül csak kisbetűs, alfanumerikus karaktereket és műveleti jeleket tartalmaz
kimenete: egy ugyanolyan hosszú string, amiben a zárójeleket meghagyjuk, azon kívül pedig minden karaktert lecserélünk egy számra, ami akkora, ahány mélyen volt az a karakter zárójelek közé zárva

Kilencnél több zárójel nem lesz egymásba ágyazva!

Példa

a*(b+c) → 00(111)
-(1/(2-3)) → 0(11(222))

descartes_product (1 pont)

Írjunk descartes_product nevű függvényt, aminek

bemenete: tetszőleges számú argumentum, melyek mindegyike egy halmazt reprezentál; duplikátumokat nem tartalmazó, iterálható objektum
kimenete: a bemenetek Descartes szorzata

Ha a bemenetben n-db halmaz van, akkor a kimenet n-hosszú tuple-ök listája legyen!
A kimenetben a tuple-ök sorrendje nem számít, de a tuple-ökön belül azt a sorrendet kell tartani, amiben a bemeneti listák voltak.
Ha a bemenetben akár egyetlen üres halmaz is található, akkor az eredmény egy üres lista legyen.

Példa

[1,2,3] → [(1,), (2,), (3,)]
[1,2], ['a','b'] → [(1,'a'), (1,'b'), (2,'a'), (2,'b')]
De a fentire nem jó ez: [('a', 1), ...]
[1,2], ['a','b'], [3,4,5] → [(1,'a',3), (1,'a', 4), ...]
[1,2], [], ['a','b'] → []

Segítség

Először csináljuk meg úgy, hogy 0 vagy 1 darab halmazra működjön.Ezután alkalmazhatunk rekurziót: vegyük n-1 darab halmaz Descartes szorzatát, majd csináljunk vele valamit, amivel az n-edik halmaz elemeit hozzátesszük.

Érdekesség

Ha a bemeneti halmazok rendre n₁, n₂ ... n_k eleműek,akkor a kimenet elemszáma n₁*n₂ ... *n_k lesz.Sőt, ez maga a szorzás definíciója bővebben itt

matrixlog (1 pont)

A függvényünk bemenete:

n, a dimenziók száma
M, egy n-dimenziós mátrix, lista formájában

Az n-dimenziós mátrix azt jelenti, hogy egy olyan lista, aminek minden eleme egy (n-1)-dimenziós mátrix. Az 1-dimenziós mátrix csak simán számok listája.

A mátrixban minden számot szeretnénk a kettes alapú logaritmusára megváltoztatni, de csak két tizedesjegy pontossággal szeretnénk az új számokat. Adjuk vissza az így kapott új mátrixot!

Segítség:

A math.log() függvénnyel tudunk logaritmust számolni.
Ha a beépített round() függvénynek megadjuk második paraméternek hogy 2, akkor 2 tizedesjegy pontossággal kerekít.
Rekurzióval a legkönnyebb megoldani a feladatot.
Két lehetséges hozzáállás van:
- Kihasználjuk hogy a lista egy mutable típus, és az eredeti mátrixnak változtatjuk meg az elemeit
- A függvény egy másolatot ad vissza a megfelelően módosított mátrixról
Mindkettő elfogadható itt, de vigyázzunk, ha keverjük a kettőt a megoldáson belül, az valószínűleg nem fog működni.

tree_cut (2 pont)

A kertészünk nagyon lelkes. Miután végzett a kertünkkel, a memóriában levő fákat is megnyesi. Egy nyesés abból áll, hogy levágja a fa összes levelét. Ezek a gráf értelemben vett levelek, tehát azok, ahova csak egy él mutat a fából, jelen esetben ezek az üres listák. A nyesés után a gráf új elemei válhatnak levelekké, de akkor azokat csak a következő nyesés távolítaná el.

Nézzünk egy példát. Egy nyesés után ebből a fából:
[[[[], []], [[], []]], [[], [], []]]
Ez lesz:
[[[], []], []]
(Ugyanezek a fák így néznek ki Python Tutor-on)

A feladat a tree_cut nevű függvény megírása. Ez a függvény egy paramétert vár:

fa, egy fa gráf, listák listájaként

A függvény térjen vissza a megnyesett fával!

Segítség:

A megoldáshoz rekurziót érdemes használni. Azonban vigyázni kell, hogy nehogy azokat a leveleket is töröljük, amik a rekurzív függvényhívás folyamán lettek levelek.

calculator_basic (1 pont)

Írjunk egy kifejezéseket értelmező osztályt, ami elkészít egy megadott sztringnek a kifejezésfáját.

Az osztály neve legyen Node, ahogyan a gyakorlaton.
Egy Node tartalmazzon data adattagot, ami vagy egy szám (float) vagy egy műveleti jel (str).
Ha data egy műveleti jel, akkor a left és right adattag a két operandus legyen (bal és jobb), melyek szintén Node objektumok.
Legyen az osztálynak egy konstruktora, ami egy sztringből előállítja a kívánt kifejezésfát, és egy calculate metódusa, ami ki is számolja az értékét.
A kifejezés olyan lesz, hogy csak a 4 alapművelet (+, -, * és /) és a hatványozás (^) lesz benne és számok. Más művelet, zárójel vagy egyéb szimbólum nem.

megtekinthető itt

Figyelem!

Figyeljünk a műveleti sorrendre
- a hatványozás a legmagasabb precedenciájú
- utána a szorzás és osztás
- majd az összeadás és kivonás

Figyeljünk az azonos precedenciájú műveletek asszociáltságára

1-2-3 = (1-2)-3 != 1-(2-3)
1/2/3 = (1/2)/3 != 1/(2/3)

calculator_paranthesis (2 pont)

Egészítsük ki a számológép Node osztályát, hogy tudjon zárójeleket kezelni.
Az előző gyakorlaton volt egy hasznos függvény, ami a zárójelekben található kifejezéseket lecserélte dollárjelekre.

A zárójelet úgy lehet magasabb precedenciájúvá tenni, hogy a kifejezésfa aljára kényszerítjük. Vagyis a fa tetején legyenek a nem zárójeles műveletek és lejjebb a zárójelbe zárt kifejezések.
Ehhez először úgy kell kezelni a kifejezést, mintha a zárójelbe lévő rész nem is lenne, és a maradékban megtalálni a műveleteket.
Ha egy kifejezésben nincs zárójel, akkor ezzel nem rontunk el semmit.
Ha az egész kifejezés zárójelbe van bezárva, akkor viszont egyszerűen elhagyható a körülötte lévő zárójel.
(1+1) = 1+1

Kell tudnunk tesztelni, hogy egy adott kifejezés teljes egészébenzárójelben van-e, ehhez is használható az előbb említett dollárjelre cserélő kód.

calculator_function (2 pont)

Ezen feladatban tovább kell fejleszteni a számológép Node osztályát úgy, hogy most már tudjon bizonyos beépített függvényeket kezelni:

szögfüggvények: sin, cos. Például:
```
cos(0)*sin(5+6*3)
```
faktoriális: ! például:
```
(2*3)!
```

Figyelem, a függvények tekinthetőek egyváltozós operátoroknak, vagyis a kifejezésfában egy csúcs lehet "sin", "cos" vagy "!" és ekkor az egyik gyereke legyen az, aminek a szinuszát, koszinuszát vagy faktoriálisát akarjuk venni.

A "sin" és "cos" csúcsoknak a right adattagja legyen a szögfüggvény hasában lévő kifejezés, mert az operandusa a függvény nevétől jobbra található.
A "!" csúcsnak a left adattagja legyen az aminek a faktoriálisát akarjuk, mert ez egy olyan egyváltozós művelet, aminek az operandusa tőle balra szerepel.
A szögfüggvények élvezzenek precedenciát minden más művelettel szemben. Például:
```
cos(1)^2 = (cos(1))^2
```
A faktoriális magasabb precendenciájú legyen, mint a már meglévő műveletek, de alacsonyabb, mint a szögfüggvények. Például:
```
1 + 2! = 1 + (2!)
```
és
```
cos(0)! = (cos(0))!
```

Segítség

Az rfind metódus rész-sztringet is tud keresni egy sztringben.
Használjuk a math függvénykönyvtár beépített függvényeit.

Megjegyzés

A faktoriális hasában mindig nem-negatív egész szám fog állni, bár létezik általánosítása, amivel tört szám faktoriálisát is lehet definiálni: gamma függvény.