day 14: skip storing most elements

All sequences converge pretty quickly on index 23.

We now only need to store digits reachable from index 23.

All other digits can be immediately discarded, since we already updating
the number of good digits as each digit is generated.

The effect on runtime is disappointing, at best a 0.1 second improvement
from 8.3 seconds -> 8.2 seconds.

However, memory usage should be greatly improved!

Author: petertseng

14_chocolate_charts.rb

@@ -42,15 +42,39 @@ def state_transitions(digits)
 
 # This code does some bad things solely for the purpose of being fast.
 def find(digits)
-  first = 0
-  second = 1
-  scores = INITIAL.dup
+  # Generated by gen14.rb
+  # 371010124515891677925107
+  prefixes = [
+    [3, 1, 1, 4, 9], # 0
+    [7, 5, 6, 0],    # 1
+    [1, 1, 1, 4, 9], # 2
+    [0, 1, 1, 4, 9], # 3
+    [1, 1, 4, 9],    # 4
+    [0, 1, 4, 9],    # 5
+    [1, 4, 9],       # 6
+    [2, 1, 8, 1],    # 7
+    [4, 9],          # 8
+    [5, 6, 0],       # 9
+  ].map(&:freeze).freeze
+  suffix = [7]
+
+  # first starts at 4
+  first_on_suffix = false
+  first_track = prefixes[0]
+  first_pos = 1
+  # second starts at 13
+  second_on_suffix = false
+  second_track = prefixes[0]
+  second_pos = 4
+
+  size = 24
+  next_write = 31
 
   state_table = state_transitions(digits)
   good_digits = 0
 
-  score1 = scores[first]
-  score2 = scores[second]
+  score1 = first_track[first_pos]
+  score2 = second_track[second_pos]
 
   # while true is faster than loop
   # https://github.com/JuanitoFatas/fast-ruby#loop-vs-while-true-code
@@ -65,29 +89,52 @@ def find(digits)
     if new_score >= 10
       new_score -= 10
       good_digits = state_table[good_digits][1]
-      return scores.size + 1 - digits.size if good_digits == digits.size
-      scores << 1
+      return size + 1 - digits.size if good_digits == digits.size
+      if size == next_write
+        suffix << 1
+        next_write += 2
+      end
+      size += 1
     end
 
     good_digits = state_table[good_digits][new_score]
-    return scores.size + 1 - digits.size if good_digits == digits.size
-    scores << new_score
+    return size + 1 - digits.size if good_digits == digits.size
+    if size == next_write
+      suffix << new_score
+      next_write += 1 + new_score
+    end
+    size += 1
 
-    unless (score1 = scores[first += 1 + score1])
-      first %= scores.size
-      score1 = scores[first]
+    unless (score1 = first_track[first_pos += 1])
+      first_pos = 0
+      if first_on_suffix
+        first_track = prefixes[next_write - size]
+        first_on_suffix = false
+      else
+        first_track = suffix
+        first_on_suffix = true
+      end
+      score1 = first_track[0]
     end
-    unless (score2 = scores[second += 1 + score2])
-      second %= scores.size
-      score2 = scores[second]
+    unless (score2 = second_track[second_pos += 1])
+      second_pos = 0
+      if second_on_suffix
+        second_track = prefixes[next_write - size]
+        second_on_suffix = false
+      else
+        second_track = suffix
+        second_on_suffix = true
+      end
+      score2 = second_track[0]
     end
   end
 end
 
 {
-  [5, 1, 5, 8, 9] => 9,
-  [0, 1, 2, 4, 5] => 5,
-  [9, 2, 5, 1, 0] => 18,
+  # No longer operative since we start w/ 24 elements.
+  #[5, 1, 5, 8, 9] => 9,
+  #[0, 1, 2, 4, 5] => 5,
+  #[9, 2, 5, 1, 0] => 18,
   [5, 9, 4, 1, 4] => 2018,
 }.each { |k, want|
   got = find(k)

README.md

@@ -55,6 +55,11 @@ Interesting approaches:
     * https://en.wikipedia.org/wiki/Summed-area_table
     * We can calculate a maximum upper bound on the size of a square with length 2N by using four squares of length N.
     * We can calculate a maximum upper bound on the size of a square with length 2N+1 by using two squares of length N plus two squares of length N+1 minus one square.
+* Day 14 (Chocolate Charts):
+    When wrapping around, you must land on one of the first ten elements of the array.
+    All sequences converge on index 23.
+    From that point forward, we only need to store the scores that elves will land on.
+    All other scores can be immediately discarded after updating the state of "how many charactes have I seen".
 
 # Takeaways
 

gen14.rb

@@ -0,0 +1,75 @@
+INITIAL = [3, 7].freeze
+def converged(scores)
+  seqs = []
+  return nil if scores.size < 10
+  (0...10).each { |start|
+    pos = start
+    poses = []
+    while (score = scores[pos])
+      poses << [score, pos]
+      pos += 1 + score
+    end
+    seqs[start] = poses
+  }
+  minlen = seqs.map(&:size).min
+  mismatch_from_right = (0...minlen).find { |i|
+    seqs.map { |s| s[-1 - i] }.uniq.size > 1
+  }
+  mismatch_from_right > 0 ? [seqs, mismatch_from_right] : nil
+end
+
+first = 0
+second = 1
+scores = INITIAL.dup
+
+step = -> {
+  scores.concat((scores[first] + scores[second]).digits.reverse)
+  first = (first + 1 + scores[first]) % scores.size
+  second = (second + 1 + scores[second]) % scores.size
+}
+
+# This could take a long time since each call to converged traverses the entire array,
+# but luckily it doesn't.
+until (seqs, mismatch_from_right = converged(scores))
+  (_arbitrary = 10).times { step[] }
+end
+
+first_matching_score, first_matching_index = seqs[0].last(mismatch_from_right).first
+
+first = 0
+second = 1
+scores = INITIAL.dup
+step[] until scores.size >= first_matching_index + 1
+
+def write_pos(name, pos, seqs, first_match)
+  if pos >= first_match
+    track = 'suffix'
+    new_pos = pos - first_match
+  else
+    track_index = seqs.index { |s| s.any? { |_, i| i == pos } }
+    track = "prefixes[#{track_index}]"
+    new_pos = seqs[track_index].index { |_, i| i == pos }
+  end
+  puts "# #{name} starts at #{pos}"
+  puts "#{name}_on_suffix = #{track == 'suffix'}"
+  puts "#{name}_track = #{track}"
+  puts "#{name}_pos = #{new_pos}"
+end
+
+puts "# generated by #{__FILE__}"
+puts "# #{scores.join}"
+puts 'prefixes = ['
+maxlen = (seqs.map(&:size).max - mismatch_from_right) * 3 + 1
+seqs.each_with_index { |s, i|
+  s = s.dup
+  s.pop(mismatch_from_right)
+  puts "  %-#{maxlen}s # #{i}" % ["[#{s.map(&:first).join(', ')}],"]
+}
+puts '].map(&:freeze).freeze'
+puts "suffix = [#{scores.drop(first_matching_index).join(', ')}]"
+puts
+write_pos('first', first, seqs, first_matching_index)
+write_pos('second', second, seqs, first_matching_index)
+puts
+puts "size = #{scores.size}"
+puts "next_write = #{first_matching_score + first_matching_index + 1}"