LC 846. Hand of Straights

Alice has hand of cards, given as an array of integers.

Now she wants to rearrange the cards into groups so that each group is size W, and consists of Wconsecutive cards.

Return true if and only if she can.

 

Example 1:

Input: hand = [1,2,3,6,2,3,4,7,8], W = 3
Output: true
Explanation: Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8].

Example 2:

Input: hand = [1,2,3,4,5], W = 4
Output: false
Explanation: Alice's hand can't be rearranged into groups of 4.

 

Note:

  1. 1 <= hand.length <= 10000
  2. 0 <= hand[i] <= 10^9
  3. 1 <= W <= hand.length

 

Runtime: 80 ms, faster than 24.90% of C++ online submissions for Hand of Straights.

我的思路很直接,用map保存。

class Solution {
public:
  bool isNStraightHand(vector<int>& hand, int W) {
        int n = hand.size();
        if (n < 1 || W < 1 || n < W)
        {
            return false;
        }
       
        if (n % W != 0)
        {
            return false;
        }
    map<int,int> mp;
    for(auto x : hand) mp[x]++;
    for(auto it : mp){
      if(it.second == 0) continue;
      int cntit = it.second;
      for(int i=1; i<W;i++){
        if(!mp.count(it.first) || mp[it.first+i] < mp[it.first]) return false;
        mp[it.first+i] -= mp[it.first];
      }
      mp[it.first] = 0;
    }
    for(auto it : mp){
      if(it.second != 0) return false;
    }
    return true;
  }
};

 

网上看到一个比较好的思路是,把所有的数%W,因为是连续的,所以一个连续的W个数modW后必定在0 ~ W-1 中是连续存在的,妙。

class Solution {
public:
    bool isNStraightHand(vector<int>& hand, int W) {
        int n = hand.size();
        if (n < 1 || W < 1 || n < W)
        {
            return false;
        }
       
        if (n % W != 0)
        {
            return false;
        }
        
        vector<int> count (W, 0);
        for (const int& h : hand)
        {
            ++count[h % W];
        }
        
        int expect = count.front();
        for(const int& c : count)
        {
            if (c != expect)
            {
                return false;
            }
        }
        
        return true;
    }
};

 

转载于:https://www.cnblogs.com/ethanhong/p/10179315.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,以下是一个简单的Clojure实现的德州扑克游戏: ```clojure (ns texas-holdem.core (:gen-class)) (def suits [:hearts :diamonds :clubs :spades]) (def ranks [:two :three :four :five :six :seven :eight :nine :ten :jack :queen :king :ace]) (defn shuffle-deck [] (shuffle (for [suit suits rank ranks] {:suit suit :rank rank}))) (defn deal [players deck] (loop [p players d deck hands []] (if (empty? p) hands (let [hand (take 2 d)] (recur (rest p) (drop 2 d) (conj hands (vec hand))))))) (defn flop [deck] (let [cards (take 3 deck) rest (drop 3 deck)] [cards rest])) (defn turn [deck] (let [card (first deck) rest (rest deck)] [card rest])) (defn river [deck] (let [card (first deck) rest (rest deck)] [card rest])) (defn best-hand [cards] (let [combinations (sequence 5 (subseq cards 0)) hands (map #(sort-by :rank %) (sequence 10 (combinations combinations))) flushes (filter #(= (count (distinct (map :suit %))) 1) hands) straights (filter #(= (count (distinct (map :rank %))) 5) hands) straight-flushes (filter #(and (= (count (distinct (map :suit %))) 1) (= (count (distinct (map :rank %))) 5)) hands) royal-flushes (filter #(= (count (distinct (map :rank %))) 5) straight-flushes)] (if (not-empty royal-flushes) {:hand :royal-flush :cards (first royal-flushes)} (if (not-empty straight-flushes) {:hand :straight-flush :cards (first straight-flushes)} (if (not-empty four-of-a-kinds) {:hand :four-of-a-kind :cards (first four-of-a-kinds)} (if (not-empty full-houses) {:hand :full-house :cards (first full-houses)} (if (not-empty flushes) {:hand :flush :cards (first flushes)} (if (not-empty straights) {:hand :straight :cards (first straights)} (if (not-empty three-of-a-kinds) {:hand :three-of-a-kind :cards (first three-of-a-kinds)} (if (not-empty two-pairs) {:hand :two-pair :cards (first two-pairs)} (if (not-empty pairs) {:hand :pair :cards (first pairs)} {:hand :high-card :cards (first hands)}))))))))))) (defn winner [hands] (let [best (apply max-key #(best-hand %) hands)] (filter #(= best (best-hand %)) hands))) (defn -main [] (let [players (list ["Player 1" :bankroll 100] ["Player 2" :bankroll 100]) deck (shuffle-deck) hands (deal players deck) [flop deck] (flop deck) [turn deck] (turn deck) [river deck] (river deck) player-hands (map #(conj % flop turn river) hands) winners (winner player-hands)] (println "Winning hand:" (best-hand (first winners))) (doseq [[hand player] (map vector player-hands players)] (println player "has" hand)) (doseq [w winners] (println (first w) "wins!")))) ``` 这个程序实现了一个简单的德州扑克游戏,包括洗牌、发牌、翻牌、转牌、河牌、计算最佳手牌和决定获胜者等功能。你可以在此基础上进行扩展,添加更多的游戏规则和功能。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值