Odd String Difference - Practice Coding Problems

Odd String Difference - Problem

You're given an array of equal-length strings where all strings follow the same character pattern except one. Your mission is to identify the odd string out!

How it works:

Each string can be converted into a difference array by calculating the difference between adjacent characters
The difference between two letters is their position difference in the alphabet: 'a'=0, 'b'=1, ..., 'z'=25
For example: "acb" → differences are [2-0, 1-2] = [2, -1]

The twist: All strings will have the same difference array except exactly one. Find that unique string!

Goal: Return the string that has a different difference pattern from all others.

Input & Output

example_1.py — Basic Example

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

› Output: "abc"

💡 Note: "adc" → [2, -1], "wzy" → [2, -1], "abc" → [1, 1]. The strings "adc" and "wzy" have the same difference pattern [2, -1], while "abc" has a unique pattern [1, 1].

example_2.py — Different Positions

$ Input: ["aaa", "bob", "ccc", "ddd"]

› Output: "bob"

💡 Note: "aaa" → [0, 0], "bob" → [13, -13], "ccc" → [0, 0], "ddd" → [0, 0]. Three strings have pattern [0, 0] while "bob" has unique pattern [13, -13].

example_3.py — Edge Case

$ Input: ["xy", "yz", "zx"]

› Output: "zx"

💡 Note: "xy" → [1], "yz" → [1], "zx" → [-23]. Two strings have pattern [1] while "zx" has unique pattern [-23] (z to x wraps around the alphabet).

Constraints

3 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 20
words[i] consists of lowercase English letters only
All strings have the same length
Exactly one string has a different difference pattern

Visualization

Tap to expand

Understanding the Visualization

Extract DNA Signatures

Convert each DNA sequence to its characteristic difference pattern

Count Pattern Frequencies

Use a hash map to count how many sequences have each pattern

Identify the Mutant

The pattern with frequency 1 belongs to the mutant sequence

Key Takeaway

🎯 Key Insight: By counting pattern frequencies, we can identify the unique string in O(n×m) time - much more efficient than comparing every pair!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses a hash map to count the frequency of each difference pattern. Since exactly one string is different, we convert each string to its difference array, count patterns, and return the string whose pattern appears only once. Time complexity: O(n × m), Space complexity: O(n × m).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Compare All Pairs)	O(n² × m)	O(m)	Compare each string's difference array with every other string to find the unique one
Hash Map Counting (Optimal)	O(n × m)	O(n × m)	Count frequency of each difference pattern and return the string with frequency 1
Two-Pass Hash Table	O(n × m)	O(n × m)	First pass builds frequency map, second pass finds the pattern with count 1

Brute Force (Compare All Pairs) — Algorithm Steps

Create a helper function to calculate difference array for any string
For each string, calculate its difference array
Compare each string's difference array with all other strings
Return the string that doesn't match any other string

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Differences

Convert each string to its difference array

Compare Pairs

Compare each string with every other string

Count Matches

Count how many strings have the same pattern

Find Unique

The string with 0 matches is our answer

Code -

solution.c — C

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

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

int equalArrays(int* a, int* b, int len) {
    for (int i = 0; i < len; i++) {
        if (a[i] != b[i]) return 0;
    }
    return 1;
}

char* oddString(char words[][100], int n, int wordLen) {
    static char result[100];
    
    for (int i = 0; i < n; i++) {
        int diffI[wordLen - 1];
        getDifference(words[i], diffI, wordLen);
        
        int matches = 0;
        for (int j = 0; j < n; j++) {
            if (i != j) {
                int diffJ[wordLen - 1];
                getDifference(words[j], diffJ, wordLen);
                if (equalArrays(diffI, diffJ, wordLen - 1)) {
                    matches++;
                }
            }
        }
        
        if (matches == 0) {
            strcpy(result, words[i]);
            return result;
        }
    }
    return "";
}

int main() {
    char words[3][100] = {"adc", "wzy", "abc"};
    printf("%s\n", oddString(words, 3, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

We compare each of n strings with every other string, and each comparison takes O(m) time where m is string length

⚠ Quadratic Growth

Space Complexity

O(m)

Only need space to store difference arrays temporarily

✓ Linear Space

18.4K Views

Medium Frequency

~15 min Avg. Time

847 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 (Compare All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler