Count Items Matching a Rule - Practice Coding Problems

Count Items Matching a Rule - Problem

Array String Easy

Imagine you're working as a digital inventory manager for an online store! 🛍️

You have a collection of items in your inventory, where each item is described by three properties: [type, color, name]. Your task is to count how many items match a specific filtering rule.

A filtering rule consists of two parts:

ruleKey: Which property to filter by ("type", "color", or "name")
ruleValue: The exact value that property should have

An item matches the rule if the specified property equals the target value. For example, if ruleKey = "color" and ruleValue = "red", then only red items will match.

Goal: Return the total count of items that satisfy the given filtering rule.

Example: If you have items like [["phone","blue","pixel"],["computer","silver","lenovo"],["phone","gold","iphone"]] and rule ruleKey="type", ruleValue="phone", the answer is 2 because two items are phones.

Input & Output

example_1.py — Basic Type Matching

$ Input: items = [["phone","blue","pixel"],["computer","silver","lenovo"],["phone","gold","iphone"]] ruleKey = "type" ruleValue = "phone"

› Output: 2

💡 Note: We're looking for items with type="phone". The first item ["phone","blue","pixel"] matches, the second ["computer","silver","lenovo"] doesn't match, and the third ["phone","gold","iphone"] matches. Total: 2 matches.

example_2.py — Color Matching

$ Input: items = [["phone","blue","pixel"],["computer","silver","mac"],["phone","gold","iphone"]] ruleKey = "color" ruleValue = "silver"

› Output: 1

💡 Note: We're searching for items with color="silver". Only the second item ["computer","silver","mac"] has a silver color, so the count is 1.

example_3.py — No Matches Edge Case

$ Input: items = [["phone","blue","pixel"],["computer","silver","lenovo"],["phone","gold","iphone"]] ruleKey = "name" ruleValue = "samsung"

› Output: 0

💡 Note: We're looking for items with name="samsung", but none of the items have this name. The names are "pixel", "lenovo", and "iphone", so the count is 0.

Constraints

1 ≤ items.length ≤ 10⁴
1 ≤ type_i.length, color_i.length, name_i.length, ruleValue.length ≤ 10
ruleKey is equal to either "type", "color", or "name"
All strings consist only of lowercase letters

Visualization

Tap to expand

Understanding the Visualization

Setup Filter

Configure the scanner to look for a specific property (type, color, or name)

Scan Inventory

Pass each item through the scanner one by one

Check & Count

For each item, check if the target property matches the filter value

Final Count

Return the total number of items that passed the filter

Key Takeaway

🎯 Key Insight: This is a straightforward filtering problem that requires just one pass through the data. No complex algorithms needed - just map the rule key to the correct array position and count matches!

Asked in

a Amazon 25 Apple 18 G Google 15 ⊞ Microsoft 12

This problem has a simple optimal solution using a single linear scan. Map the ruleKey to the correct array index (type=0, color=1, name=2), then iterate through all items counting those where item[index] == ruleValue. The solution runs in O(n) time and O(1) space, making it both time and space efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Linear Scan	O(n)	O(1)	Iterate through each item and count matches

Single Pass Linear Scan — Algorithm Steps

Initialize a counter to 0
Map ruleKey to the correct array index (type=0, color=1, name=2)
Iterate through each item in the items array
For each item, check if the property at the mapped index equals ruleValue
If it matches, increment the counter
Return the final counter value

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Initialize counter and determine which property index to check

Scan Items

Go through each item one by one

Check Match

Compare the target property with the rule value

Count

Increment counter if there's a match

Code -

solution.c — C

int countMatches(char*** items, int itemsSize, int* itemsColSize, char* ruleKey, char* ruleValue) {
    // Determine index based on ruleKey
    int index;
    if (strcmp(ruleKey, "type") == 0) {
        index = 0;
    } else if (strcmp(ruleKey, "color") == 0) {
        index = 1;
    } else { // ruleKey == "name"
        index = 2;
    }
    
    // Count matching items
    int count = 0;
    for (int i = 0; i < itemsSize; i++) {
        if (strcmp(items[i][index], ruleValue) == 0) {
            count++;
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each of the n items exactly once, performing constant-time operations for each

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the counter and index mapping

✓ Linear Space

42.0K Views

Medium Frequency

~8 min Avg. Time

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

Single Pass Linear Scan — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler