cem 0.1.4 → 0.1.5

data/examples/aoc2018/day21.rb

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

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]