Permutation Difference between Two Strings

Permutation Difference between Two Strings - Problem

Imagine you have two strings where one is a rearranged version of the other. Your task is to measure how much the characters have "moved" from their original positions.

Given two strings s and t where:

Every character appears exactly once in each string
t is a permutation (rearrangement) of s

The permutation difference is calculated as: the sum of absolute differences between the index positions of each character in both strings.

Example: If s = "abc" and t = "bac", then:

Character 'a': position 0 in s, position 1 in t → |0-1| = 1
Character 'b': position 1 in s, position 0 in t → |1-0| = 1
Character 'c': position 2 in s, position 2 in t → |2-2| = 0
Total difference: 1 + 1 + 0 = 2

Return the permutation difference between the two strings.

Input & Output

example_1.py — Basic Case

$ Input: s = "abc", t = "bac"

› Output: 2

💡 Note: Character 'a': position 0 in s, position 1 in t → |0-1| = 1. Character 'b': position 1 in s, position 0 in t → |1-0| = 1. Character 'c': position 2 in s, position 2 in t → |2-2| = 0. Total: 1 + 1 + 0 = 2.

example_2.py — No Movement

$ Input: s = "abcde", t = "abcde"

› Output: 0

💡 Note: All characters are in the same positions in both strings, so all differences are 0. Total: 0 + 0 + 0 + 0 + 0 = 0.

example_3.py — Complete Reversal

$ Input: s = "abc", t = "cba"

› Output: 4

💡 Note: Character 'a': position 0 in s, position 2 in t → |0-2| = 2. Character 'b': position 1 in s, position 1 in t → |1-1| = 0. Character 'c': position 2 in s, position 0 in t → |2-0| = 2. Total: 2 + 0 + 2 = 4.

Constraints

1 ≤ s.length ≤ 1000
t.length == s.length
s and t consist of lowercase English letters
Each character appears at most once in s
t is a permutation of s

Visualization

Tap to expand

Understanding the Visualization

Record Home Addresses

Create a hash map storing each character's original position in string s

Check Party Locations

For each character in string t, look up their home position

Calculate Travel Distance

Compute absolute difference between home and party positions

Sum Total Movement

Add up all individual distances to get total permutation difference

Key Takeaway

🎯 Key Insight: By storing character positions in a hash map, we transform expensive O(n) searches into instant O(1) lookups, reducing overall complexity from O(n²) to O(n).

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a hash table to store character positions from the first string, then iterates through the second string calculating differences with O(1) lookups. This achieves O(n) time complexity and is much more efficient than the O(n²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each character in string s, search through string t to find its position
Hash Table Approach (Optimal)	O(n)	O(n)	Store character positions in hash map for O(1) lookup time

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each character and index in string s
For each character, scan through string t to find its position
Calculate absolute difference between positions
Add the difference to running total

Visualization

Tap to expand

Step-by-Step Walkthrough

Take first character

Get character 'a' at position 0 in string s

Search in string t

Scan through t until we find 'a' at position 1

Calculate difference

Add |0-1| = 1 to our running sum

Repeat process

Continue for all remaining characters

Code -

solution.c — C

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

int findPermutationDifference(char* s, char* t) {
    int totalDiff = 0;
    int len = strlen(s);
    
    // For each character in s
    for (int i = 0; i < len; i++) {
        char ch = s[i];
        // Find this character's position in t
        for (int j = 0; j < len; j++) {
            if (t[j] == ch) {
                totalDiff += abs(i - j);
                break;
            }
        }
    }
    
    return totalDiff;
}

int main() {
    char s[1001], t[1001];
    scanf("%s %s", s, t);
    printf("%d\n", findPermutationDifference(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n characters in s, we scan through n characters in t

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for tracking position and sum

✓ Linear Space

28.4K Views

Medium Frequency

~12 min Avg. Time

845 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler