cem 0.1.4 → 0.1.5

data/examples/aoc2018/day21_v4.rb

@@ -0,0 +1,141 @@
+#
+# https://adventofcode.com/2018/day/21 part 1 and part 2 
+#
+# Does not use any 'cem' functions
+#
+# Rev 4: Replace the register array access with local variables => Double speed up. 
+#
+require 'cem'
+require 'set'
+
+lines = File.readlines("inputs/day21_input.txt", chomp: true)
+
+commandQueue = []
+
+r0 = r1 = r2 = r3 = r4 = r5 = 0
+@s = Set.new
+@last = nil
+
+def command(verb, v1, v2, v3)
+
+  case verb
+  when "addr"
+  #     addr (add @register) stores into @register C the result of adding @register A and @register B.
+    " r#{v3} = r#{v1} + r#{v2} "
+  
+  when "addi"
+  #   addi (add immediate) stores into @register C the result of adding @register A and value B.
+    " r#{v3} = r#{v1} + #{v2} "
+  
+  when "mulr"
+      # mulr (multiply @register) stores into @register C the result of multiplying @register A and @register B.
+    " r#{v3} = r#{v1} * r#{v2} "
+  
+  when "muli"
+     #  muli (multiply immediate) stores into @register C the result of multiplying @register A and value B.
+    " r#{v3} = r#{v1} * #{v2} "
+  
+  when "banr"
+     #  banr (bitwise AND @register) stores into @register C the result of the bitwise AND of @register A and @register B.
+    " r#{v3} = r#{v1} & r#{v2} "
+  
+  when "bani"
+     # bani (bitwise AND immediate) stores into @register C the result of the bitwise AND of @register A and value B.
+    " r#{v3} = r#{v1} & #{v2} "
+  
+  when "borr"
+      # borr (bitwise OR @register) stores into @register C the result of the bitwise OR of @register A and @register B.
+    " r#{v3} = r#{v1} | r#{v2} "
+  
+  when "bori"
+      # bori (bitwise OR immediate) stores into @register C the result of the bitwise OR of @register A and value B.
+    " r#{v3} = r#{v1} | #{v2} "
+  
+  when "setr"
+      # setr (set @register) copies the contents of @register A into @register C. (Input B is ignored.)
+    " r#{v3} = r#{v1} "
+  
+  when "seti"
+      # seti (set immediate) stores value A into @register C. (Input B is ignored.)
+    " r#{v3} = #{v1} "
+   
+  when "gtir"
+      # gtir (greater-than immediate/@register) sets @register C to 1 if value A is greater than @register B. Otherwise, @register C is set to 0.
+    " r#{v3} = #{v1} > r#{v2} ? 1 : 0 "
+  
+  when "gtri"
+      # gtri (greater-than @register/immediate) sets @register C to 1 if @register A is greater than value B. Otherwise, @register C is set to 0.
+    " r#{v3} = r#{v1} > #{v2} ? 1 : 0 "
+    
+  when "gtrr"
+      # gtrr (greater-than @register/@register) sets @register C to 1 if @register A is greater than @register B. Otherwise, @register C is set to 0.
+    " r#{v3} = r#{v1} > r#{v2} ? 1 : 0 "
+         
+  when "eqir"
+      # eqir (equal immediate/register) sets register C to 1 if value A is equal to register B. Otherwise, register C is set to 0.
+    " r#{v3} = #{v1} == r#{v2} ? 1 : 0 "
+        
+  when "eqri"
+      # eqri (equal register/immediate) sets register C to 1 if register A is equal to value B. Otherwise, register C is set to 0.
+    " r#{v3} = r#{v1} == #{v2} ? 1 : 0 "
+  
+  when "eqrr"
+      # eqrr (equal register/register) sets register C to 1 if register A is equal to register B. Otherwise, register C is set to 0.
+    " r#{v3} = r#{v1} == r#{v2} ? 1 : 0 
+    
+      if #{v2} == 0
+        if @s.size == 0
+          puts \"Part 1: \#{r#{v1}}\"
+        end
+        
+        puts \"\#{@s.size.to_s.rjust(10)} - \#{r#{v1}}\" if @s.size % 64 == 0
+        
+        if @s.include?(r#{v1})
+          puts \"Part 2: \#{@last}\"
+          exit
+        end
+        @s.add r#{v1}
+        @last = r#{v1}
+      end
+    "  
+  else
+    puts "error" #  raise "Error"
+  end
+end
+
+
+ip = nil
+lines.each { |line|
+
+  if line =~ /^#ip ([+-]?\d+)$/
+    ip = $1.to_i
+  end    
+
+  if line =~ /^(\w+) ([+-]?\d+) ([+-]?\d+) ([+-]?\d+)$/
+    verb = $1
+    v1 = $2.to_i
+    v2 = $3.to_i
+    v3 = $4.to_i
+    
+    commandQueue << command(verb, v1, v2, v3) 
+  end
+}
+
+ndigits = commandQueue.size.digits.size 
+
+commandQueue = <<~EOS
+while 
+
+  case r#{ip} 
+  #{commandQueue.each_with_index.map { |v, i| "when #{i.to_s.rjust(ndigits)} then #{v}"}.join("\n")}
+  else
+    raise
+  end
+  
+  r#{ip} += 1
+    
+end
+EOS
+
+puts commandQueue
+eval(commandQueue)

data/examples/aoc2018/day22.rb

@@ -0,0 +1,212 @@
+#
+# https://adventofcode.com/2018/day/22 part 1 and 2
+#
+# Demonstrates some use of Grid and Point2D
+#
+# Why this was hard: Did not read spec precisely!
+
+require 'set'
+require 'cem'
+
+EXTRAX = 10
+EXTRAY = 10
+
+verbose = false
+
+lines = File.readlines("inputs/day22_input.txt", chomp: true)
+
+depth = nil
+target = nil
+
+lines.each { |line|
+
+  if line =~ /^depth: ([+-]?\d+)$/
+    depth = $1.to_i
+  end    
+
+  if line =~ /^target: ([+-]?\d+),([+-]?\d+)$/
+    target = Point2D.new($1.to_i, $2.to_i)
+  end    
+}
+
+@depth = depth
+@target = target
+
+def erode(x)
+  return (x + @depth) % 20183
+end  
+
+grid = Grid.new(target.x + EXTRAX + 1, target.y + EXTRAY + 1)
+grid[0,0] = 0
+
+(1..target.x + EXTRAX).each { |x|
+  grid[0,x] = erode(x * 16807) 
+}
+(1..target.y + EXTRAY).each { |y|
+  grid[y,0] = erode(y * 48271) 
+}
+  
+(1..target.y + EXTRAY).each { |y|
+  (1..target.x + EXTRAX).each { |x|
+    if target.x == x && target.y == y
+      grid[y,x] = erode(0)
+    else
+      grid[y,x] = erode(grid[y-1,x] * grid[y,x-1]) 
+    end
+  }
+}
+
+puts "Part 1: #{grid[0..target.y, 0..target.x].flatten.sum { |g| g % 3 }}"
+
+if verbose
+  grid[0..target.y, 0..target.x].each { |y|
+    y.each { |c|
+      case c % 3
+        when 0
+          print '.'
+        when 1
+          print '='
+        when 2
+          print '|'
+        end
+    }
+    puts
+  }
+end
+
+#
+# Part 2
+# 
+
+neighter = 0
+torch = 1
+gear = 2
+
+toolGrid = [0,1,2,4].map { |t| Grid.new(target.x + EXTRAX + 1, target.y + EXTRAY + 1, -1)}
+
+toolGrid[torch][0,0] = 0
+
+define_method :toChar do |p|
+  case grid[p] % 3
+    when 0
+      '.'
+    when 1
+      '='
+    when 2
+      '|'
+  end
+end
+  
+define_method :supportedTools do |p|
+  
+  case grid[p] % 3 
+    when 0 # rocky
+      [gear, torch] 
+    when 1 # wet
+      [neighter, gear]
+    when 2 # narrow
+      [neighter, torch]
+    else
+      raise
+  end
+end
+
+q = [[Point2D.new(0,0), torch]]
+while q.size > 0
+
+  p, tool = q.shift
+  
+  #puts "#{p.inspect} - #{tool} - #{toolGrid[tool][p]} - #{supportedTools(p)}"
+
+  sTools = supportedTools(p)  
+  otherTools = ([0,1,2] - [tool]) & supportedTools(p)
+
+  otherTools.each { |t| 
+    raise if t == tool
+    raise if !sTools.any? { |t2| t == t2 }
+  }
+  
+  raise if toolGrid[tool][p] == -1
+  
+  otherTools.each { |other|
+    if (toolGrid[other][p] == -1) || toolGrid[tool][p] + 7 < toolGrid[other][p]
+      toolGrid[other][p] = toolGrid[tool][p] + 7
+      q << [p, other] 
+    end
+  }
+  
+  grid.nsew_index(p).each { |p2|
+    # puts "#{p2.inspect} is adjacent to #{p} and supports the following tools #{supportedTools(p2)}"
+    
+    if supportedTools(p2).include?(tool) && (toolGrid[tool][p2] == -1 || toolGrid[tool][p] + 1 < toolGrid[tool][p2])
+      toolGrid[tool][p2] = toolGrid[tool][p] + 1
+      q << [p2, tool]
+    end
+  }
+  
+  q.sort_by! { |n|
+    p, tool = n
+    toolGrid[tool][p]
+  }
+
+end    
+   
+puts "Part 2: #{[toolGrid[torch][target], toolGrid[gear][target] + 7].min}"
+
+if 0 == 1
+  (0..target.y + EXTRAY).each { |y|
+    (0..target.x + EXTRAX).each { |x|
+    
+      case grid[y,x] % 3
+        
+        when 0
+          print '.'
+        when 1
+          print '='
+        when 2
+          print '|'
+        
+      end
+      
+      print (toolGrid[torch][y,x].to_s + "," + toolGrid[neighter][y,x].to_s + "," +toolGrid[gear][y,x].to_s).rjust(8)
+    }
+    puts ""
+  } if DEBUG
+    
+  reversePath = [[target, toolGrid[torch][target], torch]]  
+  p = target
+  curTool = torch
+  while !(p.x == 0 && p.y == 0)
+    
+    moves = grid.nsew_index(p).select { |p2| supportedTools(p2).include?(curTool) }.map { |p2| [p2, toolGrid[curTool][p2], curTool]} + 
+    (supportedTools(p) - [curTool]).map { |t| [p, toolGrid[t][p], t, :toolChange] }
+
+    p moves
+    bestMove = moves.min_by { |x| x[1] }
+    
+    reversePath.unshift bestMove
+    
+    # puts p.inspect
+    
+    p = bestMove[0]
+    curTool = bestMove[2]
+  end
+
+  reversePath.each { |x|
+    puts "[#{x[0].x}, #{x[0].y}, #{x[2]}]   #{toChar(x[0])}        #{x[1]} #{x.size > 3 ? x[3] : ""}"
+  }
+end    
+    
+      
+    
+    
+    
+
+
+
+
+
+
+
+
+

data/examples/aoc2018/day23.rb

@@ -0,0 +1,148 @@
+#
+# https://adventofcode.com/2018/day/23 part 1 and part 2 
+#
+# Uses Point3D. I probably need to revisit how to subclass Point3D, Point2D.
+#
+require 'cem'
+
+Bot = Struct.new("Bot", :x, :y, :z, :r) {
+  
+  def [](i)
+    case i
+      when 0
+        x
+      when 1
+        y
+      when 2
+        z
+      when 3 
+        r
+      else 
+        raise
+    end
+  end
+  
+}
+
+def manhattan(other, bot)
+  (other.z - bot.z).abs + (other.y - bot.y).abs + (other.x - bot.x).abs
+end
+
+def manhattan_box(bot, min, max)
+
+  result = (0..2).sum { |i| 
+    if bot[i] >= min[i] && bot[i] <= max[i]
+      0
+    elsif bot[i] < min[i]
+      min[i] - bot[i]
+    else
+      bot[i] - max[i]
+    end
+  }
+  
+  #puts "#{bot.inspect} - #{min} - #{max} - #{result}"
+  return result
+  
+end
+
+lines = File.readlines("inputs/day23_input.txt", chomp: true)
+
+input = []
+
+lines.each { |line|
+
+  if line =~ /^pos=<([+-]?\d+),([+-]?\d+),([+-]?\d+)>, r=([+-]?\d+)$/
+    v1 = $1.to_i
+    v2 = $2.to_i
+    v3 = $3.to_i
+    v4 = $4.to_i
+        
+    input << Bot.new(v1,v2,v3,v4)
+  end    
+
+}
+
+#
+# Part I
+#
+bot = input.max_by { |bot| bot.r }
+
+strength = 0
+input.each { |other|
+  
+  if manhattan(bot, other) <= bot.r
+    strength += 1
+  end
+}
+
+puts "Part I: #{strength}"
+
+#
+# Part II
+#
+
+# Start with the largest group we can trivially find  
+best = []
+bestScore = -1
+
+min = Point3D.new(*[0,1,2].map { |i| input.map { |b| b[i] }.min })
+max = Point3D.new(*[0,1,2].map { |i| input.map { |b| b[i] }.max })
+
+todo = []
+
+# todo == [ queue of [Box min, Box max, number of elements fully covering box, number of elements still under considerations] ]
+todo << [min, max, 0, input]
+
+i = 0
+while todo.size > 0
+
+  mi, ma, covered, bots = todo.shift
+  
+  puts "Iteration #{i} - Still todo: #{todo.size} - Cover: #{covered} Bots: #{bots.size} Cur Size: #{(ma-mi).manhattan} - BestScore: #{bestScore}" if i % 128 == 0
+  i += 1
+
+  if mi == ma
+    hit, miss = bots.partition { |bot| manhattan(bot, mi) <= bot.r }
+    
+    if bestScore < covered + hit.size       
+      bestScore = covered + hit.size
+      best = [mi]
+    elsif bestScore == covered + hit.size
+      best << mi
+    end
+    
+    next
+  end
+  
+  # Which bots do touch the current min-max box
+  hit, miss = bots.partition { |bot| manhattan_box(bot, mi, ma) <= bot.r }
+  next if covered + hit.size < bestScore # We don't have to dig in, if we have a better high score anyway
+  
+  # Which bots do completely cover the entire box and which don't? Check 8 corners to find out
+  corners = (0..7).map { |i| Point3D.new(i & 4 == 0 ? mi.x : ma.x, i & 2 == 0 ? mi.y : ma.y, i & 1 == 0 ? mi.z : ma.z) }
+  total, partial = hit.partition { |bot| corners.count { |c| manhattan(bot, c) <= bot.r } == 8 }
+
+  # Split the largest dimension of the box in half (mi to midI, midA to ma) 
+  minDim = [0,1,2].max_by { |i| ma[i] - mi[i] }
+  
+  midI = ma.clone
+  midI[minDim] = mi[minDim] + (ma[minDim] - mi[minDim]) / 2
+  
+  midA = mi.clone
+  midA[minDim] = mi[minDim] + (ma[minDim] - mi[minDim]) / 2 + 1
+    
+  todo << [mi, midI, covered + total.size, partial]
+  todo << [midA, ma, covered + total.size, partial]
+  
+  todo.sort_by! { |t| -(t[2] + t[3].size) * (max-min).manhattan + manhattan(t[0], t[1]) } if i % 4 == 0 
+end
+
+puts "Best Positions: " + best.to_s
+puts "Number of Bots In Range: #{bestScore}"
+puts "Lowest Manhattan Distance to 0,0,0: #{best.map { |b| b.manhattan }.min}"
+
+  
+
+    
+
+