Haskell To Scratch Converter

module Main where

import Data.List (sort)

— Function to sort a list and calculate the sum
processList :: [Int] -> ([Int], Int)
processList xs = (sort xs, sum xs)

main :: IO ()
main = do
— Taking a list of integers as input
putStrLn “Enter a list of integers separated by spaces:”
input <- getLine let intList = map read (words input) :: [Int] let (sortedList, totalSum) = processList intList putStrLn $ "Sorted list: " ++ show sortedList putStrLn $ "Sum of integers: " ++ show totalSum

when green flag clicked
ask [Enter a list of integers separated by spaces:] and wait
set [input v] to (answer)
set [intList v] to (split [ ] in (input))
set [sortedList v] to (sort (intList))
set [totalSum v] to (sum (intList))
say (join [Sorted list: ] (join (sortedList) [ ]))
say (join [Sum of integers: ] (totalSum))

import System.Random
import Control.Monad
import Control.Monad.State
import qualified Data.Array as A
import qualified Data.List as List

data Direction = North | South | East | West deriving (Show, Enum)

type Cell = (Int, Int)
type Maze = A.Array Cell Bool

data State = GameState { maze :: Maze, playerPosition :: Cell, exitPosition :: Cell }

main :: IO ()
main = do
let (rows, cols) = (21, 21)
g <- newStdGen let maze = generateMaze rows cols g let exit = (rows - 2, cols - 2) let initialState = GameState maze (1, 1) exit runGame initialState runGame :: State -> IO ()
runGame state@(GameState maze position exit) = do
putStrLn $ renderMaze maze position exit
input <- getLine let newState = case input of "w" -> move state North
“s” -> move state South
“a” -> move state West
“d” -> move state East
_ -> state
if playerPosition newState == exit
then putStrLn “Congratulations! You’ve found the exit!”
else runGame newState

renderMaze :: Maze -> Cell -> Cell -> String
renderMaze maze position exit = unlines [[renderCell (r, c) | c <- [0..cols-1]] | r <- [0..rows-1]] where (rows, cols) = A.bounds maze renderCell cell | cell == position = 'P' | cell == exit = 'E' | A.! cell maze = ' ' | otherwise = '#' move :: State -> Direction -> State
move state dir = case dir of
North -> newState (0, -1)
South -> newState (0, 1)
West -> newState (-1, 0)
East -> newState (1, 0)
where
newState (dx, dy) = let (x, y) = playerPosition state
newPos = (x + dx * 2, y + dy * 2)
in if validMove (maze state) newPos
then state { playerPosition = newPos }
else state

validMove :: Maze -> Cell -> Bool
validMove maze (x, y) = x >= 0 && x < rows && y >= 0 && y < cols && A.! (x, y) maze where (rows, cols) = A.bounds maze generateMaze :: Int -> Int -> StdGen -> Maze
generateMaze rows cols g =
let arr = A.array ((0, 0), (rows-1, cols-1)) [((r, c), True) | r <- [0..rows-1], c <- [0..cols-1]] (maze', _) = runState (carveMaze arr (1, 1)) g in maze' carveMaze :: Maze -> Cell -> State IO Maze
carveMaze maze (x, y) = do
directions <- shuffle [North, South, East, West] forM_ directions $ dir -> do
let (dx, dy) = directionOffset dir
nx = x + dx * 2
ny = y + dy * 2
neighbor = (nx, ny)
when (validCell maze neighbor) $ do
let wall = (x + dx, y + dy)
putCell maze neighbor False
putCell maze wall False
carveMaze maze neighbor
return maze

directionOffset :: Direction -> (Int, Int)
directionOffset North = (-1, 0)
directionOffset South = (1, 0)
directionOffset East = (0, 1)
directionOffset West = (0, -1)

validCell :: Maze -> Cell -> Bool
validCell maze (x, y) = x > 0 && y > 0 && x < rows && y < cols && A.! (x, y) maze where (rows, cols) = A.bounds maze putCell :: Maze -> Cell -> Bool -> State IO ()
putCell maze (x, y) val = do
let newMaze = maze A.// [((x, y), val)]
return newMaze

shuffle :: [a] -> State StdGen [a]
shuffle xs = do
g <- get let (shuffled, newGen) = randomShuffle g xs put newGen return shuffled randomShuffle :: StdGen -> [a] -> ([a], StdGen)
randomShuffle g [] = ([], g)
randomShuffle g xs =
let (n, g’) = randomR (0, length xs – 1) g
(x:xs’) = List.deleteAt n xs
(ys, g”) = randomShuffle g’ xs’
in (x:ys, g”)

when gf (0, 0) {
maze = [(r, c) => 1;
r = [0..20];
c = [0..20]];
exit = (19, 19);
playerPosition = (1, 1);
runGame(maze, playerPosition, exit);
}

when runGame(maze, playerPosition, exit) {
renderMaze(maze, playerPosition, exit);
input = ask(“Enter w, a, s, d for movement: “);
if (input == “w”) {
playerPosition = move(maze, playerPosition, “North”);
} else if (input == “s”) {
playerPosition = move(maze, playerPosition, “South”);
} else if (input == “a”) {
playerPosition = move(maze, playerPosition, “West”);
} else if (input == “d”) {
playerPosition = move(maze, playerPosition, “East”);
}

if (playerPosition == exit) {
say(“Congratulations! You’ve found the exit!”);
} else {
runGame(maze, playerPosition, exit);
}
}

when renderMaze(maze, playerPosition, exit) {
for (r = 0; r < 21; r++) { line = ""; for (c = 0; c < 21; c++) { if (playerPosition == (r, c)) { line += "P"; } else if (exit == (r, c)) { line += "E"; } else { line += (maze[r][c] ? " " : "#"); } } say(line); } } when move(maze, playerPosition, direction) { if (direction == "North") { newPos = (playerPosition[0] - 2, playerPosition[1]); } else if (direction == "South") { newPos = (playerPosition[0] + 2, playerPosition[1]); } else if (direction == "West") { newPos = (playerPosition[0], playerPosition[1] - 2); } else if (direction == "East") { newPos = (playerPosition[0], playerPosition[1] + 2); } if (validMove(maze, newPos)) { return newPos; } else { return playerPosition; } } when validMove(maze, newPos) { return (newPos[0] >= 0 && newPos[0] < 21 && newPos[1] >= 0 && newPos[1] < 21 && maze[newPos[0]][newPos[1]]); } when generateMaze() { // Implementation for maze generation can use random logic and loops in Scratch // Placeholder for requiring more detailed adaptation. }