cem 0.1.4 → 0.1.5

data/examples/aoc2018/day15.rb

@@ -0,0 +1,271 @@
+
+#
+# https://adventofcode.com/2018/day/15 part 1 and part 2 
+#
+# Demonstrate use of Point2D and Grid
+#
+# This task took me a long time, because I did a array.sort instead of array.sort!
+#
+
+require 'cem'
+
+Agent = Struct.new("Agent", :pos, :faction, :hp) 
+
+class Puzzle 
+
+  attr_accessor :persons, :lines, :dirs
+  
+  def initialize 
+    @persons = []
+    @grid = []
+    @dirs = []
+  end
+  
+  def others(o)
+    @persons.select { |p| p.faction != o.faction }
+  end
+    
+  def adjacents(o)
+    @dirs.map {|dir| o.pos + dir if @grid[o.pos + dir] == '.'}.compact
+  end
+    
+  def free(pos) 
+    @grid[pos] == '.' && @persons.find { |p| p.pos == pos } == nil 
+  end
+
+  def printBoard(overlay = nil)
+
+    @grid.data.each_with_index { |l, y|
+      l.each_with_index { |c, x|
+      
+        pos = Point2D.new(x,y)
+        
+        if overlay && overlay.has_key?(pos)
+          print overlay[pos] 
+        else
+          p = @persons.find { |p| p.pos == pos } 
+          if p 
+            print p.faction
+          else
+            print c
+          end
+        end
+      }
+      
+      puts " " + @persons.select{ |p| p.pos.y == y }.sort_by { |p| p.pos.x }.map {|p| "#{p.faction}(#{p.hp})"}.join(", ")
+    }
+  end
+
+  def run(inputFilename, debug, elvenPower=3)
+  
+    # Crucial to sort the directions as given in the problem description
+    @dirs = Dirs2D.sort_by { |pos| pos.y * 10000 + pos.x }
+    
+    lines = []
+    File.readlines(inputFilename, chomp: true).each { |line|
+      lines << line.rstrip.chars
+    }
+    
+    @grid = Grid.new(lines.size, lines[0].size, ' ')
+    @grid.data = lines    
+    
+    # Read board
+    @grid.map_a! { |p, c|
+      case c
+        when 'E', 'G'
+          @persons << Agent.new(p, c, 200)
+          next '.'
+      end
+    }  
+    
+    generation = -1
+
+    loop do 
+    
+      system "cls" if debug
+
+      generation += 1
+      
+      if generation == 0
+        puts "Initial Generation with power #{elvenPower}" if debug
+      else
+        puts "After Generation: #{generation} with power #{elvenPower}" if debug
+      end
+      
+      printBoard if debug
+      #gets if debug && generation >= 70
+                 
+      @persons.sort_by { |cart| cart.pos.y * 10000 + cart.pos.x }.each { |p|
+      
+        next if !@persons.include?(p)
+        
+        if @persons.select {|p| p.faction == 'E' }.size == 0 || @persons.select {|p| p.faction == 'G' }.size == 0
+          system "cls" if debug
+          puts "Before Generation: #{generation} finishes" if debug
+          printBoard if debug
+          
+          puts "#{generation} * #{@persons.sum {|p| p.hp }} = #{generation * @persons.sum {|p| p.hp }}"
+          return (@persons[0].faction == 'E' ? 1 : -1) * generation * @persons.sum {|p| p.hp }
+        end
+      
+        # puts p.inspect
+      
+        # Moving
+        nearby = @persons.select { |o| o.faction != p.faction && dirs.any? { |dir| p.pos + dir == o.pos } }.group_by { |o| o.hp }.min_by { |k,v| k } 
+        
+        if nearby == nil || nearby.size == 0
+          distancemap = Array.new(@grid.data.size) { Array.new(@grid[0].size)}
+          
+          targets = Set.new(others(p).map {|o| adjacents(o)}.flatten)
+          
+          s = p.pos
+          distancemap[s.y][s.x] = 0
+          bfs = []
+          bfsNG = [s]
+          found = []
+          
+          target = []
+          while bfsNG.size > 0 && found.size == 0
+            bfs = bfsNG
+            bfsNG = []
+            while bfs.size > 0
+              
+              s = bfs.shift
+                          
+              dirs.each { |dir|
+                
+                s2 = s + dir
+               
+                if free(s2)
+                  
+                  if distancemap[s2.y][s2.x] == nil
+                    bfsNG << s2 
+                    #puts " free " + s2.inspect + " - " + dir.to_s
+                    distancemap[s2.y][s2.x] = dir.flip
+                  end
+                  
+                  if targets.include?(s2)
+                    found << s2
+                  end            
+                end
+              }
+            end
+          end
+          
+          if found.size > 0
+            found.sort_by! { |p| p.y * 10000 + p.x }
+            
+            overlay = {}
+            
+            if found.size > 1              
+              found.each { |p| overlay[p] = '+' }
+              overlay[found[0]] = 'X'
+            end
+            
+            target = found[0]
+            #puts "  Target: #{target}"
+            
+            lastMove = nil
+            
+            while target && target != p.pos
+              lastMove = distancemap[target.y][target.x]
+              #puts target.inspect
+              overlay[target] = 'x'
+              target = target + lastMove
+            end
+
+            #if generation >= 77
+            #  system('cls')
+            #  printBoard(overlay)
+            #  puts found.inspect
+            #  gets
+            #end
+            
+            p.pos = p.pos + lastMove.flip if lastMove
+            #puts "  Moved to #{p.pos}"
+          end
+        end
+        
+        # Fighting
+        nearby = @persons.select { |o| o.faction != p.faction && dirs.any? { |dir| p.pos + dir == o.pos } }.group_by { |o| o.hp }.min_by { |k,v| k } 
+        if nearby && nearby.size > 0 
+          nearby = nearby[1]
+        
+          #puts "Fighting"
+          nearby.sort_by! { |cart| cart.pos.y * 10000 + cart.pos.x }
+        
+          if p.faction == 'E'
+            nearby[0].hp -= elvenPower
+          else
+            nearby[0].hp -= 3
+          end           
+            
+          if (nearby[0].hp <= 0)
+            @persons -= [nearby[0]]
+            
+            if nearby[0].faction == 'E' && elvenPower > 3
+              return -1
+            end            
+          end
+        end
+        
+      }
+        
+      
+    end
+  end
+
+end
+
+part1 = {
+  # "inputs/day15_input14.txt" => -248848,
+  # "inputs/day15_input13.txt" => -261855,
+  # "inputs/day15_input12.txt" => -189000,
+  # "inputs/day15_input11.txt" => '?',
+  # "inputs/day15_input10.txt" => -261855,
+  # "inputs/day15_input2.txt" => -27730,
+  # "inputs/day15_input3.txt" => -18740,
+  # "inputs/day15_input4.txt" =>  36334,
+  # "inputs/day15_input5.txt" =>  39514,
+  # "inputs/day15_input6.txt" => -27755,
+  # "inputs/day15_input7.txt" => -28944,
+   "inputs/day15_input.txt" => '?'
+}
+
+debug = false
+
+part1.each_pair { |k,v|
+
+  power = 3
+  is = Puzzle.new.run(k, debug, power)
+  
+  puts "Part 1: #{k} == #{is}"
+  if is != v && v != '?'
+    puts "#{k} should be #{v}, but is #{is}"
+    exit
+  end
+}
+
+
+part2 = {
+  "inputs/day15_input.txt" => '?'
+}
+
+part2.each_pair { |k,v|
+
+  power = 4
+  while true
+    # puts "Elven Power: #{power} "
+    is = Puzzle.new.run(k, debug, power)
+    power += 1
+    if is > 0 
+      break;
+    end
+  end
+  
+  puts "Part 2: #{k} == #{is}"
+  if is != v && v != '?'
+    puts "#{k} should be #{v}, but is #{is}"
+    exit
+  end
+}

data/examples/aoc2018/day16.rb

@@ -0,0 +1,158 @@
+#
+# https://adventofcode.com/2018/day/16 part 1 and part 2 
+#
+# Does not use any 'cem' functions
+#
+
+input = File.readlines("inputs/day16_input.txt", chomp: true)
+
+data = []
+inputs = []
+
+input.each { |line|
+
+  if line =~ /^Before\: \[([+-]?\d+), ([+-]?\d+), ([+-]?\d+), ([+-]?\d+)\]$/
+    
+    v1 = $1.to_i
+    v2 = $2.to_i
+    v3 = $3.to_i
+    v4 = $4.to_i
+    
+    data << [v1,v2,v3,v4]
+    
+  end    
+
+  if line =~ /^([+-]?\d+) ([+-]?\d+) ([+-]?\d+) ([+-]?\d+)$/
+    
+
+    v1 = $1.to_i
+    v2 = $2.to_i
+    v3 = $3.to_i
+    v4 = $4.to_i
+    
+    data << [v1,v2,v3,v4]    
+  end    
+
+  if line =~ /^After\:  \[([+-]?\d+), ([+-]?\d+), ([+-]?\d+), ([+-]?\d+)\]$/
+    v1 = $1.to_i
+    v2 = $2.to_i
+    v3 = $3.to_i
+    v4 = $4.to_i
+    
+    data << [v1,v2,v3,v4]
+        
+    # puts data.inspect
+    inputs << data
+    data = []
+  end    
+
+  if line =~ /^$/
+    # data << $1.to_i
+  end  
+}
+
+mapping = {}
+
+def op(op, reg, command)
+
+  case op
+  
+  when 0 # addr
+    reg[command[1]] + reg[command[2]]
+  
+  when 1 # addi
+    reg[command[1]] + command[2]
+  
+  when 2 # mulr
+    reg[command[1]] * reg[command[2]]
+  
+  when 3 #muli
+    reg[command[1]] * command[2]
+  
+  when 4 # banr
+    reg[command[1]] & reg[command[2]]
+  
+  when 5 # bani
+    reg[command[1]] & command[2]
+  
+  when 6 # borr
+    reg[command[1]] | reg[command[2]]
+  
+  when 7 # bori
+    reg[command[1]] | command[2]
+  
+  when 8 # setr
+    reg[command[1]] 
+  
+  when 9 # seti
+    command[1]
+   
+  when 10 # gtir
+    command[1] > reg[command[2]] ? 1 : 0
+  
+  when 11 # gtri
+    reg[command[1]] > command[2] ? 1 : 0
+  
+  when 12 # gtrr
+    reg[command[1]] > reg[command[2]] ? 1 : 0
+   
+  when 13 # eqir
+    command[1] == reg[command[2]] ? 1 : 0
+  
+  when 14 # eqri
+    reg[command[1]] == command[2] ? 1 : 0
+  
+  when 15 # eqrr
+    reg[command[1]] == reg[command[2]] ? 1 : 0 
+  
+  else
+    raise 
+  end
+end
+
+result = 0
+inputs.each { |data|
+
+    # puts data.inspect
+
+    # puts "Before: " + data[0].inspect
+    # puts "OP    : " + data[1].inspect
+    # puts "After : " + data[2].inspect
+    
+    # puts data[1].inspect + ": Cmd #{data[1][0]} on reg#{data[1][1]} val=#{data[0][data[1][1]]} op? reg#{data[1][2]} val=#{data[0][data[1][2]]} (imm #{data[1][2]}) == #{data[2][data[1][3]]} (was #{data[0][data[1][3]]})"
+    
+    command = data[1]
+    matches = []
+    (0..15).each { |i|
+    
+      reg = data[0].dup
+      
+      reg[command[3]] = op(i, reg, command)
+      
+      if reg == data[2]
+        matches << i
+      end
+    }
+    
+    result += 1 if matches.size >= 3
+    
+    matches = matches.select { |m| !mapping.values.include?(m) } 
+    
+    if matches.size == 1
+      mapping[data[1][0]] = matches[0]
+    end
+    
+    # puts matches.inspect
+}
+
+# puts mapping.inspect
+
+puts "Part 1: #{result}"
+
+reg = [0,0,0,0]
+
+data.each { |command|
+  reg[command[3]] = op(mapping[command[0]], reg, command)
+}
+
+puts "Part 2: #{reg[0]}"

data/examples/aoc2018/day17.rb

@@ -0,0 +1,203 @@
+
+#
+# https://adventofcode.com/2018/day/17 part 1 and 2
+#
+# Demonstrates Point2D and Dir2D in particular #left, #right, #down methods. Could use Grid!
+#
+
+require 'cem'
+require 'set'
+
+input = File.readlines("inputs/day17_input.txt", chomp: true)
+
+@vert = []
+@hori = []
+@waterTiles = Set.new
+@deepWater = Set.new
+
+input.each { |line|
+
+  if line =~ /^y=([+-]?\d+), x=([+-]?\d+)..([+-]?\d+)$/
+    v1 = $1.to_i
+    v2 = $2.to_i
+    v3 = $3.to_i
+    
+    @vert << [v1,v2,v3]
+  end    
+
+  if line =~ /^x=([+-]?\d+), y=([+-]?\d+)..([+-]?\d+)$/
+    v1 = $1.to_i
+    v2 = $2.to_i
+    v3 = $3.to_i
+    
+    @hori << [v1,v2,v3]
+  end    
+}
+
+@minY = [@vert.map { |v| v[0] }.min, @hori.map { |h| h[1] }.min].min
+@maxY = [@vert.map { |v| v[0] }.max, @hori.map { |h| h[2] }.max].max
+
+@minX = [@hori.map { |v| v[0] }.min, @vert.map { |h| h[1] }.min].min
+@maxX = [@hori.map { |v| v[0] }.max, @vert.map { |h| h[2] }.max].max
+
+cursor = Point2D.new(500, @minY)
+
+@map = []
+(0..@maxY + 1).each { |y|
+  @map << []
+  (0..@maxX + 1).each { |x|
+    @map[y] << ' '
+  }
+}
+
+@vert.each { |v|
+  (v[1]..v[2]).each {|x| @map[v[0]][x] = 'x' }
+}
+@hori.each {|h|
+  (h[1]..h[2]).each {|y| @map[y][h[0]] = 'x' }
+}
+
+def free(cursor)
+  @map[cursor.y][cursor.x] == ' '
+end
+
+def printMap(filename, map, overlay, deepWater, cursor=nil, windowSizeY = 15, windowSizeX = 35)
+
+  file = File.open(filename, 'w') if filename
+
+  if !filename
+    system('cls')
+    puts cursor
+  end
+  
+  rangeY = cursor ? ((cursor.y - windowSizeY)..(cursor.y + windowSizeY)) : 0...map.size
+  rangeX = cursor ? ((cursor.x - windowSizeX)..(cursor.x + windowSizeX)) : 0...map[0].size
+  
+  rangeY.each { |y|
+    l = map[y]
+    line = ''
+    rangeX.each { |x|
+      if l != nil
+        c = l[x]
+      else
+        c = nil
+      end
+          
+      if c == nil
+        c = '?'
+      end
+          
+      pos = Point2D.new(x,y)
+      if deepWater && deepWater.include?(pos)
+        line += '~'
+      elsif overlay && overlay.include?(pos)
+        line += '|'
+      else
+        line += c
+      end
+    } 
+    if filename 
+      file.write(line + "\n")
+    else
+      puts line
+    end
+  } 
+  
+  if !filename
+    gets
+  else
+    file.close
+  end
+  
+end
+
+# 
+# returns true if all available space has been filled
+#
+def cursorMove(cursor)
+
+  cursorStart = cursor
+
+  @waterTiles << cursor
+
+  # Traverse down from cursor position
+  while free(cursor.down) && cursor.y < @maxY && !@waterTiles.include?(cursor.down)    
+    printMap(nil, @map, @waterTiles, @deepWater, cursor) if false 
+    
+    cursor = cursor.down
+    @waterTiles << cursor
+  end
+  
+  if cursor.y == @maxY 
+    return false # we moved out of the field - stop recursion
+  end
+  
+  if @waterTiles.include?(cursor.down) && !@deepWater.include?(cursor.down)
+    return false # already been here
+  end  
+  
+  # Below us is rock
+  left = right = rowStart = cursor
+  
+  row = Set.new
+  row << rowStart
+  
+  while true 
+    
+    while free(left.left) && !@waterTiles.include?(left.left) && (!free(left.down) || @deepWater.include?(left.down))
+      left = left.left
+      row << left
+      @waterTiles << left
+    end
+    
+    while free(right.right) && !@waterTiles.include?(right.right) && (!free(right.down) || @deepWater.include?(right.down))
+      right = right.right
+      row << right
+      @waterTiles << right
+    end
+  
+    printMap(nil, @map, @waterTiles, @deepWater, cursor) if false # && cursor.y > 1300 && cursor.y < 1330
+  
+    if !free(right.right) && (!free(right.down) || @deepWater.include?(right.down)) && !free(left.left) && (!free(left.down) || @deepWater.include?(left.down))
+      
+      # Move up                  
+      rowStart = rowStart.up
+      
+      @deepWater.merge row
+      row = Set.new
+      row << rowStart
+      
+      if rowStart.y < cursorStart.y
+        return true # Return true, if we filled all available space
+      end
+      
+      left = right = rowStart
+
+      # Fill again...
+      
+    else
+    
+      a = !@waterTiles.include?(right.right) && !@waterTiles.include?(left.left)
+      if free(right.down) && !(!free(right.down) || @deepWater.include?(right.down))
+        a &= cursorMove(right.down)
+      end
+      
+      if free(left.left) && !(!free(left.down) || @deepWater.include?(left.down))
+        a &= cursorMove(left.down)
+      end
+      
+      if !a 
+        break
+      end
+    end
+  end
+  
+  return false
+end
+
+cursorMove(cursor)
+
+printMap("day17.out", @map, @waterTiles, @deepWater) if false
+
+puts "Part 1: #{@waterTiles.size}"
+puts "Part 2: #{@deepWater.size}"