Count Items Matching a Rule - Practice Coding Problems

Count Items Matching a Rule - Problem

Array String Easy

You are given an array items, where each items[i] = [type_i, color_i, name_i] describes the type, color, and name of the i^th item. You are also given a rule represented by two strings, ruleKey and ruleValue.

The i^th item is said to match the rule if one of the following is true:

ruleKey == "type" and ruleValue == type_i
ruleKey == "color" and ruleValue == color_i
ruleKey == "name" and ruleValue == name_i

Return the number of items that match the given rule.

Input & Output

Example 1 — Color Filter

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

› Output: 1

💡 Note: Only the computer item has color "silver", so count = 1

Example 2 — Type Filter

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

› Output: 2

💡 Note: First and third items have type "phone", so count = 2

Example 3 — No Matches

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

› Output: 0

💡 Note: No items have name "iphone", so count = 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

Input

Array of items and rule (key, value)

Process

Check each item's attribute against rule

Output

Count of matching items

Key Takeaway

🎯 Key Insight: Map rule key to array index once, then use direct access for efficient filtering

Asked in

a Amazon 15 M Microsoft 8

The key insight is to map the ruleKey string to an array index to avoid repeated string comparisons. Best approach uses index mapping for cleaner, more efficient code. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Index Mapping Optimization	O(n)	O(1)	Map ruleKey to array index to avoid repeated string comparisons
Brute Force Linear Scan	O(n)	O(1)	Iterate through items and check rule with string comparisons

Index Mapping Optimization — Algorithm Steps

Map ruleKey to index once before loop
Iterate through items using the mapped index
Compare item[index] with ruleValue directly

Visualization

Tap to expand

Step-by-Step Walkthrough

Map Key

Convert ruleKey to array index (0, 1, or 2)

Direct Access

Use item[index] to get the attribute value

Compare

Simple string comparison with ruleValue

Code -

solution.c — C

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

int solution(char items[][3][20], int itemCount, char* ruleKey, char* ruleValue) {
    // Map ruleKey to index
    int index;
    if (strcmp(ruleKey, "type") == 0) index = 0;
    else if (strcmp(ruleKey, "color") == 0) index = 1;
    else index = 2; // name
    
    int count = 0;
    for (int i = 0; i < itemCount; i++) {
        if (strcmp(items[i][index], ruleValue) == 0) {
            count++;
        }
    }
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char items[100][3][20];
    int itemCount = 0;
    char* token = strtok(line, "[]");
    while (token != NULL && itemCount < 100) {
        if (strstr(token, ",") != NULL) {
            sscanf(token, "\"%[^\"]\",\"%[^\"]\",\"%[^\"]\"", 
                   items[itemCount][0], items[itemCount][1], items[itemCount][2]);
            itemCount++;
        }
        token = strtok(NULL, "[]");
    }
    
    char ruleKey[20], ruleValue[20];
    fgets(ruleKey, sizeof(ruleKey), stdin);
    ruleKey[strcspn(ruleKey, "\n")] = 0;
    fgets(ruleValue, sizeof(ruleValue), stdin);
    ruleValue[strcspn(ruleValue, "\n")] = 0;
    
    int result = solution(items, itemCount, ruleKey, ruleValue);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n items, but with fewer operations per item

✓ Linear Growth

Space Complexity

O(1)

Only using index variable and counter, no extra data structures

✓ Linear Space

34.8K Views

Medium Frequency

~5 min Avg. Time

892 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

Index Mapping Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler