Find Duplicate File in System - Practice Coding Problems

Find Duplicate File in System - Problem

Imagine you're a system administrator managing a large file system with thousands of files scattered across multiple directories. Over time, users have created duplicate files with identical content but stored in different locations, wasting precious storage space.

Your mission: Given a list of directory information strings, identify all groups of duplicate files that have the same content.

Each directory info string follows this format:
"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"

This means:

Directory path: root/d1/d2/.../dm
Files with their content in parentheses: f1.txt(f1_content), etc.
If m = 0, the directory is just the root

Goal: Return all groups of duplicate files, where each group contains at least 2 files with identical content. Each file should be represented by its full path: "directory_path/file_name.txt"

Example: If two files have content "hello world", group them together regardless of their location in the file system.

Input & Output

example_1.py — Basic case with duplicates

$ 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 form one group. Files with content 'abcd': root/a/1.txt, root/c/3.txt form another group.

example_2.py — No duplicates case

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

› Output: []

💡 Note: All files have unique content, so no duplicate groups are found.

example_3.py — Multiple files same directory

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

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

💡 Note: Two files in root directory have identical content 'same', forming one duplicate group.

Visualization

Tap to expand

Understanding the Visualization

Parse Directory Structure

Extract file paths and contents from directory strings, like cataloging books and their content

Hash Map Grouping

Use content as key to group files - like organizing books by their actual text content

Identify Duplicates

Files with same content are duplicates - like finding books with identical text but different covers

Build Result Groups

Return groups with 2+ files - the sets of duplicate files to consider for cleanup

Key Takeaway

🎯 Key Insight: Hash maps allow us to group files by content in O(1) time per file, making duplicate detection efficient even for massive file systems with thousands of files.

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

n is total number of files, m is average content length for string operations. Each file is processed once.

✓ Linear Growth

Space Complexity

O(n * m)

Space for hash map storing all file paths and contents, plus result groups

⚡ Linearithmic Space

Constraints

1 ≤ paths.length ≤ 2 × 10⁴
1 ≤ paths[i].length ≤ 3000
1 ≤ sum of all file contents length ≤ 5 × 10⁵
paths[i] has the format "dir file1.txt(content1) file2.txt(content2) ... fileN.txt(contentN)"
Answer can be returned in any order

Asked in

G Google 45 a Amazon 38 D Dropbox 32 ⊞ Microsoft 28

The optimal solution uses a hash map to group files by content in a single pass. Parse each directory string, extract file paths and contents, then use the content as a key to group identical files. This achieves O(n) time complexity where n is the total number of files, making it highly efficient for large file systems.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Compare All Pairs)	O(n² * m)	O(n)	Compare every file's content with every other file's content
One-Pass Hash Table (Optimal)	O(n * m)	O(n * m)	Use hash map to group files by content in a single pass

Brute Force (Compare All Pairs) — Algorithm Steps

Parse each directory string to extract file paths and contents
Store all files in a list with their full paths and contents
For each file, compare its content with every other file
Group files that have matching content
Filter out groups with only one file

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Files

Extract all file paths and their contents from directory strings

Compare Pairs

For each file, compare its content with every other file

Group Matches

Collect files with matching content into groups

Filter Results

Keep only groups with 2 or more files

Code -

solution.c — C

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

char*** findDuplicate(char** paths, int pathsSize, int* returnSize, int** returnColumnSizes) {
    typedef struct {
        char* path;
        char* content;
    } FileInfo;
    
    FileInfo* files = malloc(1000 * sizeof(FileInfo));
    int fileCount = 0;
    
    // Parse all directory strings
    for (int i = 0; i < pathsSize; i++) {
        char* pathInfo = strdup(paths[i]);
        char* directory = strtok(pathInfo, " ");
        char* fileInfo;
        
        while ((fileInfo = strtok(NULL, " ")) != NULL) {
            char* parenPos = strchr(fileInfo, '(');
            *parenPos = '\0';
            char* filename = fileInfo;
            char* content = parenPos + 1;
            content[strlen(content) - 1] = '\0'; // Remove closing paren
            
            char* fullPath = malloc(256);
            sprintf(fullPath, "%s/%s", directory, filename);
            
            files[fileCount].path = fullPath;
            files[fileCount].content = strdup(content);
            fileCount++;
        }
        free(pathInfo);
    }
    
    // Find duplicates by comparing all pairs
    char*** result = malloc(1000 * sizeof(char**));
    int* columnSizes = malloc(1000 * sizeof(int));
    int groupCount = 0;
    int* used = calloc(fileCount, sizeof(int));
    
    for (int i = 0; i < fileCount; i++) {
        if (used[i]) continue;
        
        char** currentGroup = malloc(1000 * sizeof(char*));
        int groupSize = 0;
        
        currentGroup[groupSize++] = strdup(files[i].path);
        used[i] = 1;
        
        for (int j = i + 1; j < fileCount; j++) {
            if (used[j]) continue;
            
            if (strcmp(files[i].content, files[j].content) == 0) {
                currentGroup[groupSize++] = strdup(files[j].path);
                used[j] = 1;
            }
        }
        
        if (groupSize > 1) {
            result[groupCount] = currentGroup;
            columnSizes[groupCount] = groupSize;
            groupCount++;
        } else {
            free(currentGroup[0]);
            free(currentGroup);
        }
    }
    
    *returnSize = groupCount;
    *returnColumnSizes = columnSizes;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² * m)

n is total number of files, m is average content length. We compare each file with every other file.

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store all file information and result groups

⚡ Linearithmic Space

Constraints

1 ≤ paths.length ≤ 2 × 10⁴
1 ≤ paths[i].length ≤ 3000
1 ≤ sum of all file contents length ≤ 5 × 10⁵
paths[i] has the format "dir file1.txt(content1) file2.txt(content2) ... fileN.txt(contentN)"
Answer can be returned in any order

42.0K Views

Medium Frequency

~18 min Avg. Time

1.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Compare All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler