Nada KTH 2004 jan 12 Tentamen Programmeringsparadigm 2D1350 Skrivtid 5 h 8-13 Antalet uppgifter : 1 (allmänt)+ 4 (Haskell) + 4 (Prolog) = 9 10p +( 5p + 14p +15p+ 16p) + (12p +10p + 10p +8p) = 10p + 50p + 40 p = 100p Lärare, jourhavande lärare : Leif Kusoffsky ------------------------------------------------------------------------------------------------------------------ Tillåtna hjälpmedel: Fokker : Functional programming Brna : Prolog Programming ----------------------------------------------------------------------------------------------------------------- Del : Paradigm allmänt. 1. a) Kan man programmera icke-objekt-orienterat i Java, dvs som i ett klassikt imperativt språk? 1) Nej, går ej att skriva program som är i stort ekvivalenta med t ex Pascal-program. X) Ja, i stort sett om funktioner är deklarerade som static. 2) Ja, om klasserna enbart har variabler och funktioner deklarerade utan static. b) Sekvenser av kommandon ("satser"), dvs att man programmerar i vilken ordning datorn skall utföra olika sker, förkommer i 1) imperativa språk men ej i objekt-orienterade språk X) ej i imperativa språk men i objekt-orienterade språk 2) både i imperativa språk och i objekt-orienterade språk c) Semantiken för imperativa språk kan förklaras enklast med 1) med hjälp av matematikens funktionsbegrepp X) med hjälp av begrepp från logiken 2) att man beskriver vad som händer i en von-neuman-maskin d) Semantiken för funktionella språk kan förklaras enklast med 1) med hjälp av matematikens funktionsbegrepp X) med hjälp av begrepp från logiken 2) att man beskriver vad som händer i en von-neuman-maskin e) Semantiken för logik- språk kan förklaras enklast med 1) med hjälp av matematikens funktionsbegrepp X) med hjälp av begrepp från logiken 2) att man beskriver vad som händer i en von-neuman-maskin f) I OO-design bör man enligt mångas åsikt i början av programutvecklingen fråga sig 1) MED VAD, dvs vilka sorts föremål i användarens värld skall jag modellera? X) VAD, dvs vilka funktioner vill användaren att programmet ska ha? 2) HUR, dvs hur skriver jag funktionerna som användaren vill att programmet skall ha? g) Vilka av följande begrepp kan förknippas med objekt-orienterade språk? "loopar" (dvs snurror, slingor), arv, lat evaluering, rekursion, dynamisk bindnig, unifiering. h) Gruppera i paradigmen imperativa, objektorienterade, funktionella och logiska: Haskell, C, Prolog, C++, Eiffel, Java, Pascal, Basic, Fortran, assemler, Smalltalk, Simula. (10p).
Del : Funktionell programmering. I alla deluppgifterna, använd Haskell och skriv typen för de identifierare du definierar (gärna så generella typer som möjligt). 2. Skriv i i Haskell en funktion maxlist som returerar de största elementet i en lista med element. Skriv helst ett så generellt typuttryck som möjligt. maxlist [] skall bli error. Exempel : Main> maxlist [5,14,2] 14 (5p). 3. a) Skriv i i Haskell en funktion eqlist som returerar om alla element i en lista med element är lika. Skriv helst ett så generellt typuttryck som möjligt. eqlist [] skall bli error. Exempel : Main> eqlist [5,14,2] False Main> eqlist [14,14,2] False Main> eqlist [14,14,14] True b) Skriv i i Haskell en funktion neqlist som returerar False om alla elementet i en lista med element är lika. neqlist skall skrivs med hjälp av eqlist.och inte som i c) c) Skriv i i Haskell en funktion neqlist som returerar False om alla elementet i en lista med element är lika. neqlist skall skrivs med hjälp av eqlist och ett lamdautttryck, dvs neqlist = <lamdauttryck>. d) Kan man i Haskell alltid byta ut neqlist mot <lamdauttryck >, dvs låta bli att alls definiera neqlist?. (14p). 4. Skriv i i Haskell en funktion maxoflists::ord a => [[a]] -> [a] som retunerar en lista med det maximala värdena i elementlistorna. Maxvärdena från de listor där alla elementen är lika skall ej finnas med i resultatlistan. Funktionerna i uppgift 2 får förstås användas. Exempel : Main> maxoflists [[5,14,2]] [14] Main> maxoflists [[5,14,2], [14,14,2], [14,14,14], [35, 36] ] [14,14,36] Main> maxoflists [[5,14,2], [14,14,2], [14,14,14], [35, 36], [] ] Program error: Empty list in eqlist Main> maxoflists [[5,14,2], [35, 36]] [14,36] a) Skriv en lösning som vare sig använder högre ordningens funktioner, ackumulering i parameter, eller listomfattning. b) Skriv en lösning som använder ackumulering i parameter. c) Skriv en lösning som använder map, filter. d) Skriv en lösning som använder listomfattning. (15p)
5. Givet: Implemntationer av en DT (datatyp) Square för schackrutor och en DT Piece och delvis en implemntation av en DT Board för att ett damliknade spel : Bool diag1, diag2 Square show String == /= betweensquare diag1 fromsquare tosquare returnerar om tosquare är snett ett steg uppåt eller nedåt, vänster eller höger, från tosquare. Funktionen diag2 returnerar analogt för två steg. Funktionen betweensquare returnerar mellanliggande ruta om diag2 fromsquare tosquare är True, annars error med lämpligt felmedellande. fromsquare betweensquare tosquare diag2 fromsquare tosquare är true Funktionerna kan användas för dragen i ett damliknade spel, diag1 när man går till tomma rutor, diag2 när man "hoppar" över en enda motståndarpjäs. module Square where data Square = Sq Int Int deriving (Show, Eq) -- predicates for geometrical relations between two squares diag1, diag2 :: Square -> Square ->Bool diag1 (Sq i1 j1) (Sq i2 j2) = (abs (i1-i2) == abs (j1-j2)) && ((i1-1 == i2) (i1+1 == i2)) diag2 (Sq i1 j1) (Sq i2 j2) = (abs (i1-i2) == abs (j1-j2)) && ((i1-2 == i2) (i1+2 == i2)) betweensquare :: Square -> Square -> Square betweensquare (Sq i1 j1) (Sq i2 j2) diag2 (Sq i1 j1) (Sq i2 j2) = Sq ((i1 + i2) div 2) ((j1 + j2) div 2) otherwise = error "wrong squares in betweensquare" Modulen Piece implementerar två datatyper: Colour som indikerar om en pjäs är vit (WhiteC) eller svart (BlackC). Piece som är en pjäs/tom ruta. T ex är Pi WhiteC en vit pjäs, NoPiece är en tom ruta. Det finns bara en sorts pjäs, fast en uppsättning vita och en uppsättning svarta. Datatypen skall också ha funktionen othercolour som framgår av signaturdiagrammet: othercolour WhiteC blir BlackC, othercolour BlackC blir WhiteC. Vänd!
othercolour Colour WhiteC BlackC Pi Piece NoPiece module Piece where data Colour = WhiteC BlackC deriving (Show, Eq) data Piece = Pi Colour NoPiece deriving (Show, Eq) othercolour :: Colour -> Colour othercolour WhiteC = BlackC othercolour BlackC =WhiteC Modulen Board implementerar en datatyp Board. Ett värde med typen Board innehåller en lista med 64 element. Varje element är ett par. Paren består av en ruta (Square) och schack pjäsen (Piece) på den rutan. Tomma rutor har "pjäsen" NoPiece. Delar av implementationen: module Board where import Piece import Square newtype Board = Board [(Square, Piece)] deriving Show pieceat :: Square -> Board ->Piece pieceat sq (Board ch) = onlyone [icm (isq, icm) <- ch, isq == sq] onlyone :: [Piece] -> Piece onlyone (cm:[]) = cm onlyone _ = NoPiece Datatypen har fler funktioner, som framgår av signaturdiagrammet: startboard Piece Square isdarksquare Bool (,) Board [] 2 2 1 1 pieceat Piece Board show String 3 [(Square, Piece)] legalmove2 Funktionen pieceat returnerar pjäsen på en viss ruta i ett damspel.
Uppgifter: a) Implementera i Board funktionen isdarksquare som returnerar om en ruta skall vara mörk. (Sq ix iy) är mörk om ix + iy är ett udda tal. b) Implementera i Board funktionen startboard::board, som definierar hur brädet med pjäser ser ut när spelet skall börja. Brädet består av 8*8 rutor växelvis mörka och ljusa. På de två översta raderna står 8 svarata pjäser på de mörka rutorna, på de nedersta raderna står 8 vita pjäser på de mörka rutorna. c) Implementera i Board funktionen legalmove2 returnerar en tom lista om en pjäsen på en viss ruta i ett damspel (argument 1) inte får flytta till en annan ruta (argument 2) på ett visst bräde (argument 3), annars en lista med ändrade rutor på bädet. Det är tillåtet att flytta diagonalt ett steg till en tom ruta, och att flytta diagonalt två rutor om mellanliggande ruta innehåller en motståndarpjäs. "Pjäsen" NoPiece får inte flyttas. Tips : Ett sätt är att används sig av en hjälpfunktion legalmove1 :: Piece {-moving -} -> Square {-from -} -> Square {-to -} -> Board -> [(Square, Piece)] (16p) Del : Logikprogrammering. 6. a) Skriv en definition i Prolog (utan att använda append/3 ) för select(x,harxs,ettmindrexs) med betydelsen att listan EttMindreXs är resultat av att en förekomst av X har tagits bort från HarXs. b) Skriv ett program i Prolog för append(xs,ys,xsys) med betydelsen att listan XsYs är listan Xs sammanslagen med Ys. c) Använda append/3 för att skriva en definition i Prolog för select(x,harxs,ettmindrexs) (12p) 7. Skriv i Prolog ett generate-and-test-program som löser följande problem (modifierat efter Sterling and Shapiro): Three friends came first, second, and third in a programming competition. Each of the three has a different first name, likes a different sport and has a different nationality. Michael likes basketball and did better than the American. Sven, the Swede, did better than the tennis player. The cricket player came first. Who is the Australian? What sport does Richard play? (10p)
8. Skriv i Prolog ett program som löser följande problem: I faktumet know finns en lista, ett exempel på hur en lista kan se ut finns nedan, med personer som känner varandra, t ex känner ada och barbro varandra eftersom elementet k(ada, barbro) finns i listan. know([k(ada, barbro), k(ada, cecilia), k(barbro, dorotea), k(cecilia, dorotea),k(cecilia,siv), k(ada, erika), k(fredrika, gerd), k(gerd, helga)]). Skriv ett predikat connection(a, B) som tar reda på om A och B känner varandra eller om det finns någon förbindelse mellan A och B, dvs om A känner någon person C som känner någon person... som känner B. Exempelvis:?- connection(ada, erika). % i Listan yes?- connection(barbro, siv). % Via dorotea, cecilia yes?- connection(ada, gerd). % Ingen förbindelse no (10p) 9. a) Om Prolog misslyckas med att unifiera argumenten i ett delmål f(..) med huvudet (konklusionen) i den första av flera klausuler som definierar predikatet f så 1) svarar Prolog no. X) svarar Prolog yes. 2) försöker Prolog unifiera argumenten med huvudet i den andra klausulen för predikatet f. b) Om ett Haskell-system, t ex hugs, misslyckas med att passa ("matcha") argumenten i ett anrop f.. med vänsterledet i den första av flera ekvationer som definierar funktionen f så 1) returneras False. X) svarar hugs med Program error. 2) försöker hugs "matcha" argumenten med vänsterledet i den andra ekvationen för funktionen f. c) Om Prolog misslyckas med att satisfiera ett delmål g i en konjunktion av delmål.., h(..), g(..), f(x) så 1) svarar Prolog yes X) svarar Prolog no. 2) försöker Prolog på nytt att få delmål h att lyckas. d) Om ett Haskell-system, t ex hugs, vid en körning får resultatet True vid beräkningen av funktionanropet g(x)i detta uttryck med funktionanrop h(x) g(x) f(x) så 1) blir hela uttrycket False X) blir hela uttrycket True 2) anropas f(x). (8p)
Förslag till svar tenta programmeringsparadigm 2004. < 50 U Gjort steg 9 i shacket <65 3 <80 4 <100 5 Ej steg 9 <75 3 <90 4 <100 5 Del paradigmer allmänt. X 2 2 1 X 1 loopar, arv, rekursion, dynamisk bindning OO : C++ Eiffel Java Smalltalk Simula Funktionellt : Haskell Logik : Prolog Imperativa: Övriga Del funktionell programmering. maxlist :: Ord a => [a] -> a -- 2 maxlist [] = error "Empty list in maxlist " maxlist (x:[]) = x maxlist (x:xs) = max x (maxlist xs) eqlist :: Eq a => [a] -> Bool eqlist [] = error "Empty list in eqlist " eqlist (x:[]) = True eqlist (x1:x2:xs) = (x1 == x2) && (eqlist (x2:xs)) -- 3 a neqlist :: Eq a => [a] -> Bool neqlist xs = not (eqlist xs) -- b neqlist = \xs -> not (eqlist xs) -- c Ja! -- d maxoflists [] = [] -- 4 a maxoflists (xs:xss) neqlist xs = maxlist xs : maxoflists xss otherwise = maxoflists xss maxoflists xss = ml xss [] -- b where ml [] acc = acc ml (xs:xss) acc neqlist xs = ml xss (acc ++ [maxlist xs]) otherwise = ml xss acc maxoflists xss = map maxlist (filter neqlist xss) -- c maxoflists xss = [ maxlist xs xs <- xss, not (eqlist xs) ] -- d isdarksquare :: Square -> Bool -- is square dark? isdarksquare (Sq ix iy) = (ix + iy) mod 2 /= 0 -- 5 a startboard :: Board -- b startboard = Board ( [ p (Sq ix 7 ) WhiteC ix <- [0..7]] ++ [ p (Sq ix 6 ) WhiteC ix <- [0..7]] ++ [ (Sq ix iy, NoPiece) ix <- [0..7], iy <- [2..5]] ++ [ p (Sq ix 1 ) BlackC ix <- [0..7]] ++ [ p (Sq ix 0 ) BlackC ix <- [0..7]]) where p :: Square -> Colour -> (Square, Piece) p sq colour isdarksquare sq = (sq, Pi colour) otherwise = (sq, NoPiece)
--legalmove1 :: Piece {-moving -} -> Square {-from -} -> Square {-to -} -> Board -> [(Square, Piece)] legalmove1 (Pi colour) frsq tosq board ((diag1 frsq tosq ) && (pieceat tosq board == NoPiece )) = [(frsq, NoPiece), (tosq, (Pi colour))] ((diag2 frsq tosq ) && (pieceat (betweensquare frsq tosq) board == Pi (othercolour colour) )) = [(frsq, NoPiece), (tosq, (Pi colour)), (betweensquare frsq tosq, NoPiece) ] otherwise = [] legalmove1 NoPiece _ = [] --OBS!!Denna legalmove2 returnrar lista med ändrade rutor!! tom lista felaktigt drag legalmove2 :: Square {-from -} -> Square {-to -} -> Board -> [(Square, Piece)] legalmove2 frsq tosq board = legalmove1 (pieceat frsq board) frsq tosq board Del logik programmering. select(x, [X Xs], Xs). select(x, [Y Ys], [Y Zs]) :- select(x, Ys, Zs). % 6 a append([], Ys, Ys). % b append([x Xs], Ys, [X Zs]) :- append(xs, Ys, Zs). select(x, Ys, Ys1) :- append(as, [X Xs], Ys), append(as, Xs, Ys1). % c % a person is p(name, sport, nationality) % 7 puzzle(ps) :- Ps = [p(_, cricket, _), p(_, _, _), p(_, _, _)], member(p(richard, _, _), Ps), member(p(_, _, aussie), Ps), did_better(p(michael, basket, _), p(_, _, american), Ps), did_better(p(sven, _, swede), p(_, tennis, _), Ps). did_better(x,y,[x Ys]) :- member(y, Ys). did_better(x,y,[_ Zs]):- did_better(x,y,zs). member(x, [X _]). member(x, [_ Ys]) :- member(x, Ys). /*?- puzzle(ps). Ps = [p(sven,cricket,swede),p(michael,basket,aussie),p(richard,tennis,american)]? ; no */ select(x, [X Xs], Xs). % 8 select(x, [Y Ys], [Y Zs]) :- select(x, Ys, Zs). sel(k(a,b), Ds, Ds1) :- select(k(a,b), Ds, Ds1). sel(k(a,b), Ds, Ds1) :- select(k(b,a), Ds, Ds1). recknows(a, B, Ds) :- sel(k(a,b), Ds, _ ). recknows(a, B, Ds) :- sel(k(a,v), Ds, Ds1 ), recknows(v, B, Ds1). connection(a, B) :- know(ds), recknows(a, B, Ds). 2 2 2 X % 9