Ransom Note - Practice Coding Problems

Ransom Note - Problem

Imagine you're a detective investigating a mysterious ransom note case! 🕵️‍♂️ You have a ransom note written by a kidnapper and a magazine that might have been used to cut out letters.

Your task is to determine if the ransom note could have been constructed using letters from the magazine. The catch? Each letter in the magazine can only be used once - just like cutting out physical letters from a real magazine!

Goal: Return true if the ransom note can be constructed from the magazine letters, false otherwise.

Example: If the ransom note is "aab" and the magazine is "baa", you can construct the note because the magazine contains exactly the letters needed: one 'b' and two 'a's.

Input & Output

example_1.py — Basic Construction

$ Input: ransomNote = "a", magazine = "b"

› Output: false

💡 Note: The magazine doesn't contain the letter 'a', so we cannot construct the ransom note.

example_2.py — Insufficient Characters

$ Input: ransomNote = "aa", magazine = "ab"

› Output: false

💡 Note: We need two 'a's but the magazine only contains one 'a', so construction is impossible.

example_3.py — Successful Construction

$ Input: ransomNote = "aa", magazine = "aab"

› Output: true

💡 Note: The magazine contains exactly what we need: two 'a's (and an extra 'b' we don't need).

Constraints

1 ≤ ransomNote.length ≤ 10⁵
0 ≤ magazine.length ≤ 10⁵
ransomNote and magazine consist of lowercase English letters.
Each letter in magazine can only be used once

Visualization

Tap to expand

Understanding the Visualization

Inventory the Magazine

Count how many of each letter type we have available in the magazine

Check Requirements

Go through each letter needed for the ransom note

Consume Letters

Use up letters from our inventory as we verify the ransom note

Final Verdict

Determine if construction is possible based on letter availability

Key Takeaway

🎯 Key Insight: We only need to count letter frequencies, not their positions! Hash tables provide O(1) lookup time, making this approach optimal for the ransom note problem.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22

The optimal solution uses a hash table to count character frequencies in the magazine, then checks if we have enough characters for the ransom note. This achieves O(n+m) time complexity with O(k) space where k is the number of unique characters. The key insight is that we only need to count frequencies, not worry about character order!

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(m)	For each character in ransom note, scan entire magazine to find and remove it
Two-Pass Hash Table	O(n + m)	O(k)	First count all magazine letters, then check if we have enough for ransom note
One-Pass Hash Table (Optimal)	O(n + m)	O(k)	Count magazine letters and check ransom note requirements in a single optimized pass

Brute Force (Nested Loops) — Algorithm Steps

Convert magazine string to a list so we can mark letters as used
For each character in the ransom note:
Scan through the magazine list to find an unused matching character
If found, mark it as used and continue to next ransom note character
If not found, return false (impossible to construct)
If all characters are found, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first letter

Take first letter 'a' from ransom note

Scan magazine

Search through magazine from beginning to find 'a'

Mark as used

Cross out found letter so it can't be reused

Repeat process

Continue with next ransom note letter

Code -

solution.c — C

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

bool canConstruct(char* ransomNote, char* magazine) {
    int magLen = strlen(magazine);
    char* magCopy = (char*)malloc((magLen + 1) * sizeof(char));
    strcpy(magCopy, magazine);
    
    for (int i = 0; ransomNote[i] != '\0'; i++) {
        bool found = false;
        // Try to find this character in remaining magazine letters
        for (int j = 0; j < magLen; j++) {
            if (magCopy[j] == ransomNote[i]) {
                // Mark as used
                magCopy[j] = '\0';
                found = true;
                break;
            }
        }
        
        if (!found) {
            free(magCopy);
            return false;
        }
    }
    
    free(magCopy);
    return true;
}

int main() {
    char ransomNote[1001], magazine[1001];
    fgets(ransomNote, sizeof(ransomNote), stdin);
    fgets(magazine, sizeof(magazine), stdin);
    
    // Remove newlines and quotes
    ransomNote[strcspn(ransomNote, "\n")] = 0;
    magazine[strcspn(magazine, "\n")] = 0;
    
    printf("%s\n", canConstruct(ransomNote, magazine) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each character in ransom note (n), we might scan the entire magazine (m), giving O(n×m). In worst case, this becomes O(n²)

⚠ Quadratic Growth

Space Complexity

O(m)

We convert the magazine string to a list for modification, requiring O(m) space where m is magazine length

✓ Linear Space

89.5K Views

High Frequency

~15 min Avg. Time

2.8K 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler