Find Duplicate File in System

Find Duplicate File in System - Problem

Given a list paths of directory info, including the directory path, and all the files with contents in this directory, return all the duplicate files in the file system in terms of their paths.

You may return the answer in any order.

A group of duplicate files consists of at least two files that have the same content.

A single directory info string in the input list has the following format:

"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"

It means there are n files (f1.txt, f2.txt ... fn.txt) with content (f1_content, f2_content ... fn_content) respectively in the directory "root/d1/d2/.../dm".

Note that n >= 1 and m >= 0. If m = 0, it means the directory is just the root directory.

The output is a list of groups of duplicate file paths. For each group, it contains all the file paths of the files that have the same content.

A file path is a string that has the following format: "directory_path/file_name.txt"

Input & Output

Example 1 — Basic Duplicate Detection

$ Input: paths = ["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"]

› Output: [["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]]

💡 Note: Files with content 'efgh': root/a/2.txt, root/c/d/4.txt, root/4.txt. Files with content 'abcd': root/a/1.txt, root/c/3.txt

Example 2 — No Duplicates

$ Input: paths = ["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(ijkl)"]

› Output: []

💡 Note: All files have unique content, so no duplicates exist

Example 3 — Single Directory

$ Input: paths = ["root 1.txt(same) 2.txt(same) 3.txt(different)"]

› Output: [["root/1.txt","root/2.txt"]]

💡 Note: Only files with 'same' content are duplicates: root/1.txt and root/2.txt

Constraints

1 ≤ paths.length ≤ 2 × 10⁴
1 ≤ sum of all paths[i].length ≤ 5 × 10⁵
paths[i] consists of English letters, digits, '/', '.', '(', ')', and ' '.
You may assume no files or directories share the same name in the same directory.
You may assume each given directory info represents a unique directory. A single blank space separates the directory path and file info.

Visualization

Tap to expand

Asked in

D Dropbox 25 G Google 20 a Amazon 15

The key insight is to use a hash map where file content is the key and list of file paths is the value. This automatically groups files with identical content. Parse each directory string to extract file paths and contents, then return groups with more than one file. Best approach is hash map grouping with Time: O(n), Space: O(n).

Common Approaches

✓ Greedy

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

Optimized

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

Brute Force Comparison

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

Parse all files first, then compare each file's content with every other file's content to identify duplicates. Group files with matching content together.

Hash Map Grouping

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

Parse all directory strings to extract files, then use a hash map where content is the key and list of file paths is the value. Files with same content automatically get grouped together.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void permute(int* arr, int start, int end, int* jobs, int* workers, int n, int* minDays) {
    if (start == end) {
        int maxDays = 0;
        for (int i = 0; i < n; i++) {
            int jobTime = jobs[arr[i]];
            int workerCapacity = workers[i];
            int daysNeeded = (int)ceil((double)jobTime / workerCapacity);
            if (daysNeeded > maxDays) maxDays = daysNeeded;
        }
        if (maxDays < *minDays) *minDays = maxDays;
        return;
    }
    
    for (int i = start; i <= end; i++) {
        swap(&arr[start], &arr[i]);
        permute(arr, start + 1, end, jobs, workers, n, minDays);
        swap(&arr[start], &arr[i]);
    }
}

int solution(int* jobs, int* workers, int n) {
    int* indices = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) indices[i] = i;
    
    int minDays = INT_MAX;
    permute(indices, 0, n - 1, jobs, workers, n, &minDays);
    
    free(indices);
    return minDays;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Simple parsing for arrays
    int jobs[100], workers[100];
    int n = 0;
    
    // Parse jobs array
    char* token = strtok(line1 + 1, ",]");
    while (token != NULL) {
        jobs[n] = atoi(token);
        token = strtok(NULL, ",]");
        n++;
    }
    
    // Parse workers array
    int idx = 0;
    token = strtok(line2 + 1, ",]");
    while (token != NULL && idx < n) {
        workers[idx] = atoi(token);
        token = strtok(NULL, ",]");
        idx++;
    }
    
    printf("%d\n", solution(jobs, workers, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

892 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