Solutions for days 19 - 24

Author: marcospri

day19/input.txt

@@ -0,0 +1,45 @@
+Al => ThF
+Al => ThRnFAr
+B => BCa
+B => TiB
+B => TiRnFAr
+Ca => CaCa
+Ca => PB
+Ca => PRnFAr
+Ca => SiRnFYFAr
+Ca => SiRnMgAr
+Ca => SiTh
+F => CaF
+F => PMg
+F => SiAl
+H => CRnAlAr
+H => CRnFYFYFAr
+H => CRnFYMgAr
+H => CRnMgYFAr
+H => HCa
+H => NRnFYFAr
+H => NRnMgAr
+H => NTh
+H => OB
+H => ORnFAr
+Mg => BF
+Mg => TiMg
+N => CRnFAr
+N => HSi
+O => CRnFYFAr
+O => CRnMgAr
+O => HP
+O => NRnFAr
+O => OTi
+P => CaP
+P => PTi
+P => SiRnFAr
+Si => CaSi
+Th => ThCa
+Ti => BP
+Ti => TiTi
+e => HF
+e => NAl
+e => OMg
+
+ORnPBPMgArCaCaCaSiThCaCaSiThCaCaPBSiRnFArRnFArCaCaSiThCaCaSiThCaCaCaCaCaCaSiRnFYFArSiRnMgArCaSiRnPTiTiBFYPBFArSiRnCaSiRnTiRnFArSiAlArPTiBPTiRnCaSiAlArCaPTiTiBPMgYFArPTiRnFArSiRnCaCaFArRnCaFArCaSiRnSiRnMgArFYCaSiRnMgArCaCaSiThPRnFArPBCaSiRnMgArCaCaSiThCaSiRnTiMgArFArSiThSiThCaCaSiRnMgArCaCaSiRnFArTiBPTiRnCaSiAlArCaPTiRnFArPBPBCaCaSiThCaPBSiThPRnFArSiThCaSiThCaSiThCaPTiBSiRnFYFArCaCaPRnFArPBCaCaPBSiRnTiRnFArCaPRnFArSiRnCaCaCaSiThCaRnCaFArYCaSiRnFArBCaCaCaSiThFArPBFArCaSiRnFArRnCaCaCaFArSiRnFArTiRnPMgArF

day19/solver.exs

@@ -0,0 +1,81 @@
+defmodule Day19 do
+  def load_input file do
+    [rules, molecule] = File.read!(file)
+    |> String.split("\n\n")
+    {rules, inverse_rules} = load_rules(String.split(rules, "\n"), %{}, %{})
+    atoms = split_molecule(String.strip(molecule))
+
+    {rules, inverse_rules, atoms}
+  end
+
+  def load_rules([], rules_map, inverse_rules), do: {rules_map, inverse_rules}
+  def load_rules [rule|t], rules_map, inverse_rules  do
+    [lhside, rhside] = String.split(rule, "=>") 
+    lhside = String.strip lhside
+    rhside = String.strip rhside
+
+    inverse_rules = Map.put(inverse_rules, String.reverse(rhside), String.reverse(lhside))
+
+    case rules_map[lhside] do
+      nil ->
+        rules_map = Map.put(rules_map, lhside, [rhside])
+      n ->
+        rules_map = Map.put(rules_map, lhside, [rhside|n])
+    end
+    load_rules t, rules_map, inverse_rules
+  end
+
+  def split_molecule(mol), do: split_molecule mol, []
+  defp split_molecule("", atoms), do: atoms
+  defp split_molecule mol, atoms do
+    [atom] = Regex.run(~r/[A-Z][a-z]?/, mol)
+    mol = String.slice(mol, String.length(atom)..String.length(mol))
+    
+    split_molecule(mol, [atom|atoms])
+  end
+
+  def updated_molecules(_, _, [], posibilities), do: posibilities
+  def updated_molecules molecules, index, [subtitution|t], posibilities do
+    molecule = List.replace_at(molecules, index, subtitution)
+    |> Enum.reverse
+    |> Enum.join
+
+    posibilities = Set.put(posibilities, molecule)
+
+    updated_molecules molecules, index, t, posibilities
+  end
+
+  def generate_all_molecules(molecules, rules) do
+    generate_all_molecules molecules, rules, Enum.count(molecules) - 1, HashSet.new
+  end
+
+  defp generate_all_molecules(_, _, -1, posibilities), do: posibilities
+  defp generate_all_molecules(molecules, rules, index, posibilities) do 
+    atom_substitutions = rules[Enum.at(molecules, index)] || []
+    new_molecules = updated_molecules(molecules, index, atom_substitutions, posibilities)
+
+    generate_all_molecules(molecules, rules, index - 1, new_molecules)
+  end
+end
+
+{rules, inverse_rules, atoms} = 
+  "input.txt"
+  |> Day19.load_input
+
+Day19.generate_all_molecules(atoms, rules)
+|> Enum.count
+|> IO.inspect
+
+
+# For part2 i got stuck, tried different aproaches and end up giving up
+# Ideas from reddit didn't help (niether the actual implementantions there, at least the go & python I tried)
+# Finally this guys post is the more clever solution without any real code:
+# https://www.reddit.com/r/adventofcode/comments/3xflz8/day_19_solutions/cy4etju
+total = Enum.count(atoms)
+sides = Enum.count(atoms, fn(x) -> x == "Rn" || x == "Ar"  end)
+content = Enum.count(atoms, fn(x) -> x == "Y" end)
+
+solution = total - sides - (2 * content) - 1
+IO.puts solution
+
+

day20/solver.exs

@@ -0,0 +1,36 @@
+defmodule Day20 do
+  def divisors(n) do
+    #Copy pasted this bit
+    e = n |> :math.sqrt |> trunc
+
+    (1..e)
+    |> Enum.flat_map(fn
+      x when rem(n, x) != 0 -> []
+      x when x != div(n, x) -> [x, div(n, x)]
+      x -> [x]
+    end)
+  end
+
+  def house_gifts house, cache do
+    f = divisors(house) |> Enum.sort |> Enum.filter(fn(x) -> div(house, x) <= 50 end)
+    gifts = f |> Enum.map(&(&1 * 11)) |> Enum.sum
+    {gifts, cache}
+  end
+
+  def find_house min do
+    find_house min, 1, %{} #Head start
+  end
+
+  defp find_house min, house, cache do
+    {gifts, cache} = house_gifts(house, cache) 
+    case gifts >= min do
+      true ->
+        house
+      false ->
+        find_house(min, house + 1, cache)
+    end
+  end
+end
+
+Day20.find_house(33100000)
+|> IO.inspect

day21/solver.exs

@@ -0,0 +1,79 @@
+defmodule Day21 do
+  def combination(0, _), do: [[]]
+  def combination(_, []), do: []
+  def combination(n, [x|xs]) do
+      (for y <- combination(n - 1, xs), do: [x|y]) ++ combination(n, xs)
+  end
+
+  def combine_loot weapon, armor, rings do 
+    [weapon, armor, rings]
+    |> List.flatten
+    |> List.zip
+    |> Enum.map(&Tuple.to_list/1)
+    |> Enum.map(&Enum.sum/1)
+    |> List.to_tuple
+  end
+
+  def battle({boss_points, _, _}, {_, cost, _, _}, _) when boss_points <= 0 do
+    {true, cost}
+  end
+
+  def battle(_, {player_points, cost, _, _}, _) when player_points <= 0 do
+    {false, cost}
+  end
+
+  def battle({boss_points, boss_damage, boss_armor}, {points, cost, damage, armor}, round) do
+    if rem(round, 2) == 0 do
+      player_damage = max((damage - boss_armor), 1)
+      battle({boss_points - player_damage, boss_damage, boss_armor}, {points, cost, damage, armor}, round + 1)
+
+    else
+      boss = max((boss_damage - armor), 1)
+      battle({boss_points, boss_damage, boss_armor}, {points - boss, cost, damage, armor}, round + 1)
+    end
+  end
+end
+
+weapons = [
+  {8, 4, 0},
+  {10, 5, 0},
+  {25, 6, 0},
+  {40, 7, 0},
+  {74, 8, 0},
+]
+
+armor = [
+  {0, 0, 0}, #No armor
+  {13, 0, 1},
+  {31, 0, 2},
+  {53, 0, 3},
+  {75, 0, 4},
+  {102, 0, 5},
+]
+
+rings = [
+  {0, 0, 0}, #No ring
+  {0, 0, 0}, #No ring
+  {25, 1, 0},
+  {50, 2, 0},
+  {100, 3, 0},
+  {20, 0, 1},
+  {40, 0, 2},
+  {80, 0, 3},
+]
+
+boss_stats = {103, 9, 2}
+
+ring_combinations = Day21.combination(2, rings)
+
+(for weapon <- weapons, do: 
+  (for armor <- armor, do:
+    (for ring <- ring_combinations do
+      loot_stats = Day21.combine_loot(weapon, armor, ring)
+      loot_stats = Tuple.insert_at(loot_stats, 0, 100)
+      Day21.battle(boss_stats, loot_stats, 0)
+    end)))
+|> List.flatten
+|> Enum.filter(fn ({win, _}) -> not win end)
+|> Enum.max_by(fn ({_, cost}) -> cost end)
+|> IO.inspect

day22/solver.exs

@@ -0,0 +1,98 @@
+defmodule Day22 do
+  #This is the crappiest of my solutions
+  @spells [
+    {:missile, 53, :effect, 0},
+    {:drain, 73, :effect, 0},
+    {:shield, 113, :effect, 6},
+    {:poison, 173, :effect, 6},
+    {:recharge, 229, :effect, 5},
+  ]
+
+  def apply_spell({:missile, spell_mana, _, _}, {boss_points, boss_damage}, {points, mana, effects, spent_mana}) do
+    {
+      {boss_points - 4, boss_damage}, 
+      {points, mana - spell_mana, effects, spent_mana + spell_mana}
+    }
+  end
+
+  def apply_spell({:drain, spell_mana, _, _}, {boss_points, boss_damage}, {points, mana, effects, spent_mana}) do
+    {
+      {boss_points - 2, boss_damage}, 
+      {points + 2 , mana - spell_mana, effects, spent_mana + spell_mana}
+    }
+  end
+
+  def apply_spell({spell, spell_mana, :effect, turns}, {boss_points, boss_damage}, {points, mana, effects, spent_mana}) do
+    effects = Map.put(effects, spell, turns)
+    {
+      {boss_points, boss_damage}, 
+      {points, mana - spell_mana, effects, spent_mana + spell_mana}
+    }
+  end
+
+  def apply_effects effects do
+    armor = if effects[:shield] > 0, do: 7, else: 0 
+    poison = if effects[:poison] > 0, do: 3, else: 0 
+    extra_mana = if effects[:recharge] > 0, do: 101, else: 0 
+    
+    effects = Dict.update(effects, :poison, 0, fn(v) -> max(v - 1, 0) end)
+    effects = Dict.update(effects, :recharge, 0, fn(v) -> max(v - 1, 0) end)
+    effects = Dict.update(effects, :shield, 0, fn(v) -> max(v - 1, 0) end)
+    
+    {armor, poison, extra_mana, effects} 
+  end
+
+  def posible_spells mana, effects do
+    @spells 
+    |> Enum.filter(fn({_, cost, _, _}) -> cost <= mana end)
+    |> Enum.filter(fn({name, _, _, turns}) -> turns == 0 or effects[name] <= 0 end)
+  end
+
+  def battle({boss_points, _}, {_, _, _, spent_mana}, _, sh) when boss_points <= 0 do
+    IO.puts spent_mana
+    {true, spent_mana}
+  end
+
+  def battle(_, {points, _, _, spent_mana}, _, sh) when points <= 0 do
+    {false, spent_mana}
+  end
+
+  def battle({boss_points, boss_damage}, {points, mana, effects, spent_mana}, round, sh) when rem(round, 2) == 1 do
+    {armor, poison, extra_mana, effects} = apply_effects effects
+    dealt_damage = max(boss_damage - armor, 1) 
+    battle({boss_points - poison, boss_damage}, {points - dealt_damage, mana + extra_mana, effects, spent_mana}, round + 1, sh)
+  end
+
+   def battle({boss_points, boss_damage}, {points, mana, effects, spent_mana}, round, spell_history) do
+    #Part 2
+    points = points - 1
+    if points == 0 do
+      []  
+    else
+      {_, poison, extra_mana, effects} = apply_effects effects
+      spells = posible_spells mana, effects
+      case spells do 
+        [] ->
+          []
+        _ ->
+          (for spell <- spells do
+            s = apply_spell(spell, {boss_points, boss_damage}, {points, mana, effects, spent_mana})
+            case s do
+                {false, _} -> 
+                  []
+                {{b_p, b_d}, {p, m, effects, spent_mana}} -> 
+                  battle({b_p - poison, b_d}, {p, m + extra_mana, effects, spent_mana}, round + 1, [spell|spell_history])
+            end
+          end)
+        end
+    end
+  end
+end
+boss_stats = {51, 9}
+#boss_stats = {14, 8}
+
+Day22.battle(boss_stats, {50, 500, %{:shield => 0, :poison => 0, :recharge => 0},  0}, 0, [])
+|> List.flatten
+|> Enum.filter(fn ({win, _}) -> win end)
+|> Enum.min_by(fn ({_, v}) -> v end)
+|> IO.inspect

day23/input.txt

@@ -0,0 +1,46 @@
+jio a, +16
+inc a
+inc a
+tpl a
+tpl a
+tpl a
+inc a
+inc a
+tpl a
+inc a
+inc a
+tpl a
+tpl a
+tpl a
+inc a
+jmp +23
+tpl a
+inc a
+inc a
+tpl a
+inc a
+inc a
+tpl a
+tpl a
+inc a
+inc a
+tpl a
+inc a
+tpl a
+inc a
+tpl a
+inc a
+inc a
+tpl a
+inc a
+tpl a
+tpl a
+inc a
+jio a, +8
+inc b
+jie a, +4
+tpl a
+inc a
+jmp +2
+hlf a
+jmp -7