Initial commit with Day 1, 2 and part of 3

Signed-off-by: Alek Ratzloff <alekratz@gmail.com>

day03/Day03.hs

@@ -0,0 +1,173 @@
+import Data.List
+import Data.List.Split
+import Flow
+
+main :: IO ()
+main = do
+  inputText <- getContents
+  let input = parseInput inputText
+  putStr "Part 1: "
+  putStrLn $ part1 input
+    --putStrLn $ show $ growBoard (-5, -6) $ growBoard (5, 6) emptyBoard
+
+part1 :: ([Dir], [Dir]) -> String
+part1 _ = " "
+
+parseInput :: String -> ([Dir], [Dir])
+parseInput input = (wires1, wires2)
+  where
+    wires1:wires2:_ = input |> lines |> map (splitOn "," .> map parseDir)
+
+type Mat = [[Bool]]
+
+data Board =
+  Board
+    { mat :: Mat
+    , pos :: (Int, Int)
+    , origin :: (Int, Int)
+    }
+
+emptyBoard :: Board
+emptyBoard = Board {mat = [], pos = (0, 0), origin = (0, 0)}
+
+ensureBoardPos :: (Int, Int) -> Board -> Board
+ensureBoardPos _ board = board
+
+growBoard :: (Int, Int) -> Board -> Board
+growBoard (x, y) board = growBoardX x (growBoardY y board)
+
+growBoardY :: Int -> Board -> Board
+growBoardY 0 board = board
+growBoardY y board = do
+  let incY (x0, y0) = (x0, y0 + abs y)
+  let newBoard = mapBoardMat (growMatY y) board
+  if y < 0
+    then mapBoardPos incY $ mapBoardOrigin incY newBoard
+    else newBoard
+
+growBoardX :: Int -> Board -> Board
+growBoardX 0 board = board
+growBoardX x board = do
+  let incX (x0, y0) = (x0 + abs x, y0)
+  let newBoard = mapBoardMat (growMatX x) board
+  if x < 0
+    then mapBoardPos incX $ mapBoardOrigin incX newBoard
+    else newBoard
+
+mapBoardMat :: (Mat -> Mat) -> Board -> Board
+mapBoardMat mapping board =
+  Board
+    { mat = withBoardMat mapping board
+    , pos = (pos board)
+    , origin = (origin board)
+    }
+
+withBoardMat :: (Mat -> a) -> Board -> a
+withBoardMat mapping board = (mapping (mat board))
+
+mapBoardOrigin :: ((Int, Int) -> (Int, Int)) -> Board -> Board
+mapBoardOrigin mapping board =
+  Board {mat = mat board, pos = pos board, origin = mapping (origin board)}
+
+withBoardOrigin :: ((Int, Int) -> a) -> Board -> a
+withBoardOrigin mapping board = (mapping (origin board))
+
+mapBoardPos :: ((Int, Int) -> (Int, Int)) -> Board -> Board
+mapBoardPos mapping board =
+  Board {mat = mat board, pos = mapping (pos board), origin = origin board}
+
+withBoardPos :: ((Int, Int) -> a) -> Board -> a
+withBoardPos mapping board = (mapping (pos board))
+
+instance Show Board where
+  show board =
+    concat $
+    intersperse
+      "\n"
+      [ [boardChar (x, y) board | (x, _) <- zip [0 ..] row]
+      | (y, row) <- zip [0 ..] (mat board)
+      ]
+
+boardChar :: (Int, Int) -> Board -> Char
+boardChar loc board
+  | (origin board) == loc = 'o'
+  | (pos board) == loc = '*'
+  | otherwise = do
+    let (x, y) = loc
+    if (mat board) !! y !! x
+      then '+'
+      else '.'
+
+data Dir
+  = Up Int
+  | Dn Int
+  | Lt Int
+  | Rt Int
+
+parseDir :: String -> Dir
+parseDir text = do
+  let n = read $ tail text
+  case text !! 0 of
+    'U' -> Up n
+    'D' -> Dn n
+    'L' -> Lt n
+    'R' -> Rt n
+
+dirMap :: (Int -> Int) -> Dir -> Dir
+dirMap mapping (Up n) = Up (mapping n)
+dirMap mapping (Dn n) = Dn (mapping n)
+dirMap mapping (Lt n) = Lt (mapping n)
+dirMap mapping (Rt n) = Rt (mapping n)
+
+dirMag :: Dir -> Int
+dirMag (Up n) = n
+dirMag (Dn n) = n
+dirMag (Lt n) = n
+dirMag (Rt n) = n
+
+dirPair :: Dir -> (Int, Int)
+dirPair (Up n) = (0, -n)
+dirPair (Dn n) = (0, n)
+dirPair (Lt n) = (-n, 0)
+dirPair (Rt n) = (n, 0)
+
+growMatDir :: Dir -> Mat -> Mat
+growMatDir dir mat
+  | dirMag dir == 0 = mat
+  | otherwise = growMat (dirPair dir) mat
+
+growMat :: (Int, Int) -> Mat -> Mat
+growMat (x, y) mat = growMatX x (growMatY y mat)
+
+growMatX :: Int -> Mat -> Mat
+growMatX 0 mat = mat
+growMatX x mat =
+  if x < 0
+    then [take (abs x) (repeat False) ++ row | row <- mat]
+    else [row ++ take (abs x) (repeat False) | row <- mat]
+
+growMatY :: Int -> Mat -> Mat
+growMatY 0 mat = mat
+growMatY y mat =
+  if y < 0
+    then (take (abs y) (repeat (take (matW mat) (repeat False)))) ++ mat
+    else mat ++ (take (abs y) (repeat (take (matW mat) (repeat False))))
+
+matSize :: Mat -> (Int, Int)
+matSize mat = (matW mat, matH mat)
+
+matW :: Mat -> Int
+matW mat =
+  if matH mat == 0
+    then 0
+    else mx (map length mat)
+
+matH :: Mat -> Int
+matH mat = length mat
+
+mx :: [Int] -> Int
+mx [] = 0
+mx [x] = x
+mx (x:xs)
+  | (mx xs) > x = mx xs
+  | otherwise = x