周末挑战：红宝石扑克手评估

[3, 5, 9, 6] # base score, value of tripled card, kicker, kicker

player1.score #=> [2, 7, 5, 3]
player2.score #=> [2, 7, 5, 8]

ACE_LOW  = 1
ACE_HIGH = 14

# Use Struct to model a simple Card class
Card = Struct.new :suit, :value

# This class models and evaluates a hand of cards
class Hand
  attr_reader :cards

  RANKS = {
    straight_flush:  8,
    four_of_a_kind:  7,
    full_house:      6,
    flush:           5,
    straight:        4,
    three_of_a_kind: 3,
    two_pair:        2,
    pair:            1
  }.freeze

  def initialize(cards)
    raise ArgumentError unless cards.count == 5
    @cards = cards.freeze
  end

  # The hand's rank as an array containing the hand's
  # type and that type's base score
  def rank
    RANKS.detect { |method, rank| send :"#{method}?" } || [:high_card, 0]
  end

  # The hand's type (e.g. :flush or :pair)
  def type
    rank.first
  end

  # The hand's base score (based on rank)
  def base_score
    rank.last
  end

  # The hand's score is an array starting with the
  # base score, followed by the kickers.
  def score
    [base_score] + kickers
  end

  # Tie-breaking kickers, ordered high to low.
  def kickers
    repeat_values + (aces_low? ? aces_low_values.reverse : single_values)
  end

  # If the hand's straight and flush, it's a straight flush
  def straight_flush?
    straight? && flush?
  end

  # Is a value repeated 4 times?
  def four_of_a_kind?
    repeat_counts.include? 4
  end

  # Three of a kind and a pair make a full house
  def full_house?
    three_of_a_kind? && pair?
  end

  # If the hand only contains one suit, it's flush
  def flush?
    suits.uniq.count == 1
  end

  # This is the only hand where high vs low aces comes into play.
  def straight?
    aces_high_straight? || aces_low_straight?
  end

  # Is a card value repeated 3 times?
  def three_of_a_kind?
    repeat_counts.include? 3
  end

  # Are there 2 instances of repeated card values?
  def two_pair?
    repeat_counts.count(2) == 2
  end

  # Any repeating card value?
  def pair?
    repeat_counts.include? 2
  end

  # Actually just an alias for aces_low_straight?
  def aces_low?
    aces_low_straight?
  end

  # Does the hand include one or more aces?
  def aces?
    values.include? ACE_HIGH
  end

  # The repeats in the hand
  def repeats
    cards.group_by &:value
  end

  # The number of repeats in the hand, unordered
  def repeat_counts
    repeats.values.map &:count
  end

  # The values that are repeated more than once, sorted by
  # number of occurrences
  def repeat_values
    repeated = repeats.map { |value, repeats| [value.to_i, repeats.count] }
    repeated = repeated.reject { |value, count| count == 1 }
    repeated = repeated.sort_by { |value, count| [count, value] }.reverse
    repeated.map(&:first)
  end

  # Values that are not repeated, sorted high to low
  def single_values
    repeats.select { |value, repeats| repeats.count == 1 }.map(&:first).sort.reverse
  end

  # Ordered (low to high) array of card values (assumes aces high)
  def values
    cards.map(&:value).sort
  end

  # Unordered array of card suits
  def suits
    cards.map(&:suit)
  end

  # A "standard" straight, treating aces as high
  def aces_high_straight?
    straight_values_from(values.first) == values
  end

  # Special case straight, treating aces as low
  def aces_low_straight?
    aces? && straight_values_from(aces_low_values.first) == aces_low_values
  end

  # The card values as an array, treating aces as low
  def aces_low_values
    cards.map(&:value).map { |v| v == ACE_HIGH ? ACE_LOW : v }.sort
  end

  private

  # Generate an array of 5 consecutive values
  # starting with the `from` value
  def straight_values_from(from)
    (from...from + 5).to_a
  end
end

#1 楼

我认为您的示例结构合理，我希望我的评论能为您带来一些公正。有您的担忧和其他要讨论的地方：

您将在此处找到以下代码的有效实现




常规编码风格

很好并且一致。我特别喜欢您使用问号来表示返回布尔值的方法。


也许您也可以从方法定义中省略花括号，因为您在可能的情况下在方法调用中忽略了它们。 />您留下了RANKS，您的属性和初始化程序，而没有文档。我认为特别是RANKS和初始化程序将从中受益。



RANKS和实例方法中的重复

我认为这没问题，我不会提出更好或更具可读性的方法。


flush方法

使用Enumerable#one?可以更优雅地编写它们

/>使卡片成为Struct的决定
我喜欢在代码中使用常量来提高可读性和可维护性。引起我注意的一件事是ACE_LOW和ACE_HIGH是全局常数，而RANKS不是全局常数（很好）。我认为这种设计缺陷来自于您将Card设为Struct对象的决定，以及这种对象通常缺乏逻辑的原因。让我们进行更改，使Card成为一流的公民：您的代码将受益。

 # If the hand only contains one suit, it's flush
 def flush?
   suits.uniq.one?
 end

这将对Hand中的代码进行以下改进：

class Card
  include Comparable

  attr_reader :suit, :value

  # Value to use as ace low
  ACE_LOW = 1

  # Value to use as ace high
  ACE_HIGH = 14

  # initialize the card with a suit and a value
  def initialize suit, value
    super()
    @suit = suit
    @value = value
  end

  # Return the low card
  def low_card
    ace? ? Card.new(suit, ACE_LOW) : self
  end

  # Return if the card is an ace high
  def ace?
    value == ACE_HIGH
  end

  def ace_low?
    value == ACE_LOW
  end

  # Return if the card has suit spades
  def spades?
    suit == :spades
  end

  # Return if the card has suit diamonds
  def diamonds?
    suit == :diamonds
  end

  # Return if the card is suit hearts
  def hearts?
    suit == :hearts
  end

  # Return if the card has suit clubs
  def clubs?
    suit == :clubs
  end

  # Compare cards based on values and suits
  # Ordered by suits and values - the suits_index will be introduced below
  def <=> other
    if other.is_a? Card
      (suit_index(suit) <=> suit_index(other.suit)).nonzero? || value <=> other.value
    else
      value <=> other
    end
  end

  # Allow for construction of card ranges across suits
  # the suits_index will be introduced below
  def succ
    if ace?
      i = suit_index suit
      Card.new(Deck::SUITS[i + 1] || Deck::SUITS.first, ACE_LOW)
    else
      Card.new(suit, value + 1)
    end
  end

  def successor? other
    succ == other
  end

  def straight_successor? other
    succ === other
  end

  # Compare cards for equality in value
  def == other
    if other.is_a? Card
      value == other.value
    else
      value == other
    end
  end
  alias :eql? :==

  # overwrite hash with value since cards with same values are considered equal
  alias :hash :value

  # Compare cards for strict equality (value and suit)
  def === other
    if other.is_a? Card
      value == other.value && suit == other.suit
    else
      false
    end
  end

  private

  # If no deck, this has to be done with an array of suits
  # gets the suit index
  def suit_index suit
    Deck::SUITS.index suit
  end
end

它将包含ACE_HIGH中的常数ACE_LOW和Card

更换卡是不可能。由于结构响应Struct和cards，因此仍可以修改冻结的value=阵列中的suit=卡的值。
/>我认为将Hand作为splat参数会更好。用数组初始化会不必要地降低可读性。另外，您提出的cards并不是很好的描述，可能会引起一些混乱。总而言之，这就是我的改进效果：

class Hand

  # ... 

  # Tie-breaking kickers, ordered high to low.
  def kickers
    same_of_kind + (aces_low? ? aces_low.reverse : single_cards)
  end

  # If the hand's straight and flush, it's a straight flush
  def straight_flush?
    straight? && flush?
  end

  # Is a value repeated 4 times?
  def four_of_a_kind?
    same_of_kind? 4
  end

  # Three of a kind and a pair make a full house
  def full_house?
    same_of_kind?(3) && same_of_kind?(2)
  end

  # If the hand only contains one suit, it's flush
  def flush?
    suits.uniq.one?
  end

  # This is the only hand where high vs low aces comes into play.
  def straight?
    aces_high_straight? || aces_low_straight?
  end

  # Is a card value repeated 3 times?
  def three_of_a_kind?
    collapsed_size == 2 && same_of_kind?(3)
  end

  # Are there 2 instances of repeated card values?
  def two_pair?
    collapsed_size == 2 && same_of_kind?(2)
  end

  # Any pair?
  def pair?
    same_of_kind? 2
  end

  def single_cards
    cards.select{|c| cards.count(c) == 1 }
  end

  # Does the hand include one or more aces?
  def aces?
    cards.any? &:ace?
  end

  # Ordered (low to high) array of card values (assumes aces high)
  def values
    cards.map(&:value).sort
  end

  # Unordered array of card suits
  def suits
    cards.map &:suit
  end

  # A "standard" straight, treating aces as high
  def aces_high_straight?
    all_successors? cards.sort_by(&:value)
  end

  # Special case straight, treating aces as low
  def aces_low_straight?
    aces? && all_successors?(aces_low)
  end
  alias :aces_low? :aces_low_straight?

  # The card values as an array, treating aces as low
  def aces_low
    cards.map(&:low_card).sort
  end

  private

  # Are there n cards same of kind?
  def same_of_kind?(n)
    !!cards.detect{|c| cards.count(c) == n }
  end

  # How many cards vanish if we collapse the cards to single values
  def collapsed_size
    cards.size - cards.uniq.size
  end

  # map the cards that are same of kind
  def same_of_kind
    2.upto(4).map{|n| cards.select{|c| cards.count(c) == n }.reverse }.sort_by(&:size).reverse.flatten.uniq
  end

  # Are all cards succeeding each other in value?
  def all_successors?(cards)
    cards.all?{|a| a === cards.last || a.successor?(cards[cards.index(a) + 1]) }
  end

end 

根据使用情况，可能还需要进行其他完整性检查：检查您是否真的收到了ArgumentError的5个实例。

纸牌也是纸牌阵列-相似之处使您可以将Card替换为Hand。这将使您可以直接在Array上使用Array和Hand DSL，
如果您进一步学习此代码，这可能会对您有所帮助（考虑一下Enumerable和Array类）

另外，我将为您提供默认排序，这将消除您的未排序退货问题，而且您可以为基于价值的排序进行排序。

其他的健全性检查可能是以便在您决定不初始化时立即使用Hand：


检查Deck，Game，freeze和Hand是否获得push的实例

检查是否unshift，insert，<<和Card as argument不会在手牌上添加太多卡

那么，这有什么可能呢？让我们重构一下：

def initialize(*cards)
  raise ArgumentError.new "wrong number of cards (#{cards.count} for 5)" unless cards.count == 5
  @cards = cards.freeze
end

与push类一起，这为您提供了可以构建的漂亮DSL：
只是为了好玩，如果您有一个unshift类，它也可以作为insert的子类

class Hand < Array

  # .. RANKS

  def initialize(*cards)
    raise ArgumentError.new "There must be 5 cards" unless cards.count == 5
    super(cards)
    sort_by! &:value # This will give you a nicely sorted hand by default
    freeze
  end

  # The hand's rank as an array containing the hand's
  # type and that type's base score
  def rank
    RANKS.detect { |method, rank| send :"#{method}?" } || [:high_card, 0]
  end

  # The hand's type (e.g. :flush or :pair)
  def type
    rank.first
  end

  # The hand's base score (based on rank)
  def base_score
    rank.last
  end

  # The hand's score is an array starting with the
  # base score, followed by the kickers.
  def score
    ([base_score] + kickers.map(&:value))
  end

  # Tie-breaking kickers, ordered high to low.
  def kickers
    same_of_kind + (aces_low? ? aces_low.reverse : single_cards.reverse)
  end

  # If the hand's straight and flush, it's a straight flush
  def straight_flush?
    straight? && flush?
  end

  # Is a value repeated 4 times?
  def four_of_a_kind?
    same_of_kind? 4
  end

  # Three of a kind and a pair make a full house
  def full_house?
    same_of_kind?(3) && same_of_kind?(2)
  end

  # If the hand only contains one suit, it's flush
  def flush?
    suits.uniq.one?
  end

  # single cards in the hand
  def single_cards
    select{ |c| count(c) == 1 }.sort_by(&:value)
  end

  # This is the only hand where high vs low aces comes into play.
  def straight?
    aces_high_straight? || aces_low_straight?
  end

  # Is a card value repeated 3 times?
  def three_of_a_kind?
    collapsed_size == 2 && same_of_kind?(3)
  end

  # Are there 2 instances of repeated card values?
  def two_pair?
    collapsed_size == 2 && same_of_kind?(2)
  end

  # Any repeating card value?
  def pair?
    same_of_kind?(2)
  end

  # Does the hand include one or more aces?
  def aces?
    any? &:ace?
  end

  # Ordered (low to high) array of card values (assumes aces high)
  def values
    map(&:value).sort
  end

  # Ordered Array of card suits
  def suits
    sort.map &:suit
  end

  # A "standard" straight, treating aces as high
  def aces_high_straight?
    all?{|card| card === last || card.successor?(self[index(card) + 1]) }
  end
  alias :all_successors? :aces_high_straight?

  # Special case straight, treating aces as low
  def aces_low_straight?
    aces? && aces_low.all_successors?
  end
  alias :aces_low? :aces_low_straight?

  # The card values as an array, treating aces as low
  def aces_low
    Hand.new *map(&:low_card)
  end

  private

  # Are there n cards of the same kind?
  def same_of_kind?(n)
    !!detect{|card| count(card) == n }
  end

  def same_of_kind
    2.upto(4).map{|n| select{|card| count(card) == n }.reverse }.sort_by(&:size).reverse.flatten.uniq
  end

  # How many cards vanish if we collapse the cards to single values
  def collapsed_size
    size - uniq.size
  end

end

哪里可以进一步学习


在<<上实现Card

摆脱手上的Deck以便我们可以交换卡用于某些类型的游戏
yada yada yada



正如我所说，您的榜样已经很好，希望我感谢与您分享我的想法！