How do you approach Jewels and Stones?

For each stone you need a fast way to ask: is this a jewel?

What is the time complexity of Jewels and Stones?

Time complexity: O(j + s) - build the set, then one pass over stones. Space complexity: O(j) - the jewel set.

What are common mistakes on Jewels and Stones?

Storing the current value before checking for its complement, which lets an element pair with itself. Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n). Using a plain object as the map when keys may be numbers or __proto__; a real hash-map type keeps key identity intact.

gitGood.dev

← Back to problems

Jewels and Stones

EasyData Structures

Description

You're given strings `jewels` representing the types of stones that are jewels, and `stones` representing the stones you have. Each character in `stones` is a type of stone you have. You want to know how many of the stones you have are also jewels. Letters are case sensitive, so `"a"` is considered a different type of stone from `"A"`.

Example 1

Input: jewels = "aA", stones = "aAAbbbb"

Output: 3

Explanation: The stones "a", "A", and "A" are jewels.

Example 2

Input: jewels = "z", stones = "ZZ"

Output: 0

Explanation: Case matters - 'Z' is not 'z'.

Example 3

Input: jewels = "abc", stones = "aabbcc"

Output: 6

Constraints

- 1 <= jewels.length, stones.length <= 50 - jewels and stones consist of only English letters. - All the characters of jewels are unique.

Jewels and Stones: approach, complexity and pitfalls

An easy arrays & hashing problem, graded against 6 test cases (3 of them hidden).

The pattern: Arrays & Hashing

Hash maps and sets to trade memory for time - the most common first instinct in interviews.

Reach for it when you see: "Have I seen this before?", counting occurrences, or an O(n²) scan you want to make O(n).

More Arrays & Hashingproblems →

If you are stuck

Show the 3-step hint ladder

For each stone you need a fast way to ask: is this a jewel?
Checking jewels.includes(stone) for every stone is O(j * s) - a set makes each lookup O(1).
Build a set from jewels, then count the stones that are in the set.

The optimal approach

Show the approach: Hash Set Lookup

Put every jewel character into a hash set, then scan the stones once, incrementing a counter whenever the stone is in the set. This replaces a repeated linear scan of `jewels` with O(1) membership checks.

Time: O(j + s) - build the set, then one pass over stones
Space: O(j) - the jewel set

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

Common Arrays & Hashing mistakes

These apply to the pattern as a whole, not just this problem.

Storing the current value before checking for its complement, which lets an element pair with itself.
Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n).
Using a plain object as the map when keys may be numbers or `__proto__`; a real hash-map type keeps key identity intact.