Loading…

easyStringsSometimes asked

Sparse Arrays

Q: How do you solve Sparse Arrays using the Brute Force — Re-scan Strings Per Query approach?

When to use it: Mention it to establish correctness, then point out the redundant rescanning that the map removes. For each query, loop over every input string and increment a counter when they match exactly. **Why it's the natural first attempt.** It mirrors the question directly: 'how many times does this query appear?' becomes 'count the strings equal to this query'. No data structures, just two loops. **Where the waste is.** The strings list never changes between queries, yet we walk all of it again for each one. With `n` strings and `q` queries that's `n·q` string comparisons. For the constraints (both up to 1000) that's a million comparisons — survivable here, but the moment either grows, it balloons. More importantly, it signals you didn't spot the reuse. **The fix in one sentence.** Summarize the unchanging strings list *once* into a count table, then each query reads the table in constant time. Time complexity: O(n·q). Space complexity: O(1).

Q: How do you solve Sparse Arrays using the Frequency Map — Precompute Counts (Optimal) approach?

When to use it: The intended answer: one pass to count, then O(1) per query. Make a single pass over the input strings, tallying each into a hash map keyed by the string. Then answer every query with one map lookup. **Why one pass beats many.** Every query asks the same kind of question — 'how many copies of this exact string exist?' — about the *same* unchanging collection. So compute all those counts once: a map from string to its occurrence count. After that, the strings list is never touched again. **Why the default-zero lookup matters.** A query like `'ab'` may never appear in the strings. The map simply has no key for it. Reading a missing key naively returns `null` (Java) or raises `KeyError` (Python). Using `getOrDefault(query, 0)` / `freq.get(query, 0)` returns `0` cleanly — which is exactly the count of a string that never occurs. **Why this is exact-match by construction.** The map key is the *whole* string. Two strings collide in the same bucket only if they're equal, so `'abc'` and `'ab'` are distinct keys and never cross-count. No extra logic needed to enforce exact matching — the data structure does it. **Why it scales.** Preprocessing is `O(n)`, each query is `O(1)` average, so `q` queries cost `O(q)`. Compared to the brute force's `O(n·q)`, the saving grows with the number of queries — which is the whole point when many queries hit one dataset. Time complexity: O(n + q). Space complexity: O(n).

Arrays & Hashing · 54 of 83 · 6 min

There is a collection of input strings and a collection of query strings. For each query string, determine how many times it occurs in the list of input strings. Return the counts in the same order as the queries.

In plain English

You have a fixed bag of strings and a separate list of query strings. For each query you report its exact-match occurrence count in the bag. Multiple queries hit the same bag, so it pays to summarize the bag once into counts and then look up each query.

Examples

Example 1

Input: strings = ['aba','baba','aba','xzxb'], queries = ['aba','xzxb','ab']
Output: [2, 1, 0]
Note: 'aba' appears twice, 'xzxb' once, 'ab' never (it's a substring of others but not an exact match).

Example 2

Input: strings = ['def','de','fgh'], queries = ['de','lmn','fgh']
Output: [1, 0, 1]
Note: 'de' once, 'lmn' absent → 0, 'fgh' once.

Constraints

1 ≤ n ≤ 1000 (number of strings)
1 ≤ q ≤ 1000 (number of queries)
1 ≤ length of each string/query ≤ 20
All strings consist of lowercase English letters

Clarifying questions4First question: Is the match exact or a substring/prefix?Explore questions

Q1.Is the match exact or a substring/prefix?
Exact full-string match. 'abc' does not count toward a query of 'ab'.
Q2.What do I return for a query that never appears?
0. Use a default-zero lookup so absent keys don't blow up.
Q3.Is the matching case-sensitive?
Yes — treat strings exactly as given. The constraints here are all lowercase anyway.
Q4.Must the output order match the query order?
Yes. The i-th number answers the i-th query.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Given a list of strings and a list of queries, return for each query how many times it appears in the strings. Don't re-scan all strings per query — that's O(n·q). Build a frequency map (string → count) in one pass over the strings, then answer each query with an O(1) lookup, defaulting to 0 for misses. Total O(n + q).

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you avoid the naive nested scan and instead precompute counts so repeated queries are cheap — the core 'amortize work into a hash map' instinct.

Where candidates slip

Looping over every string for every query (O(n·q)), or returning null/None for a query that never appears instead of 0.

How to stand out

Say 'I'll trade O(n) preprocessing for O(1) per query' before coding, and note the exact-match requirement so the interviewer knows you won't accidentally do substring matching.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Brute Force — Re-scan Strings Per Query	`O(n·q)`	`O(1)`	Mention it to establish correctness, then point out the redundant rescanning that the map removes.	Read
2	Frequency Map — Precompute Counts (Optimal)Optimal	`O(n + q)`	`O(n)`	The intended answer: one pass to count, then O(1) per query.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewstrings[]in map?YesNoExplore the full tree

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Brute Force — Re-scan Strings Per Query

TimeO(n·q)SpaceO(1)

Mention it to establish correctness, then point out the redundant rescanning that the map removes.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The literal approach: for each query, walk the whole strings list and count exact matches.

2Hint 2Explore hint

How many total comparisons is that across q queries and n strings?

3Hint 3Explore hint

Notice you rescan the same unchanged strings list for every query. Can you summarize it once instead?

A · Core idea

For each query, loop over every input string and increment a counter when they match exactly.

Why it's the natural first attempt. It mirrors the question directly: 'how many times does this query appear?' becomes 'count the strings equal to this query'. No data structures, just two loops.

Where the waste is. The strings list never changes between queries, yet we walk all of it again for each one. With n strings and q queries that's n·q string comparisons. For the constraints (both up to 1000) that's a million comparisons — survivable here, but the moment either grows, it balloons. More importantly, it signals you didn't spot the reuse.

The fix in one sentence. Summarize the unchanging strings list once into a count table, then each query reads the table in constant time.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

strings = ['aba','baba','aba','xzxb'], queries = ['aba','xzxb','ab']

Array state

query 'aba'

scan all 4 strings

aba

[0]

baba

[1]

aba

[2]

xzxb

[3]

Current pointerResolved stateNot processed

Final result[2, 1, 0]

C · Code with teaching comments

Reference implementation previewpublic int[] matchingStrings(String[] strings, String[] queries) { int[] result = new int[queries.length]; for (int i = 0; i < queries.length; i++) { int count = 0; for (String s : strings) {Explore the full code

solution.javaJava

Brute Force — Re-scan Strings Per Query — reference

2 teaching notes

1
public int[] matchingStrings(String[] strings, String[] queries) {
2
    int[] result = new int[queries.length];
3
    for (int i = 0; i < queries.length; i++) {
4
        int count = 0;
5
        for (String s : strings) {
6
            // Exact-string equality — never use == on String objects in Java, that
7
            // compares references.
8
            if (s.equals(queries[i])) {
9
                count++;
10
            }
11
        }
12
        // Store in query order so output index matches query index.
13
        result[i] = count;
14
    }
15
    return result;
16
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.16 lines

D · Why it works and complexityO(n·q) timeO(1) spaceOpen the invariant and proofExplore the proof

The strings list is read-only across all queries — anything you recompute per query that doesn't depend on the query is wasted work. That observation is the whole reason to precompute.

ComplexityO(n·q) time, O(1) space — q queries × n strings (× up to 20 chars per compare) = O(n·q) comparisons; nothing is reused between queries.

E · Edge cases and pitfalls5query not present — Inner loop finds no match → 0.Explore edge cases

Edge cases handled

query not presentInner loop finds no match → 0.
duplicate stringsEach occurrence increments the count, so duplicates are counted fully.

Pitfalls

Using == instead of .equals in Java — compares references, not contents.
Doing substring matching (contains) instead of exact equality.
Rescanning the unchanged list for every query when one pass would suffice.

03.2

Approach 2 of 2 · Optimal

Frequency Map — Precompute Counts (Optimal)

TimeO(n + q)SpaceO(n)

The intended answer: one pass to count, then O(1) per query.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

What structure lets you ask 'how many of this exact string?' in O(1) after a single pass?

2Hint 2Explore hint

Walk strings once, incrementing a map keyed by the string. Then each query is a lookup.

3Hint 3Explore hint

For a query missing from the map, the answer is 0 — use a default-zero accessor.

A · Core idea

Make a single pass over the input strings, tallying each into a hash map keyed by the string. Then answer every query with one map lookup.

Why one pass beats many. Every query asks the same kind of question — 'how many copies of this exact string exist?' — about the same unchanging collection. So compute all those counts once: a map from string to its occurrence count. After that, the strings list is never touched again.

Why the default-zero lookup matters. A query like 'ab' may never appear in the strings. The map simply has no key for it. Reading a missing key naively returns null (Java) or raises KeyError (Python). Using getOrDefault(query, 0) / freq.get(query, 0) returns 0 cleanly — which is exactly the count of a string that never occurs.

Why this is exact-match by construction. The map key is the whole string. Two strings collide in the same bucket only if they're equal, so 'abc' and 'ab' are distinct keys and never cross-count. No extra logic needed to enforce exact matching — the data structure does it.

Why it scales. Preprocessing is O(n), each query is O(1) average, so q queries cost O(q). Compared to the brute force's O(n·q), the saving grows with the number of queries — which is the whole point when many queries hit one dataset.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

strings = ['aba','baba','aba','xzxb'], queries = ['aba','xzxb','ab']

Hash-map state

after 'aba','baba','aba'

ValueIndex / state

aba→ 2

baba→ 1

Continue scanning

counts accumulate

Final result[2, 1, 0]

C · Code with teaching comments

solution.javaJava

Frequency Map — Precompute Counts (Optimal) — optimal

2 teaching notes

1
public int[] matchingStrings(String[] strings, String[] queries) {
2
    Map<String, Integer> freq = new HashMap<>();
3
    for (String s : strings) {
4
        // Insert s with count 1, or add 1 to its existing count — one-liner for a
5
        // frequency tally.
6
        freq.merge(s, 1, Integer::sum);
7
    }
8
    int[] result = new int[queries.length];
9
    for (int i = 0; i < queries.length; i++) {
10
        // Absent queries default to 0 instead of throwing on a null Integer.
11
        result[i] = freq.getOrDefault(queries[i], 0);
12
    }
13
    return result;
14
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.14 lines

D · Why it works and complexityO(n + q) timeO(n) spaceOpen the invariant and proofExplore the proof

Counting occurrences is the textbook hash-map-of-counts pattern. The mental move is 'separate the query-independent work (counting) from the per-query work (lookup)'. Do the expensive part once. The same shape powers anagram grouping, mode finding, and 'first unique character'.

ComplexityO(n + q) time, O(n) space — Building the map is one pass over n strings: O(n). Each of q queries is an O(1) average lookup: O(q). Total O(n + q); the map holds up to n distinct keys → O(n) space.

E · Edge cases and pitfalls5query equal to a substring of a string — No match — keys are whole strings, so 'ab' ≠ 'aba'.Explore edge cases

Edge cases handled

query equal to a substring of a stringNo match — keys are whole strings, so 'ab' ≠ 'aba'.
all queries identicalEach does the same O(1) lookup; the map is built only once.

Pitfalls

Returning null/None for an absent query instead of 0.
Building the map inside the query loop, reintroducing O(n·q).
Keying on something other than the whole string and accidentally matching substrings.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int[] matchingStrings(String[] strings, String[] queries) { Map<String, Integer> freq = new HashMap<>(); for (String s : strings) { freq.merge(s, 1, Integer::sum); }Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Reference equality in Java

`==` compares object references; two equal strings can be different objects and the count silently stays 0.

Explore the code comparison

Don't write this

if (s == queries[i]) {
    count++;
}

Write this instead

if (s.equals(queries[i])) {
    count++;
}

Crashing on absent queries

A query not in the map has no entry; a plain get returns null (Java) or raises KeyError (Python).

Explore the code comparison

Don't write this

result.append(freq[query])  # KeyError when query absent

Write this instead

result.append(freq.get(query, 0))

Rebuilding the map per query

Constructing the frequency map inside the query loop throws away the whole benefit and is back to O(n·q).

Explore the code comparison

Don't write this

for query in queries:
    freq = {}
    for s in strings:
        freq[s] = freq.get(s, 0) + 1
    result.append(freq.get(query, 0))

Write this instead

freq = {}
for s in strings:
    freq[s] = freq.get(s, 0) + 1
result = [freq.get(q, 0) for q in queries]

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Precompute a frequency map, then O(1) lookups

Code pattern to memorize

freq = {}
for s in strings: freq[s] = freq.get(s, 0) + 1
result = [freq.get(query, 0) for query in queries]

Rules to remember

1Count exact string matches — 'ab' and 'abc' are different keys, no prefix or substring logic.
2Build the map once over strings, then each query is a single O(1) lookup.
3A query absent from the map must return 0, not null/None — use getOrDefault / dict.get(q, 0).
4Preserve query order in the output: the i-th answer corresponds to the i-th query.
5Strings are case-sensitive and matched in full; don't trim or lowercase unless the prompt says so.

Use this pattern when

Repeated 'how many times does X appear?' questions over a fixed collection
Many lookups against the same dataset — amortize the scan once
Exact-match counting where a hash map's O(1) average lookup fits

Choose another pattern when

Queries are substring or prefix matches → trie or suffix structure, not a flat frequency map
The collection changes between queries → you'd rebuild or maintain incrementally
You need ranking by frequency, not point lookups → heap or sorted counts

Interview takeaway

When the same dataset is queried many times for exact-match counts, pay O(n) once to build a frequency map, then every query is O(1). The whole skill is recognizing 'count occurrences' equals 'hash map of counts'.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternPrecompute a frequency map, then O(1) lookups. When many exact-match count queries hit one fixed dataset, summarize it once (O(n)) and answer each query in O(1). The hash key being the whole string enforces exact matching for free.

Practice queueDirect variations and pattern siblings

Direct follow-ups

First Unique Character
Same frequency-map pass, then scan for the first count of 1.
Group Anagrams
Map a canonical key (sorted letters) to a bucket of strings.
Frequency Queries
Coming soon
Maintain a value→count map plus a count→how-many map for live add/remove/has-frequency queries.

Same pattern

←

Pangrams

Continue · Next problem

Closest Numbers

easyStringsSometimes asked

Sparse Arrays

Arrays & Hashing · 54 of 83 · 6 min

In plain English

Examples

Example 1

Input: strings = ['aba','baba','aba','xzxb'], queries = ['aba','xzxb','ab']
Output: [2, 1, 0]
Note: 'aba' appears twice, 'xzxb' once, 'ab' never (it's a substring of others but not an exact match).

Example 2

Input: strings = ['def','de','fgh'], queries = ['de','lmn','fgh']
Output: [1, 0, 1]
Note: 'de' once, 'lmn' absent → 0, 'fgh' once.

Constraints

1 ≤ n ≤ 1000 (number of strings)
1 ≤ q ≤ 1000 (number of queries)
1 ≤ length of each string/query ≤ 20
All strings consist of lowercase English letters

Clarifying questions4First question: Is the match exact or a substring/prefix?Explore questions

Q1.Is the match exact or a substring/prefix?
Exact full-string match. 'abc' does not count toward a query of 'ab'.
Q2.What do I return for a query that never appears?
0. Use a default-zero lookup so absent keys don't blow up.
Q3.Is the matching case-sensitive?
Yes — treat strings exactly as given. The constraints here are all lowercase anyway.
Q4.Must the output order match the query order?
Yes. The i-th number answers the i-th query.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you avoid the naive nested scan and instead precompute counts so repeated queries are cheap — the core 'amortize work into a hash map' instinct.

Where candidates slip

Looping over every string for every query (O(n·q)), or returning null/None for a query that never appears instead of 0.

How to stand out

Say 'I'll trade O(n) preprocessing for O(1) per query' before coding, and note the exact-match requirement so the interviewer knows you won't accidentally do substring matching.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Brute Force — Re-scan Strings Per Query	`O(n·q)`	`O(1)`	Mention it to establish correctness, then point out the redundant rescanning that the map removes.	Read
2	Frequency Map — Precompute Counts (Optimal)Optimal	`O(n + q)`	`O(n)`	The intended answer: one pass to count, then O(1) per query.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewstrings[]in map?YesNoExplore the full tree

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Brute Force — Re-scan Strings Per Query

TimeO(n·q)SpaceO(1)

Mention it to establish correctness, then point out the redundant rescanning that the map removes.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The literal approach: for each query, walk the whole strings list and count exact matches.

2Hint 2Explore hint

How many total comparisons is that across q queries and n strings?

3Hint 3Explore hint

Notice you rescan the same unchanged strings list for every query. Can you summarize it once instead?

A · Core idea

For each query, loop over every input string and increment a counter when they match exactly.

Why it's the natural first attempt. It mirrors the question directly: 'how many times does this query appear?' becomes 'count the strings equal to this query'. No data structures, just two loops.

The fix in one sentence. Summarize the unchanging strings list once into a count table, then each query reads the table in constant time.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

strings = ['aba','baba','aba','xzxb'], queries = ['aba','xzxb','ab']

Array state

query 'aba'

scan all 4 strings

aba

[0]

baba

[1]

aba

[2]

xzxb

[3]

Current pointerResolved stateNot processed

Final result[2, 1, 0]

C · Code with teaching comments

solution.javaJava

Brute Force — Re-scan Strings Per Query — reference

2 teaching notes

1
public int[] matchingStrings(String[] strings, String[] queries) {
2
    int[] result = new int[queries.length];
3
    for (int i = 0; i < queries.length; i++) {
4
        int count = 0;
5
        for (String s : strings) {
6
            // Exact-string equality — never use == on String objects in Java, that
7
            // compares references.
8
            if (s.equals(queries[i])) {
9
                count++;
10
            }
11
        }
12
        // Store in query order so output index matches query index.
13
        result[i] = count;
14
    }
15
    return result;
16
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.16 lines

D · Why it works and complexityO(n·q) timeO(1) spaceOpen the invariant and proofExplore the proof

The strings list is read-only across all queries — anything you recompute per query that doesn't depend on the query is wasted work. That observation is the whole reason to precompute.

ComplexityO(n·q) time, O(1) space — q queries × n strings (× up to 20 chars per compare) = O(n·q) comparisons; nothing is reused between queries.

E · Edge cases and pitfalls5query not present — Inner loop finds no match → 0.Explore edge cases

Edge cases handled

query not presentInner loop finds no match → 0.
duplicate stringsEach occurrence increments the count, so duplicates are counted fully.

Pitfalls

Using == instead of .equals in Java — compares references, not contents.
Doing substring matching (contains) instead of exact equality.
Rescanning the unchanged list for every query when one pass would suffice.

03.2

Approach 2 of 2 · Optimal

Frequency Map — Precompute Counts (Optimal)

TimeO(n + q)SpaceO(n)

The intended answer: one pass to count, then O(1) per query.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

What structure lets you ask 'how many of this exact string?' in O(1) after a single pass?

2Hint 2Explore hint

Walk strings once, incrementing a map keyed by the string. Then each query is a lookup.

3Hint 3Explore hint

For a query missing from the map, the answer is 0 — use a default-zero accessor.

A · Core idea

Make a single pass over the input strings, tallying each into a hash map keyed by the string. Then answer every query with one map lookup.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

strings = ['aba','baba','aba','xzxb'], queries = ['aba','xzxb','ab']

Hash-map state

after 'aba','baba','aba'

ValueIndex / state

aba→ 2

baba→ 1

Continue scanning

counts accumulate

Final result[2, 1, 0]

C · Code with teaching comments

solution.javaJava

Frequency Map — Precompute Counts (Optimal) — optimal

2 teaching notes

1
public int[] matchingStrings(String[] strings, String[] queries) {
2
    Map<String, Integer> freq = new HashMap<>();
3
    for (String s : strings) {
4
        // Insert s with count 1, or add 1 to its existing count — one-liner for a
5
        // frequency tally.
6
        freq.merge(s, 1, Integer::sum);
7
    }
8
    int[] result = new int[queries.length];
9
    for (int i = 0; i < queries.length; i++) {
10
        // Absent queries default to 0 instead of throwing on a null Integer.
11
        result[i] = freq.getOrDefault(queries[i], 0);
12
    }
13
    return result;
14
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.14 lines

D · Why it works and complexityO(n + q) timeO(n) spaceOpen the invariant and proofExplore the proof

E · Edge cases and pitfalls5query equal to a substring of a string — No match — keys are whole strings, so 'ab' ≠ 'aba'.Explore edge cases

Edge cases handled

query equal to a substring of a stringNo match — keys are whole strings, so 'ab' ≠ 'aba'.
all queries identicalEach does the same O(1) lookup; the map is built only once.

Pitfalls

Returning null/None for an absent query instead of 0.
Building the map inside the query loop, reintroducing O(n·q).
Keying on something other than the whole string and accidentally matching substrings.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Reference equality in Java

`==` compares object references; two equal strings can be different objects and the count silently stays 0.

Explore the code comparison

Don't write this

if (s == queries[i]) {
    count++;
}

Write this instead

if (s.equals(queries[i])) {
    count++;
}

Crashing on absent queries

A query not in the map has no entry; a plain get returns null (Java) or raises KeyError (Python).

Explore the code comparison

Don't write this

result.append(freq[query])  # KeyError when query absent

Write this instead

result.append(freq.get(query, 0))

Rebuilding the map per query

Constructing the frequency map inside the query loop throws away the whole benefit and is back to O(n·q).

Explore the code comparison

Don't write this

for query in queries:
    freq = {}
    for s in strings:
        freq[s] = freq.get(s, 0) + 1
    result.append(freq.get(query, 0))

Write this instead

freq = {}
for s in strings:
    freq[s] = freq.get(s, 0) + 1
result = [freq.get(q, 0) for q in queries]

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Precompute a frequency map, then O(1) lookups

Code pattern to memorize

freq = {}
for s in strings: freq[s] = freq.get(s, 0) + 1
result = [freq.get(query, 0) for query in queries]

Rules to remember

1Count exact string matches — 'ab' and 'abc' are different keys, no prefix or substring logic.
2Build the map once over strings, then each query is a single O(1) lookup.
3A query absent from the map must return 0, not null/None — use getOrDefault / dict.get(q, 0).
4Preserve query order in the output: the i-th answer corresponds to the i-th query.
5Strings are case-sensitive and matched in full; don't trim or lowercase unless the prompt says so.

Use this pattern when

Repeated 'how many times does X appear?' questions over a fixed collection
Many lookups against the same dataset — amortize the scan once
Exact-match counting where a hash map's O(1) average lookup fits

Choose another pattern when

Queries are substring or prefix matches → trie or suffix structure, not a flat frequency map
The collection changes between queries → you'd rebuild or maintain incrementally
You need ranking by frequency, not point lookups → heap or sorted counts

Interview takeaway

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Practice queueDirect variations and pattern siblings

Direct follow-ups

First Unique Character
Same frequency-map pass, then scan for the first count of 1.
Group Anagrams
Map a canonical key (sorted letters) to a bucket of strings.
Frequency Queries
Coming soon
Maintain a value→count map plus a count→how-many map for live add/remove/has-frequency queries.

Same pattern

←

Pangrams

Continue · Next problem

Closest Numbers