Leetcode - Rummy Card Game

Hard

Jan 13, 2026

#sliding-window

#math

Rummy Card Game

Rummy is a two-player card game played in a series of rounds. At the beginning of each round, each player is dealt a 10-card hand from a 36-card deck.

Each card in the deck is uniquely composed of the following two attributes:

One of 4 “suits” (Spades ‘S’, Hearts ‘H’, Clubs ‘C’, or Diamonds ‘D’) One of 9 “ranks” (the numbers 1-9)

The goal of the game is to group cards into groups (melds) of 3 or more cards of matching rank, which can either be:

“sets”: 3+ cards of the same rank (ex: 9D, 9S, 9C since they all have rank 9)
“runs”: 3+ cards of consecutive values within the same suit. Consecutive values are any values in the sequence of 1,2,3,4,5,6,7,8,9 (ex: 1-2-3-4 is consecutive, 1-2-4-5 is not).

Given an input of a hand of cards with suits and ranks, return all possible sets and runs that could be formed.

Example 1:

Input: cards = ["1C", "9C", "8C", "7C", "5C", "4C", "9D", "9S", "1D", "1H"]
Output: [["1C", "1D", "1H"], ["9C", "9D", "9S"], ["7C", "8C", "9C"]]

Example 2:

Input: ["4C", "2C", "3C", "1C", "8D", "6C", "9D", "9C", "1D", "1H"]
Output: [["1C", "1D", "1H"], ["1C", "2C", "3C"], ["2C", "3C", "4C"], ["1C", "2C", "3C", "4C"]]

Notes

Intuition

Rummy melds are either sets (same rank, different suits) or runs (consecutive ranks, same suit). Group cards by rank and suit separately, then generate all valid combinations.

Implementation

Build two hashmaps: one grouping cards by rank, another by suit. For sets, find ranks with 3+ cards and generate all combinations of size 3, 4, etc. For runs, sort each suit's cards by rank, find consecutive segments, and generate all windows of size 3+ within each segment.

Edge-cases

After processing consecutive cards, there may be a final segment that didn't trigger the flush logic—handle it after the loop.

Time: O(n²) — generating combinations; acceptable for small card counts
Space: O(n²) — storing all possible melds

Complexity

Solution

from typing import List, Tuple
from collections import defaultdict
from itertools import combinations

class Solution:
    def findMelds(self, cards: List[str]) -> List[List[str]]:
        def parseCard(card: str) -> Tuple[int, str]:
            return (int(card[0]), card[1])

        # Group cards by rank and suit
        # Space: O(n) -> all cards are stored
        by_rank = defaultdict(list)
        by_suit = defaultdict(list)
        # Time: O(n)
        for card in cards:
            rank, suit = parseCard(card)
            by_rank[rank].append(card)
            by_suit[suit].append(card)


        result = []

        # Find sets
        for rank in by_rank:
            rank_cards = by_rank[rank]
            # Only care about ranks that have 3 or more cards
            if len(rank_cards) < 3:
                continue
            # Create sets using combinations of 3+ cards
            for n in range(3, len(rank_cards) + 1):
                for combo in combinations(rank_cards, n):
                    result.append(list(combo))
        # Find runs
        for suit in by_suit:
            suit_cards = by_suit[suit]
            # Only care about suits that have 3 or more cards
            if len(suit_cards) < 3:
                continue
            # Sort cards by rank
            ranked = sorted([(parseCard(c)[0], c) for c in suit_cards], key=lambda x: x[0])

            # Build consecutive segments
            segments: List[Tuple[int, str]] = []

            for r, c in ranked:
                if not segments:
                    segments.append((r, c))
                else:
                    prev_r = segments[-1][0]
                    if r == prev_r + 1:
                        segments.append((r, c))
                    else:
                        # Add windows of consecutive segments to result and flush
                        if len(segments) >= 3:
                            seg_cards = [card for _, card in segments]
                            m = len(seg_cards)
                            for i in range(m):
                                for j in range(i + 3, m + 1):
                                    result.append(seg_cards[i:j])
                        segments = [(r, c)]
            # Flush the any remaining segment
            if len(segments) >= 3:
                seg_cards = [card for _, card in segments]
                m = len(seg_cards)
                for i in range(m):
                    for j in range(i + 3, m + 1):
                        result.append(seg_cards[i:j])

        return result

if __name__ == "__main__":
    # Include one-off tests here or debugging logic that can be run by running this file
    # e.g. print(solution.two_sum([1, 2, 3, 4], 3))
    solution = Solution()
    test = ["1C", "9C", "8C", "7C", "5C", "4C", "9D", "9S", "1D", "1H"]
    print(solution.findMelds(test))