Question

我的问题非常类似于“How do I return a group of sequential numbers that might exist in an array?”。

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

正如托马斯先生所说，each_cons运作良好，但在德州扑克中，直线不仅仅是2,3,4,5,6或8,9,10，J，Q，而是K，A ，2,3,4也。

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

知道怎么做到这一点？

Answer 1

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

1）对数组进行排序 2）遍历数组，当你遇到下一个数字时，多于前一个数字的一个数字返回false，因为它不是直接的。

如果你不假设J = 11，Q = 12，K = 13，A = 1，那么你需要一个额外的数据结构（也许是一个字典，因为查找是O（1），所以复杂性很低）时间。字典a =新词典（）; a.key =“K”; a.value =“13”。

现在如果你有一个[10,11，J，Q，K] =＆gt;的数组迭代它并在你的字典中查找，一旦你的价值比前一张卡大一点，那么返回假..

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

祝你好运。

Answer 2

试试这个（假设你已经用数字替换了牌，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

Answer 3

也许这不是最优的，但我会使用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"]

Answer 4

列举所有可能的直道：

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

Answer 5

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]

直接检查扑克的数字数组？

5 个答案: