cem 0.1.4 → 0.1.5

data/examples/aoc2018/day18.rb

@@ -0,0 +1,113 @@
+
+#
+# https://adventofcode.com/2018/day/18 part 1 and 2
+#
+# Demonstrates Grid and Object#peql. For an rspec based variant see day18_rspec.rb
+#
+
+require 'cem'
+require 'set'
+
+def run(inputFilename, part1, debug)
+
+  lines = []
+  File.readlines(inputFilename, chomp: true).each { |line|
+    lines << line.rstrip
+  }
+
+  maxY = lines.size
+  maxX = lines[0].length
+  
+  @m = Grid.new(maxX, maxY, '.')
+  
+  @map = []
+  lines.each_with_index { |l, y|
+    result = []
+    
+    l.chars.each_with_index { |c, x|
+      result << c
+      @m[y,x] = c
+    }
+    @map << result
+  }
+
+  puts "Initial State" if debug
+  puts @m if debug
+  
+  intermediates = Set.new
+
+  startIteration = nil
+  periodicity = nil
+  tickResultCache = nil
+  
+  # Read board
+  (1..1000000000).each { |i|
+  
+    @m2 = @m.clone
+    
+    @map.each_with_index { |l, y|
+      
+      l.each_with_index { |c, x|
+        
+        # puts "Adja: #{x} #{y}"
+        ajda = @m.adja_index(x,y)
+        case @m[y,x]
+          when '.'
+            @m2[y,x] = ajda.select { |p| @m[p] == '|' }.size >= 3 ? '|' : '.'
+          when '|'
+            @m2[y,x] = ajda.select { |p| @m[p] == '#' }.size >= 3 ? '#' : '|'             
+          when '#'
+            @m2[y,x] = ajda.select { |p| @m[p] == '#' }.size >= 1 && ajda.select { |p| @m[p] == '|' }.size >= 1 ? '#' : '.'
+        end
+        
+        puts "#{y} #{x} was #{@m[y,x]} is now #{@m2[y,x]}: #{ajda.inspect}" if debug
+        
+      }
+    }
+    
+    @m = @m2
+    
+    if part1 && i == 10
+      puts "Part 1: Score after #{i} tick is #{@m.count('#') * @m.count('|')}" # if debug
+      break
+    end
+    
+    puts @m if debug if debug
+    gets if debug
+    
+    if !part1 
+      tickResult = @m.to_a
+      
+      if periodicity == nil && tickResultCache == tickResult
+        periodicity = i - startIteration
+        # puts periodicity
+      elsif periodicity
+        if ((1000000000 - i) % periodicity) == 0
+          break
+        end
+      end
+      
+      if startIteration == nil && intermediates.include?(tickResult)
+        startIteration = i
+        tickResultCache = tickResult
+      elsif startIteration == nil
+        intermediates.add(tickResult)
+      end
+      
+    end
+  }
+    
+  @m.count('#') * @m.count('|')
+end
+
+debug = false
+
+{ 
+  "inputs/day18_test.txt"  => [1147, 0],
+  "inputs/day18_input.txt" => [589931, 222332],
+}.each_pair { |k,v|
+
+  peql(run(k, true, debug), v[0], "Testing #{k.inspect} part 1")
+  peql(run(k, false, debug), v[1], "Testing #{k.inspect} part 2")
+
+}

data/examples/aoc2018/day18_rspec.rb

@@ -0,0 +1,131 @@
+
+#
+# https://adventofcode.com/2018/day/18 part 1 and 2
+#
+# Demonstrates Grid and Object#peql. For a variant without rspec see day18.rb
+#
+
+require 'cem'
+require 'set'
+
+def run(inputFilename, part1, debug)
+
+  lines = []
+  File.readlines(inputFilename, chomp: true).each { |line|
+    lines << line.rstrip
+  }
+
+  maxY = lines.size
+  maxX = lines[0].length
+  
+  @m = Grid.new(maxX, maxY, '.')
+  
+  @map = []
+  lines.each_with_index { |l, y|
+    result = []
+    
+    l.chars.each_with_index { |c, x|
+      result << c
+      @m[y,x] = c
+    }
+    @map << result
+  }
+
+  puts "Initial State" if debug
+  puts @m if debug
+  
+  intermediates = Set.new
+
+  startIteration = nil
+  periodicity = nil
+  tickResultCache = nil
+  
+  # Read board
+  (1..1000000000).each { |i|
+  
+    @m2 = @m.clone
+    
+    @map.each_with_index { |l, y|
+      
+      l.each_with_index { |c, x|
+        
+        # puts "Adja: #{x} #{y}"
+        ajda = @m.adja_index(x,y)
+        case @m[y,x]
+          when '.'
+            @m2[y,x] = ajda.select { |p| @m[p] == '|' }.size >= 3 ? '|' : '.'
+          when '|'
+            @m2[y,x] = ajda.select { |p| @m[p] == '#' }.size >= 3 ? '#' : '|'             
+          when '#'
+            @m2[y,x] = ajda.select { |p| @m[p] == '#' }.size >= 1 && ajda.select { |p| @m[p] == '|' }.size >= 1 ? '#' : '.'
+        end
+        
+        puts "#{y} #{x} was #{@m[y,x]} is now #{@m2[y,x]}: #{ajda.inspect}" if debug
+        
+      }
+    }
+    
+    @m = @m2
+    
+    if part1 && i == 10
+      puts "Part 1: Score after #{i} tick is #{@m.count('#') * @m.count('|')}" # if debug
+      break
+    end
+    
+    puts @m if debug if debug
+    gets if debug
+    
+    if !part1 
+      tickResult = @m.to_a
+      
+      if periodicity == nil && tickResultCache == tickResult
+        periodicity = i - startIteration
+        # puts periodicity
+      elsif periodicity
+        if ((1000000000 - i) % periodicity) == 0
+          break
+        end
+      end
+      
+      if startIteration == nil && intermediates.include?(tickResult)
+        startIteration = i
+        tickResultCache = tickResult
+      elsif startIteration == nil
+        intermediates.add(tickResult)
+      end
+      
+    end
+  }
+    
+  @m.count('#') * @m.count('|')
+end
+
+debug = false
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.color = true # Use color in STDOUT
+  config.tty = true # Use color not only in STDOUT but also in pagers and files
+  config.formatter = :documentation 
+end
+
+describe $__FILE__ do
+  
+  { 
+    "inputs/day18_test.txt"  => [1147, 1],
+    "inputs/day18_input.txt" => [589931, 222332],
+  }.each_pair { |k,v|
+  
+    it "testing #{k.inspect} part 1" do
+      expect(run(k, true, debug)).to eq(v[0])
+    end  
+    
+    it "testing #{k.inspect} part 2" do
+      expect(run(k, false, debug)).to eq(v[1])
+    end
+  }
+    
+end
+
+RSpec::Core::Runner.run([$__FILE__])

data/examples/aoc2018/day19.rb

@@ -0,0 +1,145 @@
+#
+# https://adventofcode.com/2018/day/19 part 1 and 2
+#
+
+# My code was too slow to handle this problem, so this is really more analytical from observing the state of the machine and figuring out what it does.
+
+shortcut = true
+if shortcut
+
+  result = 0
+  (1..930).each { |i|
+    result += i if 930 % i == 0
+  }
+  puts "Part 1: #{result}"
+
+  result = 0
+  (1..10551330).each { |i|
+    result += i if 10551330 % i == 0
+  }
+  puts "Part 2: #{result}"
+  exit
+end
+
+
+[1,2].each { |part|
+
+  lines = File.readlines("inputs/day19_input.txt", chomp: true)
+
+  commandQueue = []
+
+  reg = [part - 1, 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
+  }
+
+  if false
+    puts "Command queue:"
+    commandQueue.each { |x|
+      puts "  " + x.inspect
+    }
+  end
+
+  ipp = 0
+  i = 0
+  reset = true
+
+  while ipp >= 0 && ipp < commandQueue.size
+
+    reg[ip] = ipp
+    command = commandQueue[ipp]
+    
+    puts command.inspect + " " + reg.inspect if i % (256*1024) == 0
+    i += 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
+    
+    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
+     
+    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 
+    
+    else
+      raise "Error"      
+    end
+
+    ipp = reg[ip]
+    ipp += 1
+  end    
+
+  puts reg.inspect
+  puts "Part#{part}: #{reg[0]}"
+}

data/examples/aoc2018/day20.rb

@@ -0,0 +1,103 @@
+#
+# https://adventofcode.com/2018/day/20 part 1 and 2
+#
+# Took 1:10 min for both parts (not bad!)
+#
+# Could have been faster, but ruzzles parts had to be created for this:
+#
+#  - Grid.minmax
+#  - Point2D.from_s
+#  - Point2D.to_dir_bitmask / from_dir_bitmask
+#  - Dirs2D
+#
+
+require 'cem'
+
+line = File.read("inputs/day20_input.txt")
+
+stack = [[Point2D.new(500,500)]]
+
+grid = Grid.new(1000, 1000, 0)
+
+line.chars.each { |c|
+  case c
+
+    when '$'   
+      # ignore
+    when '^'  
+      # ignore  
+    when "\n"
+      # ignore    
+    
+    when '(' 
+      newCurCursor = stack.last.map { |p| p.dup }
+      stack << []           # One below top() are all cursors we collected as part of this opening brace group
+      stack << newCurCursor # Stack.top() is all current cursor position we are tracking
+
+    when ')'      
+      lastGroup = stack.pop
+      otherGroupsInBrace = stack.pop
+      replacedGroup = stack.pop
+      stack << (lastGroup + otherGroupsInBrace).uniq
+    
+    when 'E', 'N', 'S', 'W'      
+      dir = Point2D.from_s(c)
+      
+      stack.last.map! { |p|
+        grid[p] |= dir.to_dir_bitmask
+        p += dir
+        grid[p] |= dir.flip.to_dir_bitmask
+        p
+      }
+    when '|'   
+      lastGroup = stack.pop
+      stack.last.concat lastGroup
+      stack << stack[-2].map { |p| p.dup }
+      
+  else
+    raise "Unknown char '#{c.inspect}'"
+  end
+}
+
+if false # Print Grid for debugging
+
+  min, max = grid.minmax(0)  
+  count = 0
+  
+  (min.y..max.y).each {|y|
+    a = ""
+    b = ""
+    (min.x..max.x).each { |x|
+      count += 1 if grid[y,x] > 0
+      a += "#" + (grid[y,x] & 1 == 1 ? "|" : "#") 
+      b += (grid[y,x] & 8 == 8 ? "-" : "#") + (grid[y,x] > 0 ? "." : "#")
+    }
+    puts a + "#"
+    puts b + "#"
+  }
+  
+end
+
+# Run BFS search
+q = [[Point2D.new(500,500), 0]]
+
+maxSteps = 0
+rooms = 0
+while q.size > 0
+  p, maxSteps = q.shift
+  
+  if maxSteps >= 1000
+    rooms += 1
+  end
+    
+  Point2D.from_dir_bitmask(grid[p]).each { |dir|
+    grid[p+dir] &= ~dir.flip.to_dir_bitmask # Close door we walked through. Due to BFS, we never have to get to it again
+    
+    q << [p+dir, maxSteps+1]    
+  }
+  grid[p] = 0
+
+end
+
+puts "Part 1: #{maxSteps}"
+puts "Part 2: #{rooms}"