Codestin Search App

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.

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

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.

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
✓ 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)	O(n×m×k)	O(n)	For each feature, count its occurrences across all responses by scanning every response

Two-Pass Hash Table (Optimal) — Algorithm Steps

Initialize an empty hash map to store feature popularity counts
First pass - Process all responses:
For each response, split into unique words (use set to avoid duplicates)
For each unique word, increment its count in the hash map
Second pass - Sort features:
Create tuples of (feature, popularity, original_index) using the hash map
Sort by popularity (descending) and original index (ascending)
Extract and return the sorted feature names

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Map Creation

Create empty hash map for counting

Response Processing

Process each response once, updating counts

Count Recording

Hash map now contains all popularity counts

Feature Sorting

Use hash map to sort features efficiently

Result Generation

Return sorted feature list

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 100

typedef struct {
    char word[MAX_WORD_LEN];
    int count;
} WordCount;

typedef struct {
    char name[MAX_WORD_LEN];
    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 findWordIndex(WordCount* words, int size, const char* word) {
    for (int i = 0; i < size; i++) {
        if (strcmp(words[i].word, word) == 0) {
            return i;
        }
    }
    return -1;
}

char** sortFeatures(char** features, int featuresSize, char** responses, int responsesSize, int* returnSize) {
    WordCount popularity[MAX_WORDS];
    int wordCount = 0;
    
    // First pass: build popularity count map
    for (int i = 0; i < responsesSize; i++) {
        char temp[1000];
        strcpy(temp, responses[i]);
        
        char uniqueWords[MAX_WORDS][MAX_WORD_LEN];
        int uniqueCount = 0;
        
        // Extract unique words from current response
        char* word = strtok(temp, " ");
        while (word != NULL) {
            int found = 0;
            for (int j = 0; j < uniqueCount; j++) {
                if (strcmp(uniqueWords[j], word) == 0) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                strcpy(uniqueWords[uniqueCount], word);
                uniqueCount++;
            }
            word = strtok(NULL, " ");
        }
        
        // Update popularity counts
        for (int j = 0; j < uniqueCount; j++) {
            int idx = findWordIndex(popularity, wordCount, uniqueWords[j]);
            if (idx == -1) {
                strcpy(popularity[wordCount].word, uniqueWords[j]);
                popularity[wordCount].count = 1;
                wordCount++;
            } else {
                popularity[idx].count++;
            }
        }
    }
    
    // Second pass: sort features using the count map
    FeatureInfo* result = (FeatureInfo*)malloc(featuresSize * sizeof(FeatureInfo));
    
    for (int i = 0; i < featuresSize; i++) {
        strcpy(result[i].name, features[i]);
        result[i].index = i;
        result[i].popularity = 0;
        
        int idx = findWordIndex(popularity, wordCount, features[i]);
        if (idx != -1) {
            result[i].popularity = popularity[idx].count;
        }
    }
    
    qsort(result, featuresSize, sizeof(FeatureInfo), compareFeatures);
    
    char** answer = (char**)malloc(featuresSize * sizeof(char*));
    for (int i = 0; i < featuresSize; i++) {
        answer[i] = (char*)malloc(MAX_WORD_LEN * 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(m×k + n log n)

m responses × k words per response for counting + n log n for sorting features

⚡ Linearithmic

Space Complexity

O(u + n)

u unique words across all responses for hash map + n space for result tuples

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler