Making File Names Unique - Practice Coding Problems

Making File Names Unique - Problem

Unique File System Manager

You're building a file system that automatically handles duplicate folder names! Given an array of names containing n folder names, you need to create folders one by one in chronological order.

Here's the challenge: no two folders can have identical names. When you try to create a folder with a name that already exists, the system automatically appends a suffix (k) where k is the smallest positive integer that makes the name unique.

Goal: Return an array showing the actual names assigned to each folder after the system processes duplicates.

Example: If you try to create folders ["doc", "doc", "doc"], the system will create: ["doc", "doc(1)", "doc(2)"]

Input & Output

example_1.py — Basic duplicates

$ Input: ["doc", "doc", "image", "doc(1)", "doc"]

› Output: ["doc", "doc(1)", "image", "doc(1)(1)", "doc(2)"]

💡 Note: First 'doc' is unique. Second 'doc' becomes 'doc(1)'. 'image' is unique. 'doc(1)' already exists, so it becomes 'doc(1)(1)'. Last 'doc' becomes 'doc(2)' since 'doc' and 'doc(1)' exist.

example_2.py — No duplicates

$ Input: ["file", "image", "video"]

› Output: ["file", "image", "video"]

💡 Note: All names are unique, so no modifications needed. The output is identical to input.

example_3.py — Edge case with parentheses

$ Input: ["test", "test(1)", "test", "test(1)", "test(2)", "test"]

› Output: ["test", "test(1)", "test(2)", "test(1)(1)", "test(2)(1)", "test(3)"]

💡 Note: Complex case where both base names and names with suffixes can conflict. Each gets the smallest available suffix.

Constraints

1 ≤ names.length ≤ 5 × 10⁴
1 ≤ names[i].length ≤ 20
names[i] consists of lowercase English letters, digits, and/or round brackets
No guarantee on input format - names may already contain parentheses

Visualization

Tap to expand

Understanding the Visualization

Registry Setup

Initialize a registry to track all used names and counters for each base name

Name Processing

For each incoming folder request, check the registry instantly

Conflict Resolution

If conflict found, use the counter to assign next available suffix

Registry Update

Update both the used names set and increment the counter for future conflicts

Key Takeaway

🎯 Key Insight: By maintaining a counter for each base name, we eliminate the need to search from suffix (1) every time, transforming an O(n²) problem into an optimal O(n) solution.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a hash set to track used names in O(1) time and a hash map to remember the next available suffix for each base name. This eliminates redundant searches and achieves O(n) time complexity instead of the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Use hash map to track used names and next available suffix for each base name
Brute Force (Linear Search)	O(n²)	O(1)	For each duplicate name, search through all existing names to find the next available suffix

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize a set to track used names and a map for next suffix counters
For each folder name in input
If name is not in used set, add it directly to result and mark as used
If name exists, use the counter to get next suffix, increment counter
Add the new name with suffix to result and mark as used

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Structures

Create hash set for used names and map for counters

Process Each Name

O(1) lookup in hash set, O(1) counter access

Instant Assignment

No searching needed, direct suffix assignment

Code -

solution.c — C

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

#define MAX_NAMES 5000
#define MAX_LEN 1000

struct HashEntry {
    char name[MAX_LEN];
    int count;
    int used;
};

struct HashEntry hashTable[MAX_NAMES * 2];
int hashSize = MAX_NAMES * 2;

int hash(const char* str) {
    unsigned long hash = 5381;
    int c;
    while ((c = *str++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % hashSize;
}

int isUsed(const char* name) {
    int index = hash(name);
    int original = index;
    while (hashTable[index].used && strcmp(hashTable[index].name, name) != 0) {
        index = (index + 1) % hashSize;
        if (index == original) return 0;
    }
    return hashTable[index].used && strcmp(hashTable[index].name, name) == 0;
}

void markUsed(const char* name) {
    int index = hash(name);
    while (hashTable[index].used && strcmp(hashTable[index].name, name) != 0) {
        index = (index + 1) % hashSize;
    }
    strcpy(hashTable[index].name, name);
    hashTable[index].used = 1;
}

int getNextSuffix(const char* name) {
    int index = hash(name);
    int original = index;
    while (hashTable[index].used && strcmp(hashTable[index].name, name) != 0) {
        index = (index + 1) % hashSize;
        if (index == original) return 1;
    }
    if (hashTable[index].used) {
        return ++hashTable[index].count;
    }
    strcpy(hashTable[index].name, name);
    hashTable[index].count = 2;
    hashTable[index].used = 1;
    return 1;
}

char** getFolderNames(char** names, int namesSize, int* returnSize) {
    memset(hashTable, 0, sizeof(hashTable));
    char** result = (char**)malloc(namesSize * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < namesSize; i++) {
        if (!isUsed(names[i])) {
            result[*returnSize] = (char*)malloc(strlen(names[i]) + 1);
            strcpy(result[*returnSize], names[i]);
            markUsed(names[i]);
            (*returnSize)++;
        } else {
            int k = getNextSuffix(names[i]);
            char newName[MAX_LEN];
            sprintf(newName, "%s(%d)", names[i], k);
            
            while (isUsed(newName)) {
                k++;
                sprintf(newName, "%s(%d)", names[i], k);
            }
            
            result[*returnSize] = (char*)malloc(strlen(newName) + 1);
            strcpy(result[*returnSize], newName);
            markUsed(newName);
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    char* names[] = {"doc", "doc", "doc"};
    int returnSize;
    char** result = getFolderNames(names, 3, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%s ", result[i]);
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each name is processed exactly once with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique names plus counters

⚡ Linearithmic Space

28.6K Views

Medium Frequency

~25 min Avg. Time

890 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler