Making File Names Unique

Making File Names Unique - Problem

Given an array of strings names of size n. You will create n folders in your file system such that, at the i^th minute, you will create a folder with the name names[i].

Since two files cannot have the same name, if you enter a folder name that was previously used, the system will have a suffix addition to its name in the form of (k), where k is the smallest positive integer such that the obtained name remains unique.

Return an array of strings of length n where ans[i] is the actual name the system will assign to the i^th folder when you create it.

Input & Output

Example 1 — Basic Duplicates

$ Input: names = ["pes","fifa","gta","pes(2023)"]

› Output: ["pes","fifa","gta","pes(2023)"]

💡 Note: All names are unique, so no modifications needed. The system assigns exact names as requested.

Example 2 — Multiple Duplicates

$ Input: names = ["gta","gta(1)","gta","avalon"]

› Output: ["gta","gta(1)","gta(2)","avalon"]

💡 Note: First 'gta' is unique. 'gta(1)' is unique. Second 'gta' conflicts with first, so becomes 'gta(2)' (since 'gta(1)' exists). 'avalon' is unique.

Example 3 — Sequential Conflicts

$ Input: names = ["kaido","kaido(1)","kaido","kaido(1)"]

› Output: ["kaido","kaido(1)","kaido(2)","kaido(1)(1)"]

💡 Note: First 'kaido' is unique. 'kaido(1)' is unique. Second 'kaido' becomes 'kaido(2)'. Second 'kaido(1)' becomes 'kaido(1)(1)'.

Constraints

1 ≤ names.length ≤ 5 × 10⁴
1 ≤ names[i].length ≤ 20
names[i] consists of lower case English letters, digits, and/or round brackets.

Visualization

Tap to expand

Asked in

a Amazon 15 f Facebook 12

The key insight is to track each name's next available suffix using a hash map. When we encounter a duplicate, we use the stored suffix number and increment it for future duplicates. Best approach uses hash map tracking for O(1) lookups. Time: O(n), Space: O(n)

Common Approaches

✓ Binary Search Answer

⏱️ Time: N/A Space: N/A

Greedy

⏱️ Time: N/A Space: N/A

Brute Force - Linear Search

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

Process each name sequentially. For duplicates, try suffixes (1), (2), (3)... until finding one not in the previous results. This requires checking all previous names for each conflict.

Hash Map - Track Used Names

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

Maintain a hash map where keys are base names and values are the next available suffix number. When we see a duplicate, we use the stored suffix number and increment it for future use.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int max(int a, int b) {
    return a > b ? a : b;
}

bool canAchieve(int* points, int n, int m, int target) {
    const int INF = 1000000000;
    int* prev = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        prev[i] = INF;
    }
    
    // First move must go to position 0 from -1
    prev[0] = points[0];
    
    for (int move = 1; move < m; move++) {
        int* curr = (int*)malloc(n * sizeof(int));
        for (int i = 0; i < n; i++) {
            curr[i] = INF;
        }
        
        for (int pos = 0; pos < n; pos++) {
            if (prev[pos] == INF) continue;
            
            // Try moving left
            if (pos > 0) {
                int val = prev[pos];
                if (prev[pos - 1] != INF) {
                    val = min(val, prev[pos - 1] + points[pos - 1]);
                }
                curr[pos - 1] = min(curr[pos - 1], val);
            }
            
            // Try moving right
            if (pos < n - 1) {
                int val = prev[pos];
                if (prev[pos + 1] != INF) {
                    val = min(val, prev[pos + 1] + points[pos + 1]);
                }
                curr[pos + 1] = min(curr[pos + 1], val);
            }
            
            // Stay at same position (add more points)
            curr[pos] = min(curr[pos], prev[pos] + points[pos]);
        }
        
        free(prev);
        prev = curr;
    }
    
    int minVal = prev[0];
    for (int i = 1; i < n; i++) {
        if (prev[i] < minVal) {
            minVal = prev[i];
        }
    }
    
    free(prev);
    return minVal >= target;
}

int solution(int* points, int n, int m) {
    int maxPoint = points[0];
    for (int i = 1; i < n; i++) {
        maxPoint = max(maxPoint, points[i]);
    }
    
    int left = 0, right = m * maxPoint;
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canAchieve(points, n, m, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int points[100];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        points[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int m;
    scanf("%d", &m);
    
    int result = solution(points, n, m);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

850 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