Deklaratív programozás pótzárthelyi
                      Révkomárom, 2004. április 23.
                  ====================================
            SML megoldások, V1.1, dp04s-zh2rk-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 * 2.0, ord #"a", 9.0 div 3.0]
       - különböző típusú elemek (1.2 * 2.0 : real, ord #"a" : int)
         vannak a listában
       - div az egészosztás jele, itt a / műveleti jelet kellene
         használni

   (b) ("A", 2*2=4, ~12) = (chr 65, 4, ~5-7)
       - "A" : string, chr 65 : char -- különböző a típusuk, nem
         hasonlíthatók össze
       - 2*2=4 : bool, 4 : int -- különböző a típusuk, nem
         hasonlíthatók össze

   (c) map (fn x => real(x) + 1) [3.0, 4.0, 5.0]
       - a listaelemek típusa nem jó, mert a real függvény int típusú
         értéket vár (i)
       - az int típusú 1 nem adható hozzá a real függvény real típusú
         eredményéhez (ii)

Pontozás (összesen max. 7 pont):
   5.a - 5.c  Helyes válasz 2-2-3 pont.
   Az 5.c esetben (i) 2 pontot, (ii) 1 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(tl(tl(explode "RevKomArom")))
          k = #"m"

   (b) val k = map (fn x => x <= 3) [1,7,3,9,5]
          k =  [true, false, true, false, false]

   (c) val (_::_::k) = List.filter Char.isUpper (explode "sZiLvA")
          k = [#"A"]

Pontozás (összesen max. 7 pont):
   6.a - 6.c  Helyes válasz 2-2-3 pont.
   A 6.c. esetben listában rossz érték 2 pontot, nem listában jó érték 1
   pontot ér.
   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(xs, ys) | comb (_, _) = []
   fun f zs = map (fn (a,b) => b-a) (comb(tl zs, 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([2,3,4], [1,2,3,4]) függvényalkalmazás
       egyszerűsítési lépéseit, mohó kiértékelést feltételezve!

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

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 ismétlődő lépések ennyire részletes
   kifejtése.


8. Csúcshármasnak nevezzük egy egészlista három szomszédos elemét, ha
   közülük az első és a harmadik elem összege nem kisebb a második elem
   kétszeresénél.  Írjon olyan SML-függvényt csucs3ok néven, amelynek
   eredménye egy egészlistában lévő csúcshármasok száma.  Segédfüggvényt
   definiálhat (fejkommenttel!).

  (* csucs3ok : int list -> int
     csucs3ok zs = a zs-beli csúcshármasok száma
  *)

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

   Egy megvalósítása:

   fun csucs3ok (x::y::z::xs) =
         (if x+z>=2*y then 1 else 0) + csucs3ok (y::z::xs)
     | csucs3ok 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.