cem 0.1.3 → 0.1.7

data/examples/aoc2018/day21_v2.rb

@@ -0,0 +1,137 @@
+#
+# https://adventofcode.com/2018/day/21 part 1 and part 2 
+#
+# Does not use any 'cem' functions
+#
+# Using Lambdas instead of interpreting each command. 
+#
+require 'set'
+
+lines = File.readlines("inputs/day21_input.txt", chomp: true)
+
+commandQueue = []
+
+@reg = [0,0,0,0,0,0]
+@s = Set.new
+@last = nil
+
+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 << case verb
+        
+    when "addr"
+    #     addr (add @register) stores into @register C the result of adding @register A and @register B.
+      Proc.new { @reg[v3] = @reg[v1] + @reg[v2] }
+    
+    when "addi"
+    #   addi (add immediate) stores into @register C the result of adding @register A and value B.
+      Proc.new { @reg[v3] = @reg[v1] + v2 }
+    
+    when "mulr"
+        # mulr (multiply @register) stores into @register C the result of multiplying @register A and @register B.
+      Proc.new { @reg[v3] = @reg[v1] * @reg[v2] }
+    
+    when "muli"
+       #  muli (multiply immediate) stores into @register C the result of multiplying @register A and value B.
+      Proc.new { @reg[v3] = @reg[v1] * v2 }
+    
+    when "banr"
+       #  banr (bitwise AND @register) stores into @register C the result of the bitwise AND of @register A and @register B.
+      Proc.new { @reg[v3] = @reg[v1] & @reg[v2] }
+    
+    when "bani"
+       # bani (bitwise AND immediate) stores into @register C the result of the bitwise AND of @register A and value B.
+      Proc.new { @reg[v3] = @reg[v1] & v2 }
+    
+    when "borr"
+        # borr (bitwise OR @register) stores into @register C the result of the bitwise OR of @register A and @register B.
+      Proc.new { @reg[v3] = @reg[v1] | @reg[v2] }
+    
+    when "bori"
+        # bori (bitwise OR immediate) stores into @register C the result of the bitwise OR of @register A and value B.
+      Proc.new { @reg[v3] = @reg[v1] | v2 }
+    
+    when "setr"
+        # setr (set @register) copies the contents of @register A into @register C. (Input B is ignored.)
+      Proc.new { @reg[v3] = @reg[v1] }
+    
+    when "seti"
+        # seti (set immediate) stores value A into @register C. (Input B is ignored.)
+      Proc.new { @reg[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.
+      Proc.new { @reg[v3] = v1 > @reg[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.
+      Proc.new { @reg[v3] = @reg[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.
+      Proc.new { @reg[v3] = @reg[v1] > @reg[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.
+      Proc.new { @reg[v3] = v1 == @reg[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.
+      Proc.new { @reg[v3] = @reg[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.
+      Proc.new { @reg[v3] = @reg[v1] == @reg[v2] ? 1 : 0 
+      
+        if v2 == 0
+          if @s.size == 0
+            puts "Part 1: #{@reg[v1]}"
+          end
+          
+          puts "#{@s.size.to_s.rjust(10)} - #{@reg[v1]}" if @s.size % 64 == 0
+          
+          if @s.include?(@reg[v1])
+            puts "Part 2: #{@last}"
+            exit
+          end
+          @s.add @reg[v1]
+          @last = @reg[v1]
+        end
+      }
+    
+    else
+      puts "error" #  raise "Error"
+    end
+    
+  end
+}
+
+ipp = 0
+iteration = 0
+
+while ipp >= 0 && ipp < commandQueue.size
+
+  @reg[ip] = ipp
+  commandQueue[ipp].call()
+  ipp = @reg[ip]
+  ipp += 1
+  
+  #puts iteration.to_s.rjust(13) + " " + command.inspect.ljust(40) + " " + reg.inspect if iteration % (1024*1024) == 0
+  #iteration += 1                                  
+  
+end    
+
+puts @reg.inspect
+puts @reg[0]

data/examples/aoc2018/day21_v3.rb

@@ -0,0 +1,157 @@
+#
+# https://adventofcode.com/2018/day/21 part 1 and part 2 
+#
+# Does not use any 'cem' functions
+#
+# Version 3: Put everything into a single Proc (did not help much)
+#
+require 'set'
+
+lines = File.readlines("inputs/day21_input.txt", chomp: true)
+
+commandQueue = []
+
+@reg = [0,0,0,0,0,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.
+    " @reg[#{v3}] = @reg[#{v1}] + @reg[#{v2}] "
+  
+  when "addi"
+  #   addi (add immediate) stores into @register C the result of adding @register A and value B.
+    " @reg[#{v3}] = @reg[#{v1}] + #{v2} "
+  
+  when "mulr"
+      # mulr (multiply @register) stores into @register C the result of multiplying @register A and @register B.
+    " @reg[#{v3}] = @reg[#{v1}] * @reg[#{v2}] "
+  
+  when "muli"
+     #  muli (multiply immediate) stores into @register C the result of multiplying @register A and value B.
+    " @reg[#{v3}] = @reg[#{v1}] * #{v2} "
+  
+  when "banr"
+     #  banr (bitwise AND @register) stores into @register C the result of the bitwise AND of @register A and @register B.
+    " @reg[#{v3}] = @reg[#{v1}] & @reg[#{v2}] "
+  
+  when "bani"
+     # bani (bitwise AND immediate) stores into @register C the result of the bitwise AND of @register A and value B.
+    " @reg[#{v3}] = @reg[#{v1}] & #{v2} "
+  
+  when "borr"
+      # borr (bitwise OR @register) stores into @register C the result of the bitwise OR of @register A and @register B.
+    " @reg[#{v3}] = @reg[#{v1}] | @reg[#{v2}] "
+  
+  when "bori"
+      # bori (bitwise OR immediate) stores into @register C the result of the bitwise OR of @register A and value B.
+    " @reg[#{v3}] = @reg[#{v1}] | #{v2} "
+  
+  when "setr"
+      # setr (set @register) copies the contents of @register A into @register C. (Input B is ignored.)
+    " @reg[#{v3}] = @reg[#{v1}] "
+  
+  when "seti"
+      # seti (set immediate) stores value A into @register C. (Input B is ignored.)
+    " @reg[#{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.
+    " @reg[#{v3}] = #{v1} > @reg[#{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.
+    " @reg[#{v3}] = @reg[#{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.
+    " @reg[#{v3}] = @reg[#{v1}] > @reg[#{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.
+    " @reg[#{v3}] = #{v1} == @reg[#{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.
+    " @reg[#{v3}] = @reg[#{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.
+    " @reg[#{v3}] = @reg[#{v1}] == @reg[#{v2}] ? 1 : 0 
+    
+      if #{v2} == 0
+        if @s.size == 0
+          puts \"Part 1: \#{@reg[#{v1}]}\"
+        end
+        
+        puts \"\#{@s.size.to_s.rjust(10)} - \#{@reg[#{v1}]}\" if @s.size % 64 == 0
+        
+        if @s.include?(@reg[#{v1}])
+          puts \"Part 2: \#{@last}\"
+          exit
+        end
+        @s.add @reg[#{v1}]
+        @last = @reg[#{v1}]
+      end
+    "
+  
+  else
+    puts "error" #  raise "Error"
+  end
+end
+
+
+      
+ipid = 0
+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
+    
+    p = command(verb, v1, v2, v3) 
+    
+    puts p
+    
+    commandQueue << p
+    
+  end
+}
+
+ippMax = commandQueue.size
+
+commandQueue = "case ipp\n" + commandQueue.each_with_index.map { |v, i|
+  "when #{i}\n  #{v}\n"
+}.join("\n") + "\nend"
+
+ipp = 0
+iteration = 0
+
+puts commandQueue
+commandQueue = eval("
+while #ipp >= 0 && ipp < ippMax
+
+  @reg[ip] = ipp
+  
+  #{commandQueue}
+  
+  ipp = @reg[ip]
+  ipp += 1
+    
+end")
+
+ #{commandQueue} }")
+
+
+puts @reg.inspect
+puts @reg[0]

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    
+    
+      
+    
+    
+    
+
+
+
+
+
+
+
+
+