cem 0.1.3 → 0.1.7

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

data/examples/aoc2018/day24.rb

@@ -0,0 +1,156 @@
+#
+# https://adventofcode.com/2018/day/24 part 1 and 2
+#
+# Does not use any cem functions
+#
+
+Group = Struct.new("Group", :immuneSystem, :units, :hitPoints, :weakness, :immunities, :damage, :damageType, :initiative) {
+
+  def damageCalc(other)
+    damage * units * (other.immunities.include?(damageType) ? 0 : 1) * (other.weakness.include?(damageType) ? 2 : 1)
+  end
+  
+  def effectivePow
+    damage * units
+  end
+}
+
+lines = File.readlines("inputs/day24_input.txt")
+
+groups = []
+immuneSystem = false
+
+lines.each { |line|
+  line.strip!
+
+  if line =~ /^Immune System:$/
+    immuneSystem = true
+  elsif line =~ /^Infection:$/
+    immuneSystem = false
+  elsif line =~ /^([+-]?\d+) units each with ([+-]?\d+) hit points\s*(.*?) with an attack that does ([+-]?\d+) (\w+) damage at initiative ([+-]?\d+)$/
+    units = $1.to_i
+    hitPoints = $2.to_i
+    immunities = []
+    weakness = []
+    w = $3
+    damage = $4.to_i
+    damageType = $5
+    initiative = $6.to_i
+    
+    w.gsub(/\(|\)/, "").split("; ").each { |s|
+      if s =~ /immune to (.*)/
+        immunities = $1.split(", ")
+      end
+      if s =~ /weak to (.*)/
+        weakness = $1.split(", ")
+      end
+    }
+    
+    g = Group.new(immuneSystem, units, hitPoints, weakness, immunities, damage, damageType, initiative)
+    groups << g
+    # puts g.inspect
+  elsif line == ""
+  
+  else
+    raise line.inspect
+  end    
+}
+
+def run(groups)
+
+  max_init = groups.map { |g| g.initiative }.max + 1
+
+  @max_init = max_init
+
+  round = 0
+  
+  while groups.count { |g| g.immuneSystem } != 0 && groups.count { |g| !g.immuneSystem } != 0
+
+    anyDamage = false  
+  
+    groups.sort_by! { |g| [-g.damage * g.units, -g.initiative] }
+    
+    # Target Selection
+    attackedGroups = []
+    attackPairs = []
+    groups.each { |g|
+      others = groups.select { |other| g.immuneSystem != other.immuneSystem && !attackedGroups.include?(other) }
+      
+      groupToAttack = others.sort_by { |other| [-g.damageCalc(other), -other.damage * other.units, -other.initiative] }.first
+      
+      if groupToAttack && g.damageCalc(groupToAttack) != 0
+        attackedGroups << groupToAttack
+        attackPairs << [g, groupToAttack]
+      end
+    }
+    
+    attackPairs.sort_by! { |x| -x[0].initiative } 
+    
+    # Attack phase
+    attackPairs.each { |x|
+      from, to = x
+      damage = from.damageCalc(to)
+      
+      killedUnits = damage / to.hitPoints
+      if killedUnits > 0
+        anyDamage = true
+      end
+      to.units -= killedUnits 
+          
+      if to.units <= 0
+        to.units = 0
+        groups = groups - [to]
+      end
+    }
+
+    groups.sort_by! { |g| -(g.immuneSystem ? 1 : 0) * 100000000000 - (g.damage * g.units * max_init + g.initiative)}
+    
+    # puts round
+    round += 1
+    # system("cls") if round % 1024 == 0    
+    # groups.each { |g| puts g.inspect } if round % 1024 == 0
+      
+    if !anyDamage 
+      groups.each { |g| puts g.inspect }
+      return 
+    end
+  end
+  
+  groups
+end  
+
+tempGroup = groups.map { |g| g.dup }
+
+puts "Part 1: #{run(tempGroup).sum{|g| g.units }}"
+
+def part2(groups)
+
+  minAdd = 1
+  
+  loop do  
+    
+    tempGroup = groups.map { |g| g.dup }
+  
+    tempGroup.each { |g| 
+      if g.immuneSystem
+        g.damage += minAdd
+      end
+    }
+  
+    res = run(tempGroup)
+    
+    if res == nil
+      puts "Boost: #{minAdd} - Got stuck"
+    else
+      puts "Boost: #{minAdd} - #{res[0].immuneSystem}"  
+    
+      if res[0].immuneSystem
+        return res
+      end
+    end
+  
+    minAdd += 1
+  end 
+end
+
+puts "Part 2: #{part2(groups).sum { |g| g.units }}"

data/examples/aoc2018/day25.rb

@@ -0,0 +1,52 @@
+
+#
+# https://adventofcode.com/2018/day/25 part 1 (there is only 1
+#
+# Uses Point4D, but not much to see here.
+#
+require 'cem'
+
+lines = File.readlines("inputs/day25_input.txt")
+
+input = []
+
+lines.each { |line|
+
+  if line =~ /^\s*([+-]?\d+),([+-]?\d+),([+-]?\d+),([+-]?\d+)\s*$/
+    v1 = $1.to_i
+    v2 = $2.to_i
+    v3 = $3.to_i
+    v4 = $4.to_i
+    input << Point4D.new(v1,v2,v3,v4)
+  else
+    raise line.inspect
+  end
+}
+
+constellations = []
+
+input.each { |p|
+  if c = constellations.find { |c| c.any? { |p2| p2.manhattan(p) <= 3 } }
+    c << p
+  else
+    constellations << [p]
+  end
+}
+
+loop do  
+  count = constellations.count { |c| c.size > 0 }
+  
+  constellations.each_with_index { |c,i|
+    constellations.each_with_index { |d,j|
+      next if j <= i 
+      if c.any? { |p| d.any? { |p2| p2.manhattan(p) <= 3 } }
+        c.push(*d)
+        d.clear
+      end
+    }
+  }
+  break if count == constellations.count { |c| c.size > 0 }
+end
+
+puts "Part 1: #{constellations.count { |c| c.size > 0 }}"
+

data/examples/aoc2018/day2_2.rb

@@ -0,0 +1,27 @@
+
+#
+# https://adventofcode.com/2018/day/2 part 2
+#
+# Does not use any cem functions \o/
+
+previous = ''
+File.readlines("inputs/day2_input.txt").sort.each { |l|
+
+  mismatch = 0
+  s = ''
+  if previous != ''
+    l.split("").each_with_index { |c, i|
+      if previous[i] != c 
+        mismatch += 1 
+      else
+        s += c
+      end      
+    }  
+  end
+  
+  if mismatch == 1
+    puts s
+  end
+  
+  previous = l
+}

data/examples/aoc2018/day3.rb

@@ -0,0 +1,71 @@
+
+#
+# https://adventofcode.com/2018/day/3 part 1 and 2
+#
+# Demonstrates: Point2D, min(a,b), Array::with_progress
+#
+# Areas for improvement: Rect intersection
+
+require 'set'
+require 'cem'
+
+claims = []
+intersections = Set.new
+doesIntersect = Set.new
+
+Claim = Struct.new("Claim", :x, :y, :width, :height, :claimId)
+
+File.readlines("inputs/day3_input.txt").with_progress.each { |l|
+
+  if l =~ /^\#(\d+) \@ (\d+),(\d+)\: (\d+)x(\d+)$/
+
+    claim = Claim.new($2.to_i, $3.to_i, $4.to_i, $5.to_i, $1.to_i)
+    
+    claims.each { |other|
+      
+      x = claim.x
+      y = claim.y
+      w = claim.width
+      h = claim.height
+      
+      x2 = other.x
+      y2 = other.y
+      w2 = other.width
+      h2 = other.height
+      
+      if x2 < x 
+        x, x2 = x2, x
+        w, w2 = w2, w
+      end
+      
+      if y2 < y
+        y, y2 = y2, y
+        h, h2 = h2, h
+      end
+      
+      # puts "#{claim} - #{other}"
+      
+      if x + w >= x2 && y + h >= y2
+            
+        width = min(x2 + w2, x + w)
+        height = min(y2 + h2, y + h)
+        
+        doesIntersect.add(other)
+        doesIntersect.add(claim)
+      
+        for a in x2...width
+          for b in y2...height
+            # puts "#{a} #{b}"
+            intersections.add(Point2D.new(a,b))
+          end
+        end        
+        
+      end
+    }
+    
+    claims << claim
+  end  
+}
+
+puts "Part 1: #{intersections.size}"
+puts "Part 2: #{claims.to_set.subtract(doesIntersect).first.claimId}"

data/examples/aoc2018/day4.rb

@@ -0,0 +1,46 @@
+
+#
+# https://adventofcode.com/2018/day/4
+#
+# Does not use any cem functions \o/
+
+Guard = Struct.new("Guard", :id, :total, :minutes)
+
+guards = {}
+guard = nil
+asleep = nil
+
+File.readlines("inputs/day4_input.txt", chomp: true).sort.each { |l|
+
+  if l =~ /Guard \#(\d+) begins shift$/
+  
+    id = $1.to_i
+    guard = guards[id] ||= Guard.new(id, 0, [0] * 60)
+  
+  elsif / 00:(?<minute>\d+)\] falls asleep$/ =~ l
+  
+    asleep = minute.to_i 
+  
+  elsif l =~ / 00:(\d+)\] wakes up$/
+  
+    awake = $1.to_i
+    
+    guard.total += awake - asleep
+    (asleep...awake).each { |min|
+      guard.minutes[min] += 1
+    }
+    
+  end
+}
+
+guard = (guards.values.sort_by {|g| g.total}).last
+puts "Part1: #{guard.id * guard.minutes.each_with_index.max[1]}"
+
+guard = (guards.values.sort_by {|g| g.minutes.each_with_index.max[0] }).last
+puts "Part2: #{guard.id * guard.minutes.each_with_index.max[1]}"
+
+
+
+
+
+

data/examples/aoc2018/day5.rb

@@ -0,0 +1,23 @@
+
+#
+# https://adventofcode.com/2018/day/5 Part 1
+#
+# Does not use any cem functions \o/ but did you know:
+#
+#  - String#swapcase turns "Hello" into "hELLO"?
+# 
+
+out = []
+
+File.read("inputs/day5_input.txt").each_char { |c|
+  
+  if out.empty? || out.last != c.swapcase
+    out << c
+  else
+    out.pop
+  end
+
+}
+
+puts out.join.size
+

data/examples/aoc2018/day5_part2.rb

@@ -0,0 +1,29 @@
+
+#
+# https://adventofcode.com/2018/day/5 Part 2
+#
+# Does not use any cem functions \o/ but did you know:
+#
+#  - String#swapcase turns a Hello into hELLO?
+#  - Regex support 'i' for insensitive matches?
+# 
+
+File.readlines("inputs/day5_input.txt").each { |line|
+
+  puts [*'a'..'z'].map { |delete|
+            
+    out = []
+    
+    line.gsub(/#{delete}/i, '').each_char { |c|    
+      if out.empty? || out.last != c.swapcase
+        out << c
+      else
+        out.pop
+      end
+    }
+    
+    out.join.size
+  }.min
+}
+
+

data/examples/aoc2018/day6.rb

@@ -0,0 +1,53 @@
+
+#
+# https://adventofcode.com/2018/day/6 Part 1 and 2
+#
+# Uses Point2D from cem
+
+require 'cem'
+
+out = {}
+points = []
+largestRegion = 0
+
+File.readlines("inputs/day6_input.txt", chomp: true).each { |line|
+  if line =~ /^(\d+), (\d+)$/
+    v1 = $1.to_i
+    v2 = $2.to_i
+    
+    points << Point2D.new(v1, v2)
+  end
+}
+
+minX, maxX = points.map { |p| p.x }.minmax
+minY, maxY = points.map { |p| p.y }.minmax
+
+(minX..maxX).each { |x|
+  (minY..maxY).each { |y|
+  
+    coord = Point2D.new(x,y)
+  
+    nearest = points.group_by { |p| p.manhattan(coord) }.min_by { |k,v| k } 
+        
+    # puts nearest.inspect
+    if nearest.last.size == 1
+      (out[nearest.last.first] ||= []) << coord
+    end
+    
+    if points.sum { |p| p.manhattan(coord) } < 10000
+      largestRegion += 1
+    end
+  }
+}
+
+puts "Part 1"
+puts out.max_by { |k,v|
+  if v.select { |coord| (coord.x == maxX || coord.x == minX || coord.y == maxY || coord.y == minY) }.empty?
+    v.size
+  else
+    0 # don't care about infinite
+  end
+}.last.size
+
+puts "Part 2"
+puts largestRegion 

data/examples/aoc2018/day7.rb

@@ -0,0 +1,110 @@
+
+#
+# https://adventofcode.com/2018/day/7 part 1 and 2
+#
+# Does not use any cem functions \o/ 
+# 
+
+require 'set'
+
+Worker = Struct.new("Worker", :readyAt, :workingOn)
+
+def read
+  input = File.readlines("inputs/day7_input.txt", chomp: true)
+
+  @edges = {}
+  @chars = Set.new
+
+  input.each { |line|
+
+    if line =~ /^Step (.+) must be finished before step (.+) can begin.$/
+      to   = $1
+      from = $2    
+      
+      @chars.add(to)
+      @chars.add(from)
+      
+      (@edges[from] ||= []) << to
+    end    
+    
+    @chars.each { |c| @edges[c] ||= [] }
+  }
+end
+
+def anyWorkerReady 
+  return @idleWorkers.size > 0
+end
+
+def availableWork
+  return @chars.select { |c| @edges.include?(c) && @edges[c].size == 0 }.sort
+end
+
+def anyWorkAvailable
+  return availableWork.size > 0
+end
+
+def timeStep
+  
+  puts "#{@timeNow}: #{@busyWorkers.inspect}" if $DEBUG
+  
+  w = @busyWorkers.min_by { |w| w.readyAt }
+  @timeNow = w.readyAt
+  @busyWorkers -= [w]
+  @idleWorkers += [w]
+  
+  c = w.workingOn
+    
+  @result += c  
+    
+  @edges.update(@edges) { |k,v|
+    v - [c]
+  }
+end
+  
+def scheduleWork
+
+  nextTask = availableWork.first
+  
+  w = @idleWorkers.pop
+  @busyWorkers += [w]
+  w.workingOn = nextTask
+  w.readyAt = @timeNow + 61 + nextTask.ord - 'A'.ord
+  @edges.delete(nextTask)
+
+  puts "Scheduling #{nextTask} to be ready at #{w.readyAt}" if $DEBUG
+  
+end
+  
+def process(parallelism)
+
+  read()
+
+  @timeNow = 0
+  @result = ""
+
+  @busyWorkers = []
+  @idleWorkers = []
+  parallelism.times { @idleWorkers << Worker.new(0, '') }
+
+  loop do
+
+    while (!anyWorkerReady || !anyWorkAvailable) && @busyWorkers.size > 0
+      timeStep
+    end
+    
+    if !anyWorkAvailable
+      break
+    end
+    
+    scheduleWork 
+    
+  end
+    
+  puts "Parallelism: #{parallelism}"
+  puts @result
+  puts @timeNow
+  
+end
+
+process(1)
+process(5)