trackler 2.0.0.1 → 2.0.0.2

data/tracks/ruby/exercises/transpose/transpose_test.rb

@@ -0,0 +1,303 @@
+#!/usr/bin/env ruby
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'transpose'
+
+# Test data version:
+# 0a51cfc
+class TransposeTest < Minitest::Test
+  def test_empty_string
+    # skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_two_characters_in_a_row
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      A1
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      A
+      1
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_two_characters_in_a_column
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      A
+      1
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      A1
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_simple
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      ABC
+      123
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      A1
+      B2
+      C3
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_single_line
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      Single line.
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      S
+      i
+      n
+      g
+      l
+      e
+       
+      l
+      i
+      n
+      e
+      .
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_first_line_longer_than_second_line
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      The fourth line.
+      The fifth line.
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      TT
+      hh
+      ee
+        
+      ff
+      oi
+      uf
+      rt
+      th
+      h 
+       l
+      li
+      in
+      ne
+      e.
+      .
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_second_line_longer_than_first_line
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      The first line.
+      The second line.
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      TT
+      hh
+      ee
+        
+      fs
+      ie
+      rc
+      so
+      tn
+       d
+      l 
+      il
+      ni
+      en
+      .e
+       .
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_square
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      HEART
+      EMBER
+      ABUSE
+      RESIN
+      TREND
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      HEART
+      EMBER
+      ABUSE
+      RESIN
+      TREND
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_rectangle
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      FRACTURE
+      OUTLINED
+      BLOOMING
+      SEPTETTE
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      FOBS
+      RULE
+      ATOP
+      CLOT
+      TIME
+      UNIT
+      RENT
+      EDGE
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_triangle
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      T
+      EE
+      AAA
+      SSSS
+      EEEEE
+      RRRRRR
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      TEASER
+       EASER
+        ASER
+         SER
+          ER
+           R
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  def test_many_lines
+    skip
+    input = <<-INPUT.gsub(/^ {6}/, '')
+      Chor. Two households, both alike in dignity,
+      In fair Verona, where we lay our scene,
+      From ancient grudge break to new mutiny,
+      Where civil blood makes civil hands unclean.
+      From forth the fatal loins of these two foes
+      A pair of star-cross'd lovers take their life;
+      Whose misadventur'd piteous overthrows
+      Doth with their death bury their parents' strife.
+      The fearful passage of their death-mark'd love,
+      And the continuance of their parents' rage,
+      Which, but their children's end, naught could remove,
+      Is now the two hours' traffic of our stage;
+      The which if you with patient ears attend,
+      What here shall miss, our toil shall strive to mend.
+    INPUT
+    actual = Transpose.transpose(input)
+    expected = <<-EXPECTED.gsub(/^ {6}/, '')
+      CIFWFAWDTAWITW
+      hnrhr hohnhshh
+      o oeopotedi ea
+      rfmrmash  cn t
+      .a e ie fthow 
+       ia fr weh,whh
+      Trnco miae  ie
+      w ciroitr btcr
+      oVivtfshfcuhhe
+       eeih a uote  
+      hrnl sdtln  is
+      oot ttvh tttfh
+      un bhaeepihw a
+      saglernianeoyl
+      e,ro -trsui ol
+      h uofcu sarhu 
+      owddarrdan o m
+      lhg to'egccuwi
+      deemasdaeehris
+      sr als t  ists
+      ,ebk 'phool'h,
+        reldi ffd   
+      bweso tb  rtpo
+      oea ileutterau
+      t kcnoorhhnatr
+      hl isvuyee'fi 
+       atv es iisfet
+      ayoior trr ino
+      l  lfsoh  ecti
+      ion   vedpn  l
+      kuehtteieadoe 
+      erwaharrar,fas
+         nekt te  rh
+      ismdsehphnnosa
+      ncuse ra-tau l
+       et  tormsural
+      dniuthwea'g t 
+      iennwesnr hsts
+      g,ycoi tkrttet
+      n ,l r s'a anr
+      i  ef  'dgcgdi
+      t  aol   eoe,v
+      y  nei sl,u; e
+      ,  .sf to l   
+           e rv d  t
+           ; ie    o
+             f, r   
+             e  e  m
+             .  m  e
+                o  n
+                v  d
+                e  .
+                ,
+    EXPECTED
+    assert_equal expected.strip, actual
+  end
+
+  # Problems in exercism evolve over time, as we find better ways to ask
+  # questions.
+  # The version number refers to the version of the problem you solved,
+  # not your solution.
+  #
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module, which may be placed near the end of your file.
+  #
+  # In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
+  # If you are curious, read more about constants on RubyDoc:
+  # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+
+  def test_bookkeeping
+    skip
+    assert_equal 1, BookKeeping::VERSION
+  end
+end

data/tracks/ruby/lib/bowling_cases.rb

@@ -0,0 +1,46 @@
+class BowlingCase < OpenStruct
+  def test_name
+    "test_#{description.downcase.tr(' ', '_')}"
+  end
+
+  def skipped
+    index.zero? ? '# skip' : 'skip'
+  end
+
+  def work_load
+    indent_lines(assert)
+  end
+
+  private
+
+  def roll
+    "roll(#{rolls})"
+  end
+
+  def assert
+    if assert_error?
+      [
+        'assert_raises StandardError do',
+        "  #{roll}",
+        '  @game.score',
+        'end'
+      ]
+    else
+      [roll, "assert_equal #{expected}, @game.score"]
+    end
+  end
+
+  def assert_error?
+    expected == -1
+  end
+
+  def indent_lines(code)
+    code.join("\n" + ' ' * 4)
+  end
+end
+
+BowlingCases = proc do |data|
+  JSON.parse(data)['score']['cases'].map.with_index do |row, i|
+    BowlingCase.new(row.merge('index' => i))
+  end
+end

data/tracks/ruby/lib/isogram_cases.rb

@@ -13,7 +13,7 @@ class IsogramCase < OpenStruct
   end
 
   def skip
-    'skip' unless index.zero?
+    index.zero? ? '# skip' : 'skip'
   end
 end
 

data/tracks/ruby/lib/tournament_cases.rb

@@ -0,0 +1,45 @@
+class TournamentCase < OpenStruct
+  def test_name
+    "test_#{description.tr(' ', '_').tr('()', '')}"
+  end
+
+  def skipped
+    index.zero? ? '# skip' : 'skip'
+  end
+
+  def workload
+    'Tournament.tally(input)'
+  end
+
+  def expect
+    indented_heredoc(expected, 'TALLY')
+  end
+
+  def input_text
+    indented_heredoc(input, 'INPUT')
+  end
+
+  private
+
+  def indented_heredoc(string, delimiter)
+    [
+      "<<-#{delimiter}.gsub(/^ */, '')",
+      indent_lines(string),
+      indent_line(delimiter)
+    ].join("\n")
+  end
+
+  def indent_lines(lines, indent = 3)
+    lines.map { |line| indent_line(line, indent) }.join("\n")
+  end
+
+  def indent_line(line, indent = 2)
+    ' ' * indent * 2 + line
+  end
+end
+
+TournamentCases = proc do |data|
+  JSON.parse(data)['valid_inputs']['cases'].map.with_index do |row, i|
+    TournamentCase.new(row.merge('index' => i))
+  end
+end

data/tracks/ruby/lib/transpose_cases.rb

@@ -0,0 +1,45 @@
+class TransposeCase < OpenStruct
+  def test_name
+    "test_#{description.tr(' ', '_')}"
+  end
+
+  def skipped
+    index.zero? ? '# skip' : 'skip'
+  end
+
+  def workload
+    'Transpose.transpose(input)'
+  end
+
+  def expect
+    indented_heredoc(expected, 'EXPECTED')
+  end
+
+  def input_text
+    indented_heredoc(input, 'INPUT')
+  end
+
+  private
+
+  def indented_heredoc(string, delimiter)
+    [
+      "<<-#{delimiter}.gsub(/^ {6}/, '')",
+      indent_lines(string),
+      indent_line(delimiter)
+    ].join("\n")
+  end
+
+  def indent_lines(lines, indent = 3)
+    lines.map { |line| indent_line(line, indent) }.join("\n")
+  end
+
+  def indent_line(line, indent = 2)
+    ' ' * indent * 2 + line
+  end
+end
+
+TransposeCases = proc do |data|
+  JSON.parse(data)['cases'].map.with_index do |row, i|
+    TransposeCase.new(row.merge('index' => i))
+  end
+end

data/tracks/rust/config.json

@@ -11,6 +11,7 @@
     "bob",
     "beer-song",
     "difference-of-squares",
+    "grains",
     "hamming",
     "pascals-triangle",
     "scrabble-score",
@@ -29,6 +30,7 @@
     "robot-simulator",
     "bracket-push",
     "queen-attack",
+    "bowling",
     "sublist",
     "space-age",
     "allergies",

data/tracks/rust/exercises/bowling/.gitignore

@@ -0,0 +1,7 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

data/tracks/rust/exercises/bowling/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "bowling"
+version = "0.0.0"

data/tracks/rust/exercises/bowling/example.rs

@@ -0,0 +1,134 @@
+
+pub struct BowlingGame {
+    frames: Vec<Frame>,
+}
+
+struct Frame {
+    rolls: Vec<u16>,
+    bonus: Vec<u16>,
+}
+
+impl Frame {
+    fn score(&self) -> u16 {
+        self.roll_score() + self.bonus_score()
+    }
+
+    fn roll_score(&self) -> u16 {
+        self.rolls.iter().sum()
+    }
+
+    fn bonus_score(&self) -> u16 {
+        self.bonus.iter().sum()
+    }
+
+    fn is_valid(&self) -> bool {
+        self.rolls_valid() && self.bonus_valid()
+    }
+
+    fn rolls_valid(&self) -> bool {
+        self.roll_score() <= 10
+    }
+
+    fn bonus_valid(&self) -> bool {
+        if self.is_open() || !self.bonus_done() {
+            return true;
+        }
+
+        if self.is_spare() {
+            return self.bonus_score() <= 10;
+        }
+
+        if let Some(first) = self.bonus.iter().next() {
+            if *first == 10 {
+                self.bonus_score() <= 20
+            } else {
+                self.bonus_score() <= 10
+            }
+        } else {
+            unreachable!();
+        }
+    }
+
+    fn is_complete(&self) -> bool {
+        self.is_open() || self.bonus_done()
+    }
+
+    fn rolls_done(&self) -> bool {
+        self.rolls.len() == 2 || self.is_strike()
+    }
+
+    fn bonus_done(&self) -> bool {
+        (self.is_spare() && self.bonus.len() == 1) || (self.is_strike() && self.bonus.len() == 2)
+    }
+
+    fn is_open(&self) -> bool {
+        self.rolls.len() == 2 && self.roll_score() < 10
+    }
+
+    fn is_spare(&self) -> bool {
+        self.rolls.len() == 2 && self.roll_score() == 10
+    }
+
+    fn is_strike(&self) -> bool {
+        self.rolls.len() == 1 && self.roll_score() == 10
+    }
+
+    fn add_roll(&mut self, roll: u16) {
+        if !self.is_complete() {
+            if self.is_spare() || self.is_strike() {
+                self.bonus.push(roll)
+            } else {
+                self.rolls.push(roll)
+            }
+        }
+    }
+
+    fn new() -> Self {
+        Frame {
+            rolls: vec![],
+            bonus: vec![],
+        }
+    }
+}
+
+impl BowlingGame {
+    pub fn new() -> Self {
+        BowlingGame { frames: vec![Frame::new()] }
+    }
+
+    pub fn roll(&mut self, pins: u16) -> Result<(), &'static str> {
+        if pins > 10 {
+            Err("Greater than 10 pins")
+        } else {
+            if self.score().is_ok() {
+                return Err("Game Finished. No more rolls.");
+            }
+
+            for mut frame in self.frames.iter_mut() {
+                frame.add_roll(pins)
+            }
+
+            if self.frames.iter().any(|f| !f.is_valid()) {
+                return Err("Invalid Roll");
+            }
+
+            if self.frames.iter().last().unwrap().rolls_done() && self.frames.len() < 10 {
+                self.frames.push(Frame::new());
+            }
+
+            Ok(())
+        }
+    }
+
+    pub fn score(&self) -> Result<u16, &'static str> {
+        if !self.is_done() {
+            Err("Game Incomplete")
+        } else {
+            Ok(self.frames.iter().fold(0, |acc, r| acc + r.score()))
+        }
+    }
+
+    fn is_done(&self) -> bool {
+        self.frames.len() == 10 && self.frames.iter().all(|f| f.is_complete())
+    }
+}