digging with bing

「AIだからすごいんでしょ」 うーん、アルゴリズムの表現の場合は、どうなんでしょ？

前回からやってるChatGPTに依頼した迷路作成だが、永久ループの泥沼から脱 出出来ずに、無理を指示しちゃった。AIと言えども、ヒントを与えないと頭を 働かせられない。debuggerを使って、堂々巡りしてる所を発見し、そこを改善 させたのさ。その結果が、これだ。

ghci> :main
##########
# # # # #
##########
# # # # #
##########
# # # # #
##########
# # # # #
##########
# # # # #

迷路失格である。原因と思う所は、配列の範囲外をアクセスしちゃう部分の防 止策。なんだかなあって方法で回避してたぞ。今となっては、それを追求する 気にもなれない。穴掘り方法だけを上げておく。

dig :: Maze -> (Int, Int) -> StdGen -> IO ()
dig maze (x, y) gen = do
  let directions = shuffle [minBound..maxBound] gen
  dig' maze (x, y) directions gen

dig' :: Maze -> (Int, Int) -> [Direction] -> StdGen -> IO ()
dig' maze _ [] _ = return ()
dig' maze (x, y) (dir:dirs) gen = do
  let nextCell = move dir (x, y)
      wallCell = move (opposite dir) nextCell
  isWallCellVisited <- readArray maze wallCell
  isNextCellVisited <- readArray maze nextCell  -- 新しく追加
  if isWallCellVisited == wall || isNextCellVisited == path  -- 新しく追加
    then dig' maze (x, y) dirs gen
    else do
      writeArray maze nextCell path
      writeArray maze wallCell path
      dig maze nextCell gen
      let remainingDirs = delete dir dirs
      randomIndex <- randomRIO (0, length remainingDirs - 1)
      let nextDir = remainingDirs !! randomIndex
      dig' maze nextCell (delete nextDir remainingDirs) gen

何だかなあの結末。

ならばbingではどうよ。セカンド・オピニオンしてみる。

穴掘り法を利用して、迷路を作成して下さい。出力言語はhaskellでお願いします。
盤の構造には、Array.IOを使用して下さい。

haskell maze digging method を検索しています

上の質問が、こんな風に要約されてるみたい。で、bingは何を参考書にしたん だやら。こんなコードを提示してきた。ああ、勿論オイラーが悪い所は修正し ましたよ。特にshuffleなんて出鱈目のいいところだったので、書き換えた。

それから、質問の回数が以前は5回だったんだけど、今回は10回に増量されて た。みんなオマケが大好きだからなあ。煎餅が1枚増量なんて言われると、い ちもにもなく飛び付きますからなあ。

import System.Random
import Data.Array.IO
import Control.Monad
import Debug.Trace

type Maze = IOUArray (Int, Int) Char

maze :: Int -> Int -> IO Maze
maze rows cols = newArray ((0, 0), (rows - 1, cols - 1)) '#'

dig :: Maze -> (Int, Int) -> IO ()
dig maze (row, col) = do
    writeArray maze (trace("(row,col)=" ++ show (row,col)) (row, col)) ' '
    directions <- shuffle [(0, -1), (-1, 0), (0, 1), (1, 0)]
    forM_ directions $ \(r, c) -> do
        let loc = (row + r * 2,  col + c * 2)
        okP <- liftM2 (&&)
          (inRange <$> getBounds maze <*> pure loc)
          (((==) '#') <$> readArray maze loc)
        when okP $ do
            writeArray maze (r + row, c + col) ' '
            dig maze loc

shuffle :: [a] -> IO [a]
shuffle xs = shuffle' xs []
  where
    shuffle' [] ys = return ys
    shuffle' zs ys  = do
      index <- randomRIO (0, length zs - 1)
      let elem = zs !! index
          zs' = take index zs ++ drop (index + 1) zs
      shuffle' zs' (elem : ys)
      
printMaze :: Maze -> IO ()
printMaze maze = do
    ((minRow, minCol), (maxRow, maxCol)) <- getBounds maze
    forM_ [minRow..maxRow] $ \row -> do
        forM_ [minCol..maxCol] $ \col -> do
            putChar =<< readArray maze (row, col)
        putChar '\n'

main :: IO ()
main = do
    let rows = 21 -- odd number to make the algorithm work properly.
        cols = 21 -- odd number to make the algorithm work properly.
    m <- maze rows cols
    dig m (1, 1)
    printMaze m

で、結果。

ghci> main
(row,col)=(1,1)
 *** Exception: Error in array index
ghci> main
(row,col)=(1,1)
(row,col)=(1,3)
(row,col)=(3,3)
(row,col)=(3,1)
 *** Exception: Error in array index

なんだかなあ、だ。

bingに指示した壁延し法により迷路作成。インチキっぽいな。適当に寄せ集め したんではなかろうか。落ちるしね。

import Data.Array.IO
import Control.Monad
import System.Random

type Maze = IOArray (Int, Int) Int

makeMaze :: Int -> Int -> IO Maze
makeMaze w h = do
    maze <- newArray ((0, 0), (w-1, h-1)) 1
    let start = (1, 1)
    dig maze start
    return maze

dig :: Maze -> (Int, Int) -> IO ()
dig maze pos@(x, y) = do
    writeArray maze pos 0
    let neighbors = [(x-2, y), (x+2, y), (x, y-2), (x, y+2)]
    validNeighbors <- filterM (\n -> do
        val <- readArray maze n
        return $ val == 1) neighbors
    case validNeighbors of
        [] -> return ()
        ns -> do
            next <- choose ns
            let mid = ((fst pos + fst next) `div` 2,
                       (snd pos + snd next) `div` 2)
            writeArray maze mid 0
            dig maze next
            dig maze pos

choose :: [a] -> IO a
choose xs = do
    i <- randomRIO (0, length xs - 1)
    return $ xs !! i

printMaze :: Maze -> IO ()
printMaze maze = do
    (_, (maxX, maxY)) <- getBounds maze
    forM_ [0..maxY] $ \y -> do
        forM_ [0..maxX] $ \x -> do
            cell <- readArray maze (x, y)
            putStr $ if cell == 1 then "#" else " "
        putStrLn ""

main :: IO ()
main = do
  out <- makeMaze 11 11   -- must be odd
  printMaze out

ならば、少し復習。

なでしこさんで迷路を自動生成したり、探索したり

迷路を作ろう[手法編]​

迷路作成アルゴリズムまとめ

こちらはhaskellでAIですってさ。

Learning to Navigate the Maze! in Haskell

こういうのを博物館と言うんだろうな。色々な言語での迷路作成。 色々な言語でハロワじゃ子供騙しだからね。せめてこれぐらいは、やってよね、 です。

Maze generation by many lang

そして、こちらは、言語コンバータです。裏でChatGPTが動いているに違いな い。

Welcome to Code Language Converter!

This year's Index

Home