Naming a Company - Practice Coding Problems

Naming a Company - Problem

You're helping an innovative startup find the perfect company name using a creative naming process! 🚀

Given an array of ideas containing potential name fragments, you need to count how many valid company names can be created using this special process:

Choose two distinct ideas from the list (let's call them ideaA and ideaB)
Swap their first letters - if ideaA = "coffee" and ideaB = "donuts", they become "doffee" and "conuts"
Check validity - if both new words are NOT in the original ideas list, then "ideaA ideaB" (space-separated) is a valid company name
Count all possibilities - return the total number of distinct valid company names

Example: With ideas ["coffee", "donuts", "time", "toffee"], swapping first letters of "coffee" and "time" gives us "toffee" and "cime". Since "toffee" exists in our original list, this combination is invalid. But "coffee" + "donuts" → "doffee" + "conuts" works since neither appears in the original list!

Input & Output

example_1.py — Basic Example

$ Input: ideas = ["coffee", "donuts", "time", "toffee"]

› Output: 6

💡 Note: Valid combinations: (coffee,donuts)→"doffee conuts", (donuts,coffee)→"conuts doffee", (coffee,time)→invalid (creates "toffee" which exists), (donuts,time)→"tonuts dime", (time,donuts)→"dime tonuts", (donuts,toffee)→"tonuts doffee", (toffee,donuts)→"doffee tonuts". Total valid names: 6

example_2.py — Simple Case

$ Input: ideas = ["lack", "back"]

› Output: 0

💡 Note: Swapping 'lack' and 'back' gives 'back' and 'lack', both of which already exist in the original ideas array, so no valid company names can be formed.

example_3.py — All Different Letters

$ Input: ideas = ["aaa", "baa", "caa", "daa"]

› Output: 12

💡 Note: All ideas have the same suffix 'aa' but different first letters. Any pair will create two new strings that don't exist in the original set. With 4 ideas, we have C(4,2) = 6 pairs, each contributing 2 valid names (both orderings), giving us 6 × 2 = 12 total.

Constraints

2 ≤ ideas.length ≤ 5 × 10⁴
1 ≤ ideas[i].length ≤ 10
ideas[i] consists of lowercase English letters
All ideas[i] are distinct

Visualization

Tap to expand

Understanding the Visualization

Group Organization

Sort all word ideas into buckets based on their first letter, like organizing cards by suit

Suffix Analysis

For each pair of letter groups, identify which suffixes appear in both groups (these create invalid swaps)

Combination Counting

Calculate valid pairs using the formula: (group1_size - overlaps) × (group2_size - overlaps) × 2

Final Summation

Add up all valid combinations across all possible letter group pairs

Key Takeaway

🎯 Key Insight: Instead of checking every pair individually (O(n²)), group by first letters and use mathematical counting to calculate valid combinations in O(n + 26²) time!

Asked in

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

The optimal approach groups ideas by their first letter and uses combinatorial counting. For each pair of letter groups, we calculate valid combinations by subtracting overlapping suffixes from total possibilities, achieving O(n × k + 26²) time complexity instead of the brute force O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Group by First Letter (Optimized)	O(n × k + 26²)	O(n × k)	Group ideas by first letter, then count valid combinations between groups
Brute Force (Check Every Pair)	O(n² × k)	O(n × k)	Try all possible pairs and check if swapped versions exist in original set

Group by First Letter (Optimized) — Algorithm Steps

Group all ideas by their first letter into a map
For each pair of different first letters (A, B)
Find suffixes that appear in both groups A and B
Calculate valid combinations: (|A| - overlaps) × (|B| - overlaps) × 2
Sum up all valid combinations across all letter pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Letter

Organize all ideas by their first letter

Find Overlaps

For each pair of groups, find common suffixes

Calculate Valid

Count non-overlapping combinations

Sum Results

Add up valid combinations from all group pairs

Code -

solution.c — C

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

#define MAX_GROUPS 26
#define MAX_SUFFIXES 2000

typedef struct {
    char suffixes[MAX_SUFFIXES][51];
    int count;
} SuffixGroup;

long long distinctNames(char** ideas, int ideasSize) {
    SuffixGroup groups[MAX_GROUPS];
    bool hasGroup[MAX_GROUPS] = {false};
    
    // Initialize groups
    for (int i = 0; i < MAX_GROUPS; i++) {
        groups[i].count = 0;
    }
    
    // Group ideas by first letter
    for (int i = 0; i < ideasSize; i++) {
        int letterIndex = ideas[i][0] - 'a';
        hasGroup[letterIndex] = true;
        strcpy(groups[letterIndex].suffixes[groups[letterIndex].count], ideas[i] + 1);
        groups[letterIndex].count++;
    }
    
    long long count = 0;
    
    // Check all pairs of different first letters
    for (int i = 0; i < MAX_GROUPS; i++) {
        if (!hasGroup[i]) continue;
        
        for (int j = i + 1; j < MAX_GROUPS; j++) {
            if (!hasGroup[j]) continue;
            
            // Count overlapping suffixes
            int overlaps = 0;
            for (int a = 0; a < groups[i].count; a++) {
                for (int b = 0; b < groups[j].count; b++) {
                    if (strcmp(groups[i].suffixes[a], groups[j].suffixes[b]) == 0) {
                        overlaps++;
                        break;
                    }
                }
            }
            
            // Valid combinations
            long long validA = groups[i].count - overlaps;
            long long validB = groups[j].count - overlaps;
            count += validA * validB * 2;
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k + 26²)

n×k to process all strings and group them, 26² to check all letter pair combinations

✓ Linear Growth

Space Complexity

O(n × k)

Storage for all strings grouped by their first letters

⚡ Linearithmic Space

43.7K Views

Medium-High Frequency

~25 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

Group by First Letter (Optimized) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler