Card Game Gem Affordability and Discount Calculation Functions

Your task is to build a small system that lets a player buy cards by spending colored gems.

There are exactly five gem colors: BLUE, WHITE, GREEN, RED, and YELLOW.

A Card carries two pieces of data:

• color: the color the card itself belongs to.
• cost[color]: the number of gems of each color needed to acquire it. Any color not listed counts as 0.

A Player carries:

• gems[color]: how many gems of each color the player currently holds. Any color not listed counts as 0.
• hand: the list of cards the player already owns.

Requirement 1: canPurchase

Write canPurchase(player, card). It returns true when the player holds enough gems to cover what the card costs, and false when they do not.

Requirement 2: purchase

Write purchase(player, card).

• When the player is able to afford the card, it must:
  1. Subtract the gems that the card requires from player.gems.
  2. Append the card to player.hand.
  3. Return true.
• When the player cannot afford it, leave the player's state completely untouched and return false.

Requirement 3: Discounts

Extend the system so that cards already in the player's hand make new cards cheaper.

• For each color, the discount equals the count of cards of that color currently in hand.
• When a new card is bought, the discount is applied color by color to its cost:
  • $pay[color] = \max(cost[color] - discount[color],\ 0)$
• A purchase is possible only if, for every color, the player has at least $pay[color]$ gems.

For instance, suppose the hand contains 2 WHITE cards and 1 RED card. Then discount[WHITE]=2 and discount[RED]=1. Buying a card whose cost is WHITE=4, RED=1 requires paying WHITE=max(4-2,0)=2 and RED=max(1-1,0)=0, i.e. 2 WHITE gems in total.

I/O Contract

Provide two functions (or equivalent methods):

• canPurchase(player, card) -> bool
• purchase(player, card) -> bool

Both player.gems and player.hand must be kept in a correct state across calls.

Example 1:

Input:
(conceptual)
Player gems: {RED:5}
Hand: []
Card: color=RED cost={RED:2}
Call: purchase

Output: true (after: RED=3, hand size +1)

Explanation: The player holds 5 RED gems, which covers the cost of 2, so the purchase succeeds, leaving 3 RED gems and one more card in hand.

Test Cases

1. Basic affordable

   • Player gems: RED=5, hand empty
   • Card cost: RED=2
   • purchase=true; afterwards RED=3, hand grows by 1

2. Basic not affordable

   • Player gems: GREEN=1
   • Card cost: GREEN=2
   • canPurchase=false, purchase=false; state is unchanged

3. Affordable due to discount

   • Player gems: WHITE=2
   • Hand: two WHITE cards (discount[WHITE]=2)
   • Card cost: WHITE=4
   • Pay WHITE=2; purchase=true; afterwards WHITE=0

4. Discount can reduce cost to zero

   • Player gems: RED=0
   • Hand: three RED cards (discount[RED]=3)
   • Card cost: RED=2
   • Pay RED=0; purchase=true; afterwards RED=0

5. Multi-color discounts

   • Player gems: WHITE=2, RED=0
   • Hand: two WHITE cards and one RED card
   • Card cost: WHITE=4, RED=1
   • Pay WHITE=2, RED=0; purchase=true

Constraints:

• The number of colors is fixed at 5.
• gems[color] and cost[color] are non-negative integers and may be as large as $10^9$ (range $0 \sim 10^9$).
• hand may be large, yet every purchase check must run in $O(\#colors)$ time.