0

我的问题与“如何返回一组可能存在于数组中的序列号？ ”非常相似。

我需要找到一种方法来检查给定的数字数组（基本上是卡片值）是否是扑克顺子，或者只是返回最长的序列。

正如托马斯先生所建议的，each_cons效果很好，但在德州扑克中，顺子不仅是 2、3、4、5、6 或 8、9、10、J、Q，而且还包括 K、A、2、3、4。

如果我们将数字签名为数字，我认为这将使一切变得更容易：J 将是 11，Q 将是 12，依此类推。

知道如何实现这一目标吗？

4

5 回答 5

1

您的输入是一个数字数组。所以我假设 J = 11，Q = 12，K= 13 和 A= 1。

1) 对数组进行排序 2) 遍历数组，当你遇到下一个数字比前一个数字大一个数字时返回 false，因为它不是顺手。

如果您不假设 J=11、Q=12、K=13、A=1，那么您需要一个额外的数据结构（也许是一个字典来降低复杂性，因为查找是 O(1)）时间。字典 a = new Dictionary(); a.key = "K"; a.value = "13"。

现在如果你有一个数组 [10,11,J,Q,K] => 遍历它并在你的字典中查找，一旦你的值比前一张卡片大一个，然后返回 false..

显然你会有基本情况，如果输入数组的长度超过 5。或者是空的或者 < 5。如果你正在做重叠的直线，那么在 K 之后唯一可以出现的是值为 1 的 A ，所以如果是这样的话，那么继续你的循环。希望这会有所帮助。

祝你好运。

于 2013-02-19T23:47:45.943 回答
1

试试这个（假设你已经用数字替换了卡片，A=1, 2=2）

def straight?(my_cards)    
  sorted = my_cards.uniq.sort

  if sorted.length < 5
    # cant form a straight with duplicates
    false

  else
    # also give an Ace a value of 14 so it can be placed after a King
    sorted << 14 if sorted[0] == 1

    # returns true if the last number is equal to 4 plus the first so
    # a hand with 2,3,4,5,6 will return true
    sorted.first + 4 == sorted.last
  end
于 2013-02-20T00:34:18.937 回答
1

也许它不是最佳的，但我会使用Array#rotate!：

@values = %w{A 2 3 4 5 6 7 8 9 10 J Q K A}

def longest_sequence cards
  cards, values = cards.sort_by{|c| @values.index c}, @values.dup
  # iterate down from 5 and rotate through cards/values until you find a match
  5.downto(1).each do |n|
    values.length.times do
      cards.length.times do
        return cards[0...n] if cards[0...n] == values[0...n]
        cards.rotate!
      end
      values.rotate!
    end
  end
end

longest_sequence ['A', '3', '4']
#=> ["3", "4"]
longest_sequence ['A', '3', '4', '2', '5']
#=> ["A", "2", "3", "4", "5"]
longest_sequence ['A', '10', 'Q', 'J', 'K']
#=> ["10", "J", "Q", "K", "A"]
于 2013-02-20T06:47:35.353 回答
1

只需列举所有可能的顺子：

All_Poker_Straights = %w(A 2 3 4 5 6 7 8 9 10 J Q K A).each_cons(5)

并检查（排序的）手是否是其中之一：

p All_Poker_Straights.include?(%w(4 5 6 7 8))
# => true
于 2013-02-20T10:23:35.913 回答
0 
class Array
  def sequences
    a = sort.uniq.inject([]){|a, e|
      a.last && e == a.last.last + 1 ? a.last.push(e) : a.push([e])
      a
    }
    a.push([*a.pop, *a.shift]) if a.first.first == 1 && a.last.last == 13
    a
  end
end

[1, 3, 4].sequences # => [[1], [3, 4]]
[1, 3, 4, 2, 5].sequences # => [[1, 2, 3, 4, 5]]
[1, 10, 12, 11, 13].sequences # => [[10, 11, 12, 13, 1]]

[1, 3, 4].sequences.max{|a| a.length} # => [3, 4]
[1, 3, 4, 2, 5].sequences.max{|a| a.length} # => [1, 2, 3, 4, 5]
[1, 10, 12, 11, 13].sequences.max{|a| a.length} # => [10, 11, 12, 13, 1]
于 2013-02-20T08:21:30.253 回答