trackler 1.0.4.0 → 1.0.4.1

data/tracks/ruby/exercises/gigasecond/gigasecond_test.rb

@@ -1,7 +1,7 @@
 require 'minitest/autorun'
 require_relative 'gigasecond'
 
-# Test data version: 9d027ad
+# Test data version: 9049dc7
 
 class GigasecondTest < Minitest::Test
   def test_2011_04_25
@@ -56,6 +56,6 @@ class GigasecondTest < Minitest::Test
   # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
 
   def test_bookkeeping
-    assert_equal 4, BookKeeping::VERSION
+    assert_equal 5, BookKeeping::VERSION
   end
 end

data/tracks/ruby/exercises/isogram/.version

@@ -0,0 +1 @@
+1

data/tracks/ruby/exercises/isogram/example.rb

@@ -0,0 +1,10 @@
+module BookKeeping
+  VERSION = 1
+end
+
+class Isogram
+  def self.is_isogram?(str)
+    letters = str.downcase.gsub(/[[:punct:]]| /, '').chars
+    letters == letters.uniq
+  end
+end

data/tracks/ruby/exercises/isogram/example.tt

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'isogram'
+
+# Common test data version: <%= sha1 %>
+class IsogramTest < Minitest::Test<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
+    <%= test_case.skip %>
+    string = '<%= test_case.input %>'
+    <%= test_case.assertion %> Isogram.is_isogram?(string)
+  end
+<% end %>
+<%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+  def test_bookkeeping
+    skip
+    assert_equal <%= version.next %>, BookKeeping::VERSION
+  end
+end

data/tracks/ruby/exercises/isogram/isogram_test.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+gem 'minitest', '>= 5.0.0'
+require 'minitest/autorun'
+require_relative 'isogram'
+
+# Common test data version: 3dfde31
+class IsogramTest < Minitest::Test
+  def test_duplicates
+    
+    string = 'duplicates'
+    assert Isogram.is_isogram?(string)
+  end
+
+  def test_eleven
+    skip
+    string = 'eleven'
+    refute Isogram.is_isogram?(string)
+  end
+
+  def test_subdermatoglyphic
+    skip
+    string = 'subdermatoglyphic'
+    assert Isogram.is_isogram?(string)
+  end
+
+  def test_alphabet
+    skip
+    string = 'Alphabet'
+    refute Isogram.is_isogram?(string)
+  end
+
+  def test_thumbscrew_japingly
+    skip
+    string = 'thumbscrew-japingly'
+    assert Isogram.is_isogram?(string)
+  end
+
+  def test_hjelmqvist_gryb_zock_pfund_wax
+    skip
+    string = 'Hjelmqvist-Gryb-Zock-Pfund-Wax'
+    assert Isogram.is_isogram?(string)
+  end
+
+  def test_heizölrückstoßabdämpfung
+    skip
+    string = 'Heizölrückstoßabdämpfung'
+    assert Isogram.is_isogram?(string)
+  end
+
+  def test_the_quick_brown_fox
+    skip
+    string = 'the quick brown fox'
+    refute Isogram.is_isogram?(string)
+  end
+
+  def test_emily_jung_schwartzkopf
+    skip
+    string = 'Emily Jung Schwartzkopf'
+    assert Isogram.is_isogram?(string)
+  end
+
+  def test_éléphant
+    skip
+    string = 'éléphant'
+    refute Isogram.is_isogram?(string)
+  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/exercises/poker/example.rb

@@ -1,80 +1,138 @@
 module BookKeeping
-  VERSION = 1
+  VERSION = 2
 end
 
 class Poker
-  def initialize(hands)
-    @hands = hands
+
+  def initialize(hand_arrays)
+    @hands = hand_arrays.map { |hand_array| Hand.new(hand_array) }
   end
 
   def best_hand
-    best_score = @hands.map { |hand| hand_rank(hand) }.max
-    @hands.select { |hand| hand_rank(hand) == best_score }
+    hands.select { |hand| hand.score == highest_score }.map(&:to_a)
   end
 
   private
 
-  def hand_rank(hand)
-    hand_parser(hand)
-    top_hand || low_hand
+  attr_reader :hands
+
+  def highest_score
+    hands.map(&:score).max
   end
 
-  def hand_parser(hand)
-    @card_ranks = hand.map { |ele| '..23456789TJQKA'.index(ele[0]) }
-    @card_suits = hand.map { |ele| '.HSDC'.index(ele[1]) }
-    @card_split = @card_ranks.each_with_object(Hash.new(0)) { |r, h| h[r] += 1 }
-    @groups = @card_split.values.sort.reverse
+end
+
+class Hand
+
+  def initialize(hand_array)
+    @hand_array = hand_array
+    @cards = hand_array.map { |rank_and_suit| Card.new(rank_and_suit) }
   end
 
-  def top_hand
-    straight_flush || square || full || flush || straight
+  def to_a
+    hand_array
   end
 
-  def low_hand
-    three_of_a_kind || double_pair || pair || 0 + @card_ranks.max
+  def score
+    [hand_score, card_score].flatten
   end
 
-  def straight_flush
-    800 + @card_ranks.max if straight? && flush?
+  private
+
+  attr_reader :hand_array, :cards
+
+  def hand_score
+    scoring_hands.map.with_index { |scoring_hand, i| i if scoring_hand }.compact.max
   end
 
-  def square
-    700 + @card_split.key(4) if @groups == [4, 1]
+  def card_score
+    five_high_straight? ? [5, 4, 3, 2, 1] : card_score_array
   end
 
-  def full
-    600 + @card_split.key(3) if @groups == [3, 2]
+  def card_score_array
+    rank_count_hash
+        .sort_by { |rank, count| [-count, -rank] }
+        .map { |count_rank_array| count_rank_array[0] }
   end
 
-  def flush
-    500 + @card_ranks.max if flush?
+  def scoring_hands
+    [high_card?, one_pair?, two_pair?, three_of_a_kind?, five_high_straight?,
+     straight?, flush?, full_house?, four_of_a_kind?, straight_flush?]
   end
 
-  def straight
-    400 + @card_ranks.max if straight?
+  def high_card?
+    rank_count_totals.max == 1
   end
 
-  def three_of_a_kind
-    300 + @card_split.key(3) if @groups == [3, 1, 1]
+  def one_pair?
+    rank_count_totals.max == 2
   end
 
-  def double_pair
-    if @groups == [2, 2, 1]
-      @card_split.delete(@card_split.key(1))
-      return 200 + @card_split.max_by { |k| k }[0]
-    end
+  def two_pair?
+    rank_count_totals == [1, 2, 2]
   end
 
-  def pair
-    100 + @card_split.key(2) if @groups == [2, 1, 1, 1]
+  def three_of_a_kind?
+    rank_count_totals.max == 3
+  end
+
+  def five_high_straight?
+    rank_values == [2, 3, 4, 5, 14]
   end
 
   def straight?
-    @card_ranks = [1, 2, 3, 4, 5] if @card_ranks.sort == [2, 3, 4, 5, 14]
-    @card_ranks.uniq.length == 5 && @card_ranks.max - @card_ranks.min == 4
+    rank_values.each_cons(2).all? { |a, b| a + 1 == b }
   end
 
   def flush?
-    @card_suits.uniq.length == 1
+    suits.uniq.count == 1
+  end
+
+  def full_house?
+    rank_count_totals == [2, 3]
+  end
+
+  def four_of_a_kind?
+    rank_count_totals.max == 4
+  end
+
+  def straight_flush?
+    straight? && flush?
   end
+
+  def rank_count_totals
+    rank_count_hash.values.sort
+  end
+
+  def rank_count_hash
+    rank_values.each_with_object(Hash.new(0)) { |value, count| count[value] += 1 }
+  end
+
+  def rank_values
+    cards.map(&:rank_value).sort
+  end
+
+  def suits
+    cards.map(&:suit)
+  end
+
 end
+
+class Card
+
+  RANK_VALUES = {'2' => 2, '3' => 3, '4' => 4, '5' => 5, '6' => 6,
+                 '7' => 7, '8' => 8, '9' => 9, '10' => 10,
+                 'J' => 11, 'Q' => 12, 'K' => 13, 'A' => 14}
+
+  attr_reader :rank, :suit
+
+  def initialize(rank_and_suit)
+    @rank = rank_and_suit[0..-2]
+    @suit = rank_and_suit[-1]
+  end
+
+  def rank_value
+    RANK_VALUES[rank]
+  end
+
+end

data/tracks/ruby/exercises/poker/poker_test.rb

@@ -5,7 +5,6 @@ require_relative 'poker'
 
 class PokerTest < Minitest::Test
   def test_one_hand
-    # skip
     high_of_jack = %w(4S 5S 7H 8D JC)
     game = Poker.new([high_of_jack])
     assert_equal [high_of_jack], game.best_hand
@@ -14,14 +13,22 @@ class PokerTest < Minitest::Test
   def test_highest_card
     skip
     high_of_8 = %w(4S 5H 6S 8D 2H)
-    high_of_queen = %w(2S 4H 6S 9D QH)
+    high_of_queen = %w(2S 4H 6C 9D QH)
     game = Poker.new([high_of_8, high_of_queen])
     assert_equal [high_of_queen], game.best_hand
   end
 
+  def test_highest_card_10
+    skip
+    high_of_8 = %w(4D 5S 6S 8D 3C)
+    high_of_10 = %w(2S 4C 7S 9H 10H)
+    game = Poker.new([high_of_8, high_of_10])
+    assert_equal [high_of_10], game.best_hand
+  end
+
   def test_nothing_vs_one_pair
     skip
-    high_of_king = %w(4S 5H 6S 8D KH)
+    high_of_king = %w(4S 5H 6C 8D KH)
     pair_of_4 = %w(2S 4H 6S 4D JH)
     game = Poker.new([high_of_king, pair_of_4])
     assert_equal [pair_of_4], game.best_hand
@@ -30,7 +37,7 @@ class PokerTest < Minitest::Test
   def test_two_pair
     skip
     pair_of_2 = %w(4S 2H 6S 2D JH)
-    pair_of_4 = %w(2S 4H 6S 4D JH)
+    pair_of_4 = %w(2S 4H 6C 4D JD)
     game = Poker.new([pair_of_2, pair_of_4])
     assert_equal [pair_of_4], game.best_hand
   end
@@ -38,62 +45,78 @@ class PokerTest < Minitest::Test
   def test_one_pair_vs_double_pair
     skip
     pair_of_8 = %w(2S 8H 6S 8D JH)
-    double_pair = %w(4S 5H 4S 8D 5H)
-    game = Poker.new([pair_of_8, double_pair])
-    assert_equal [double_pair], game.best_hand
+    fives_and_fours = %w(4S 5H 4C 8C 5C)
+    game = Poker.new([pair_of_8, fives_and_fours])
+    assert_equal [fives_and_fours], game.best_hand
   end
 
   def test_two_double_pair
     skip
-    double_pair_2_and_8 = %w(2S 8H 2S 8D JH)
-    double_pair_4_and_5 = %w(4S 5H 4S 8D 5H)
-    game = Poker.new([double_pair_2_and_8, double_pair_4_and_5])
-    assert_equal [double_pair_2_and_8], game.best_hand
+    eights_and_twos = %w(2S 8H 2D 8D 3H)
+    fives_and_fours = %w(4S 5H 4C 8S 5D)
+    game = Poker.new([eights_and_twos, fives_and_fours])
+    assert_equal [eights_and_twos], game.best_hand
+  end
+
+  def test_another_two_double_pair
+    skip
+    aces_and_twos = %w(2S AH 2C AD JH)
+    queens_and_jacks = %w(JD QH JS 8D QC)
+    game = Poker.new([aces_and_twos, queens_and_jacks])
+    assert_equal [aces_and_twos], game.best_hand
   end
 
   def test_double_pair_vs_three
     skip
-    double_pair_2_and_8 = %w(2S 8H 2S 8D JH)
-    three_of_4 = %w(4S 5H 4S 8D 4H)
-    game = Poker.new([double_pair_2_and_8, three_of_4])
+    eights_and_twos = %w(2S 8H 2H 8D JH)
+    three_of_4 = %w(4S 5H 4C 8S 4H)
+    game = Poker.new([eights_and_twos, three_of_4])
     assert_equal [three_of_4], game.best_hand
   end
 
   def test_two_three
     skip
-    three_of_2 = %w(2S 2H 2S 8D JH)
-    three_of_1 = %w(4S AH AS 8D AH)
-    game = Poker.new([three_of_2, three_of_1])
-    assert_equal [three_of_1], game.best_hand
+    three_twos = %w(2S 2H 2C 8D JH)
+    three_aces = %w(4S AH AS 8C AD)
+    game = Poker.new([three_twos, three_aces])
+    assert_equal [three_aces], game.best_hand
   end
 
   def test_three_vs_straight
     skip
-    three_of_4 = %w(4S 5H 4S 8D 4H)
-    straight = %w(3S 4H 2S 6D 5H)
+    three_of_4 = %w(4S 5H 4C 8D 4H)
+    straight = %w(3S 4D 2S 6D 5C)
     game = Poker.new([three_of_4, straight])
     assert_equal [straight], game.best_hand
   end
 
-  def test_an_ace_high_straight
+  def test_a_5_high_straight
     skip
-    three_of_4 = %w(4S 5H 4S 8D 4H)
-    straight_to_5 = %w(4S AH 3S 2D 5H)
+    three_of_4 = %w(4S 5H 4C 8D 4H)
+    straight_to_5 = %w(4D AH 3S 2D 5C)
     game = Poker.new([three_of_4, straight_to_5])
     assert_equal [straight_to_5], game.best_hand
   end
 
   def test_two_straights
     skip
-    straight_to_8 = %w(4S 6H 7S 8D 5H)
+    straight_to_8 = %w(4S 6C 7S 8D 5H)
     straight_to_9 = %w(5S 7H 8S 9D 6H)
     game = Poker.new([straight_to_8, straight_to_9])
     assert_equal [straight_to_9], game.best_hand
   end
 
+  def test_5_high_straight_vs_other_straight
+    skip
+    straight_to_jack = %w(8H 7C 10D 9D JH)
+    straight_to_5 = %w(4S AH 3S 2D 5H)
+    game = Poker.new([straight_to_jack, straight_to_5])
+    assert_equal [straight_to_jack], game.best_hand
+  end
+
   def test_straight_vs_flush
     skip
-    straight_to_8 = %w(4S 6H 7S 8D 5H)
+    straight_to_8 = %w(4C 6H 7D 8D 5H)
     flush_to_7 = %w(2S 4S 5S 6S 7S)
     game = Poker.new([straight_to_8, flush_to_7])
     assert_equal [flush_to_7], game.best_hand
@@ -109,8 +132,8 @@ class PokerTest < Minitest::Test
 
   def test_flush_vs_full
     skip
-    flush_to_8 = %w(3H 6H 7H 8H 5H)
-    full = %w(4S 5H 4S 5D 4H)
+    flush_to_8 = %w(3H 6H 7H 8H 5C)
+    full = %w(4S 5H 4C 5D 4H)
     game = Poker.new([flush_to_8, full])
     assert_equal [full], game.best_hand
   end
@@ -125,26 +148,26 @@ class PokerTest < Minitest::Test
 
   def test_full_vs_square
     skip
-    full = %w(4S 5H 4S 5D 4H)
-    square_of_3 = %w(3S 3H 2S 3D 3H)
+    full = %w(4S 5H 4D 5D 4H)
+    square_of_3 = %w(3S 3H 2S 3D 3C)
     game = Poker.new([square_of_3, full])
     assert_equal [square_of_3], game.best_hand
   end
 
   def test_two_square
     skip
-    square_of_2 = %w(2S 2H 2S 8D 2H)
-    square_of_5 = %w(4S 5H 5S 5D 5H)
+    square_of_2 = %w(2S 2H 2C 8D 2D)
+    square_of_5 = %w(4S 5H 5S 5D 5C)
     game = Poker.new([square_of_2, square_of_5])
     assert_equal [square_of_5], game.best_hand
   end
 
   def test_square_vs_straight_flush
     skip
-    square_of_5 = %w(4S 5H 5S 5D 5H)
-    straight_flush_to_9 = %w(5S 7S 8S 9S 6S)
-    game = Poker.new([square_of_5, straight_flush_to_9])
-    assert_equal [straight_flush_to_9], game.best_hand
+    square_of_5 = %w(4S 5H 5S 5D 5C)
+    straight_flush_to_10 = %w(7S 8S 9S 6S 10S)
+    game = Poker.new([square_of_5, straight_flush_to_10])
+    assert_equal [straight_flush_to_10], game.best_hand
   end
 
   def test_two_straight_flushes
@@ -155,6 +178,14 @@ class PokerTest < Minitest::Test
     assert_equal [straight_flush_to_9], game.best_hand
   end
 
+  def test_highest_card_down_to_fifth_card
+    skip
+    high_of_8_low_of_3 = %w(3S 5H 6S 8D 7H)
+    high_of_8_low_of_2 = %w(2S 5D 6D 8C 7S)
+    game = Poker.new([high_of_8_low_of_3, high_of_8_low_of_2])
+    assert_equal [high_of_8_low_of_3], game.best_hand
+  end
+
   def test_three_hand_with_tie
     skip
     spade_straight_to_9 = %w(9S 8S 7S 6S 5S)
@@ -166,6 +197,6 @@ class PokerTest < Minitest::Test
   end
 
   def test_bookkeeping
-    assert_equal 1, BookKeeping::VERSION
+    assert_equal 2, BookKeeping::VERSION
   end
 end