Maximum Number of Balloons - Practice Coding Problems

Maximum Number of Balloons - Problem

Imagine you're organizing a birthday party and want to spell out the word "balloon" using alphabet magnets. You have a collection of letter magnets represented by a string text, where each character can only be used once.

Your goal is to determine the maximum number of complete instances of the word "balloon" you can form using the available letters.

Example: If you have the letters "nlaebolko", you can form exactly 1 instance of "balloon" because you have all the required letters: b(1), a(1), l(2), o(2), n(1).

Note: The word "balloon" requires: 1 'b', 1 'a', 2 'l's, 2 'o's, and 1 'n'.

Input & Output

example_1.py — Basic Case

$ Input: text = "nlaebolko"

› Output: 1

💡 Note: The string contains exactly the letters needed for one "balloon": b(1), a(1), l(2), o(2), n(1). We can form exactly 1 complete instance.

example_2.py — Multiple Balloons

$ Input: text = "loonbalxballpoon"

› Output: 2

💡 Note: We have b(2), a(2), l(4), o(4), n(2). The limiting factors are b, a, and n with 2 each. We can form min(2,2,4//2,4//2,2) = 2 balloons.

example_3.py — Insufficient Letters

$ Input: text = "leetcode"

› Output: 0

💡 Note: The string doesn't contain the required letters for "balloon" (missing b, a, n). We cannot form any complete instance.

Visualization

Tap to expand

Understanding the Visualization

Inventory Check

Count all your available letter magnets: separate them into piles by letter type

Requirement Analysis

Remember that BALLOON needs: 1×B, 1×A, 2×L, 2×O, 1×N

Calculate Capacity

For each letter type, determine how many complete balloon words it can support

Find the Bottleneck

The letter type with the smallest capacity determines your maximum balloon count

Form Complete Words

Use the bottleneck number to form that many complete BALLOON words

Key Takeaway

🎯 Key Insight: The limiting character (considering required quantities) determines the maximum number of complete words. Count once, calculate ratios, find the minimum!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count characters, plus constant time to calculate result

✓ Linear Growth

Space Complexity

O(1)

Only need to store counts for 5 specific characters (b,a,l,o,n), regardless of input size

✓ Linear Space

Constraints

1 ≤ text.length ≤ 10⁴
text consists of lowercase English letters only
Each character in text can be used at most once

Asked in

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

The optimal solution uses a hash table to count character frequencies in one pass, then calculates the maximum balloons by finding the limiting character. Since 'balloon' requires specific quantities (b:1, a:1, l:2, o:2, n:1), we take the minimum of count['b'], count['a'], count['l']//2, count['o']//2, and count['n']. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character Removal)	O(n²)	O(n)	Try to form balloon words one by one, removing used characters each time
One-Pass Hash Table (Optimal)	O(n)	O(1)	Count all characters once, then calculate maximum balloons using the minimum ratio

Brute Force (Character Removal) — Algorithm Steps

Initialize a counter for balloon instances
Convert the input string to a mutable list
For each balloon attempt, try to find and remove: b, a, l, l, o, o, n
If all required characters are found and removed, increment counter
Continue until unable to form another complete balloon
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the input string 'nlaebolko'

Search for 'b'

Find and mark 'b' at position 4

Search for 'a'

Find and mark 'a' at position 2

Search for 'l'

Find and mark first 'l' at position 1

Search for second 'l'

Find and mark second 'l' at position 5

Complete balloon

Found all characters, form one balloon word

Code -

solution.c — C

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

int maxNumberOfBalloons(char* text) {
    int len = strlen(text);
    char* chars = malloc((len + 1) * sizeof(char));
    strcpy(chars, text);
    int currentLen = len;
    int balloonCount = 0;
    
    while (1) {
        char target[] = "balloon";
        int targetCount[] = {1, 1, 2, 2, 1}; // b, a, l, o, n
        char targetChars[] = "balon";
        int foundIndices[7];
        int foundCount = 0;
        
        for (int t = 0; t < 5; t++) {
            for (int count = 0; count < targetCount[t]; count++) {
                int found = 0;
                for (int i = 0; i < currentLen; i++) {
                    if (chars[i] == targetChars[t]) {
                        foundIndices[foundCount++] = i;
                        chars[i] = '*'; // Mark as used
                        found = 1;
                        break;
                    }
                }
                if (!found) {
                    free(chars);
                    return balloonCount;
                }
            }
        }
        
        // Remove marked characters
        int writeIdx = 0;
        for (int i = 0; i < currentLen; i++) {
            if (chars[i] != '*') {
                chars[writeIdx++] = chars[i];
            }
        }
        currentLen = writeIdx;
        chars[currentLen] = '\0';
        balloonCount++;
    }
    
    free(chars);
    return balloonCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, for each balloon formation attempt (up to n/7 attempts), we scan the entire string

⚠ Quadratic Growth

Space Complexity

O(n)

We create a mutable copy of the input string to track used characters

⚡ Linearithmic Space

Constraints

1 ≤ text.length ≤ 10⁴
text consists of lowercase English letters only
Each character in text can be used at most once

28.5K Views

Medium Frequency

~12 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Character Removal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler