棘手的haskell问题

我对Haskell类有这个任务，但是我觉得这很困难。如果你能帮上忙。您将得到一个迷宫棘手的haskell问题

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

，你可以通过空格只能步行。你从（0,1）开始，该函数必须返回与方向的字符串逃过这是迷宫：

f - forward 
r- turn right 
l - turn left

如果你有你总是喜欢选择正确转发，并转发到左。对于当前的例子，答案是事先

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

来源

2011-07-08 munch

现在，哪里是问题吗？你已经做了什么？你卡在哪里？ – Howard

使用[“墙壁追随者”]（http://en.wikipedia.org/wiki/Maze_solving_algorithm）;） – Jacob

我在Haskell开始工作，我以前有过使用函数式语言的经验。我知道我需要重新解决这个问题，但我无法在Haskel中实现它。 – munch

我看到的第一件事是ffllffrffrfflf

谢谢，你有一个优先发布。表达式(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) 
```

来源

2011-07-08 13:10:58 fuz

我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

来源

2011-07-08 13:41:16 eternalmatt

'data Point =（Int，Int）'不正确。 –

谢谢！这帮了我很多，但得到了无限的递归，尽管我已经三重检查了代码。 – munch

您是否检查过您没有添加您已经访问过的职位？ – Landei

棘手的haskell问题

回答

相关问题