Add unoptimized, messy solutions for days 7-12 2022

Author: vaeng

2022/Elixir/lib/advent_of_code/day_07.ex

@@ -1,130 +1,97 @@
 defmodule AdventOfCode.Day07 do
-  defmodule Folder do
-    @enforce_keys [:name]
-    defstruct [:name, files: %{}, folders: %{}, type: :dir]
-  end
-
-  defmodule File do
-    @enforce_keys [:name, :size]
-    defstruct [:name, :size, type: :file]
-  end
-
-  @doc"""
-  defimpl Inspect, for: Folder do
-    def inspect(folder, _opts) do
-      folderText = "" # folder.folders.keys()
-      fileText = "|- a file\n"
-      "-- {folder.name}\n" <> folderText <> fileText
-    end
-  end
-
-  defimpl Inspect, for: File do
-    def inspect(file, _opts) do
-      "-- {file.size} {file.name}\n"
-    end
-  end
-  """
-  defprotocol FileTree do
-    def size(value)
-  end
-
-  defimpl FileTree, for: Folder do
-    def size(dir), do:
-      dir.content
-      |> Enum.map(&FileTree.size/1)
-      |> Enum.sum()
-  end
-
-  defimpl FileTree, for: File do
-    def size(file), do: file.size
-  end
-
   @spec parseCommand(String.t()) :: list()
   def parseCommand(rawStr) do
     cond do
-      String.starts_with?(rawStr, "$ ls") -> [:ls]
-      String.starts_with?(rawStr, "$ cd") -> [:cd, String.trim_leading(rawStr, "$ cd ")]
-      String.starts_with?(rawStr, "dir") -> [:dir, String.trim_leading(rawStr, "dir ")]
+      String.starts_with?(rawStr, "$ ls") ->
+        [:ls]
+
+      String.starts_with?(rawStr, "$ cd") ->
+        [:cd, String.trim_leading(rawStr, "$ cd ")]
+
+      String.starts_with?(rawStr, "dir") ->
+        [:dir, String.trim_leading(rawStr, "dir ")]
+
       String.match?(rawStr, ~r/^\d+ .+$/) ->
         [size, name] = String.split(rawStr, " ")
         [:file, String.to_integer(size), name]
-      true -> [:unknown, rawStr]
+
+      true ->
+        [:unknown, rawStr]
     end
   end
 
-  @spec executeCommand(list(), list()) :: %Folder{}
-  def executeCommand([:cd, "/"], [_path, rootNode]), do: [["/"], rootNode]
-  def executeCommand([:cd, ".."], [["/"], rootNode]), do: [["/"], rootNode]
-  def executeCommand([:cd, ".."], [path, rootNode]), do: [Enum.drop(path, -1), rootNode]
-  def executeCommand([:cd, folder], [path, rootNode]) do
-     # nextNode = Enum.find(currentNode.content, fn x -> x.type == :dir && x.name == folder  end)
-     [ path ++ [folder], rootNode]
-  end
-  def executeCommand([:ls], [path, rootNode]), do: [path, rootNode]
-  def executeCommand([:file, size, name], [path, rootNode])
-    do
-      newFile = %File{name: name, size: size}
-      newTree = addItemToContent(path, rootNode, newFile)
-      [path, newTree]
-    end
-  def executeCommand([:dir, name], [path, rootNode])
-    do
-      newDir = %Folder{name: name}
-      newTree = addItemToContent(path, rootNode, newDir)
-      [path, newTree]
-    end
+  def executeCommand([:cd, "/"], [_path, rootNode, folders]),
+    do: [["/"], rootNode, folders]
 
-  @spec addItemToContent(list(), %Folder{}, %Folder{} | %File{}) :: %Folder{}
-  def addItemToContent(path, root, item) do
-    access_path = transformToAccessPath(path)
-    dir = if access_path == [], do: root, else: get_in(root, access_path)
-    IO.inspect(dir)
-    if duplicate?(dir, item)
-      do
-        root
-      else
-        # get_and_update_in(root, [Access.key(:files), Access.key(:abaa), Access.key(:size)], &{&1, &1 + 1000})
-        #get_and_update_in(root, path, fn currentFolder -> %{currentFolder | content: Map.update(dir.content, item.name, item)} end)
-        if access_path != []
-          do
-            update_in(root, access_path, &(Map.put(&1, item.name,  item)))
-          else
-            key = if item.type == :dir, do: :folders, else: :files
-            # update(root, )
-          end
-      end
-    end
+  def executeCommand([:cd, ".."], [["/"], rootNode, folders]),
+    do: [["/"], rootNode, folders]
 
-  def transformToAccessPath(path) do
-    path |> Enum.map(&Access.key/1) |> Enum.intersperse(Access.key(:folders)) |> Enum.drop(1)
-  end
+  def executeCommand([:cd, ".."], [path, rootNode, folders]),
+    do: [Enum.drop(path, -1), rootNode, folders]
 
-  @spec duplicate?(%Folder{}, %Folder{} | %File{}) :: boolean()
-  def duplicate?(folder, item) do
-    key = if item.type == :dir, do: :folders, else: :files
-    get_in(folder, [Access.key(key)]) |> Map.keys() |> Enum.member?(item.name)
-  end
+  def executeCommand([:cd, folder], [path, rootNode, folders]),
+    do: [path ++ [folder], rootNode, MapSet.put(folders, path ++ [folder])]
+
+  def executeCommand([:ls], [path, rootNode, folders]),
+    do: [path, rootNode, folders]
+
+  def executeCommand([:file, size, name], [path, rootNode, folders]),
+    do: [path, update_in(rootNode, path, &Map.put(&1, name, size)), folders]
+
+  def executeCommand([:dir, name], [path, rootNode, folders]),
+    do: [path, update_in(rootNode, path, &Map.put(&1, name, %{})), folders]
 
   def part1(args) do
-    root = %Folder{name: "/"}
+    root = %{"/" => %{}}
 
-    tree = args
-    |> String.trim()
-    |> String.split("\n")
-    |> Enum.map(&parseCommand/1)
-    |> Enum.reduce(["/", root], fn x, acc -> executeCommand(x, acc) end)
+    [_, tree, visitedPaths] =
+      args
+      |> String.trim()
+      |> String.split("\n")
+      |> Enum.map(&parseCommand/1)
+      |> Enum.reduce(["/", root, MapSet.new([["/"]])], fn x, acc -> executeCommand(x, acc) end)
 
-    IO.inspect(tree)
+    visitedPaths
+    |> Enum.map(&(get_in(tree, &1) |> getSize()))
+    |> Enum.filter(&(&1 <= 100_000))
+    |> Enum.sum()
   end
 
-  def part2(_args) do
+  def part2(args) do
+    root = %{"/" => %{}}
+
+    [_, tree, visitedPaths] =
+      args
+      |> String.trim()
+      |> String.split("\n")
+      |> Enum.map(&parseCommand/1)
+      |> Enum.reduce(["/", root, MapSet.new([["/"]])], fn x, acc -> executeCommand(x, acc) end)
+
+    otherDirectories = MapSet.delete(visitedPaths, [["/"]])
+
+    space_available = 70_000_000 - getSize(get_in(tree, ["/"]))
+    additional_space_needed = 30_000_000 - space_available
+
+    directorySizes =
+      otherDirectories
+      |> Enum.map(&(get_in(tree, &1) |> getSize()))
+      |> Enum.sort()
+      |> Enum.filter(&(&1 >= additional_space_needed))
+      |> hd
   end
 
   @spec getSize(list) :: number
   @doc """
   Returns the size of a filetree in form of a Map.
   """
-  def getSize(tree) do
-    tree |> Map.to_list() |> List.flatten() |> Enum.map(&getSize/1) |> Enum.sum()
+  def getSize(element) when is_integer(element), do: element
+
+  def getSize(tuple) when is_tuple(tuple) and tuple_size(tuple) == 2 do
+    {_, map} = tuple
+    getSize(map)
+  end
+
+  def getSize(map) when is_map(map) do
+    map |> Map.to_list() |> List.flatten() |> Enum.map(&getSize/1) |> Enum.sum()
   end
 end

2022/Elixir/lib/advent_of_code/day_08.ex

@@ -1,8 +1,12 @@
 defmodule AdventOfCode.Day08 do
-  def part1(_args) do
+  import AdventOfCode.Util
+
+  def part1(args) do
+    args |> inputToNumGrid() |> countVisibilityOnGrid()
   end
 
-  def part2(_args) do
+  def part2(args) do
+    args |> inputToNumGrid() |> getMaxScenicScoreOnGrid()
   end
 
   def inputToNumGrid(input) do
@@ -15,69 +19,70 @@ defmodule AdventOfCode.Day08 do
     )
   end
 
-  def setAllToUnknown(numgrid) do
-    numgrid |> Enum.map(&Enum.map(&1, fn x -> [x, :unknown] end))
+  @spec getScenicScore([list], integer, integer) :: number
+  def getScenicScore(grid, x, y) do
+    height = grid |> Enum.at(y) |> Enum.at(x)
+    allWest = getAllWest(grid, x, y) |> countVisibleTrees(height)
+    allEast = getAllEast(grid, x, y) |> countVisibleTrees(height)
+    allSouth = getAllSouth(grid, x, y) |> countVisibleTrees(height)
+    allNorth = getAllNorth(grid, x, y) |> countVisibleTrees(height)
+
+    Enum.product([allWest, allEast, allSouth, allNorth])
   end
 
-  def initializeBoarders(tagGrid) do
-    tagGrid
-    |> List.update_at(-1, &Enum.map(&1, fn [x, _] -> [x, :visible] end))
-    |> List.update_at(0, &Enum.map(&1, fn [x, _] -> [x, :visible] end))
-    |> Enum.map(fn [[x, _] | rest] -> [[x, :visible] | rest] end)
-    |> Enum.map(&List.update_at(&1, -1, fn [x, _] -> [x, :visible] end))
+  def countVisibleTrees(list, height) do
+    cansee = Enum.take_while(list, &(&1 < height)) |> length()
+    if cansee < length(list), do: cansee + 1, else: cansee
   end
 
-  def updateStatus(_, _, _, :visible, _), do: :visible
-  def updateStatus(_, _, _, :invisible, _), do: :invisible
+  def getMaxScenicScoreOnGrid(grid) do
+    yMax = length(grid) - 1
+    xMax = length(Enum.at(grid, 0)) - 1
+
+    0..yMax
+    |> Enum.map(fn y -> Enum.map(0..xMax, &[&1, y]) end)
+    |> Enum.map(&Enum.map(&1, fn [x, y] -> AdventOfCode.Day08.getScenicScore(grid, x, y) end))
+    |> List.flatten()
+    |> Enum.max()
+  end
 
-  def updateStatus(rix, cix, height, :unknown, grid) do
-    # [[hup, sup], [hdown, sdown], [hleft, sleft], [hright, sright]] = getEnvironment(grid, rix, cix)
-    getEnvironment(grid, rix, cix) |> Enum.any?()
+  def countVisibilityOnGrid(grid) do
+    yMax = length(grid) - 1
+    xMax = length(Enum.at(grid, 0)) - 1
 
-    # cases for: all blocking -> invis
-    # any is smaller and vis? -> vis
-    # else -> unknown
+    0..yMax
+    |> Enum.map(fn y -> Enum.map(0..xMax, &[y, &1]) end)
+    |> Enum.map(&Enum.map(&1, fn [x, y] -> AdventOfCode.Day08.isVisible?(grid, x, y) end))
+    |> List.flatten()
+    |> Enum.count(&(&1 == true))
   end
 
-  def updateStatus(_, _, _, _, _), do: :error
-
-  def updateGrid(tagGrid) do
-    newStatus = fn _, _, _, _ -> :test end
-
-    workList =
-      tagGrid
-      |> Enum.with_index()
-      |> Enum.map(fn {row, rix} ->
-        Enum.with_index(row, fn element, cix -> [rix, cix, element] end)
-      end)
-      |> List.flatten()
-      |> Enum.chunk_every(4)
-
-    workList
-    |> Enum.reduce(tagGrid, fn [rix, cix, height, status], accgrid ->
-      List.update_at(
-        accgrid,
-        rix,
-        &List.update_at(&1, cix, fn [x, status] ->
-          [x, updateStatus(rix, cix, height, status, accgrid)]
-        end)
-      )
-    end)
+  def isVisible?(grid, x, y) do
+    height = grid |> Enum.at(y) |> Enum.at(x)
+    allWest = getAllWest(grid, x, y) |> Enum.all?(&(&1 < height))
+    allEast = getAllEast(grid, x, y) |> Enum.all?(&(&1 < height))
+    allSouth = getAllSouth(grid, x, y) |> Enum.all?(&(&1 < height))
+    allNorth = getAllNorth(grid, x, y) |> Enum.all?(&(&1 < height))
+
+    Enum.any?([allWest, allEast, allSouth, allNorth])
   end
 
-  def getVisibleTrees(grid), do: grid |> List.flatten() |> Enum.count(&(&1 == :visible))
+  @doc """
+  Zero based access. Map origin is upper left corner at 0,0
+  """
+  def getAllWest(grid, x, y) do
+    grid |> Enum.fetch!(y) |> Enum.take(x) |> Enum.reverse()
+  end
 
-  def updateStatusByCoordinate(grid, rix, cix, newStatus),
-    do: grid |> List.update_at(rix, &List.update_at(&1, cix, fn [x, _] -> [x, newStatus] end))
+  def getAllEast(grid, x, y) do
+    grid |> Enum.fetch!(y) |> Enum.drop(x + 1)
+  end
 
-  def getElement(grid, rix, cix),
-    do: grid |> Enum.fetch(rix) |> then(fn {_, row} -> Enum.fetch!(row, cix) end)
+  def getAllSouth(grid, x, y) do
+    grid |> transpose() |> Enum.fetch!(x) |> Enum.drop(y + 1)
+  end
 
-  def(getEnvironment(grid, rix, cix)) do
-    up = getElement(grid, rix - 1, cix)
-    down = getElement(grid, rix + 1, cix)
-    left = getElement(grid, rix, cix - 1)
-    right = getElement(grid, rix, cix + 1)
-    [up, down, left, right]
+  def getAllNorth(grid, x, y) do
+    grid |> transpose() |> Enum.fetch!(x) |> Enum.take(y) |> Enum.reverse()
   end
 end

2022/Elixir/lib/advent_of_code/day_09.ex

@@ -1,15 +1,6 @@
 defmodule AdventOfCode.Day09 do
-  @moduledoc """
-  This module is using named directions in a 2D Space.
-  The center X be [0,0]. eg. NN is [0,2].
-  |      |     |    |     |      |
-  |:----:|:---:|:---:|:---:|:----:|
-  | NWNW | NNW | NN | NNE | NENE |
-  | NWW  | NW  | N  | NE  | NEE  |
-  | WW   | W   | X  | E   | EE   |
-  | SWW  | SW  | S  | SE  | SEE  |
-  | SWSW | SSW | SS | SSE | SESE |
-  """
+  import AdventOfCode.Util
+
   def part1(args) do
     args
     |> parseInput()
@@ -65,7 +56,7 @@ defmodule AdventOfCode.Day09 do
       &(String.split(&1, " ")
         |> then(fn [dir, num] -> String.duplicate(dir, String.to_integer(num)) end))
     )
-    |> Enum.reduce("", &(&2 <> &1))
+    |> Enum.join()
   end
 
   def updateHead(h, "R"), do: getE(h)
@@ -103,33 +94,4 @@ defmodule AdventOfCode.Day09 do
       true -> raise "unknown skip"
     end
   end
-
-  def getN([x, y]), do: [x, y + 1]
-  def getNN([x, y]), do: [x, y + 2]
-  def getS([x, y]), do: [x, y - 1]
-  def getSS([x, y]), do: [x, y - 2]
-  def getW([x, y]), do: [x - 1, y]
-  def getWW([x, y]), do: [x - 2, y]
-  def getE([x, y]), do: [x + 1, y]
-  def getEE([x, y]), do: [x + 2, y]
-
-  def getSE([x, y]), do: [x + 1, y - 1]
-  def getSSE([x, y]), do: [x + 1, y - 2]
-  def getSEE([x, y]), do: [x + 2, y - 1]
-  def getSESE([x, y]), do: [x + 2, y - 2]
-
-  def getNE([x, y]), do: [x + 1, y + 1]
-  def getNNE([x, y]), do: [x + 1, y + 2]
-  def getNEE([x, y]), do: [x + 2, y + 1]
-  def getNENE([x, y]), do: [x + 2, y + 2]
-
-  def getSW([x, y]), do: [x - 1, y - 1]
-  def getSSW([x, y]), do: [x - 1, y - 2]
-  def getSWW([x, y]), do: [x - 2, y - 1]
-  def getSWSW([x, y]), do: [x - 2, y - 2]
-
-  def getNW([x, y]), do: [x - 1, y + 1]
-  def getNNW([x, y]), do: [x - 1, y + 2]
-  def getNWW([x, y]), do: [x - 2, y + 1]
-  def getNWNW([x, y]), do: [x - 2, y + 2]
 end