Diff Tool Builder - Problem

Build a text diff tool that compares two strings line by line, showing additions (+), deletions (-), and unchanged lines.

Requirements:

Split both strings into lines
Compare each line and mark as: unchanged, added (+), or deleted (-)
Return an array of strings where each string represents one line with its prefix
Unchanged lines have no prefix, additions start with '+', deletions start with '-'

Note: This is a simplified diff tool - you don't need to implement complex alignment algorithms.

Input & Output

Example 1 — Basic Diff

$ Input: text1 = "line1\nline2\nline3", text2 = "line1\nline4\nline3"

› Output: ["line1", "-line2", "line3", "+line4"]

💡 Note: Line1 and line3 are unchanged, line2 was deleted from text1, line4 was added in text2

Example 2 — All Changes

$ Input: text1 = "hello\nworld", text2 = "goodbye\nuniverse"

› Output: ["-hello", "-world", "+goodbye", "+universe"]

💡 Note: No common lines - all lines from text1 are deleted, all from text2 are added

Example 3 — Empty Text

$ Input: text1 = "", text2 = "new line"

› Output: ["+new line"]

💡 Note: Empty first text, so the line in text2 is an addition

Constraints

0 ≤ text1.length, text2.length ≤ 10⁴
Each line contains only printable ASCII characters
Lines are separated by '\n' character

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 G GitHub 8 G GitLab 6

The key insight is using a hash set to enable O(1) line lookups instead of scanning through all lines repeatedly. The optimal approach builds a frequency map of text2 lines, then processes text1 lines with instant lookups. Time: O(n+m), Space: O(m).

Common Approaches

✓ Brute Force Comparison

⏱️ Time: O(n×m) Space: O(n+m)

Split both texts into lines, then for each line in text1, scan through all lines in text2 to check if it exists. Then do the reverse for additions.

Hash Set Lookup

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

Store all lines from text2 in a hash set, then check each line from text1 against the set in constant time. Handle duplicates by tracking usage.

Brute Force Comparison — Algorithm Steps

Split both texts into arrays of lines
For each line in text1, scan all of text2 to see if it exists
Mark as deleted (-) if not found, unchanged if found
For remaining lines in text2, mark as added (+)

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Texts

Split both texts into arrays of lines

Scan for Matches

For each line in text1, scan all lines in text2

Mark Changes

Mark lines as unchanged, deleted (-), or added (+)

Code -

solution.c — C

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

#define MAX_LINES 1000
#define MAX_LINE_LEN 1000

int splitLines(const char* text, char lines[][MAX_LINE_LEN]) {
    if (strlen(text) == 0) return 0;
    
    int count = 0;
    const char* start = text;
    const char* end = strchr(start, '\n');
    
    while (end != NULL) {
        int len = end - start;
        strncpy(lines[count], start, len);
        lines[count][len] = '\0';
        count++;
        start = end + 1;
        end = strchr(start, '\n');
    }
    
    // Add the last line if it doesn't end with newline
    if (strlen(start) > 0) {
        strcpy(lines[count], start);
        count++;
    }
    
    return count;
}

int solution(const char* text1, const char* text2, char result[][MAX_LINE_LEN]) {
    char lines1[MAX_LINES][MAX_LINE_LEN];
    char lines2[MAX_LINES][MAX_LINE_LEN];
    int count1 = splitLines(text1, lines1);
    int count2 = splitLines(text2, lines2);
    int resultCount = 0;
    int usedIndices[MAX_LINES] = {0};
    
    // Check each line in text1
    for (int i = 0; i < count1; i++) {
        int found = 0;
        for (int j = 0; j < count2; j++) {
            if (!usedIndices[j] && strcmp(lines1[i], lines2[j]) == 0) {
                strcpy(result[resultCount], lines1[i]);  // unchanged
                usedIndices[j] = 1;
                found = 1;
                resultCount++;
                break;
            }
        }
        if (!found) {
            result[resultCount][0] = '-';
            strcpy(result[resultCount] + 1, lines1[i]);  // deleted
            resultCount++;
        }
    }
    
    // Add remaining lines from text2 as additions
    for (int j = 0; j < count2; j++) {
        if (!usedIndices[j]) {
            result[resultCount][0] = '+';
            strcpy(result[resultCount] + 1, lines2[j]);  // added
            resultCount++;
        }
    }
    
    return resultCount;
}

int main() {
    char text1[10000], text2[10000];
    char result[MAX_LINES][MAX_LINE_LEN];
    
    fgets(text1, sizeof(text1), stdin);
    fgets(text2, sizeof(text2), stdin);
    
    // Remove trailing newlines
    text1[strcspn(text1, "\n")] = 0;
    text2[strcspn(text2, "\n")] = 0;
    
    int count = solution(text1, text2, result);
    for (int i = 0; i < count; i++) {
        printf("%s\n", result[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

For each of n lines in text1, we scan all m lines in text2

✓ Linear Growth

Space Complexity

O(n+m)

Store lines from both texts and result array

⚡ Linearithmic Space

30.8K Views

Medium Frequency

~25 min Avg. Time

856 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

Diff Tool Builder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler