Funk.2

A programkód minőségét is értékelem: komment-eljünk, adjunk "olvasható" neveket a változóknak, gondolkodjunk a specifikáción.
Minden függvénynek adjuk meg a típusát (ha nem tudjuk, akkor kérdezzük meg a rendszert a :t fgv paranccsal)

1. Írjunk egy kódoló algoritmust, ami egy string-et kódol, az alábbi módon.
   - kiszűrjük a szóközöket
   - kisbetűsítünk
   - egy m széles négyszöget alkotunk a szövegből
   pl. "Alma a Fa aLatt" m=5 ->
   "almaa"
   "faala"
   "tt   "
   - majd, oszloponként olvassuk vissza a négyzet tartalmát:
   "aftlatmaalaa"
   - végül, c méretű darabokra osztjuk ezt a szöveget, szóközökkel elválasztva:
   c=5 esetén, az eredmény: "aftla tmaal aa"
                                                                                                                                                                                 2
2. Modellezzük a régi - nyomógombos - mobilt, ahol egy üzenetet úgy írtunk, hogy minden betűhöz egyszer vagy többször nyomtunk meg adott gombot. Az alábbiakban a gombokat adjuk meg, asszociálva a gomb kimenetével ha egyszer, kétszer ... van megnyomva (nevezzük oldPhone kódolásnak):
   1 - "1"
2 - "aábc2"
3 - "deéf3"
4 - "ghií4"
5 - "jkl5"
6 - "mnoóöő6"
7 - "pqrs7"
8 - "tuúüűv8"
9 - "wxyz9"
0 - "+ 0"
* - MOD_C
# - ".,#"
A forráskódban a gombokhoz tartozó karaktereket csak a következő formátumban lehet megadni: ["1", "aábc2", "deéf3", "ghií4", ..., "+ 0", ".,#"] (A * karakter hozzáadása a listához opcionális)
   A fenti kódolásnál a nagybetűket a "*" módosítóval tudjuk elérni, melyet az illető szám kódja előtt nyomunk meg. Például az "Alma" leírásának a szekvenciája: "*255562" -> [('*',1),('2',1),('5',3),('6',1),('2',1)]
   Feladat:
   a. Adjuk meg a függvényt, mely egy mondatra - Sztring-re - megmondja, ogy ábrázolható-e az oldPhone kódolásban. Például a "Lehel! 2+4=6" nem ábrázolható.
   b. Határozzuk meg egy mondat oldPhone kódját.
   
   2
3. Az until függvény használatával számítsuk ki a Haskell valós precizitását a kettes számrendszerben. 
   A precizitás a kettőnek az a legnagyobb negatív hatványa, mely kettővel osztva nullát eredményez.
   1
4. Az until függvény használatával határozzuk meg egy pozitív szám természetes alapú logaritmusának - ln(y)-nek - az értékét. Használjuk a következő sorbafejtést:
   ln(1+x) = - sum_{k,1,inf} (-x)^k/k
   Írjuk úgy a kódot, hogy minél hatékonyabb legyen a függvény. Alakítsuk át a divergens sorozatokat a ln(y)=-ln(1/y)összefüggéssel (amely akkor kell, ha |x|>=1).
   1
5. A cumul_op függvény implementálása: 
   Írjunk függvényt, mely egy listából és egy operátorból azt a listát állítja elő, mely egy pozíciójának a k-adik eleme a bemenő lista első k elemének az op szerinti összetevése. 
   Példa: 
   cumul_op (+) [2,4,3,4,3] -> [2,6,9,13,16] 
   cumul_op (++) ["a","l","m","a"]) -> ["a","al","alm","alma"] 
   Nem használható foldl/r vagy scanl/r.
   
   
   1
6. A bináris fák ábrázolásához tekintsük a következő típust:
   

   data BinFa a =
      Nodus (BinFa a) a (BinFa a)
      | Level

   mely egy bináris fát ábrázol. A következőkben a fákat rendezett keresési fáknak tekintjük: a nódusban található elem mindig nagyobb, mint a bal oldali fa összes eleme és kisebb a jobb oldali fa összes eleménél.
   Írjuk meg a következő függvényeket:
   1. A beszur függvényt, mely egy bináris fába szúr be egy elemet.
   2. A listából függvényt, egy számlistát alakít át bináris fává.
   3. A torol függvényt, mely egy bináris fából egy elemet töröl. Használjuk a MayBe típust a hibakezelésre.
   2
7. A komplex számok a+i.b alakúak, ahol a a valós része, b az imaginárius része a számnak, az i meg a -1 négyzetgyöke. Definiáljuk a C komplex szám adattípust. Írjuk meg a show, az aritmetikai műveleteknek (+,-,*,/,abs) a Haskell kódját.
   
   2
8. (opc) Implementáljuk a 2-3 keresési fákat Haskell-ben. A 2-3 fa minden eleme vagy levél, vagy egy elemet és két oldalágat, vagy két elemet és három ágat tartalmazó struktúra. A 2-3 fák előnye, hogy a beszúrás és törlés műveletek implementálhatóak hatékonyan úgy, hogy a fa mindig kiegyensúlyozott marad. A beszúrásnál például a következőképp tudunk eljárni: mindig a levél-szinten szúrunk és ha kettőnél több nódusunk van, akkor a három- vagy négy elemet elosztjuk két nódus között, ezeket adjuk vissza, ezen eseteket a gyökérben kezeljük le.
   Implementáljuk a bináris keresési fánál definiált műveleteket a 2-3 fákat tartalmazó struktúrára is (a 2-3 fák sajátossága, hogy a beszúrás és törlés műveletek során a fa kiegyensúlyozott marad).
   Implementáljuk a beszúrást (1), a törlést (3), illetve a kiíratást (1) a 2-3 fára vonatkozóan. Használjuk a Maybe Fa23 típust.
   Egy lehetséges változata a típusnak:
   

   data Fa23 a =
    Nodus2 (Fa23 a) a (Fa23 a)
    | Nodus3 (Fa23 a) a (Fa23 a) a (Fa23 a)
    | Level

   5