Sort Features by Popularity - Practice Coding Problems

Sort Features by Popularity - Problem

You're a product manager analyzing user feedback for your latest software release! 🚀

You have a list of features in your product and a collection of user responses from surveys. Each response contains space-separated feature names that users mentioned they liked.

Your goal: Rank features by popularity to prioritize development efforts!

📊 Popularity Rules:

A feature's popularity = number of responses that mention it
If a user mentions the same feature multiple times in one response, count it only once
Sort features in descending order by popularity
If two features have the same popularity, maintain their original order from the features array

Example: If features = ["photoSharing", "videoCall", "chat"] and responses = ["photoSharing videoCall", "videoCall chat chat"], then "videoCall" appears in 2 responses (most popular), while "photoSharing" and "chat" each appear in 1 response. Since "photoSharing" comes before "chat" originally, the result is ["videoCall", "photoSharing", "chat"].

Input & Output

example_1.py — Basic Feature Ranking

$ Input: features = ["photoSharing", "videoCall", "chat"] responses = ["photoSharing videoCall", "videoCall chat chat"]

› Output: ["videoCall", "photoSharing", "chat"]

💡 Note: videoCall appears in 2 responses (most popular). photoSharing and chat each appear in 1 response, but photoSharing comes first in the original order.

example_2.py — Equal Popularity Tie-Breaking

$ Input: features = ["search", "messaging", "notifications"] responses = ["search messaging", "notifications search"]

› Output: ["search", "messaging", "notifications"]

💡 Note: All features appear in exactly 1 response each. Since they have equal popularity, we maintain the original order from the features array.

example_3.py — Single Response Multiple Mentions

$ Input: features = ["like", "comment", "share"] responses = ["like like comment share share share"]

› Output: ["like", "comment", "share"]

💡 Note: Even though 'like' appears twice and 'share' appears three times in the response, each feature is only counted once per response. All have popularity 1, so original order is preserved.

Visualization

Tap to expand

Understanding the Visualization

Data Collection

Gather all user responses (like collecting feedback cards from restaurant customers)

Counting Phase

Build popularity hash map by processing each response and counting unique feature mentions

Ranking Phase

Sort features by popularity (descending) and original index (ascending) for tie-breaking

Result Generation

Return ranked feature list for product management decisions

Key Takeaway

🎯 Key Insight: Separate data collection from decision making - build complete popularity statistics first, then sort efficiently using pre-computed data.

Time & Space Complexity

Time Complexity

⏱️

O(n×m×k)

n features × m responses × k average words per response. Each feature requires scanning all responses.

✓ Linear Growth

Space Complexity

O(n)

Only storing the result list with n tuples, no additional hash maps needed.

⚡ Linearithmic Space

Constraints

1 ≤ features.length ≤ 10⁴
1 ≤ features[i].length ≤ 10
features[i] contains only lowercase letters
1 ≤ responses.length ≤ 10³
1 ≤ responses[i].length ≤ 10³
responses[i] contains only lowercase letters and spaces
All feature names are unique

Asked in

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

The optimal solution uses a two-pass hash table approach. First pass builds a popularity count map by processing each response once. Second pass sorts features using pre-computed counts. This achieves O(m×k + n log n) time complexity where m=responses, k=avg words per response, n=features.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n×m×k)	O(n)	For each feature, count its occurrences across all responses by scanning every response
Two-Pass Hash Table (Optimal)	O(m×k + n log n)	O(u + n)	First pass builds popularity count map, second pass sorts features using the map

Brute Force (Nested Loops) — Algorithm Steps

Create a list to store (feature, popularity, original_index) tuples
For each feature in the features array:
Initialize popularity counter to 0
For each response in responses:
Split response into words and check if feature exists
If feature exists, increment popularity counter
Store (feature, popularity, original_index) in result list
Sort result list by popularity (descending), then by original index (ascending)
Extract and return just the feature names

Visualization

Tap to expand

Step-by-Step Walkthrough

Feature Selection

Pick the first feature 'photoSharing'

Response Scanning

Scan each response to count occurrences

Count Recording

Record popularity count for current feature

Repeat Process

Move to next feature and repeat scanning

Final Sorting

Sort all features by popularity and original index

Code -

solution.c — C

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

typedef struct {
    char name[100];
    int popularity;
    int index;
} FeatureInfo;

int compareFeatures(const void* a, const void* b) {
    FeatureInfo* fa = (FeatureInfo*)a;
    FeatureInfo* fb = (FeatureInfo*)b;
    
    if (fa->popularity != fb->popularity) {
        return fb->popularity - fa->popularity; // desc by popularity
    }
    return fa->index - fb->index; // asc by index
}

int containsFeature(const char* response, const char* feature) {
    char temp[1000];
    strcpy(temp, response);
    
    char* word = strtok(temp, " ");
    while (word != NULL) {
        if (strcmp(word, feature) == 0) {
            return 1;
        }
        word = strtok(NULL, " ");
    }
    return 0;
}

char** sortFeatures(char** features, int featuresSize, char** responses, int responsesSize, int* returnSize) {
    FeatureInfo* result = (FeatureInfo*)malloc(featuresSize * sizeof(FeatureInfo));
    
    for (int i = 0; i < featuresSize; i++) {
        strcpy(result[i].name, features[i]);
        result[i].popularity = 0;
        result[i].index = i;
        
        for (int j = 0; j < responsesSize; j++) {
            if (containsFeature(responses[j], features[i])) {
                result[i].popularity++;
            }
        }
    }
    
    qsort(result, featuresSize, sizeof(FeatureInfo), compareFeatures);
    
    char** answer = (char**)malloc(featuresSize * sizeof(char*));
    for (int i = 0; i < featuresSize; i++) {
        answer[i] = (char*)malloc(100 * sizeof(char));
        strcpy(answer[i], result[i].name);
    }
    
    *returnSize = featuresSize;
    free(result);
    return answer;
}

int main() {
    char* features[] = {"photoSharing", "videoCall", "chat"};
    char* responses[] = {"photoSharing videoCall", "videoCall chat chat"};
    
    int returnSize;
    char** result = sortFeatures(features, 3, responses, 2, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%s ", result[i]);
        free(result[i]);
    }
    printf("\n");
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m×k)

n features × m responses × k average words per response. Each feature requires scanning all responses.

✓ Linear Growth

Space Complexity

O(n)

Only storing the result list with n tuples, no additional hash maps needed.

⚡ Linearithmic Space

Constraints

1 ≤ features.length ≤ 10⁴
1 ≤ features[i].length ≤ 10
features[i] contains only lowercase letters
1 ≤ responses.length ≤ 10³
1 ≤ responses[i].length ≤ 10³
responses[i] contains only lowercase letters and spaces
All feature names are unique

52.0K Views

High Frequency

~18 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler