Number of Ways to Build House of Cards - Practice Coding Problems

Number of Ways to Build House of Cards - Problem

Imagine you're a master card architect tasked with building intricate houses of cards using exactly n playing cards. But there are specific architectural rules you must follow!

A valid house of cards consists of multiple rows, where each row contains:

Triangles: Formed by leaning two cards against each other (△)
Horizontal cards: Placed between adjacent triangles in the same row for stability

The construction rules are:

Each triangle requires exactly 2 cards
Between every pair of adjacent triangles in a row, you must place 1 horizontal card
Triangles in upper rows must be supported by horizontal cards from the row below
All triangles are placed as far left as possible in each row

For example, a row with 3 triangles needs: 2×3 = 6 cards for triangles + 2 horizontal cards between them = 8 total cards

Goal: Return the number of distinct ways to build a complete house of cards using all n cards. Two houses are different if any row contains a different number of cards.

Input & Output

example_1.py — Basic House

$ Input: n = 2

› Output: 1

💡 Note: With 2 cards, we can only build 1 triangle (1 row with 1 triangle = 2 cards). Only 1 way possible.

example_2.py — Medium House

$ Input: n = 8

› Output: 2

💡 Note: With 8 cards: Way 1: [3 triangles in 1 row] = 8 cards. Way 2: [1 triangle, then 1 triangle] = 2+2 cards (but this violates support rules). Actually: Way 1: [3 triangles] = 8 cards. Way 2: [2 triangles, then 1 triangle] = 5+2 = 7 cards (invalid). Only 1 way: single row with 3 triangles.

example_3.py — Complex House

$ Input: n = 16

› Output: 5

💡 Note: Multiple valid configurations: 1) Single row with many triangles, 2) Two-row configurations, 3) Multi-row pyramids. Each represents a different architectural arrangement.

Constraints

1 ≤ n ≤ 500
n represents the total number of playing cards available
Each triangle requires exactly 2 cards
Each horizontal separator requires exactly 1 card

Visualization

Tap to expand

Understanding the Visualization

Single Triangle

Start with 1 triangle (2 cards) - simplest house

Add Horizontal Card

Add 1 horizontal card to prepare for next triangle

Second Triangle

Add another triangle (2 more cards) = 5 total

Multi-row Option

Alternatively, build second row on top using horizontal cards as base

Key Takeaway

🎯 Key Insight: Each row configuration follows the formula 3k-1 cards for k triangles. Dynamic programming with memoization efficiently counts all valid multi-row combinations.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

This problem is solved optimally using dynamic programming with memoization. The key insight is that a row with k triangles requires exactly 3k-1 cards (2k cards for triangles + (k-1) horizontal cards between them). We recursively try all possible row sizes and use memoization to avoid recalculating the same subproblems, achieving O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Memoized Recursion (Dynamic Programming)	O(n²)	O(n)	Use memoization to cache results and avoid recalculating same subproblems
Recursive Brute Force	O(3^(n/3))	O(n/3)	Try all possible first row sizes and recursively count ways for remaining cards

Memoized Recursion (Dynamic Programming) — Algorithm Steps

Create a memoization cache to store results for each card count
For each recursive call, check if result is already cached
If cached, return stored result immediately
Otherwise, compute result using same logic as brute force
Store result in cache before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

First computation

Calculate result for a specific card count

Store in cache

Save the result in memoization table

Cache hit

When same subproblem appears, return cached result

Avoid recomputation

Skip redundant calculations using stored results

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

static int memo[1001]; // Assuming n <= 1000
static int memo_init = 0;

int dp(int cardsLeft) {
    if (!memo_init) {
        for (int i = 0; i < 1001; i++) memo[i] = -1;
        memo_init = 1;
    }
    
    if (cardsLeft == 0) return 1;
    if (cardsLeft < 0) return 0;
    
    if (memo[cardsLeft] != -1) {
        return memo[cardsLeft];
    }
    
    int ways = 0;
    int triangles = 1;
    while (1) {
        int cardsNeeded = 3 * triangles - 1;
        if (cardsNeeded > cardsLeft) break;
        ways += dp(cardsLeft - cardsNeeded);
        triangles++;
    }
    
    memo[cardsLeft] = ways;
    return ways;
}

int numWaysToTowerOfCards(int n) {
    return dp(n);
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", numWaysToTowerOfCards(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each of n subproblems solved once, each taking O(n) time to try all row sizes

⚠ Quadratic Growth

Space Complexity

O(n)

Memoization cache stores results for up to n different card counts

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Memoized Recursion (Dynamic Programming) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler