Deklaratív programozás nagyzárthelyi
                      Révkomárom, 2004. március 24.
                  ====================================
            SML megoldások, V1.1, dp04s-zh1rk-mlmegol.txt
            =============================================


5. Az alábbi, egymástól független, szintaktikailag helyes
   SML-kifejezésekben kifejezésenként két-két hiba van.  Mik ezek?

   (a) [1 > 2.0, #"a" > #"b", 7*3]
       - különböző típusú elemek (bool, int) vannak a listában
       - az 1 > 2.0 relációban real helyett int típusú szám kell

   (b) (97, 3=2, 12) = (chr "a", (1,2), 5+7)

       - a chr függvény argumentuma is, eredménye is rossz típusú, az
         utóbbi miatt a hármasok első tagjának eltérő a típusa (int és
         char)
       - a hármasok második tagjának is eltérő a típusa (bool és int*int)

   (c) map (fn (x,_) => round(x+1) ) [3.1, 4.2, 5.3]
       - a listaelemek típusa nem jó, mert a névtelen függvény párokat vár
       - a round függvény argumentumának nem jó a típusa

Pontozás (összesen max. 7 pont):
   5.a - 5.c  Helyes válasz 2-2-3 pont.
   Az 5.b esetben két pontot ér az is, ha egynek tekinti a kettős hibát.
   Az 5.c esetben a névtelen függvény mint hibaok megtalálása 1 pontot, a
   hiba pontosabb megfogalmazása 2 pontot ér.


6.  Mi a k értéke az alábbi, egymástól független deklarációk kiértékelése
    után?

   (a) val (_::_::_::k) = tl(explode "AlMa")
          k = [] : char list

   (b) val k = map (fn x => x > 3) [1,7,3,5]
          k = [false, true, false, true] : bool list

   (c) val (_::k::_) = List.filter Char.isUpper (explode "sZiLvA")
          k = #"L" : char

Pontozás (összesen max. 7 pont):
   6.a - 6.c  Helyes válasz 2-2-3 pont.
   A feladatokban csak a kifejezések értékét kérdezzük, a típusukat nem!


7. Nézzük a következő függvények definícióját!

   fun comb (x::xs, y::ys) = (y, x) :: comb(ys, xs) | comb _ = []
   fun f zs = map (fn (a,b) => a-b) (comb(zs, tl zs))

   (a) Mi az x értéke az alábbi, egymástól független deklarációk
       kiértékelése után?

     (a1) val x = f [1,2,3,4,5]
             x = [1, ~1, 1, ~1] : int list

     (a2) val x = f [~1]
             x = [] : int list

     (a3) val x = f [~1,1]
             x = [2] : int list

     (a4) val x = f []
             az mosml hibát jelez

   (b) Mutassa be a comb([1,2,3,4], [2,3,4]) függvényalkalmazás
       egyszerűsítési lépéseit, mohó kiértékelést feltételezve!

       comb([1,2,3,4], [2,3,4]) --> (2,1) :: comb([3,4], [2,3,4]) -->
       (2,1) :: (2,3) :: comb([3,4], [4]) -->
       (2,1) :: (2,3) :: (4,3) :: comb([], [4]) -->
       (2,1) :: (2,3) :: (4,3) :: [] --> ... --> [(2,1),(2,3),(4,3)]

Pontozás (összesen max. 7 pont):
   7.a Minden helyes válaszért 1-1 pont.
   7.b Helyes válaszért 3 pont.
   A 7.b esetén nem elvárás az ennyire részletes kifejtés.


8. Átlaghármasnak nevezzük egy egészlista három szomszédos elemét, ha
   közülük az első és a harmadik elem átlaga a második elemmel egyezik meg.
   Írjon olyan SML-függvényt atlag néven, amelynek eredménye egy
   egészlistában lévő átlaghármasok száma.  Segédfüggvényt definiálhat
   (fejkommenttel!).

  (* atlag : int list -> int
     atlag zs = a zs-beli átlaghármasok száma
  *)

   Példák:
           atlag [1,1] = 0;
           atlag [1,2,1] = 0;
           atlag [1,0,~1] = 1;
           atlag [1,2,3,4] = 2;
           atlag [4,1,2,3,2,1] = 2;
           atlag [2,4,6,8,2,3,4] = 3;

   Egy megvalósítása:

   fun atlag (x::y::z::xs) =
         (if x+z=2*y then 1 else 0) + atlag (y::z::xs)
     | atlag xs = 0

Pontozás (összesen max. 9 pont):
   Minden kisebb hibáért 1-1 pont, minden súlyos hibáért 2 vagy 3 pont
   levonás. Súlyos hibának számít pl. az else ág elhagyása (-2 pont) vagy
   a végtelen rekurzió (-3 pont).
   Nem követelmény a hatékony program.