Programare Declarativa: test de laborator v2 https://goo.

gl/RZc5mT
Problemele din acest test se petrec pe o tablă de s, ah. O pozit, ie pe tabla de s, ah este reprezentată ca o pereche (linie, coloana), unde
linie este o cifră între 1 s, i 8 iar coloana este o literă mică între ‘a’ s, i ‘h’.
Căsut, a din jos-stânga a tablei de s, ah are pozit, ia (1, 'a') iar cea din sus-dreapta are pozit, ia (8, 'h').
type Linie = Int
type Coloana = Char
type Pozitie = (Linie, Coloana)
O mutare (validă) a unei piese de s, ah este dată de o pereche (dlin, dcol) reprezentând deplasamentul pe linie, respectiv coloană,
indus de mutare.
Un deplasament de x pe linie (coloană) înseamnă o mutare cu x căsut, e în sus (spre dreapta). Un deplasament negativ indică mutarea în
direct, ia opusă, i.e. jos (stânga).
De exemplu, mutarea (1, -2) reprezintă mutarea (validă pentru un cal) a unei căsut, e in sus s, i două căsut, e la stânga.
type DeltaLinie = Int
type DeltaColoana = Int
type Mutare = (DeltaLinie,DeltaColoana)

Exercit, iul 1 (2 puncte): Efectuarea unei mutări

Implementat, i o funct, ie mutaDacaValid care dată fiind o mutare m s, i o pozit, ie p, întoarce pozit, ia obt, inută după efectuarea mutării piesei
din pozit, ia p folosind mutarea descrisă de m. Dacă mutarea nu este posibilă, se va întoarce vechea pozit, ie.
mutaDacaValid :: Mutare -> Pozitie -> Pozitie
mutaDacaValid = undefined

Mutări posibile; mutări indexate. Joc s, i desfăs, urarea lui

Definit, ia de mai jos reprezintă lista mutărilor valide pentru un cal. Mutările valide pentru un cal sunt în forma literei L: 2 căsut, e într-o
direct, ie s, i 1 căsut, ă într-o direct, ie perpendiculară.
mutariPosibile :: [Mutare]
mutariPosibile = [(-2,-1),(-2,1),(2,-1),(2,1),(-1,-2),(1,-2),(-1,2),(1,2)]
În continuare vom reprezenta mai succint o mutare a unui cal ca un indice (de la 0 la 7) în lista de mutări posibile.
type IndexMutare = Int
Un “joc” este o secvent, ă de sărituri ale calului, dată ca o listă de indici de mutare.
type Joc = [IndexMutare]
Desfăs, urarea unui joc este definită ca lista de pozit, ii indusă de un joc, executând mutările în ordine, pornind de la o pozit, ie init, ială.
type DesfasurareJoc = [Pozitie]

Exercit, iul 2 (2 puncte): simularea unui joc

Implementat, i o funct, ie joaca care pentru o secvent, ă de indici joc s, i o pozit, ie init, ială p produce desfăs, urarea jocului corespunzător,
adică lista de pozit, ii care sunt atinse începând cu p s, i efectuând în ordine mutările corespunzătoare din mutariPosibile descrise de
indicii din joc.
Dacă indicele nu reprezintă o pozit, ie din mutariPosibile, sau dacă mutarea este invalidă (ar ajunge în afara tablei), atunci acesta este
ignorat.
joaca :: Joc -> Pozitie -> DesfasurareJoc
joaca = undefined

Traseul calului pe tabla de s, ah. Arbore de joc.

Un joc put, in mai interesant este acela în care vrem să ne asigurăm ca nu vizităm acceas, i căsut, ă de mai multe ori. Pentru aceasta, va
trebui să t, inem minte căsut, ele pe care l-am vizitat deja.
Pentru a explora desfăs, urarea unui joc putem folosi un arbore de joc, în care un nod constă dintr-o pozit, ie s, i are ca subarbori evolut, ii
posibile ale jocului pornind din acea pozit, ie.
data ArboreJoc = Nod Pozitie [ArboreJoc]
deriving (Show, Eq)
Deoarece arborele de joc va fi foarte mare, vom folosi următoarea funct, ie pentru a obt, ine arborele doar până la o adâncime dată.
parcurge :: Int -> ArboreJoc -> ArboreJoc
parcurge adancime (Nod p as)
| adancime <= 0 = Nod p []
| otherwise = Nod p (map (parcurge (adancime - 1)) as)

Exercitiul 3 (2 puncte): Generarea unui arbore de joc

Implementat, i o funct, ie generează care dată fiind o pozit, ie generează arborele de joc corespunzător traseelor unui cal care pleacă din
pozit, ia dată s, i face sărituri pe tabla de s, ah, fără a ies, i în afara ei, s, i fără a ajunge pe aceeas, i pozit, ie de 2 ori (pe orice drum de la
rădăcină spre frunze, nodurile au pozit, ii distincte).
Sugestie: folosit, i o funct, ie auxiliară care t, ine minte pozit, iile deja generate. Putet, i folosi funct, iile definite mai sus.
Atent, ie! Nu încercat, i să afis, at, i întreg arborele de joc. Folosit, i funct, ia parcurge pentru a restrict, iona numărul de nivele.
genereaza :: Pozitie -> ArboreJoc
genereaza = undefined

Monada Writer specializată la Joc

newtype JocWriter a = Writer { runWriter :: (a, Joc) }
scrie ia ca argument un singur indice de mutare s, i “scrie la ies, ire” jocul constând doar din acel indice.
scrie :: IndexMutare -> JocWriter ()
scrie i = Writer ((), [i])
instance Monad JocWriter where
return a = Writer (a, [])
ma >>= k = let (x, jocM) = runWriter ma
(y, jocK) = runWriter (k x)
in Writer (y, jocM ++ jocK)

instance Functor JocWriter where

fmap f ma = ma >>= return . f

instance Applicative JocWriter where

pure = return
mf <*> ma = mf >>= (<$> ma)

Exercitiul 4 (1 punct): Simulare joc cu obt, inerea mutărilor valide

Cerint, ele sunt aproximativ aceleas, i ca la exercit, iul 2, cu diferent, a că
1. La fel ca la exercit, iul 3, o mutare care duce spre o pozit, ie deja vizitată devine invalidă
2. Daca mutarea este validă, indexul ei trebuie scris folosind monada Writer
Implementat, i o funct, ie joacaBine care pentru o secvent, ă de indici joc s, i o pozit, ie init, ială p produce desfăs, urarea jocului corespunzător,
adică lista de pozit, ii care sunt atinse începând cu p s, i efectuând în ordine mutările corespunzătoare din mutariPosibile descrise de
indicii din joc. Efectul lateral al funct, iei este calcularea listei indicilor de mutare valizi.
Dacă indicele nu reprezintă o pozit, ie din mutariPosibile, sau dacă mutarea este invalidă (ar ajunge în afara tablei sau pe o pozit, ie
deja vizitată), atunci acesta este ignorat.
Sugestie: folosit, i o funct, ie auxiliară care t, ine minte pozit, iile deja generate. Putet, i folosi funct, iile definite mai sus.
joacaBine :: Joc -> Pozitie -> JocWriter DesfasurareJoc
joacaBine = undefined

Exercit, iu suplimentar (0,5p): Identifică mutarea

Date fiind două pozit, ii p1 s, i p2, să se determine dacă un cal poate fi mutat de la p1 la p2 printr-o singură mutare, s, i in caz pozitiv să se
afle indicele corespunzător mutarii în tabela mutariPosibile.
gasesteMutare :: Pozitie -> Pozitie -> Maybe IndexMutare
gasesteMutare = undefined

Link trimitere solut, ii: https://goo.gl/m23eM2