Loading…

easyArraysFrequently asked

Ice Cream Parlor

Q: How do you solve Ice Cream Parlor using the Brute Force — Nested Pair Scan approach?

When to use it: Open with this to pin down the 1-indexed output, then optimize. Try all distinct position pairs and return the first whose prices sum to `money`. The inner loop begins at `i + 1`, so each pair is examined once and no flavor is paired with itself. **Why +1 on the result.** Flavor ids are 1-based positions, so indices `i` and `j` become ids `i + 1` and `j + 1`. With `i < j`, the ids are already in increasing order. **Why it's only a starting point.** For up to 50 trips of `n = 10⁴` flavors the quadratic scan passes, but it tells the interviewer you didn't reach for the hash map. State it, then improve. Time complexity: O(n²). Space complexity: O(1).

Q: How do you solve Ice Cream Parlor using the Complement Hash Map — One Pass (Optimal) approach?

When to use it: The answer they want — recognize Two Sum and do one pass. Walk the cost list once. For flavor `i` priced `cost[i]`, the complement `money − cost[i]` is the unique partner price. A hash map of previously seen prices answers 'have I seen that price?' in O(1). **Look up before inserting.** Querying the complement before recording the current price keeps the two matched flavors at different indices — no flavor can complete the purchase by pairing with itself. cost = [2, 2], money = 4 works precisely because the first 2 is stored before the second 2 queries it. **Sorted ids for free.** A found complement was stored at an earlier index, so returning `[seen[need] + 1, i + 1]` lists the smaller id first. **The 1-indexing.** Indices are 0-based during iteration but ids are 1-based, so add 1 on return. Dropping that `+1` is the single most common bug here. With one guaranteed pair, return on the first match. Time complexity: O(n). Space complexity: O(n).

Arrays & Hashing · 74 of 83 · 8 min

On a trip to the Ice Cream Parlor, you have a fixed amount of money and a list of flavor costs. A flavor's id is its 1-based index in the list. Choose two distinct flavors whose costs sum to exactly money and return their ids in increasing order.

Exactly one valid pair exists for each trip.

In plain English

Locate the two distinct positions whose prices add to `money` and report their **1-based** ids in increasing order. Repeated prices are fine — two equally priced flavors at different positions form a valid pair. The output is ids, never prices.

Examples

Example 1

Input: money = 5, cost = [2, 1, 3, 5, 6]
Output: 1 3
Note: cost[0]=2 and cost[2]=3 sum to 5 → ids 1 and 3.

Example 2

Input: money = 4, cost = [2, 2, 4, 3]
Output: 1 2
Note: cost[0]=2 and cost[1]=2 sum to 4 → ids 1 and 2.

Example 3

Input: money = 6, cost = [1, 4, 5, 3, 2]
Output: 1 3
Note: cost[0]=1 and cost[2]=5 sum to 6 → ids 1 and 3. The 1 is recorded first, so its complement 5 is matched at the earlier id.

Constraints

1 ≤ number of trips ≤ 50
2 ≤ n ≤ 10⁴ (flavors per trip)
2 ≤ money ≤ 10⁵
1 ≤ cost[i] ≤ 10⁴, with exactly one valid pair

Clarifying questions4First question: Are ids 0-based or 1-based?Explore questions

Q1.Are ids 0-based or 1-based?
1-based. Position 0 in the array is flavor id 1, so the returned ids are indices plus one.
Q2.Can two flavors cost the same?
Yes. cost = [2, 2, 4], money = 4 returns ids 1 and 2. Check-before-insert handles this.
Q3.Is the cost list sorted?
Not necessarily. The hash map works on unsorted input in one pass; sorting would enable a two-pointer alternative.
Q4.Always exactly one solution?
Yes, so we can return as soon as the first complement is found.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Spend exactly `money` on two distinct flavors. Flavor ids are **1-based** positions in the `cost` array. One pass with a complement map: for each price `cost[i]`, if `money − cost[i]` was already seen, return `[seenIndex + 1, i + 1]`. Check the complement before inserting so a flavor never pairs with itself, and add 1 to each index to convert to a flavor id.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you see Two Sum behind the narrative and produce the 1-indexed ids without off-by-one slips.

Where candidates slip

Returning 0-based indices or prices, inserting before checking (self-pairing), or scanning the whole list per element instead of using a map.

How to stand out

Call it Two Sum up front, flag the +1 conversion as the only real difference, and note the result is sorted because the earlier index is returned first.

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 — Nested Pair Scan	`O(n²)`	`O(1)`	Open with this to pin down the 1-indexed output, then optimize.	Read
2	Complement Hash Map — One Pass (Optimal)Optimal	`O(n)`	`O(n)`	The answer they want — recognize Two Sum and do one pass.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewScan cost[i]need already seen?YesNoExplore the full tree

Two Sum behind the story

How to read it:Find the complement price, then report 1-based ids.

Rendering diagram…

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 — Nested Pair Scan

TimeO(n²)SpaceO(1)

Open with this to pin down the 1-indexed output, then optimize.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Exactly one pair sums to money — what's the most direct way to find it?

2Hint 2Explore hint

Try every pair (i, j) with j > i and check cost[i] + cost[j] == money.

3Hint 3Explore hint

Return ids i+1 and j+1 on the first match.

A · Core idea

Try all distinct position pairs and return the first whose prices sum to money. The inner loop begins at i + 1, so each pair is examined once and no flavor is paired with itself.

Why +1 on the result. Flavor ids are 1-based positions, so indices i and j become ids i + 1 and j + 1. With i < j, the ids are already in increasing order.

Why it's only a starting point. For up to 50 trips of n = 10⁴ flavors the quadratic scan passes, but it tells the interviewer you didn't reach for the hash map. State it, then improve.

B · Visual dry run

Interactive dry run

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

money = 5, cost = [2, 1, 3, 5, 6]

Array state

i=0,j=2

2 + 3 = 5 → ids 1 and 3

i ↓

[0]

[1]

j ↓

[2]

[3]

[4]

Current pointerResolved stateNot processed

Final result1 3

C · Code with teaching comments

Reference implementation previewpublic int[] whatFlavors(int[] cost, int money) { for (int i = 0; i < cost.length; i++) { for (int j = i + 1; j < cost.length; j++) { if (cost[i] + cost[j] == money) { return new int[]{i + 1, j + 1};Explore the full code

solution.javaJava

Brute Force — Nested Pair Scan — reference

2 teaching notes

1
public int[] whatFlavors(int[] cost, int money) {
2
    for (int i = 0; i < cost.length; i++) {
3
        // j > i keeps the flavors distinct and the ids ordered.
4
        for (int j = i + 1; j < cost.length; j++) {
5
            if (cost[i] + cost[j] == money) {
6
                // Convert 0-based indices to 1-based flavor ids.
7
                return new int[]{i + 1, j + 1};
8
            }
9
        }
10
    }
11
    return new int[]{};
12
}

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

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

Starting j at i + 1 makes the first discovered match come out smaller-id-first, so no extra sorting is needed.

ComplexityO(n²) time, O(1) space — Up to n(n−1)/2 pairs, each tested in O(1).

E · Edge cases and pitfalls5money = 4, cost = [2, 2] — Single pair → ids 1 2.Explore edge cases

Edge cases handled

money = 4, cost = [2, 2]Single pair → ids 1 2.
money = 11, cost = [5, 6, 1]5 + 6 = 11 → ids 1 2.

Pitfalls

Returning 0-based indices instead of 1-based ids.
Returning prices instead of ids.
Starting j at 0 — pairs a flavor with itself.

03.2

Approach 2 of 2 · Optimal

Complement Hash Map — One Pass (Optimal)

TimeO(n)SpaceO(n)

The answer they want — recognize Two Sum and do one pass.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The partner price for cost[i] is money − cost[i]. What gives O(1) 'seen this price?' checks?

2Hint 2Explore hint

Map price → 0-based index; check the complement before inserting the current price.

3Hint 3Explore hint

On a hit, return [storedIndex + 1, i + 1] — +1 makes ids and the earlier index is smaller.

A · Core idea

Walk the cost list once. For flavor i priced cost[i], the complement money − cost[i] is the unique partner price. A hash map of previously seen prices answers 'have I seen that price?' in O(1).

Look up before inserting. Querying the complement before recording the current price keeps the two matched flavors at different indices — no flavor can complete the purchase by pairing with itself. cost = [2, 2], money = 4 works precisely because the first 2 is stored before the second 2 queries it.

Sorted ids for free. A found complement was stored at an earlier index, so returning [seen[need] + 1, i + 1] lists the smaller id first.

The 1-indexing. Indices are 0-based during iteration but ids are 1-based, so add 1 on return. Dropping that +1 is the single most common bug here.

With one guaranteed pair, return on the first match.

B · Visual dry run

Interactive dry run

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

money = 5, cost = [2, 1, 3, 5, 6]

Hash-map state

i=0, price 2

lookup 3

ValueIndex / state

2→ 0

Continue scanning

need 3 absent → insert 2 → 0

Final result1 3

C · Code with teaching comments

solution.javaJava

Complement Hash Map — One Pass (Optimal) — optimal

4 teaching notes

1
public int[] whatFlavors(int[] cost, int money) {
2
    Map<Integer, Integer> seen = new HashMap<>();
3
    for (int i = 0; i < cost.length; i++) {
4
        // The price that completes the purchase with the current flavor.
5
        int need = money - cost[i];
6
        // Lookup before insert keeps the two flavors distinct.
7
        if (seen.containsKey(need)) {
8
            // +1 converts indices to 1-based ids; earlier index is the smaller id.
9
            return new int[]{seen.get(need) + 1, i + 1};
10
        }
11
        // Record price → index for future flavors.
12
        seen.put(cost[i], i);
13
    }
14
    return new int[]{};
15
}

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

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

Strip the ice-cream narrative and this is Two Sum verbatim; the only original step is mapping a 0-based index to a 1-based id. Training yourself to unwrap story problems into their core pattern is the transferable skill — pairs of songs, complementary items, and 'two numbers that sum to X' are all this same map.

ComplexityO(n) time, O(n) space — One pass with O(1) average map ops → O(n) time; up to n−1 stored prices → O(n) space.

E · Edge cases and pitfalls5money = 4, cost = [2, 2, 4, 3] — First 2 stored, second 2 finds complement 2 at index 0 → ids 1 2.Explore edge cases

Edge cases handled

money = 4, cost = [2, 2, 4, 3]First 2 stored, second 2 finds complement 2 at index 0 → ids 1 2.
money = 8, cost = [3, 5, 5]3 stored, first 5 finds 3 at index 0 → ids 1 2.

Pitfalls

Forgetting the +1 and returning 0-based indices.
Inserting before the complement check — can self-pair a flavor.
Storing index → price, making the lookup O(n).

Practice

Try the solution yourself

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

Editable code previewpublic int[] whatFlavors(int[] cost, int money) { Map<Integer, Integer> seen = new HashMap<>(); for (int i = 0; i < cost.length; i++) { int need = money - cost[i]; if (seen.containsKey(need)) {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.

Off-by-one on the flavor id

Ids are 1-based but indices are 0-based; returning the raw indices is one short of the expected id.

Explore the code comparison

Don't write this

return new int[]{seen.get(need), i};

Write this instead

return new int[]{seen.get(need) + 1, i + 1};

Insert before check (self-pair)

Recording cost[i] before the lookup lets a flavor match itself when 2·cost[i] == money, returning a duplicated id.

Explore the code comparison

Don't write this

seen[c] = i
if money - c in seen:
    return [seen[money - c] + 1, i + 1]

Write this instead

if money - c in seen:
    return [seen[money - c] + 1, i + 1]
seen[c] = i

Returning prices, not ids

The story foregrounds costs, but the required output is the flavor ids.

Explore the code comparison

Don't write this

return [c, money - c]

Write this instead

return [seen[money - c] + 1, i + 1]

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Complement lookup, return 1-indexed ids

Code pattern to memorize

seen = {}                    # price -> 0-based index
for i, c in enumerate(cost):
    if (money - c) in seen:
        return [seen[money - c] + 1, i + 1]
    seen[c] = i

Rules to remember

1Flavor id = array position + 1. Return ids, not 0-based indices and not prices.
2Look up money − cost[i] before inserting cost[i] so the two flavors stay distinct.
3The earlier-seen flavor has the smaller id, so [seen[need]+1, i+1] is already increasing.
4Map keys are prices (the thing you look up), values are indices (what you report).
5Exactly one pair exists per trip — return on the first match.

Use this pattern when

Find the one pair of distinct items whose values reach a target
Original ids/positions are required, not the values
Unsorted prices where a single O(n) pass beats sorting
The 'seen the partner already?' framing applies

Choose another pattern when

Prices already sorted and space is tight → two pointers, O(1) space
All pairs wanted, not just one → accumulate instead of returning
Values wanted, not ids → no index bookkeeping needed
Multiple valid pairs with a specific tie-break → revisit the stored value

Interview takeaway

Ice Cream Parlor is Two Sum with 1-based ids. The complement map finds the pair in one pass; the only added step is the +1 index-to-id conversion, and check-before-insert keeps the flavors distinct.

Continue

Transfer the pattern to another problem

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

Transferable patternStory-wrapped Two Sum with 1-based ids. Complement hash map finds the unique pair in one pass; the +1 index-to-id conversion is the only twist beyond the standard pattern.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Same pattern

←

Hash Tables: Ice Cream Parlor

Continue · Next problem

Maximum Subarray Sum

easyArraysFrequently asked

Ice Cream Parlor

Arrays & Hashing · 74 of 83 · 8 min

Exactly one valid pair exists for each trip.

In plain English

Examples

Example 1

Input: money = 5, cost = [2, 1, 3, 5, 6]
Output: 1 3
Note: cost[0]=2 and cost[2]=3 sum to 5 → ids 1 and 3.

Example 2

Input: money = 4, cost = [2, 2, 4, 3]
Output: 1 2
Note: cost[0]=2 and cost[1]=2 sum to 4 → ids 1 and 2.

Example 3

Input: money = 6, cost = [1, 4, 5, 3, 2]
Output: 1 3
Note: cost[0]=1 and cost[2]=5 sum to 6 → ids 1 and 3. The 1 is recorded first, so its complement 5 is matched at the earlier id.

Constraints

1 ≤ number of trips ≤ 50
2 ≤ n ≤ 10⁴ (flavors per trip)
2 ≤ money ≤ 10⁵
1 ≤ cost[i] ≤ 10⁴, with exactly one valid pair

Clarifying questions4First question: Are ids 0-based or 1-based?Explore questions

Q1.Are ids 0-based or 1-based?
1-based. Position 0 in the array is flavor id 1, so the returned ids are indices plus one.
Q2.Can two flavors cost the same?
Yes. cost = [2, 2, 4], money = 4 returns ids 1 and 2. Check-before-insert handles this.
Q3.Is the cost list sorted?
Not necessarily. The hash map works on unsorted input in one pass; sorting would enable a two-pointer alternative.
Q4.Always exactly one solution?
Yes, so we can return as soon as the first complement is found.

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 see Two Sum behind the narrative and produce the 1-indexed ids without off-by-one slips.

Where candidates slip

Returning 0-based indices or prices, inserting before checking (self-pairing), or scanning the whole list per element instead of using a map.

How to stand out

Call it Two Sum up front, flag the +1 conversion as the only real difference, and note the result is sorted because the earlier index is returned first.

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 — Nested Pair Scan	`O(n²)`	`O(1)`	Open with this to pin down the 1-indexed output, then optimize.	Read
2	Complement Hash Map — One Pass (Optimal)Optimal	`O(n)`	`O(n)`	The answer they want — recognize Two Sum and do one pass.	Read

Two Sum behind the story

How to read it:Find the complement price, then report 1-based ids.

Rendering diagram…

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 — Nested Pair Scan

TimeO(n²)SpaceO(1)

Open with this to pin down the 1-indexed output, then optimize.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Exactly one pair sums to money — what's the most direct way to find it?

2Hint 2Explore hint

Try every pair (i, j) with j > i and check cost[i] + cost[j] == money.

3Hint 3Explore hint

Return ids i+1 and j+1 on the first match.

A · Core idea

Try all distinct position pairs and return the first whose prices sum to money. The inner loop begins at i + 1, so each pair is examined once and no flavor is paired with itself.

Why +1 on the result. Flavor ids are 1-based positions, so indices i and j become ids i + 1 and j + 1. With i < j, the ids are already in increasing order.

Why it's only a starting point. For up to 50 trips of n = 10⁴ flavors the quadratic scan passes, but it tells the interviewer you didn't reach for the hash map. State it, then improve.

B · Visual dry run

Interactive dry run

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

money = 5, cost = [2, 1, 3, 5, 6]

Array state

i=0,j=2

2 + 3 = 5 → ids 1 and 3

i ↓

[0]

[1]

j ↓

[2]

[3]

[4]

Current pointerResolved stateNot processed

Final result1 3

C · Code with teaching comments

solution.javaJava

Brute Force — Nested Pair Scan — reference

2 teaching notes

1
public int[] whatFlavors(int[] cost, int money) {
2
    for (int i = 0; i < cost.length; i++) {
3
        // j > i keeps the flavors distinct and the ids ordered.
4
        for (int j = i + 1; j < cost.length; j++) {
5
            if (cost[i] + cost[j] == money) {
6
                // Convert 0-based indices to 1-based flavor ids.
7
                return new int[]{i + 1, j + 1};
8
            }
9
        }
10
    }
11
    return new int[]{};
12
}

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

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

Starting j at i + 1 makes the first discovered match come out smaller-id-first, so no extra sorting is needed.

ComplexityO(n²) time, O(1) space — Up to n(n−1)/2 pairs, each tested in O(1).

E · Edge cases and pitfalls5money = 4, cost = [2, 2] — Single pair → ids 1 2.Explore edge cases

Edge cases handled

money = 4, cost = [2, 2]Single pair → ids 1 2.
money = 11, cost = [5, 6, 1]5 + 6 = 11 → ids 1 2.

Pitfalls

Returning 0-based indices instead of 1-based ids.
Returning prices instead of ids.
Starting j at 0 — pairs a flavor with itself.

03.2

Approach 2 of 2 · Optimal

Complement Hash Map — One Pass (Optimal)

TimeO(n)SpaceO(n)

The answer they want — recognize Two Sum and do one pass.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The partner price for cost[i] is money − cost[i]. What gives O(1) 'seen this price?' checks?

2Hint 2Explore hint

Map price → 0-based index; check the complement before inserting the current price.

3Hint 3Explore hint

On a hit, return [storedIndex + 1, i + 1] — +1 makes ids and the earlier index is smaller.

A · Core idea

Sorted ids for free. A found complement was stored at an earlier index, so returning [seen[need] + 1, i + 1] lists the smaller id first.

The 1-indexing. Indices are 0-based during iteration but ids are 1-based, so add 1 on return. Dropping that +1 is the single most common bug here.

With one guaranteed pair, return on the first match.

B · Visual dry run

Interactive dry run

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

money = 5, cost = [2, 1, 3, 5, 6]

Hash-map state

i=0, price 2

lookup 3

ValueIndex / state

2→ 0

Continue scanning

need 3 absent → insert 2 → 0

Final result1 3

C · Code with teaching comments

solution.javaJava

Complement Hash Map — One Pass (Optimal) — optimal

4 teaching notes

1
public int[] whatFlavors(int[] cost, int money) {
2
    Map<Integer, Integer> seen = new HashMap<>();
3
    for (int i = 0; i < cost.length; i++) {
4
        // The price that completes the purchase with the current flavor.
5
        int need = money - cost[i];
6
        // Lookup before insert keeps the two flavors distinct.
7
        if (seen.containsKey(need)) {
8
            // +1 converts indices to 1-based ids; earlier index is the smaller id.
9
            return new int[]{seen.get(need) + 1, i + 1};
10
        }
11
        // Record price → index for future flavors.
12
        seen.put(cost[i], i);
13
    }
14
    return new int[]{};
15
}

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

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

ComplexityO(n) time, O(n) space — One pass with O(1) average map ops → O(n) time; up to n−1 stored prices → O(n) space.

E · Edge cases and pitfalls5money = 4, cost = [2, 2, 4, 3] — First 2 stored, second 2 finds complement 2 at index 0 → ids 1 2.Explore edge cases

Edge cases handled

money = 4, cost = [2, 2, 4, 3]First 2 stored, second 2 finds complement 2 at index 0 → ids 1 2.
money = 8, cost = [3, 5, 5]3 stored, first 5 finds 3 at index 0 → ids 1 2.

Pitfalls

Forgetting the +1 and returning 0-based indices.
Inserting before the complement check — can self-pair a flavor.
Storing index → price, making the lookup O(n).

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.

Off-by-one on the flavor id

Ids are 1-based but indices are 0-based; returning the raw indices is one short of the expected id.

Explore the code comparison

Don't write this

return new int[]{seen.get(need), i};

Write this instead

return new int[]{seen.get(need) + 1, i + 1};

Insert before check (self-pair)

Recording cost[i] before the lookup lets a flavor match itself when 2·cost[i] == money, returning a duplicated id.

Explore the code comparison

Don't write this

seen[c] = i
if money - c in seen:
    return [seen[money - c] + 1, i + 1]

Write this instead

if money - c in seen:
    return [seen[money - c] + 1, i + 1]
seen[c] = i

Returning prices, not ids

The story foregrounds costs, but the required output is the flavor ids.

Explore the code comparison

Don't write this

return [c, money - c]

Write this instead

return [seen[money - c] + 1, i + 1]

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Complement lookup, return 1-indexed ids

Code pattern to memorize

seen = {}                    # price -> 0-based index
for i, c in enumerate(cost):
    if (money - c) in seen:
        return [seen[money - c] + 1, i + 1]
    seen[c] = i

Rules to remember

1Flavor id = array position + 1. Return ids, not 0-based indices and not prices.
2Look up money − cost[i] before inserting cost[i] so the two flavors stay distinct.
3The earlier-seen flavor has the smaller id, so [seen[need]+1, i+1] is already increasing.
4Map keys are prices (the thing you look up), values are indices (what you report).
5Exactly one pair exists per trip — return on the first match.

Use this pattern when

Find the one pair of distinct items whose values reach a target
Original ids/positions are required, not the values
Unsorted prices where a single O(n) pass beats sorting
The 'seen the partner already?' framing applies

Choose another pattern when

Prices already sorted and space is tight → two pointers, O(1) space
All pairs wanted, not just one → accumulate instead of returning
Values wanted, not ids → no index bookkeeping needed
Multiple valid pairs with a specific tie-break → revisit the stored value

Interview takeaway

Ice Cream Parlor is Two Sum with 1-based ids. The complement map finds the pair in one pass; the only added step is the +1 index-to-id conversion, and check-before-insert keeps the flavors distinct.

Continue

Transfer the pattern to another problem

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

Transferable patternStory-wrapped Two Sum with 1-based ids. Complement hash map finds the unique pair in one pass; the +1 index-to-id conversion is the only twist beyond the standard pattern.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Same pattern

←

Hash Tables: Ice Cream Parlor

Continue · Next problem

Maximum Subarray Sum