euler_poker 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 006bcaa584aea2730f6321f36e756b4ac45aedc7
+  data.tar.gz: d528d36fc097becdec5f17cb918537fb6f7582ef
+SHA512:
+  metadata.gz: e076703a9c5bbdf0332d187d6d310dd934b5a1575e6d92d88e01b1c5dd48a140eb29e44d8e3f368dba8ca5acb90cc3c332216be3955685f9a800f43795002605
+  data.tar.gz: 80c2b1989aa4463c28617791bdbe22bd2f6edc508f60d9101e24af2453abbdc841e99cb51ce26c12ac035ddfd64272beb57498853c1d1f4fa4e0e1245bc3b75a

data/bin/euler_poker

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+# Adds this gem's lib path the the Ruby load path.
+# Borrowed from https://stackoverflow.com/a/5294358/918507
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'euler_poker'
+
+file = ARGV[0]
+EulerPoker::CLI.new(file)

data/lib/euler_poker.rb

@@ -0,0 +1,8 @@
+require 'euler_poker/hand'
+require 'euler_poker/card'
+require 'euler_poker/hand_factory'
+require 'euler_poker/round'
+require 'euler_poker/cli'
+
+module EulerPoker
+end

data/lib/euler_poker/card.rb

@@ -0,0 +1,34 @@
+module EulerPoker
+  RANKS = {
+    '2' => 2,
+    '3' => 3,
+    '4' => 4,
+    '5' => 5,
+    '6' => 6,
+    '7' => 7,
+    '8' => 8,
+    '9' => 9,
+    'T' => 10,
+    'J' => 11,
+    'Q' => 12,
+    'K' => 13,
+    'A' => 14
+  }
+
+  SUITS = {
+    'S' => :spade,
+    'H' => :heart,
+    'D' => :diamond,
+    'C' => :club
+  }
+
+  class Card
+    attr_reader :value, :rank, :suit
+
+    def initialize(card)
+      @value = card
+      @rank = RANKS[card[0]]
+      @suit = SUITS[card[1]]
+    end
+  end
+end

data/lib/euler_poker/cli.rb

@@ -0,0 +1,27 @@
+module EulerPoker
+  class CLI
+    attr_reader :results
+
+    def initialize(file)
+      @file = File.open(file, 'r')
+      print_results
+    end
+
+    private
+
+    def print_results
+      hands = 0
+      results = []
+
+      @file.each_line do |line|
+        round = EulerPoker::Round.new(line)
+
+        results << round.winner
+        hands += 1
+      end
+      @file.close
+
+      puts "Player 1 won #{results.count(:first)} out of #{hands} hands."
+    end
+  end
+end

data/lib/euler_poker/hand.rb

@@ -0,0 +1,82 @@
+module EulerPoker
+  class Hand
+    include Comparable
+
+    def initialize(cards)
+      @cards = cards
+    end
+
+    def <=>(other)
+      ranking <=> other.ranking
+    end
+
+    def ranking
+      RANKED_HANDS.reverse.index(self.class)
+    end
+
+    def ranks
+      @cards.map(&:rank)
+    end
+
+    def suits
+      @cards.map(&:suit)
+    end
+
+    def descending_ranks
+      ranks.sort.reverse
+    end
+
+    private
+
+    def rank_counts
+      ranks.reduce(Hash.new(0)) do |counts, rank|
+        counts[rank] += 1
+        counts
+      end
+    end
+
+    def straight_flush?
+      return true if straight? && flush?
+    end
+
+    def four_of_a_kind?
+      rank_counts.values.any? { |count| count == 4 }
+    end
+
+    def full_house?
+      rank_counts.values.include?(3) && rank_counts.values.include?(2)
+    end
+
+    def flush?
+      suits.uniq.length == 1
+    end
+
+    def straight?
+      # Can't be a straight unless all cards are different ranks
+      return false unless ranks.uniq.count == 5
+
+      sorted_cards = ranks.sort
+      smallest = sorted_cards.first
+      largest = sorted_cards.last
+
+      # Since these are unique and sorted, if the difference between
+      # largest and smallest is 4, then these are consecutive cards
+      largest - smallest == 4
+    end
+
+    def three_of_a_kind?
+      rank_counts.values.any? { |count| count == 3 }
+    end
+
+    def two_pair?
+      rank_counts
+        .values
+        .select { |count| count == 2 }
+        .count == 2
+    end
+
+    def one_pair?
+      rank_counts.values.any? { |count| count == 2 }
+    end
+  end
+end

data/lib/euler_poker/hand_factory.rb

@@ -0,0 +1,41 @@
+Dir[File.dirname(__FILE__) + '/hands/*.rb'].each { |file| require file }
+
+module EulerPoker
+  RANKED_HANDS = [
+    StraightFlush,
+    FourOfAKind,
+    FullHouse,
+    Flush,
+    Straight,
+    ThreeOfAKind,
+    TwoPair,
+    OnePair,
+    HighCard
+  ]
+
+  class HandFactory
+    def self.round(round)
+      cards = parse_cards(round)
+      first = build_hand(cards.first(5))
+      second = build_hand(cards.last(5))
+      [first, second]
+    end
+
+    def self.hand(hand)
+      cards = parse_cards(hand)
+      build_hand(cards)
+    end
+
+    def self.parse_cards(cards_string)
+      cards_string
+        .split
+        .map { |card_string| Card.new(card_string) }
+    end
+
+    def self.build_hand(cards)
+      RANKED_HANDS
+        .map { |h| h.new(cards) }
+        .find{ |h| h.valid? }
+    end
+  end
+end

data/lib/euler_poker/hands/flush.rb

@@ -0,0 +1,13 @@
+module EulerPoker
+  class Flush < Hand
+    def <=>(other)
+      return super unless super == 0
+
+      descending_ranks <=> other.descending_ranks
+    end
+
+    def valid?
+      flush?
+    end
+  end
+end

data/lib/euler_poker/hands/four_of_a_kind.rb

@@ -0,0 +1,19 @@
+module EulerPoker
+  class FourOfAKind < Hand
+    def <=>(other)
+      return super unless super == 0
+
+      return quartet_rank <=> other.quartet_rank
+    end
+
+    def quartet_rank
+      rank_counts
+        .find { |rank, count| count == 4 }
+        .first
+    end
+
+    def valid?
+      four_of_a_kind?
+    end
+  end
+end

data/lib/euler_poker/hands/full_house.rb

@@ -0,0 +1,29 @@
+module EulerPoker
+  class FullHouse < Hand
+    def <=>(other)
+      return super unless super == 0
+
+      if triplet_rank == other.triplet_rank
+        return pair_rank <=> other.pair_rank
+      else
+        return triplet_rank <=> other.triplet_rank
+      end
+    end
+
+    def triplet_rank
+      rank_counts
+        .find { |rank, count| count == 3 }
+        .first
+    end
+
+    def pair_rank
+      rank_counts
+        .find { |rank, count| count == 2 }
+        .first
+    end
+
+    def valid?
+      full_house?
+    end
+  end
+end

data/lib/euler_poker/hands/high_card.rb

@@ -0,0 +1,13 @@
+module EulerPoker
+  class HighCard < Hand
+    def <=>(other)
+      return super unless super == 0
+
+      descending_ranks <=> other.descending_ranks
+    end
+
+    def valid?
+      true
+    end
+  end
+end

data/lib/euler_poker/hands/one_pair.rb

@@ -0,0 +1,27 @@
+module EulerPoker
+  class OnePair < Hand
+    def <=>(other)
+      return super unless super == 0
+
+      if pair_rank != other.pair_rank
+        pair_rank <=> other.pair_rank
+      else
+        ranked_extra_cards <=> other.ranked_extra_cards
+      end
+    end
+
+    def pair_rank
+      rank_counts
+        .find { |rank, count| count == 2 }
+        .first
+    end
+
+    def ranked_extra_cards
+      descending_ranks.reject { |rank| rank == pair_rank }
+    end
+
+    def valid?
+      one_pair?
+    end
+  end
+end

data/lib/euler_poker/hands/straight.rb

@@ -0,0 +1,13 @@
+module EulerPoker
+  class Straight < Hand
+    def <=>(other)
+      return super unless super == 0
+
+      return ranks.max <=> other.ranks.max
+    end
+
+    def valid?
+      straight?
+    end
+  end
+end

data/lib/euler_poker/hands/straight_flush.rb

@@ -0,0 +1,13 @@
+module EulerPoker
+  class StraightFlush < Hand
+    def <=>(other)
+      return super unless super == 0
+
+      return ranks.max <=> other.ranks.max
+    end
+
+    def valid?
+      straight_flush?
+    end
+  end
+end

data/lib/euler_poker/hands/three_of_a_kind.rb

@@ -0,0 +1,27 @@
+module EulerPoker
+  class ThreeOfAKind < Hand
+    def <=>(other)
+      return super unless super == 0
+
+      if triplet_rank == other.triplet_rank
+        return ranked_extra_cards <=> other.ranked_extra_cards
+      else
+        return triplet_rank <=> other.triplet_rank
+      end
+    end
+
+    def triplet_rank
+      rank_counts
+        .find { |rank, count| count == 3 }
+        .first
+    end
+
+    def ranked_extra_cards
+      descending_ranks.reject { |rank| rank == triplet_rank }
+    end
+
+    def valid?
+      three_of_a_kind?
+    end
+  end
+end

data/lib/euler_poker/hands/two_pair.rb

@@ -0,0 +1,41 @@
+module EulerPoker
+  class TwoPair < Hand
+    def <=>(other)
+      return super unless super == 0
+
+      if high_pair_rank != other.high_pair_rank
+        high_pair_rank <=> other.high_pair_rank
+      elsif low_pair_rank != other.low_pair_rank
+        low_pair_rank <=> other.low_pair_rank
+      else
+        extra_card <=> other.extra_card
+      end
+    end
+
+    def high_pair_rank
+      pair_ranks.max
+    end
+
+    def low_pair_rank
+      pair_ranks.min
+    end
+
+    def extra_card
+      rank_counts
+        .find { |rank, count| count == 1 }
+        .first
+    end
+
+    def valid?
+      two_pair?
+    end
+
+    private
+
+    def pair_ranks
+      rank_counts
+        .select { |rank, count| count == 2 }
+        .keys
+    end
+  end
+end

data/lib/euler_poker/round.rb

@@ -0,0 +1,17 @@
+module EulerPoker
+  class Round
+    def initialize(round)
+      @first, @second = HandFactory.round(round)
+    end
+
+    def winner
+      if @first > @second
+        :first
+      elsif @first < @second
+        :second
+      else
+        :tie
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: euler_poker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Richard Jones
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-26 00:00:00.000000000 Z
+dependencies: []
+description: A solution to problem 54 of Project Euler
+email: rico@toasterlovin.com
+executables:
+- euler_poker
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/euler_poker
+- lib/euler_poker.rb
+- lib/euler_poker/card.rb
+- lib/euler_poker/cli.rb
+- lib/euler_poker/hand.rb
+- lib/euler_poker/hand_factory.rb
+- lib/euler_poker/hands/flush.rb
+- lib/euler_poker/hands/four_of_a_kind.rb
+- lib/euler_poker/hands/full_house.rb
+- lib/euler_poker/hands/high_card.rb
+- lib/euler_poker/hands/one_pair.rb
+- lib/euler_poker/hands/straight.rb
+- lib/euler_poker/hands/straight_flush.rb
+- lib/euler_poker/hands/three_of_a_kind.rb
+- lib/euler_poker/hands/two_pair.rb
+- lib/euler_poker/round.rb
+homepage: https://github.com/toasterlovin/euler_poker
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Euler Poker
+test_files: []