# Reduce Hamming distance by swapping two characters

• Difficulty Level : Medium
• Last Updated : 18 Nov, 2022

Given two strings S and T. Find the positions of two letters to be swapped in S so that the hamming distance between strings S and T is as small as possible.
Hamming Distance: Hamming distance between two strings S and T of the same length, which is defined as the number of positions in which S and T have different characters

Examples:

```Input : S = "permanent", T = "pergament"
Output: 4 6

Input : S = "double" T = "bundle"
Output : 4 1```
• Explanation 1: Initially, the hamming distance between S and T is 2(at 4 and 6). After swapping the letters at positions 4 and 6 it becomes “pernament”. Here, the hamming distance is only 1. This is the minimum possible.
• Explanation 2: Before swapping: “double” “bundle”, distance = 4
After swapping: “boudle” “bundle”, distance = 2

Approach :

In the given string, hamming distance can be decreased by at most two because, only two characters can be moved.

• Case-I: Decrease distance by two is possible, if there are two positions with the same two letters in two strings but that appear in different order(like “bundle” and “double”).
• Case-II: Decrease by one is possible by “fixing” the characters that are on wrong positions(like in “permanent” and “pergament”, here n stands in wrong pair with m and there is also unmatched m, which we can fix).
• Case-III: If not possible to decrease the hamming distance, print -1.

Implementation:

• Case-I: To decrease the distance by two, create a 2-d array dp[i][j](i is s[] – ‘a’ and j is t[] – ‘a’) and assign it to the index of i in string S. If repeated pair is found, print the corresponding indexes.
• Case-II: To decrease the distance by one, maintain two arrays A[] and B[]

Implementation:

## C++

 `// C++ code to decrease``// hamming distance using swap.``#include ``using` `namespace` `std;` `#define MAX 26` `// Function to return the``// swapped indexes to get``// minimum hamming distance.``void` `Swap(string s, string t, ``int` `n)``{``    ``int` `dp[MAX][MAX];``    ``memset``(dp, -1, ``sizeof` `dp);` `    ``// Find the initial hamming``    ``// distance``    ``int` `tot = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``if` `(s[i] != t[i])``            ``tot++;``    ` `    ``// Case-I: To decrease distance``    ``// by two``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// ASCII values of present``        ``// character.``        ``int` `a = s[i] - ``'a'``;``        ``int` `b = t[i] - ``'a'``;` `        ``if` `(a == b)``            ``continue``;` `        ``// If two same letters appear``        ``// in different positions``        ``// print their indexes``        ``if` `(dp[a][b] != -1) {``            ``cout << i + 1 << ``" "``                ``<< dp[a][b] + 1 << endl;``            ``return``;``        ``}` `        ``// Store the index of``        ``// letters which is``        ``// in wrong position``        ``dp[b][a] = i;``    ``}` `    ``// Case:II``    ``int` `A[MAX], B[MAX];``    ``memset``(A, -1, ``sizeof` `A);``    ``memset``(B, -1, ``sizeof` `B);` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `a = s[i] - ``'a'``;``        ``int` `b = t[i] - ``'a'``;``        ``if` `(a == b)``            ``continue``;` `        ``// If misplaced letter``        ``// is found, print its``        ``// original index and``        ``// its new index``        ``if` `(A[b] != -1) {``            ``cout << i + 1 << ``" "` `<<``                  ``A[b] + 1 << endl;``            ``return``;``        ``}` `        ``if` `(B[a] != -1) {``            ``cout << i + 1 << ``" "` `<<``                  ``B[a] + 1 << endl;``            ``return``;``        ``}` `        ``// Store the index of``        ``// letters in wrong position``        ``A[a] = i;``        ``B[b] = i;``    ``}` `    ``// Case-III``    ``cout << -1 << endl;``}` `// Driver code``int` `main()``{``    ``string S = ``"permanent"``;``    ``string T = ``"pergament"``;``    ``int` `n = S.length();` `    ``if` `(S == ``""` `|| T == ``""``)``        ``cout << ``"Required string is empty."``;``    ``else``        ``Swap(S, T, n);` `    ``return` `0;``}`

## Java

 `// Java code to decrease``// hamming distance using swap.``import` `java.util.Arrays;` `class` `GFG``{``    ` `static` `final` `int` `MAX = ``26``;` `// Function to return the``// swapped indexes to get``// minimum hamming distance.``static` `void` `Swap(String s, String t, ``int` `n)``{``    ``int` `dp[][] = ``new` `int``[MAX][MAX];``    ``for``(``int` `i = ``0``; i < MAX; i++)``    ``{``        ``for``(``int` `j = ``0``; j < MAX; j++)``        ``{``            ``dp[i][j]=-``1``;``        ``}``    ``}` `    ``// Find the initial hamming``    ``// distance``    ``int` `tot = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``if` `(s.charAt(i) != t.charAt(i))``            ``tot++;``    ` `    ``// Case-I: To decrease distance``    ``// by two``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// ASCII values of present``        ``// character.``        ``int` `a = s.charAt(i)- ``'a'``;``        ``int` `b = t.charAt(i) - ``'a'``;` `        ``if` `(a == b)``            ``continue``;` `        ``// If two same letters appear``        ``// in different positions``        ``// print their indexes``        ``if` `(dp[a][b] != -``1``)``        ``{``            ``System.out.println(i + ``1` `+ ``" "` `+``                            ``(dp[a][b] + ``1``));``            ``return``;``        ``}` `        ``// Store the index of``        ``// letters which is``        ``// in wrong position``        ``dp[b][a] = i;``    ``}` `    ``// Case:II``    ``int` `A[] = ``new` `int``[MAX], B[] = ``new` `int``[MAX];``    ``Arrays.fill(A, -``1``);``    ``Arrays.fill(B, -``1``);` `    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``int` `a = s.charAt(i)- ``'a'``;``        ``int` `b = t.charAt(i) - ``'a'``;``        ``if` `(a == b)``            ``continue``;` `        ``// If misplaced letter``        ``// is found, print its``        ``// original index and``        ``// its new index``        ``if` `(A[b] != -``1``)``        ``{``            ``System.out.println(i + ``1` `+ ``" "` `+``                                ``(A[b] + ``1``));``            ``return``;``        ``}` `        ``if` `(B[a] != -``1``)``        ``{``            ``System.out.println(i + ``1` `+ ``" "` `+``                                 ``(B[a] + ``1``));``            ``return``;``        ``}` `        ``// Store the index of``        ``// letters in wrong position``        ``A[a] = i;``        ``B[b] = i;``    ``}` `    ``// Case-III``    ``System.out.println(-``1``);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``String S = ``"permanent"``;``    ``String T = ``"pergament"``;``    ``int` `n = S.length();` `    ``if` `(S == ``""` `|| T == ``""``)``        ``System.out.println(``"Required string is empty."``);``    ``else``        ``Swap(S, T, n);``}``}` `// This code is contributed by Rajput-Ji`

## Python 3

 `# Python 3 code to decrease``# hamming distance using swap.``MAX` `=` `26` `# Function to return the swapped indexes``# to get minimum hamming distance.``def` `Swap(s, t, n):` `    ``dp ``=` `[[``-``1` `for` `x ``in` `range``(``MAX``)]``              ``for` `y ``in` `range``(``MAX``)]` `    ``# Find the initial hamming``    ``# distance``    ``tot ``=` `0``;``    ``for` `i ``in` `range``(n):``        ``if` `(s[i] !``=` `t[i]):``            ``tot ``+``=` `1``    ` `    ``# Case-I: To decrease distance``    ``# by two``    ``for` `i ``in` `range``(n) :` `        ``# ASCII values of present``        ``# character.``        ``a ``=` `ord``(s[i]) ``-` `ord``(``'a'``)``        ``b ``=` `ord``(t[i]) ``-` `ord``(``'a'``)` `        ``if` `(a ``=``=` `b):``            ``continue` `        ``# If two same letters appear``        ``# in different positions``        ``# print their indexes``        ``if` `(dp[a][b] !``=` `-``1``) :``            ``print``(i ``+` `1``,``" "``, dp[a][b] ``+` `1``)``            ``return` `        ``# Store the index of``        ``# letters which is``        ``# in wrong position``        ``dp[b][a] ``=` `i` `    ``# Case:II``    ``A ``=` `[``-``1``] ``*` `MAX``    ``B ``=` `[``-``1``] ``*` `MAX` `    ``for` `i ``in` `range``(n) :``        ``a ``=` `ord``(s[i]) ``-` `ord``(``'a'``)``        ``b ``=` `ord``(t[i]) ``-` `ord``(``'a'``)``        ``if` `(a ``=``=` `b):``            ``continue` `        ``# If misplaced letter is found,``        ``# print its original index and``        ``# its new index``        ``if` `(A[b] !``=` `-``1``) :``            ``print``( i ``+` `1``, A[b] ``+` `1``)``            ``return` `        ``if` `(B[a] !``=` `-``1``) :``            ``print``( i ``+` `1``, B[a] ``+` `1``)``            ``return` `        ``# Store the index of``        ``# letters in wrong position``        ``A[a] ``=` `i``        ``B[b] ``=` `i``    ` `    ``# Case-III``    ``print``( ``"-1"` `)` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``S ``=` `"permanent"``    ``T ``=` `"pergament"``    ``n ``=` `len``(S)` `    ``if` `(S ``=``=` `"``" or T == "``"):``        ``print``(``"Required string is empty."``)``    ``else``:``        ``Swap(S, T, n)` `# This code is contributed``# by ChitraNayal`

## C#

 `// C# code to decrease``// hamming distance using swap.``using` `System;` `class` `GFG``{``    ` `static` `readonly` `int` `MAX = 26;` `    ``// Function to return the``    ``// swapped indexes to get``    ``// minimum hamming distance.``    ``static` `void` `Swap(``string` `s, ``string` `t, ``int` `n)``    ``{``        ``int` `[,]dp = ``new` `int``[MAX, MAX];``        ``for``(``int` `i = 0; i < MAX; i++)``        ``{``            ``for``(``int` `j = 0; j < MAX; j++)``            ``{``                ``dp[i, j]=-1;``            ``}``        ``}` `        ``// Find the initial hamming``        ``// distance``        ``int` `tot = 0;``        ``for` `(``int` `i = 0; i < n; i++)``            ``if` `(s[i] != t[i])``                ``tot++;` `        ``// Case-I: To decrease distance``        ``// by two``        ``for` `(``int` `i = 0; i < n; i++)``        ``{` `            ``// ASCII values of present``            ``// character.``            ``int` `a = s[i] - ``'a'``;``            ``int` `b = t[i] - ``'a'``;` `            ``if` `(a == b)``                ``continue``;` `            ``// If two same letters appear``            ``// in different positions``            ``// print their indexes``            ``if` `(dp[a,b] != -1)``            ``{``                ``Console.WriteLine(i + 1 + ``" "` `+``                                ``(dp[a, b] + 1));``                ``return``;``            ``}` `            ``// Store the index of``            ``// letters which is``            ``// in wrong position``            ``dp[b,a] = i;``        ``}` `        ``// Case:II``        ``int` `[]A = ``new` `int``[MAX]; ``int` `[]B = ``new` `int``[MAX];``        ``for` `(``int` `i = 0; i < MAX; i++)``        ``{``            ``A[i]=-1;``            ``B[i]=-1;``        ``}` `        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``int` `a = s[i] - ``'a'``;``            ``int` `b = t[i] - ``'a'``;``            ``if` `(a == b)``                ``continue``;` `            ``// If misplaced letter``            ``// is found, print its``            ``// original index and``            ``// its new index``            ``if` `(A[b] != -1)``            ``{``                ``Console.WriteLine(i + 1 + ``" "` `+``                                    ``(A[b] + 1));``                ``return``;``            ``}` `            ``if` `(B[a] != -1)``            ``{``                ``Console.WriteLine(i + 1 + ``" "` `+``                                    ``(B[a] + 1));``                ``return``;``            ``}` `            ``// Store the index of``            ``// letters in wrong position``            ``A[a] = i;``            ``B[b] = i;``        ``}` `        ``// Case-III``        ``Console.WriteLine(-1);``    ``}` `    ``// Driver code``    ``public` `static` `int` `Main()``    ``{``        ``string` `S = ``"permanent"``;``        ``string` `T = ``"pergament"``;``        ``int` `n = S.Length;` `        ``if` `(S == ``""` `|| T == ``""``)``            ``Console.WriteLine(``"Required string is empty."``);``        ``else``            ``Swap(S, T, n);` `        ``return` `0;``    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`6 4`

Time Complexity: O(n), where n is the length of the given strings.
Auxiliary Space: O(MAX * MAX), where MAX is a predefined value. Here, MAX = 26

My Personal Notes arrow_drop_up