Jewels and Stones - Practice Coding Problems

Jewels and Stones - Problem

Imagine you're a treasure hunter who has collected a bag of various stones during your adventure. You also have a jeweler's guide that tells you which types of stones are actually precious jewels!

Given two strings:

jewels - represents the types of stones that are considered jewels (each character is a jewel type)
stones - represents all the stones you have collected (each character is a stone you own)

Your task is to count how many of your stones are actually jewels. Note that the problem is case-sensitive, meaning 'a' and 'A' are considered different types of stones.

Goal: Return the total count of stones that are also jewels.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: The stones 'a', 'A', and 'A' are jewels (case-sensitive). The stones 'b' are not jewels.

example_2.py — No Matches

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

› Output: 0

💡 Note: Since the problem is case-sensitive, 'z' and 'Z' are different. No stones match the jewels.

example_3.py — All Matches

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

› Output: 6

💡 Note: All stones are jewels: 2 'a's, 2 'b's, and 2 'c's = 6 total jewels.

Constraints

1 ≤ jewels.length, stones.length ≤ 50
jewels and stones consist of only English letters
jewels has no duplicate characters
Both strings are case-sensitive

Visualization

Tap to expand

Understanding the Visualization

Prepare Reference

Create a quick-lookup reference (hash set) of all jewel types

Process Collection

Go through each stone in your collection once

Quick Check

For each stone, instantly check if it's a jewel using the reference

Count Results

Tally up all the jewels found in your stone collection

Key Takeaway

🎯 Key Insight: Converting the jewels into a hash set enables O(1) lookup time instead of O(m) linear search, reducing overall complexity from O(n×m) to O(n+m)

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 25 f Meta 20

The optimal solution uses a hash set to store jewel types for O(1) lookup time. First, convert the jewels string into a hash set, then iterate through each stone and count matches. This achieves O(n+m) time complexity compared to the brute force O(n×m) approach, making it significantly more efficient for larger inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n×m)	O(1)	For each stone, search through all jewel types to check if it matches
Hash Set (Optimal)	O(n+m)	O(m)	Store jewel types in a hash set for O(1) lookup, then count matching stones

Brute Force (Nested Loops) — Algorithm Steps

Initialize a counter to 0
For each stone in the stones string
For each jewel type in the jewels string
If the stone matches the jewel type, increment counter
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first stone

Take the first stone from your collection

Check against all jewels

Compare this stone with each jewel type in the guide

Count if match found

If stone matches any jewel type, increment counter

Repeat for all stones

Continue this process for every stone in collection

Code -

solution.c — C

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

int numJewelsInStones(char* jewels, char* stones) {
    int count = 0;
    int stonesLen = strlen(stones);
    int jewelsLen = strlen(jewels);
    
    for (int i = 0; i < stonesLen; i++) {
        for (int j = 0; j < jewelsLen; j++) {
            if (stones[i] == jewels[j]) {
                count++;
                break;
            }
        }
    }
    return count;
}

int main() {
    char jewels[101], stones[101];
    fgets(jewels, sizeof(jewels), stdin);
    fgets(stones, sizeof(stones), stdin);
    
    // Remove quotes and newlines
    jewels[strcspn(jewels, "\n\"")] = 0;
    stones[strcspn(stones, "\n\"")] = 0;
    
    printf("%d\n", numJewelsInStones(jewels, stones));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Where n is length of stones and m is length of jewels. For each stone, we check all jewel types

✓ Linear Growth

Space Complexity

O(1)

Only using a counter variable, no additional data structures

✓ Linear Space

68.3K Views

High Frequency

~8 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