Permutation Difference between Two Strings

Permutation Difference between Two Strings - Problem

You are given two strings s and t such that every character occurs at most once in s and t is a permutation of s.

The permutation difference between s and t is defined as the sum of the absolute difference between the index of the occurrence of each character in s and the index of the occurrence of the same character in t.

Return the permutation difference between s and t.

Input & Output

Example 1 — 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 — No Movement

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

› Output: 0

💡 Note: Both strings are identical, so no characters moved positions. All differences are 0.

Example 3 — Complete Reversal

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

› Output: 12

💡 Note: Each character moved to the opposite end: 'a' moved 4 positions, 'b' moved 2, 'c' stayed, 'd' moved 2, 'e' moved 4. Total: 4+2+0+2+4 = 12

Constraints

1 ≤ s.length ≤ 26
Each character occurs at most once in s
t is a permutation of s

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a hash map to store character positions from string t, enabling O(1) lookups. Best approach is the two-pass hash map solution. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Search

⏱️ Time: O(n²) Space: O(1)

Iterate through each character in string s and search through string t to find where that character appears. Calculate the absolute difference and sum all differences.

Hash Map Optimization

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

First pass creates a hash map storing each character's position in string t. Second pass iterates through s and uses the hash map to instantly find each character's position in t.

Brute Force Search — Algorithm Steps

For each character at position i in s
Search through t to find its position j
Add |i - j| to the total difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Character

Take character from position i in s

Search in t

Linear search through t to find matching character

Calculate Difference

Add |i - j| to running sum

Code -

solution.c — C

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

int solution(char* s, char* t) {
    int totalDiff = 0;
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        char ch = s[i];
        // Find position of char 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];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    int result = solution(s, t);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop n iterations, inner search up to n iterations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for counters and sum

✓ Linear Space

12.5K Views

Medium Frequency

~10 min Avg. Time

342 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 Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler