Count Items Matching a Rule

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

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

✓ Brute Force Linear Scan

⏱️ Time: O(n) Space: O(1)

For each item, use if-else statements to check which attribute (type/color/name) matches the ruleValue. Count matching items.

Index Mapping Optimization

⏱️ Time: O(n) Space: O(1)

Instead of comparing ruleKey with strings in every iteration, map it once to the corresponding array index (0 for type, 1 for color, 2 for name). Then directly access and compare values.

Brute Force Linear Scan — Algorithm Steps

Iterate through each item in the array
Use if-else to check ruleKey and compare with corresponding attribute
Increment counter for matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Rule

Compare ruleKey with "type", "color", "name"

Compare Value

Check if item's attribute equals ruleValue

Count Match

Increment counter if match found

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) {
    int count = 0;
    for (int i = 0; i < itemCount; i++) {
        if (strcmp(ruleKey, "type") == 0 && strcmp(items[i][0], ruleValue) == 0) {
            count++;
        } else if (strcmp(ruleKey, "color") == 0 && strcmp(items[i][1], ruleValue) == 0) {
            count++;
        } else if (strcmp(ruleKey, "name") == 0 && strcmp(items[i][2], ruleValue) == 0) {
            count++;
        }
    }
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for array format
    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, constant work per item

✓ Linear Growth

Space Complexity

O(1)

Only using counter variable, 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

Brute Force Linear Scan — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler