Odd String Difference

Odd String Difference - Problem

You are given an array of equal-length strings words. Assume that the length of each string is n.

Each string words[i] can be converted into a difference integer array difference[i] of length n - 1 where difference[i][j] = words[i][j+1] - words[i][j] where 0 <= j <= n - 2. Note that the difference between two letters is the difference between their positions in the alphabet i.e. the position of 'a' is 0, 'b' is 1, and 'z' is 25.

For example, for the string "acb", the difference integer array is [2 - 0, 1 - 2] = [2, -1].

All the strings in words have the same difference integer array, except one. You should find that string.

Return the string in words that has different difference integer array.

Input & Output

Example 1 — Basic Case

$ Input: words = ["abc", "bcd", "acb"]

› Output: "acb"

💡 Note: "abc" → [1,1] (b-a=1, c-b=1), "bcd" → [1,1] (c-b=1, d-c=1), "acb" → [2,-1] (c-a=2, b-c=-1). The string "acb" has a different pattern.

Example 2 — Different Position

$ Input: words = ["adc", "wzy", "abc"]

› Output: "adc"

💡 Note: "adc" → [3,-1] (d-a=3, c-d=-1), "wzy" → [-3,1] (z-w=-3, y-z=1), "abc" → [1,1]. The string "adc" has a unique difference pattern.

Example 3 — Edge Case

$ Input: words = ["aaa", "bob", "ccc"]

› Output: "bob"

💡 Note: "aaa" → [0,0] (a-a=0, a-a=0), "bob" → [13,-13] (o-b=13, b-o=-13), "ccc" → [0,0]. The string "bob" is the only one with non-zero differences.

Constraints

3 ≤ words.length ≤ 100
n == words[i].length
2 ≤ n ≤ 20
words[i] consists of lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 8

The key insight is that with exactly one odd string out, we only need to compare the first three strings to determine which pattern is unique. The optimal approach uses three-way comparison logic. Time: O(m), Space: O(m).

Common Approaches

✓ Brute Force Comparison

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

Convert each string to its difference array, then for each string, check if it matches any other string's difference array. The one that doesn't match any other is the answer.

Frequency Count

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

Convert all strings to difference arrays, count how many times each pattern appears, then return the string whose pattern appears only once.

Three-Way Comparison

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

Since exactly one string is different, we only need to check the first three strings. If the first two match, the third is odd; if first and third match, second is odd; otherwise, first is odd.

Brute Force Comparison — Algorithm Steps

Convert each string to difference array
For each string, compare with all others
Return the string that has no matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Arrays

Transform each string to difference array

Compare Pairs

Check each array against all others

Find Unique

Identify the array with no matches

Code -

solution.c — C

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

void calculateDifference(char* str, int* diff, int len) {
    for (int i = 0; i < len - 1; i++) {
        diff[i] = str[i + 1] - str[i];
    }
}

int areDifferencesEqual(int* diff1, int* diff2, int len) {
    for (int i = 0; i < len; i++) {
        if (diff1[i] != diff2[i]) {
            return 0;
        }
    }
    return 1;
}

char* oddString(char** words, int wordsSize) {
    int n = strlen(words[0]);
    int diffLen = n - 1;
    
    int** differences = (int**)malloc(wordsSize * sizeof(int*));
    for (int i = 0; i < wordsSize; i++) {
        differences[i] = (int*)malloc(diffLen * sizeof(int));
        calculateDifference(words[i], differences[i], n);
    }
    
    char* result = NULL;
    
    for (int i = 0; i < wordsSize; i++) {
        int matchCount = 0;
        
        for (int j = 0; j < wordsSize; j++) {
            if (areDifferencesEqual(differences[i], differences[j], diffLen)) {
                matchCount++;
            }
        }
        
        if (matchCount == 1) {
            result = (char*)malloc((n + 1) * sizeof(char));
            strcpy(result, words[i]);
            break;
        }
    }
    
    for (int k = 0; k < wordsSize; k++) {
        free(differences[k]);
    }
    free(differences);
    
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    // Parse input array
    char** words = malloc(100 * sizeof(char*));
    int wordsSize = 0;
    
    // Remove brackets and quotes
    char* ptr = input;
    while (*ptr != '\0') {
        if (*ptr == '"') {
            ptr++;
            char* start = ptr;
            while (*ptr != '"' && *ptr != '\0') {
                ptr++;
            }
            int len = ptr - start;
            words[wordsSize] = (char*)malloc((len + 1) * sizeof(char));
            strncpy(words[wordsSize], start, len);
            words[wordsSize][len] = '\0';
            wordsSize++;
            if (*ptr == '"') ptr++;
        } else {
            ptr++;
        }
    }
    
    char* result = oddString(words, wordsSize);
    
    if (result != NULL) {
        printf("%s\n", result);
        free(result);
    }
    
    for (int i = 0; i < wordsSize; i++) {
        free(words[i]);
    }
    free(words);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² comparisons between strings, each taking O(m) time where m is string length

⚠ Quadratic Growth

Space Complexity

O(n × m)

Store difference arrays for all n strings, each of length m-1

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~12 min Avg. Time

245 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

Brute Force Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler