Сложная проблема с Haskell

Question

У меня было это задание для моего класса на Haskell, но я нахожу его довольно трудным.Если бы вы могли немного помочь.Вам дан лабиринт

maze = ["x xxx",
        "x   x",
        "x x x",
        "x x  ",
        "xxxxx"]

, и вы можете ходить только через пробелы.Вы начинаете с (0,1), и функция должна возвращать строку с указаниями для выхода из лабиринта:

f - forward
r- turn right
l - turn left 

И если у вас есть выбор, вы всегда предпочитаете направлять вперед и впередоставил.Для текущего примера ответом будет ffllffrffrfflf

Заранее спасибо

data Direction = N | W | S | E deriving (Show,Eq)

maze = ["x xxx",
        "x   x",
        "x x x",
        "x x  ",
        "xxxxx"]

d = 's'
pos = (0,1)

fpath d pos | fst pos == (length maze - 1) = ""
            | snd  (pos) ==0 || (snd ( pos ) == ((length (maze!!0))-1)) = ""
            | rightPossible d pos = "r" ++ ( fpath (rightRotate d) pos )
            | forwardPossible d  pos = "f" ++ ( fpath d (nstep d pos) )
            | True = "l" ++ fpath (leftRotate d) pos
            where nstep :: Direction -> (Int, Int) -> (Int, Int) {-next step-}
                  nstep N (x,y) = (x-1,y)
                  nstep W  (x,y) = (x,y-1) 
                  nstep S (x,y) = (x+1,y) 
                  nstep E  (x,y) = (x,y+1)

                  rightPossible :: Direction -> (Int, Int) -> Bool 
                  rightPossible N (x,y)= (maze !! x)!! (y+1) == ' '
                  rightPossible W (x,y)= (maze !! (x-1))!! y   == ' '              
                  rightPossible S (x,y)= (maze !! x)!! (y-1) == ' '                   
                  rightPossible E (x,y)= (maze !! (x+1))!! y   == ' '

                  rightRotate :: Direction -> Direction 
                  rightRotate N = E
                  rightRotate W = N
                  rightRotate S = W
                  rightRotate E = S

                  forwardPossible :: Direction -> (Int, Int) -> Bool 
                  forwardPossible N (x,y)= ((maze !! (x-1))!! y) == ' ' 
                  forwardPossible W (x,y)= ((maze !! x)!! (y-1)) == ' '
                  forwardPossible S (x,y)= ((maze !! (x+1))!! y) == ' '
                  forwardPossible E (x,y)= ((maze !! x)!! (y+1)) == ' '

                  leftRotate :: Direction -> Direction
                  leftRotate N = W
                  leftRotate W = S
                  leftRotate S = E
                  leftRotate E = N

Answer 1

Первое, что я вижу, это то, что у вас есть проблема приоритета.Выражение (maze !! x)!! y-1 анализируется как ((maze !! x)!! y)-1, тогда как вы хотите, чтобы оно анализировалось как (maze !! x)!! (y-1).Добавьте фигурные скобки, чтобы решить эту проблему.

После добавления код компилируется, хотя ваш алгоритм, похоже, не работает.Может быть, кто-то еще может помочь вам.

Некоторые советы по кодированию:

• Добавьте сигнатуры типов в соответствующих местах для облегчения отладки.(Если тип завершится неудачно, компилятор, скорее всего, покажет ошибку в нужном месте)

• Использовать сопоставление с образцом вместо дополнительных операторов case.Вместо

  nstep d (x,y)   {-next step-}
                  | d == 'n' = (x-1,y)
                  | d == 'w' = (x,y-1)
                  | d == 's' = (x+1,y)
                  | d == 'e' = (x,y+1)
  

  напишите

  nstep 'n' (x,y) = (x-1,y)
  nstep 'w' (x,y) = (x,y-1)
  nstep 's' (x,y) = (x+1,y)
  nstep 'e' (x,y) = (x,y+1)
  

• Напишите свои собственные типы data вместо символов.Например, вы можете создать собственный тип данных для направлений:

  data Direction = N | W | S | E deriving (Show,Eq)
  

Answer 2

Я согласен с FUZxxl.Если вы создаете новый тип данных, вы можете делать такие вещи, как

Типы данных

data Direction = North | West | South | East deriving (Show,Eq) 
type Point = (Int, Int)

Использование типов данных в удобочитаемом и эффективном виде

nstep :: Direction -> Point -> Point
nstep North (x,y) = (x-1,y)
nstep West  (x,y) = (x,y-1) 
nstep South (x,y) = (x+1,y) 
nstep East  (x,y) = (x,y+1)

Снова здесь.Кроме того, использование именованных функций вместо просто r, что мало что значит.

rightPossible :: Direction -> Point -> Bool
rightPossible North = (maze !! x)!! (y-1) == ' '
rightPossible West  = (maze !! x+1)!! y   == ' '              
rightPossible South = (maze !! x)!! (y+1) == ' '                   
rightPossible East  = (maze !! x-1)!! y   == ' '

Надеюсь, это поможет вам немного понять язык.

изменить: изменено data Point на type Point