advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2017/16.yml

@@ -0,0 +1,238 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/7k572l/2017_day_16_solutions/drbrxaa/
+  :body: |-
+    This day made me so unsure what I want from Advent of Code. Yesterday, I thought "I really wish the problems made us think more, rather than a contest of who can type the fastest". Today, the problem made us think more and it did not go well: missed part 2 leaderboard because I went with the broken approach of thinking the total relative permutation from one iteration can simply be reapplied multiple times. Nope, because there are absolute permutations too. I think what I ultimately want is to continue to have problems that make us think... but for me to be better at thinking of the right solution in the heat of the moment. Oh well, next time.
+
+    Here is a Ruby solution that finds a cycle.
+
+    ```ruby
+    def dance(orig, steps)
+      steps.each_with_object(orig.dup) { |step, progs|
+        args = step[1..-1]
+        case step[0]
+        when ?s
+          progs.replace(progs.chars.rotate(-args.to_i).join)
+        when ?x
+          l, r = args.scan(/\d+/).map(&:to_i)
+          progs[l], progs[r] = [progs[r], progs[l]]
+        when ?p
+          l, r = args.split(?/)
+          progs.tr!(l + r, r + l)
+        else raise "Unknown dance step #{step}"
+        end
+      }
+    end
+
+    input = (ARGV.empty? ? DATA : ARGF).read.split(?,).map(&:freeze).freeze
+
+    progs = [(?a..?p).to_a.join.freeze]
+
+    loop {
+      progs << dance(progs[-1], input).freeze
+      break if progs[-1] == progs[0]
+    }
+
+    progs.pop
+
+    puts progs[1]
+    puts progs[1_000_000_000 % progs.length]
+
+    __END__
+    x3/4,pm/e,x15/7,pp/l,etc.
+    ```
+
+    Note that I have since scrapped this solution in favour of one that splits up the dance into relative and absolute moves, however I will defer to https://www.reddit.com/r/adventofcode/comments/7k572l/2017_day_16\_solutions/drbqb27/ to explain how that looks, since it wasn't my idea.
+  :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7k572l/2017_day_16_solutions/drbootv/
+  :body: |-
+    Ruby (#23/#44); Pleasant challenge! Part 2 was a shock, but I've actually encountered [a problem with the same mechanic](https://cdn.discordapp.com/attachments/385778069098463232/391459810425700352/unknown.png) before (which handles more details), so I went to look up my solution on that site and re-implemented the relevant parts here. (Also, that problem took me an all-nighter to figure out (maths and I don't get along), so it's nice that it came back to save me here!) I was lucky to have no bugs!
+
+    ```ruby
+    g=(?a..?p).to_a
+    y=gets.split(?,)
+    h={} # part 2
+    c=1000000000
+    c.times{|x|break if x>=c
+    (
+    tv,w=h[g*'']
+    gap=x-tv
+    remain=c-x-1
+    (
+        skiptimes=remain/gap
+        c-=skiptimes*gap
+    )if remain>=gap
+    ) if h.has_key?(g*'')
+
+    uu=g*'' # part 2 end
+    y.each{|x|case x
+    when /s(.+)/
+    g.rotate!(-$1.to_i)
+    when /x(\d+)\/(\d+)/
+    a,b=$1.to_i,$2.to_i
+    g[a],g[b]=g[b],g[a]
+    when /p(.)\/(.)/
+    a,b=g.index($1),g.index($2)
+    g[a],g[b]=g[b],g[a]
+    end}
+    h[uu]=[x,g[0..-1]]} # part 2
+    p g.join
+    ```
+
+    [postscript](https://cdn.discordapp.com/attachments/293355384436162560/391462643325599774/unknown.png)
+  :replies: []
+- :author: Fluffy_ribbit
+  :url: https://www.reddit.com/r/adventofcode/comments/7k572l/2017_day_16_solutions/drbwp49/
+  :body: |-
+    Ruby. I am like a little baby.
+
+    ```ruby
+    class DanceLine
+      attr_accessor :programs, :moves
+      def initialize(programs, dance_moves)
+        self.programs = programs
+        self.moves = dance_moves.split(',')
+      end
+
+      def spin(arg)
+        x = arg.to_i
+        self.programs = self.programs[-x..-1] + self.programs[0..(-x - 1)]
+      end
+
+      def exchange(args) # switch programs at position a and b
+        a, b = args.chomp.split('/').map(&:to_i)
+        hold = self.programs[a]
+        self.programs[a] = self.programs[b]
+        self.programs[b] = hold
+      end
+
+      def partner(args) # switch programs named a and b
+        a, b = args.chomp.split('/')
+        hold_index = self.programs.find_index(b)
+        self.programs[self.programs.find_index(a)] = b
+        self.programs[hold_index] = a
+      end
+
+      def execute(move)
+        #p [move, self.programs]
+        case move[0]
+        when 's' then spin(move[1..-1])
+        when 'x' then exchange(move[1..-1])
+        when 'p' then partner(move[1..-1])
+        end
+      end
+
+      def run
+        self.moves.each {|move| execute(move)}
+
+        self.programs.join
+      end
+    end
+
+    p DanceLine.new(('a'..'e').to_a, "s1,x3/4,pe/b").run
+    p DanceLine.new(('a'..'p').to_a, File.read("../input/dance_moves.txt").chomp).run
+
+    require_relative "part1.rb"
+
+    dance = DanceLine.new(('a'..'p').to_a, File.read("../input/dance_moves.txt"))
+
+    start = dance.run
+    cycle_length = 1_000_000_000
+    100.times do |n|
+      dance.run
+
+      cycle_length = n + 1 if dance.programs.join == start
+    end
+
+    dance = dance = DanceLine.new(('a'..'p').to_a, File.read("../input/dance_moves.txt"))
+
+    (1_000_000_000 % cycle_length).times {dance.run}
+
+    p dance.programs.join
+    ```
+  :replies:
+  - :author: Grimnur87
+    :url: https://www.reddit.com/r/adventofcode/comments/7k572l/2017_day_16_solutions/drc03cr/
+    :body: |-
+      Similar approach here, only I added my methods directly to the Array class:
+
+      ```ruby
+      # Extend built-in:
+      class Array
+          # Array rotator
+          def s!(num)
+              self.rotate!(-num)
+          end
+
+          # Array swap pair by index
+          def x!(i,j)
+              self[i], self[j] = self[j], self[i]
+              self
+          end
+
+          # Array swap pair by value
+          def p!(a,b)
+              i, j = self.find_index(a), self.find_index(b)
+              self.x!(i,j)
+          end
+      end
+      ```
+
+      After processing the instructions I called them thusly: `dance.send(head+'!', *tail)`.
+
+      Bit of a waste of time but I learned something new.
+    :replies: []
+- :author: rkachowski
+  :url: https://www.reddit.com/r/adventofcode/comments/7k572l/2017_day_16_solutions/drc3bi9/
+  :body: |-
+    ruby
+
+    I was completely stumped. I had to read this thread to remove some of my misconceptions. I was determined to believe that this could be reduced to a fixed permutation function. I wrote some crazy metaprogramming fast\_dance function to dynamically generate a function that would perform the permutation. It was pretty cool and completely useless.
+
+    Even after that I still couldn't figure out why the result wasn't 1000000000 % seen.size. Too much holiday spirit i guess...
+
+    ```ruby
+    input = File.read("input").chomp.split(",").map(&:chars)
+    input.map! do |line|
+      op = line.shift
+      args = line.join.split("/")
+      args.map!(&:to_i) unless op == "p"
+
+      [op.to_sym, args]
+    end
+
+    def s arr, v
+      arr.rotate!(-v)
+    end
+
+    def x arr, a,b
+      arr[a], arr[b] = arr[b], arr[a]
+    end
+
+    def p arr, a, b
+      x arr, arr.index(a), arr.index(b)
+    end
+
+    arr = ("a".."p").to_a
+
+    def dance input, arr
+      input.each { |(op, args)| send op, arr, *args }
+    end
+
+    dance input, arr
+    puts arr.join
+
+    arr = ("a".."p").to_a
+    seen = []
+    1000000000.times do |i|
+      if seen.include? arr.join
+        puts seen[1000000000 % i]
+        break
+      end
+
+      seen << arr.join
+      dance input, arr
+    end
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2017/17.yml

@@ -0,0 +1,143 @@
+---
+- :author: p_tseng
+  :url: https://www.reddit.com/r/adventofcode/comments/7kc0xw/2017_day_17_solutions/drd5y54/
+  :body: |-
+    [How I did part 2](#s "zero is ALWAYS at the start of the buffer, so the only time a value after it changes is if the spinlock lands on zero"). Edit: Okay, looks like most people figured this same thing out, figures.
+
+    Ruby
+
+    ```ruby
+    input = ARGV[0]&.to_i || 354
+
+    buffer = [0]
+    pos = 0
+
+    (1..2017).each { |n|
+      pos = (pos + input) % buffer.size
+      buffer.insert(pos + 1, n)
+      pos += 1
+    }
+    puts buffer[pos + 1]
+
+    value_after_zero = nil
+
+    pos = 0
+
+    (1..50_000_000).each { |n|
+      pos = (pos + input) % n
+      value_after_zero = n if pos == 0
+      pos += 1
+    }
+
+    puts value_after_zero
+    ```
+
+    However, this takes about four seconds to run on my computer, that's too slow. ~~Does anyone know a way to make this faster?~~
+
+    Edit: [figured it out](https://www.reddit.com/r/adventofcode/comments/7kc0xw/2017_day_17_solutions/drd8b1n/)
+  :replies:
+  - :author: p_tseng
+    :url: https://www.reddit.com/r/adventofcode/comments/7kc0xw/2017_day_17_solutions/drd8b1n/
+    :body: |-
+      > Does anyone know a way to make this faster?
+
+      Figured it out. Do multiple iterations of part 2 at a time, because not all iterations result in having to take a remainer modulo buffer length. Now runs in insiginificant time (0.07 seconds for the entire thing on my computer).
+
+      ```ruby
+      NAIVE = ARGV.delete('--naive')
+
+      step_size = ARGV[0]&.to_i || 354
+
+      buffer = [0]
+      pos = 0
+
+      (1..2017).each { |n|
+        pos = (pos + step_size) % buffer.size
+        buffer.insert(pos + 1, n)
+        pos += 1
+      }
+      puts buffer[pos + 1]
+
+      value_after_zero = nil
+      pos = 0
+      LIMIT = 50_000_000
+
+      if NAIVE
+        (1..LIMIT).each { |n|
+          pos = (pos + step_size) % n
+          value_after_zero = n if pos == 0
+          pos += 1
+        }
+        puts value_after_zero
+        exit 0
+      end
+
+      # Instead, do multiple iterations in one go,
+      # so that we do fewer modulo operations.
+      n = 0
+      while n < LIMIT
+        value_after_zero = n if pos == 1
+        # How many steps fit between `pos` and the next n to wrap?
+        # Call this `fits`.
+        # Each time we add step_size + 1 steps, so:
+        # pos + step_size * fits + fits >= n + fits
+        # pos + step_size * fits >= n
+        fits = (n - pos) / step_size
+        # We advance `fits` times (right before we wrap) and one more (wrap).
+        # As noted above, we add (step_size + 1) each time,
+        # but we only add the very last step after wrapping + writing.
+        n += fits + 1
+        pos = (pos + (fits + 1) * (step_size + 1) - 1) % n + 1
+      end
+      puts value_after_zero
+      ```
+
+      So, correct answer for my input, but a little suspicious it may have an off-by-one error somewhere. Need to verify.
+    :replies:
+    - :author: if0nz
+      :url: https://www.reddit.com/r/adventofcode/comments/7kc0xw/2017_day_17_solutions/drdulxd/
+      :body: |-
+        I've just implemented your p2's algorithm in Java and the avg execution time is 150 **microseconds**! Kudos (:
+
+        ```ruby
+        public static int part2v2(int input) {
+            int currPos = 0;
+            int result = 0;
+            int limit = 50000000;
+            int n = 0;
+            while (n < limit) {
+                if (currPos == 1)
+                    result = n;
+                int fits = (n-currPos)/input;
+                n+=(fits+1);
+                currPos = (currPos + (fits+1)*(input+1) -1) % n +1;
+            }
+            return result;
+        }
+        ```
+      :replies: []
+- :author: Unihedron
+  :url: https://www.reddit.com/r/adventofcode/comments/7kc0xw/2017_day_17_solutions/drd600h/
+  :body: |-
+    Ruby, part 1
+
+    ```ruby
+    v=gets.to_i
+    #v=3
+    w=[y=0]
+    2017.times{w.rotate!(v)
+    w+=[y+=1]
+    }
+    p w[0]
+    ```
+
+    Part 2 did not run in time, I'm tempted to think optimizations are needed, but I barely understand the problem to do anything. Going to let it run for a few hours to check it works before posting it.
+  :replies:
+  - :author: theyangmaster
+    :url: https://www.reddit.com/r/adventofcode/comments/7kc0xw/2017_day_17_solutions/drd62jc/
+    :body: Try observing what the first element in the list is.
+    :replies:
+    - :author: Unihedron
+      :url: https://www.reddit.com/r/adventofcode/comments/7kc0xw/2017_day_17_solutions/drd9yx4/
+      :body: https://cdn.discordapp.com/attachments/293355384436162560/391855738282311681/unknown.png
+      :replies: []