Haskell To Kotlin Converter

sortAndCount :: (Ord a) => [a] -> ([a], Int)
sortAndCount xs = (sort xs, length xs)

main :: IO ()
main = do
putStrLn “Enter a list of numbers separated by spaces:”
input <- getLine let numbers = map read (words input) :: [Int] let (sortedNumbers, count) = sortAndCount numbers putStrLn ("Sorted List: " ++ show sortedNumbers) putStrLn ("Number of elements: " ++ show count)

fun sortAndCount(xs: List): Pair, Int> {
return Pair(xs.sorted(), xs.size)
}

fun main() {
val scanner = Scanner(System.`in`)
println(“Enter a list of numbers separated by spaces:”)
val input = scanner.nextLine()
val numbers = input.split(” “).map { it.toInt() }
val (sortedNumbers, count) = sortAndCount(numbers)
println(“Sorted List: $sortedNumbers”)
println(“Number of elements: $count”)
}

type Board = [[Char]]

emptyBoard :: Board
emptyBoard = replicate 3 (replicate 3 ‘ ‘)

displayBoard :: Board -> IO ()
displayBoard board = putStrLn $ intercalate “n—–n” (map (intercalate “|”) board)

isWin :: Char -> Board -> Bool
isWin player board = any (all (== player)) (rows ++ cols ++ diags)
where
rows = board
cols = transpose board
diags = [[board !! i !! i | i <- [0..2]], [board !! i !! (2 - i) | i <- [0..2]]] transpose :: Board -> Board
transpose ([]:_) = []
transpose xs = map head xs : transpose (map tail xs)

isDraw :: Board -> Bool
isDraw board = all (/= ‘ ‘) (concat board) && not (isWin ‘X’ board) && not (isWin ‘O’ board)

makeMove :: Int -> Int -> Char -> Board -> Board
makeMove x y player board = take x board ++ [take y row ++ [player] ++ drop (y + 1) row] ++ drop (x + 1) board
where row = board !! x

main :: IO ()
main = do
putStrLn “Welcome to Tic-Tac-Toe!”
gameLoop emptyBoard ‘X’

gameLoop :: Board -> Char -> IO ()
gameLoop board player = do
displayBoard board
if isWin ‘X’ board
then putStrLn “Player X wins!”
else if isWin ‘O’ board
then putStrLn “Player O wins!”
else if isDraw board
then putStrLn “It’s a draw!”
else do
putStrLn $ “Player ” ++ [player] ++ “‘s turn. Enter your move (row and column):”
input <- getLine let (x:y:_) = map read (words input) :: [Int] if board !! x !! y == ' ' then gameLoop (makeMove x y player board) (if player == 'X' then 'O' else 'X') else do putStrLn "Invalid move. Try again." gameLoop board player

typealias Board = Array>

fun emptyBoard(): Board {
return Array(3) { Array(3) { ‘ ‘ } }
}

fun displayBoard(board: Board) {
println(board.joinToString(“n—–n”) { it.joinToString(“|”) })
}

fun isWin(player: Char, board: Board): Boolean {
val rows = board.toList()
val cols = transpose(board)
val diags = arrayOf(
Array(3) { board[it][it] },
Array(3) { board[it][2 – it] }
)
return (rows + cols + diags).any { it.all { cell -> cell == player } }
}

fun transpose(board: Board): Board {
return Array(board[0].size) { col -> Array(board.size) { row -> board[row][col] } }
}

fun isDraw(board: Board): Boolean {
return board.flatten().all { it != ‘ ‘ } && !isWin(‘X’, board) && !isWin(‘O’, board)
}

fun makeMove(x: Int, y: Int, player: Char, board: Board): Board {
val newBoard = board.map { it.clone() }.toTypedArray()
newBoard[x][y] = player
return newBoard
}

fun main() {
println(“Welcome to Tic-Tac-Toe!”)
gameLoop(emptyBoard(), ‘X’)
}

fun gameLoop(board: Board, player: Char) {
displayBoard(board)
when {
isWin(‘X’, board) -> println(“Player X wins!”)
isWin(‘O’, board) -> println(“Player O wins!”)
isDraw(board) -> println(“It’s a draw!”)
else -> {
println(“Player ${player}’s turn. Enter your move (row and column):”)
val input = readLine() ?: “”
val (x, y) = input.split(” “).map { it.toInt() }
if (board[x][y] == ‘ ‘) {
gameLoop(makeMove(x, y, player, board), if (player == ‘X’) ‘O’ else ‘X’)
} else {
println(“Invalid move. Try again.”)
gameLoop(board, player)
}
}
}
}