You probably started with id, name, and subdomain columns.

Later there were things that had to be configured per tenant. So you simply added a bunch of columns.

The project started to grow rapidly and you added more flags, external API credentials, and even frontend configuration. You did it automatically. Before you knew it, you had several dozen columns with names similar to "sales_page_menu_text_hover_color" or "proforma_invoices_generated_automatically".

That's literally my case... My Tenant class had above 30 associations defined, 20 validations, and 8 enums. Almost 500 lines of code. It is mapped to 190 columns. All of this data was loaded at the very beginning of basically each request for the purpose of setting current_tenant where only the id is necessary to limit other queries scopes...

I wasn't interested in splitting the tenant configuration across multiple tables for that moment. I just wanted to reduce the amount of redundant data being constantly loaded and do some decomposition for better maintainability.

I limited the number of columns being selected for setting the current_tenant.

class ApplicationController < ActionController::Base
  # ...
  def set_tenant
    tenant = System.select(:id).find_by_subdomain(request.subdomain)
    set_current_tenant(tenant)
  end
end

I introduced a generic TenantConfiguration class.

class TenantConfiguration < ApplicationRecord
  self.abstract_class = true
  self.table_name = 'tenants'

  default_scope { select(['id'] + const_get('COLUMNS')) }

  def self.for_tenant(tenant)
    self.find(tenant)
  end
end

And created a specific class for each configuration area, for example:

class LumpTaxConfiguration < TenantConfiguration
  COLUMNS = [:lump_taxpayer, :payment_fee_lump_code, :delivery_lump_code]
  # ...
end

Whenever I really need a specific configuration, I just fetch it explicitly, by invoking:

LumpTaxConfiguration.for_tenant(current_tenant).lump_taxpayer?

I believe It is a step in a good direction. What is your opinion? Do you see a problem with the fat Tenant model in your multi-tenant projects? How do you cope with it?

  def l_factor
    ((bending_stiffness * 10000000000) / k) ** 0.25
  end

This big number looks so unreadable. I started moving the mouse cursor and counting zeros. There are ten of them. I was wondering how I could write it better. And actually, I found 3 ways to make it more readable:

🔍 Underscore notation

10_000_000_000

You can format a number with grouped thousands using an underscore delimiter. Ruby lets you insert underscores anywhere inside integers.

🧮 Expotential notation

10**10

You would just read it like: \( 10^{10}\)

🧑‍🔬 Scientific notation

1e10

This one is my best choice. It actually means: \( 1\cdot10^{10}\) and this notation is commonly used by scientists, mathematicians, and engineers.

Which one would you choose? 🤷 Leave a comment.

• Not all products need to keep track of their inventory level. Consider electronic products like ebooks. The sellers usually don't want to limit purchases for that kind of goods. But sometimes they do. I personally distinguish between empty stock and undefined stock as this is a pretty flexible solution. If the stock status is undefined, then we consider the goods to be available.

• Warehouse operations do not have an atomic nature. This is why we should provide a reservation concept. The goods can be reserved and still remain in the warehouse. The actual availability is the difference between the stock level and the reservation count.

• Reservation can be often mapped one-to-one to the Order, but remember we stay in the Inventory bounded context and it has its own ubiquitous language. Separation of these contexts may pay off in the future. I can imagine the part of the stock being reserved for giving away for promotional purposes.

• When it comes to real things it is crucial to have a reliable audit log. The business must have an insight into the history of warehouse events. That is what you get for free with event sourcing - a full history of how the stock level has been changing over time and why.

Having these things in mind your Inventory bounded context can be as simple as 5 commands and 2 aggregates.

1. Include cookies with the request

When the VideoJS withCredentials property is set to true, all XHR requests for playlist and segments would have withCredentials set to true as well. I refer you to this post if you aren't sure why it is required.

var player = videojs('player', {
            html5: {vhs: {withCredentials: true}}
        });

2. CORS settings

Now on the AWS side:

• Set CORS configuration for your S3 bucket

  [
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "GET",
            "HEAD"
        ],
        "AllowedOrigins": [
            "your.app.domain"
        ],
        "ExposeHeaders": [],
        "MaxAgeSeconds": 3000
    }
  ]
  

• Change the default cache behavior of your CloudFront instance. Enable OPTIONS as cached HTTP method. Choose Cache Policy and Origin Request Policy that both have origin header whitelisted.

3. Refresh cookies regularly

You must ensure that the client's browser always has a valid cookie when content is being streamed. For this, I regularly hit the backend to get a new one. The interval depends on cookies expiration time and cookies DateLessThan statement.

function reportProgress(uri, progress, async = true) {
    let s3Key = uri.substring(uri.lastIndexOf("/") + 1, uri.lastIndexOf("."));
    $.ajax({
        url: "/chapters/progress",
        type: "POST",
        async: async,
        data: {progress: progress, "s3_key": s3Key},
    });
}

player.on('beforeplaylistitem', (event, item) => {
    let uri = item.sources[0].src;
    reportProgress(uri, 0, false);
})

player.setInterval(function () {
    let uri = player.currentSource().src;
    reportProgress(uri, player.currentTime());
}, interval);

There are two ways of securing content that CloudFront delivers: signed URLs and signed cookies. In the case of a segmented file, URL signing doesn't seem to be a way to go. We have to take advantage of signed cookies.

The client browser should have a proper cookie already set while requesting .m3u8 playlist file for each streaming session. You can later refresh this cookie asynchronously. A valid cookie must be attached to the request for each .aac segment file.

When you create a signed cookie, you provide a policy statement that specifies the restrictions on the signed cookie:

• You can specify the date and time that users can begin to access your content
• You can specify the date and time that users can no longer access your content
• You can specify the IP address or range of IP addresses of the users who can access your content

My implementation uses CookieSigner from the official CloudFront SDK for Ruby. You can get it with aws-sdk-cloudfront gem.

module Panel
  class ChaptersController < Panel::PanelController

    def progress
      chapter = Chapter.find_by(user_id: current_user.id, s3_key: params[:s3_key].split('_converted').first)
      chapter.update_columns playback_progress: params[:progress], playback_progress_saved_at: DateTime.now
      sign_cookie(chapter.s3_key)
      head :no_content
    end

    private

    def sign_cookie(s3_key)
      signer = Aws::CloudFront::CookieSigner.new(
        key_pair_id: Rails.application.credentials.aws[:cloudfront_private_key_pair_id],
        private_key: Rails.application.credentials.aws[:cloudfront_private_key]
      )
      signer.signed_cookie(
        nil,
        policy: policy(s3_key, DateTime.now + 1.minute)
      ).each do |key, value|
        cookies[key] = {
          value: value,
          domain: :all
        }
      end
    end

    def policy(s3_key, expiry)
      {
        "Statement" => [
          {
            "Resource" => "#{Rails.application.credentials.aws[:cloudfront_url]}/#{s3_key}*",
            "Condition" => {
              "DateLessThan" => {
                "AWS:EpochTime" => expiry.utc.to_i
              },
              "IpAddress" => {
                "AWS:SourceIp" => "#{request.remote_ip}/32"
              }
            }
          }
        ]
      }.to_json
    end
  end
end

In such cases, I use a very simple pattern based on ActiveJob's retry_on and discard_on methods.

retry_on reschedules job for re-execution after specific delay, for a specific number of attempts. What I like about it is that this mechanism catches exceptions prior to your underlying queuing system (Sidekiq, for instance). In practical terms, that means you have a different retry interval when you just wait for the task to be finished than when, for example, a timeout error occurs.

You can also pass a block that will be invoked if the retry attempts fail rather than let the exception bubble up. It's a good place to inform developers that the task wasn't finished in a rational time, or at least log it.

discard_on is to specify an exception discarding the job. In my example, I don't want to check progress any more if the task gets canceled in the external system. Again, this is the case that should be noticed. So all you have to do is pass a block that will be invoked.

The following example references the implementation of MediaConverterJobInspector you can find in the previous post .

module Converting
  class TrackConvertJobOnConvertJobInitialized < ActiveJob::Base
    prepend RailsEventStore::AsyncHandler

    class TrackConvertJobError < StandardError
      attr_reader :s3_key, :media_convert_job_id

      def initialize(s3_key:, media_convert_job_id:)
        super
        @s3_key = s3_key
        @media_convert_job_id = media_convert_job_id
      end
    end

    ConvertJobCanceled = Class.new(TrackConvertJobError)
    ConvertJobNotFinishedYet = Class.new(TrackConvertJobError)

    TIME_INTERVAL = 20.seconds
    TIME_LIMIT = 1.hour

    retry_on(ConvertJobNotFinishedYet, wait: TIME_INTERVAL, attempts: TIME_LIMIT / TIME_INTERVAL) do |job, error|
      Rails.configuration.event_store.publish(
        ContentConvertJobTimeLimitExceeded.new(
          data: {
            media_convert_job_id: error.media_convert_job_id,
            s3_key: error.s3_key
          }
        )
      )
    end

    discard_on ConvertJobCanceled do |job, error|
      Rails.configuration.event_store.publish(
        ContentConvertJobCanceled.new(
          data: {
            media_convert_job_id: error.media_convert_job_id,
            s3_key: error.s3_key
          }
        )
      )
    end

    def perform(event)
      s3_key = event.data[:s3_key]
      media_convert_job_id = event.data[:media_convert_job_id]
      inspector = job_inspector_class.new(media_convert_job_id)
      inspector.call
      case inspector.status
      when "COMPLETE"
        event_store.publish ContentConvertJobCompleted.new(data: { media_convert_job_id: media_convert_job_id, s3_key: s3_key })
      when "ERROR"
        event_store.publish ContentConvertJobFailed.new(data: { media_convert_job_id: media_convert_job_id, s3_key: s3_key })
      when "CANCELED"
        raise ConvertJobCanceled.new(s3_key: s3_key, media_convert_job_id: media_convert_job_id)
      else
        raise ConvertJobNotFinishedYet.new(s3_key: s3_key, media_convert_job_id: media_convert_job_id)
      end
    end

    private

    def event_store
      Rails.configuration.event_store
    end

    def job_inspector_class
      Rails.env.test? ? FakeConvertJobInspector : MediaConverterJobInspector
    end
  end
end

I explained why a file conversion is required. The simplest way, I discovered, to get this done, is using the AWS Elemental MediaConvert service. It was an obvious choice for me as I am a bit familiar with the AWS stack.

Are you even going to show me the code??

Sure! There will be a lot of code this time as kicking off a convert job requires passing extensive configuration hash. My implementation wraps the official MediaConvert SDK for Ruby. You can get it having aws-sdk-mediaconvert listed in your Gemfile.

class Converting::MediaConverterWrapper
  protected

  def client
    Aws::MediaConvert::Client.new(
      region: Rails.configuration.aws[:region],
      access_key_id: Rails.application.credentials.aws[:access_key_id],
      secret_access_key: Rails.application.credentials.aws[:secret_access_key],
      endpoint: Rails.configuration.aws[:endpoint]
    )
  end
end

class Converting::MediaConverterJobInitializer < Converting::MediaConverterWrapper

  def initialize source_s3_key
    @source_s3_key = source_s3_key
  end

  def call
    source_S3_bucket = Rails.configuration.aws[:source_S3_bucket]
    source_S3 = "s3://#{source_S3_bucket}/#{@source_s3_key}"
    destination_S3_bucket = "s3://#{Rails.configuration.aws[:destination_S3_bucket]}/"
    queue = Rails.configuration.aws[:queue]
    role = Rails.configuration.aws[:role]

    # Kicking off a job
    @response = client.create_job(create_job_request_body(source_S3, queue, role, destination_S3_bucket))
    nil
  end

  def job_id
    @response[:job][:id]
  end

  private

  def create_job_request_body source_S3, queue, role, destination_S3
    {
      :queue => queue,
      :user_metadata => {},
      role: role,
      :settings => {
        :timecode_config => {
          :source => 'ZEROBASED'
        },
        :output_groups => [
          {
            :name => 'Apple HLS',
            :outputs => [
              {
                :container_settings => {
                  :container => 'M3U8',
                  :m3u_8_settings => {
                    :audio_frames_per_pes => 4,
                    :pcr_control => 'PCR_EVERY_PES_PACKET',
                    :pmt_pid => 480,
                    :private_metadata_pid => 503,
                    :program_number => 1,
                    :pat_interval => 0,
                    :pmt_interval => 0,
                    :scte_35_source => 'NONE',
                    :nielsen_id_3 => 'NONE',
                    :timed_metadata => 'NONE',
                    :video_pid => 481,
                    :audio_pids => [482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492],
                    :audio_duration => 'DEFAULT_CODEC_DURATION' }
                },
                :audio_descriptions => [
                  {
                    :audio_type_control => 'FOLLOW_INPUT',
                    :audio_source_name => 'Audio Selector 1',
                    :codec_settings => {
                      :codec => 'AAC',
                      :aac_settings => {
                        :audio_description_broadcaster_mix => 'NORMAL',
                        :bitrate => 96_000,
                        :rate_control_mode => 'CBR',
                        :codec_profile => 'LC',
                        :coding_mode => 'CODING_MODE_2_0',
                        :raw_format => 'NONE',
                        :sample_rate => 48_000,
                        :specification => 'MPEG4'
                      }
                    },
                    :language_code_control => 'FOLLOW_INPUT'
                  }
                ],
                :output_settings => {
                  :hls_settings => {
                    :audio_group_id => 'program_audio',
                    :audio_only_container => 'AUTOMATIC',
                    :i_frame_only_manifest => 'EXCLUDE'
                  }
                },
                :name_modifier => '_converted'
              }
            ],
            :output_group_settings => {
              :type => 'HLS_GROUP_SETTINGS',
              :hls_group_settings => {
                :manifest_duration_format => 'INTEGER',
                :segment_length => 10,
                :timed_metadata_id_3_period => 10,
                :caption_language_setting => 'OMIT',
                :destination => destination_S3,
                :timed_metadata_id_3_frame => 'PRIV',
                :codec_specification => 'RFC_4281',
                :output_selection => 'MANIFESTS_AND_SEGMENTS',
                :program_date_time_period => 600,
                :min_segment_length => 0,
                :min_final_segment_length => 0,
                :directory_structure => 'SINGLE_DIRECTORY',
                :program_date_time => 'EXCLUDE',
                :segment_control => 'SEGMENTED_FILES',
                :manifest_compression => 'NONE',
                :client_cache => 'ENABLED',
                :audio_only_header => 'INCLUDE',
                :stream_inf_resolution => 'INCLUDE'
              }
            }
          }
        ],
        :ad_avail_offset => 0,
        :inputs => [
          {
            :audio_selectors => {
              'Audio Selector 1' => {
                :offset => 0,
                :default_selection => 'DEFAULT',
                :program_selection => 1
              }
            },
            :filter_enable => 'AUTO',
            :psi_control => 'USE_PSI',
            :filter_strength => 0,
            :deblock_filter => 'DISABLED',
            :denoise_filter => 'DISABLED',
            :input_scan_type => 'AUTO',
            :timecode_source => 'ZEROBASED',
            :file_input => source_S3
          }
        ]
      },
      :acceleration_settings => { :mode => 'DISABLED' },
      :status_update_interval => 'SECONDS_60',
      :priority => 0
    }
  end
end

Take note of several options for this advanced configuration:

• queue passing this should be optional as there is such a thing as a "default queue"
• role identifier of AWS IAM role with permissions to access both: source and destination, S3 buckets
• bitrate specifies output .aac files bitrate. You can specify multiple AudioDescriptions with different bitrates to have an adaptive stream
• segment_length duration in seconds of .aac segment files
• destination identifier of S3 bucket for storing converted files
• name_modifier specifies output file name addon
• file_input S3 identifier of source file

What's next?

Remember to save obtained job_id, to be able to check the status of initialized convert job later. Of course, I also have a service class for this purpose.

class Converting::MediaConverterJobInspector < Converting::MediaConverterWrapper
  def initialize media_convert_job_id
    @media_convert_job_id = media_convert_job_id
  end

  def call
    @response = client.get_job({ id: @media_convert_job_id })
    nil
  end

  # returns job status
  def status
    @response[:job][:status]
  end
  # ...
end

1. File format

Real streaming requires file conversion. After conversion, which will be a topic of another blog post, there is no longer one mp3 file. The conversion generates .m3u8 playlist file which the player requests once at the start of the streaming session and a bunch of .aac files that are short segments of the audio track.

2. Bandwidth usage

The segments of converted audio track are being fetched one by one and when the user clicks pause on the video player, then the segments stop being downloaded. What is more, the user can start playback from any point. How crucial it is if we are talking about audiobook chapters that can last tens of minutes or even hours! The standard progressive download doesn't have such features, so streaming is the only economically viable option if you expect heavy traffic. Services like AWS Cloudfront charge you for the data transfer.

3. Security

Standard mp3 files can be easily downloaded using third-party browser plugins like Video Downloader. It is not so trivial with the streams. Again, this is very important when it comes to audiobooks, the intellectual property that is highly vulnerable to piracy. Furthermore, as the stream is downloading files incrementally you can prevent access to further listening if, for example, someone else starts using the same account.

Granting access to a stream with a signed cookie with AWS Cloudfront is a topic of another blog post in this series.

4. Adaptivity

You can convert your input file to many bitrates. All this data is stored in the mentioned .m3u8 playlist file. Depending on the available bandwidth the player will automatically choose a segment from an appropriate bitrate. If the user enters the area of a poor Internet connection he can still listen to his audiobook even if the audio quality is a little bit worse. Transitioning between bitrates is seamless.

In this game, the players take turns saying numbers. They begin by taking turns reading from a list of starting numbers (the puzzle input). Then, each turn consists of considering the most recently spoken number:

• If that was the first time the number has been spoken, the current player says 0.
• Otherwise, the number had been spoken before; the current player announces how many turns apart the number is from when it was previously spoken.

In the first task, you are asked what would be the 2020th number spoken. Later, you are supposed to check the 30000000th one. If you choose an effective method using an associative array, you can solve both tasks with one function.

My Ruby solution:

def determine_number starting_numbers, nth
  i = starting_numbers.size - 1
  last = starting_numbers.last
  last_spoken = starting_numbers[0..-2].map.with_index { |v, index| {v => index} }.reduce(:merge)
  while i < nth - 1
    prev_last = last
    last = last_spoken.has_key?(prev_last) ? i - last_spoken[prev_last] : 0
    last_spoken[prev_last] = i
    i += 1
  end
  last
end

INPUT = [7, 12, 1, 0, 16, 2].freeze
puts "First task answer: #{determine_number INPUT, 2020}"
puts "Second task answer: #{determine_number INPUT, 30000000}"

In the first task, a bitmask is used to transform a value before writing it. A 0 or 1 overwrites the corresponding bit in the value, while an X leaves the bit in the value unchanged.

In another task, a bitmask is used to transform an address. Immediately before a value is written to memory, each bit in the bitmask modifies the corresponding bit of the destination memory address in the following way:

• If the bitmask bit is 0, the corresponding memory address bit is unchanged.
• If the bitmask bit is 1, the corresponding memory address bit is overwritten with 1.
• If the bitmask bit is X, the corresponding memory address bit is floating. A floating bit is not connected to anything and instead fluctuates unpredictably. In practice, this means the floating bits will take on all possible values, potentially causing many memory addresses to be written all at once.

This is my Ruby solution:

def int_to_bin value
  value.to_i.to_s(2).rjust(36, "0")
end

def sum_mem_values file, decode_address = false
  mem = {}
  mask = 'X' * 36
  file.each_line do |line|
    command = line.split " = "
    variable = command.first
    address = variable.scan(/\d+/).first.to_i
    value = command.last.strip

    if variable == 'mask'
      mask = value
    elsif decode_address
      address_bin = int_to_bin(address)
      ['0', '1'].repeated_permutation(mask.count('X')) do |x_values|
        address_bin_copy = address_bin
        mask.each_char.with_index do |char, index|
          address_bin_copy[index] = '1' if char == '1'
          address_bin_copy[index] = x_values[mask[0...index].count('X')] if char == 'X'
        end
        mem[address_bin_copy.to_i(2)] = value.to_i
      end
    else # decode value
      value_bin = int_to_bin(value)
      mask.each_char.with_index do |char, index|
        value_bin[index] = '1' if char == '1'
        value_bin[index] = '0' if char == '0'
      end
      mem[address] = value_bin.to_i(2)
    end
  end
  mem.values.sum
end

file = File.read('inputs/day14.txt')
puts "First task answer: #{sum_mem_values(file)}"
puts "Second task answer: #{sum_mem_values(file, true)}"

The first task is about finding the closest arrival timestamp knowing how often each bus courses. This part is trivial:

file = File.read('inputs/day13.txt')
timestamp = file.lines.first.to_i
bus_lines = file.lines.last.split(',').map{|n| n.to_i if n.match(/\d+/)}
arrivals = bus_lines.compact.map do |line|
  {line => (timestamp.to_f / line).ceil * line}
end.inject(:merge)

first_arrival = arrivals.min_by { |k, v| v }
puts "First task answer: #{(first_arrival.last - timestamp) * first_arrival.first}"

But the second one requires some non-elemental mathematical knowledge. Specifically, you should be aware about Chinese Remainder Theorem. I used this implementation. Here is the entire solution:

def extended_gcd(a, b)
  last_remainder, remainder = a.abs, b.abs
  x, last_x, y, last_y = 0, 1, 1, 0
  while remainder != 0
    last_remainder, (quotient, remainder) = remainder, last_remainder.divmod(remainder)
    x, last_x = last_x - quotient * x, x
    y, last_y = last_y - quotient * y, y
  end
  return last_remainder, last_x * (a < 0 ? -1 : 1)
end

def invmod(e, et)
  g, x = extended_gcd(e, et)
  if g != 1
    raise 'Multiplicative inverse modulo does not exist!'
  end
  x % et
end

def chinese_remainder(mods, remainders)
  max = mods.inject(:*) # product of all moduli
  series = remainders.zip(mods).map { |r, m| (r * max * invmod(max / m, m) / m) }
  series.inject(:+) % max
end

remainders_hash = bus_lines.each_with_index.map do |value, index|
  {value.to_i => value.to_i - index} if value
end.compact.inject(:merge)

puts "Second task answer: #{chinese_remainder(remainders_hash.keys, remainders_h

• Action N means to move north by the given value.
• Action S means to move south by the given value.
• Action E means to move east by the given value.
• Action W means to move west by the given value.
• Action L means to turn left the given number of degrees.
• Action R means to turn right the given number of degrees.
• Action F means to move forward by the given value in the direction the ship is currently facing.

Here is my ship implementation form the first task.

require 'matrix'

WORLD_DIRECTIONS = {
    'N' => Vector[0, 1],
    'E' => Vector[1, 0],
    'S' => Vector[0, -1],
    'W' => Vector[-1, 0]
}.freeze

def number_of_crosses action, angle
  ((action == 'L' ? 1 : -1) * angle / 90) % 4
end

class Ship
  attr_reader :position

  def initialize
    @position = Vector[0, 0]
    @rotation = Vector[1, 0]
  end

  def navigate instructions
    instructions.each do |instruction|
      action = instruction[0]
      value = instruction.scan(/\d+/).first.to_i
      process_instruction action, value
    end
  end

  protected

  def process_instruction action, value
    if action.start_with? 'L', 'R'
      rotate action, value
    else
      move action, value
    end
  end

  def rotate action, angle
    number_of_crosses(action, angle).times { @rotation = @rotation.cross }
  end

  def move action, distance
    vector = WORLD_DIRECTIONS.merge('F' => @rotation)[action]
    @position += distance * vector
  end
end

In the second task, instruction are different:

• Action N means to move the waypoint north by the given value.
• Action S means to move the waypoint south by the given value.
• Action E means to move the waypoint east by the given value.
• Action W means to move the waypoint west by the given value.
• Action L means to rotate the waypoint around the ship left (counter-clockwise) the given number of degrees.
• Action R means to rotate the waypoint around the ship right (clockwise) the given number of degrees.
• Action F means to move forward to the waypoint a number of times equal to the given value.

I provided a second ship implementation extending the previous one. Here is the rest of the code:

class ShipWithWaypoints < Ship
  def initialize
    @waypoint_position = Vector[10, 1]
    super
  end

  protected

  def process_instruction action, value
    if action.start_with? 'L', 'R'
      rotate_waypoint action, value
    elsif action.start_with? 'F'
      move value
    else
      move_waypoint action, value
    end
  end

  def rotate_waypoint action, angle
    number_of_crosses(action, angle).times { @waypoint_position = @waypoint_position.cross }
  end

  def move_waypoint action, distance
    vector = WORLD_DIRECTIONS[action]
    @waypoint_position += distance * vector
  end

  def move value
    @position += @waypoint_position * value
  end
end

file = File.read('inputs/day12.txt')
instructions = file.lines
[Ship, ShipWithWaypoints].each do |ship_type|
  ship = ship_type.new
  ship.navigate(instructions)
  puts(ship.position.sum { |v| v.abs })
end

The process of taking seats is iterative. Rules which are applied to every seat simultaneously differ for the first and second tasks.

In the first puzzle:

• If a seat is empty (L) and there are no occupied seats adjacent to it, the seat becomes occupied.
• If a seat is occupied (#) and four or more seats adjacent to it are also occupied, the seat becomes empty.
• Otherwise, the seat's state does not change.
• Floor (.) never changes; seats don't move, and nobody sits on the floor.

In the second one, instead of considering just the eight immediately adjacent seats, consider the first seat in each of the eight directions. It now takes five or more visible occupied seats for an occupied seat to become empty. The rest of the rules stay unchanged.

To deal with those tasks, I implemented WaitingArea class and two different taking seat policies.

require 'matrix'

class WaitingArea
  def initialize file
    @seats = Matrix.rows file.lines.map { |line| line.strip.chars }
  end

  def take_seats policy_class
    policy = policy_class.new(@seats)
    new_seats = @seats.dup
    @seats.each_with_index do |e, row, col|
      next if e == '.'
      new_seats[row, col] = policy.take_seat?(row, col) ? '#' : 'L'
    end
    @seats = new_seats
  end

  def occupied_seats
    @seats.select { |adjacent_seat| adjacent_seat == '#' }.size
  end
end

class SimpleTakingSeatPolicy
  def initialize seats
    @seats = seats
  end

  def take_seat? row, col
    seat = @seats[row, col]
    adjacent_seats = @seats.minor(
        [row - 1, 0].max..[row + 1, @seats.row_count - 1].min,
        [col - 1, 0].max..[col + 1, @seats.column_count - 1].min
    )
    occupied_adjacent_seats = adjacent_seats.select { |adjacent_seat| adjacent_seat == '#' }.size
    return occupied_adjacent_seats <= 4 if seat == '#'
    occupied_adjacent_seats.zero?
  end
end

class AlternativeTakingSeatPolicy
  def initialize seats
    @seats = seats
  end

  def take_seat? row, col
    seat = @seats[row, col]
    occupied_visible_seats = 0
    ([-1, 0, +1].repeated_permutation(2).to_a - [[0, 0]]).each do |row_mod, col_mod|
      i = 0
      while i += 1
        x = row + (row_mod * i)
        y = col + (col_mod * i)
        break if x < 0 || x >= @seats.row_count
        break if y < 0 || y >= @seats.column_count
        tmp_seat = @seats[x, y]
        next if tmp_seat == '.'
        occupied_visible_seats += 1 if tmp_seat == '#'
        break
      end
    end
    return occupied_visible_seats < 5 if seat == '#'
    occupied_visible_seats.zero?
  end
end

file = File.read('inputs/day11.txt')
[SimpleTakingSeatPolicy, AlternativeTakingSeatPolicy].each_with_index do |policy, index|
  craft = WaitingArea.new(file)
  occupied_seats = nil
  while occupied_seats != occupied_seats = craft.occupied_seats
    craft.take_seats(policy)
  end
  puts craft.occupied_seats
end

The input file contains above hundred of integers. The order is random and there is no continuity between them. The difference between the two following numbers can be 1, 2, or 3.

The first task is about counting how many differences are 1 and 3. You are asked for product of their numbers. This part is easy:

file = File.read('inputs/day10.txt')
numbers = [0]
numbers += file.lines.map(&:to_i)
numbers.sort!
numbers << numbers.last + 3
gaps = {1 => 0, 2 => 0, 3 => 0}

numbers.drop(1).each_with_index do |number, index|
  gaps[number - numbers[index]] += 1
end

puts "First task answer: #{gaps[1] * gaps[3]}"

The second puzzle is problematic. You have to find total number of distinct subsets such that the difference between two following numbers still does not exceed 3. I wrote following recuresive algorithm:

def count_arrangements numbers, start_index
  arrangements = 1
  numbers.each_with_index do |number, index|
    if index > start_index && index < numbers.size - 1
      arrangements += count_arrangements(numbers - [number], index-1) if numbers[index + 1] - numbers[index - 1] <= 3
    end
  end
  arrangements
end

It was good with sample inputs but when it came to my file it took ages! Then I remembered the principle of divide and conquer. I split my input where the difference was 3. I used my recursive algorithm on each part of them and multiplied the obtained results. It succeeded!

def split numbers
  splitted = []
  tmp = []
  numbers.each_with_index do |number, index|
    tmp << number
    if index == numbers.size - 1 || numbers[index+1] - number == 3
      splitted << tmp
      tmp = []
    end
  end
  splitted
end

puts "Second task answer: #{split(numbers).map { |ns| count_arrangements(ns, 0) }.reduce(:*)}"

The first task is to find the first value that violates protocol rules. It means finding the first number in the list (after the preamble) which is not the sum of two of the 25 numbers before it.

Having this value found, you have to find a contiguous set of at least two numbers in the stream which sum to this value.

Here is my Ruby code:

def find_invalid_number numbers, preamble
  numbers.drop(preamble).each_with_index do |number, index|
    valid = numbers[index...index + preamble].combination(2).any? do |combination|
      combination.sum == number
    end
    return number unless valid
  end
end

def find_contiguous_range_of_sum numbers, value
  numbers.each_with_index do |number, index|
    sum = number
    i = 0
    while sum < value
      sum += numbers[index + (i += 1)]
    end
    return numbers[index...index + i] if sum == value
  end
end

file = File.read('inputs/day9.txt')
numbers = file.lines.map(&:to_i)
puts "First task answer: #{invalid_value = find_invalid_number(numbers, 25)}"
range = find_contiguous_range_of_sum(numbers, invalid_value)
puts "Second task answer: #{range.first + range.last}"

I chose an objective approach and implemented InstructionProcessor and ProcessInstruction classes.

class InstructionProcessor
  class InfinityLoop < StandardError
    attr_reader :acc, :steps_sequence

    def initialize acc, steps_sequence
      @acc = acc
      @steps_sequence = steps_sequence
    end
  end

  def initialize
    @acc = 0
    @index = 0
  end

  def process_instructions instruction
    steps_sequence = []
    while @index < instruction.size
      raise InfinityLoop.new(@acc, steps_sequence) if steps_sequence.include? @index
      steps_sequence << @index
      step = instruction.get_step @index
      send step[:command], step[:value] if step
    end
    @acc
  end

  private

  def acc value
    @acc += value
    @index += 1
  end

  def jmp value
    @index += value
  end

  def nop value
    @index += 1
  end
end

class ProcessInstruction
  def initialize path
    @file = File.read('inputs/day8.txt')
    reload
  end

  def reload
    @steps = @file.lines.map do |line|
      args = line.split
      {command: args.first, value: args.last.to_i}
    end
  end

  def get_step index
    @steps[index]
  end

  def size
    @steps.size
  end

  def swap_command index
    step = @steps[index]
    if step[:command] == 'jmp'
      @steps[index][:command] = 'nop'
    elsif step[:command] == 'nop'
      @steps[index][:command] = 'jmp'
    end
  end
end

Having those classes implemented it is easy to solve both tasks:

instructions = ProcessInstruction.new('inputs/day8.txt')
retry_count = 0
begin
  res = InstructionProcessor.new.process_instructions(instructions)
  puts "Second task answer: #{res}"
rescue InstructionProcessor::InfinityLoop => e
  if retry_count == 0
    puts "First task answer: #{e.acc}"
    original_step_sequence = e.steps_sequence
  end
  instructions.reload
  retry_count += 1
  instructions.swap_command(original_step_sequence[original_step_sequence.size - retry_count])
  retry
end

You get text instructions in not-trivial to parse form, like:

• striped white bags contain 4 drab silver bags.
• drab silver bags contain no other bags.
• pale plum bags contain 1 dark black bag.
• muted gold bags contain 1 wavy red bag, 3 mirrored violet bags, 5 bright gold bags, 5 plaid white bags.

Obviously, the file is much longer.

So the first intuitive step is to parse them to ruby structure like Hash:

file = File.read('inputs/day7.txt')

@bags_hash = {}
file.each_line do |line|
  bags_params = line.scan(/(?:\d+ )?[[:alpha:]]+ [[:alpha:]]+(?= bags?)/)
  @bags_hash[bags_params[0]] = {}
  bags_params[1..].each do |bag|
    next if bag == 'no other'
    expression_params = bag.split(/(?<=\d) /)
    quantity = expression_params.size == 1 ? 1 : expression_params.first.to_i
    color_name = expression_params.last
    @bags_hash[bags_params[0]][color_name] = quantity
  end
end

The first task is to count how many bag colors can eventually contain at least one "shiny gold bag". I do it this way:

def bag_include_requested_color_bag? color_bag, requested_color_bag
  return true if @bags_hash[color_bag].keys.include? requested_color_bag
  return @bags_hash[color_bag].any? do |key, value|
    bag_include_requested_color_bag?(key, requested_color_bag)
  end
end

res = @bags_hash.keys.sum do |color|
  bag_include_requested_color_bag?(color, 'shiny gold') ? 1 : 0
end

puts "First task answer: #{res}"

Another task is to find how many individual bags are required inside a single "shiny gold bag". Here is my code:

def bags_count color_bag, quantity
  quantity + @bags_hash[color_bag].sum do |key, value|
    quantity * bags_count(key, value)
  end
end

res = @bags_hash['shiny gold'].sum do |key, value|
  value * bags_count(key, 1)
end

puts "Second task answer: #{res}"

Your job in the first puzzle is to find how many unique letters occur in each group and count them together.

In the second task, you are supposed to check how many unique letters occur across all entries of each group and to count them together.

So basically, solutions of those 2 tasks differ in one operator. In the first task, it is a union (| operator) and in the second one, it is an intersection (& operator).

def count_letters file, operator
  letters_count = 0
  file.each_line("\n\n") do |group|
    letters_count += group.strip.lines.map { |line| line.strip.chars }.inject(operator).size
  end
  letters_count
end

file = File.read('inputs/day6.txt')
puts "First task answer: #{count_letters(file, :|)}"
puts "Second task answer: #{count_letters(file, :&)}"

After converting them to decimal numbers it is trivial to pick the maximum value. The first task is completed.

In the second puzzle, you are asked to find a missing entry among the file. There are few ways of doing that. I managed to find it by comparing following values with the loop index.

file = File.read('inputs/day5.txt')
entries = file.lines.map do |line|
  line.gsub(/[FBLR]/, 'F' => 0, 'B' => 1, 'L' => 0, 'R' => 1).to_i(2)
end
entries.sort!
puts "First task answer: #{entries.last}"

entries.each_with_index do |entry, index|
  if index + entries.first != entry
    puts "Second task answer: #{index + entries.first}"
    return
  end
end

In the first task, only validating the presence of some keys is required. In the second one, you have to check if values meet certain specific constraints:

• byr (Birth Year) - four digits; at least 1920 and at most 2002.
• iyr (Issue Year) - four digits; at least 2010 and at most 2020.
• eyr (Expiration Year) - four digits; at least 2020 and at most 2030.
• hgt (Height) - a number followed by either cm or in: If cm, the number must be at least 150 and at most 193. If in, the number must be at least 59 and at most 76.
• hcl (Hair Color) - a # followed by exactly six characters 0-9 or a-f.
• ecl (Eye Color) - exactly one of: amb blu brn gry grn hzl oth.
• pid (Passport ID) - a nine-digit number, including leading zeroes.
• cid (Country ID) - ignored, missing or not.

REQUIRED_FIELDS = %w(byr iyr eyr hgt hcl ecl pid)
EYE_COLORS = %w(amb blu brn gry grn hzl oth)

def count_valid_entries file, strong_validation = false
  valid = 0
  file.each_line("\n\n") do |entry|
    attrs = Hash[entry.split.map { |key_and_val| key_and_val.split(':') }]
    next unless (REQUIRED_FIELDS - attrs.keys).empty?
    if strong_validation
      next unless attrs['byr'].to_i.between?(1920, 2002)
      next unless attrs['iyr'].to_i.between?(2010, 2020)
      next unless attrs['eyr'].to_i.between?(2020, 2030)
      hgt = attrs['hgt'].scan(/\d+/).first.to_i
      if attrs['hgt'].end_with?('cm')
        next unless hgt.between?(150, 193)
      elsif attrs['hgt'].end_with?('in')
        next unless hgt.between?(59, 76)
      else next
      end
      next unless attrs['hcl'].match? /\A#[0-9a-fA-F]{6}\z/
      next unless EYE_COLORS.include? attrs['ecl']
      next unless attrs['pid'].match? /\A\d{9}\z/
    end
    valid += 1
  end
  valid
end

file = File.read('inputs/day4.txt')
puts count_valid_entries(file)
puts count_valid_entries(file, true)