Open in App
Not now

# Find a rotation with maximum hamming distance

• Difficulty Level : Easy
• Last Updated : 17 Mar, 2023

Given an array of N elements, create a new array which is a rotation of the given array, and hamming distance between both the arrays is maximum. The task is to print the maximized hamming distance between given and new arrays.

Hamming distance between two arrays or strings of equal length is the number of positions at which the corresponding characters (elements) are different.

Examples:

Input: N = 3, arr = {1, 4, 1}
Output: 2
Explanation:  Possible rotations of given array = 4 1 1 and 1 1 4. In each case the hamming distance is 2. Therefore the maximum hamming distance will be 2.

Input: N = 4, arr = {2, 4, 8, 0}
Output: 4
Explanation: Among possible rotations of given array, the rotations 8 0 2 4 and 0 2 4 8, have the maximum hamming distance of 4.

### Naive Approach:

The idea is to create another array that is double the size of the original array, such that the elements of this new array (copy array) are just the elements of the original array repeated twice in the same sequence. For example, if the original array is 1 4 1, then the copy array is 1 4 1 1 4 1. Now, iterate through the copy array and find hamming distance with every shift (or rotation). So we check 4 1 1, 1 1 4, 1 4 1, and choose the output for which the hamming distance is maximum.

Illustration:

Given array arr[]={2, 4, 6, 8}.
New array brr[]={2, ,4, 6, 8, 2, 4, 6, 8} , count=0

• In first iteration : {2, 4, 6, 8} & {2 ,4, 6, 8, 2, 4, 6, 8} , count=1
• In second iteration : {2, 4, 6, 8} & {2 ,4, 6, 8, 2, 4, 6, 8} , count=2
• In third iteration : {2, 4, 6, 8} & {2 ,4, 6, 8, 2, 4, 6, 8} , count=3
• In fourth iteration : {2, 4, 6, 8} & {2 ,4, 6, 8, 2, 4, 6, 8} , count=4
• count = size of original array, hence output is 4

Implementation:

We will create another array twice the size of the original array and insert the elements in it one by one, twice. Now we will perform rotation on the array and for each rotation, we will check if the value of the original array matches the newly created array.

• If they don’t match we will increase our counter value
• After the value is incremented we will perform a condition to check the max value, to keep a check on the maximum value that can be obtained.
• Else if the values don’t match, we don’t have to perform any operation
• Inside the checking loop, we will also have to keep a check if the value of counter = size of the original array, as it is the maximum value that we can obtain. If the condition matches, we may return the value. This condition optimizes our code.

Below is the code implementation of the above approach:

## C++

 `// C++ program to Find another array such that the hamming` `// distance from the original array is maximum` `#include ` `using` `namespace` `std;`   `// Return the maximum hamming distance of a rotation` `int` `maxHamming(``int` `arr[], ``int` `n)` `{` `    ``// arr[] to brr[] two times so that` `    ``// we can traverse through all rotations.` `    ``int` `brr[2 * n + 1];` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``brr[i] = arr[i];` `        ``brr[n + i] = arr[i];` `    ``}`   `    ``// We know hamming distance with 0 rotation would be 0.` `    ``int` `maxHam = 0;`   `    ``// We try other rotations one by one and compute` `    ``// Hamming distance of every rotation` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``int` `currHam = 0;` `        ``for` `(``int` `j = i, k = 0; j < (i + n); j++, k++)` `            ``if` `(brr[j] != arr[k])` `                ``currHam++;`   `        ``// We can never get more than n.` `        ``if` `(currHam == n)` `            ``return` `n;`   `        ``maxHam = max(maxHam, currHam);` `    ``}`   `    ``return` `maxHam;` `}`   `// Driver program` `int` `main()` `{` `    ``int` `arr[] = { 2, 4, 6, 8 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << maxHamming(arr, n);` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to Find another array such that the hamming` `// distance from the original array is maximum` `#include `   `// Find maximum between two numbers.` `int` `max(``int` `num1, ``int` `num2)` `{` `    ``return` `(num1 > num2) ? num1 : num2;` `}`   `// Return the maximum hamming distance of a rotation` `int` `maxHamming(``int` `arr[], ``int` `n)` `{` `    ``// arr[] to brr[] two times so that` `    ``// we can traverse through all rotations.` `    ``int` `brr[2 * n + 1];` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``brr[i] = arr[i];` `        ``brr[n + i] = arr[i];` `    ``}`   `    ``// We know hamming distance with 0 rotation would be 0.` `    ``int` `maxHam = 0;`   `    ``// We try other rotations one by one and compute` `    ``// Hamming distance of every rotation` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``int` `currHam = 0;` `        ``for` `(``int` `j = i, k = 0; j < (i + n); j++, k++)` `            ``if` `(brr[j] != arr[k])` `                ``currHam++;`   `        ``// We can never get more than n.` `        ``if` `(currHam == n)` `            ``return` `n;`   `        ``maxHam = max(maxHam, currHam);` `    ``}`   `    ``return` `maxHam;` `}`   `// Driver program` `int` `main()` `{` `    ``int` `arr[] = { 2, 4, 6, 8 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``printf``(``"%d\n"``, maxHamming(arr, n));` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program to Find another array` `// such that the hamming distance` `// from the original array is maximum`   `import` `java.io.*;`   `class` `GFG {` `    ``// Return the maximum hamming` `    ``// distance of a rotation` `    ``static` `int` `maxHamming(``int` `arr[], ``int` `n)` `    ``{` `        ``// arr[] to brr[] two times so that` `        ``// we can traverse through all rotations.` `        ``int` `brr[] = ``new` `int``[``2` `* n + ``1``];` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``brr[i] = arr[i];` `            ``brr[n + i] = arr[i];` `        ``}`   `        ``// We know hamming distance with` `        ``// 0 rotation would be 0.` `        ``int` `maxHam = ``0``;`   `        ``// We try other rotations one by one` `        ``// and compute Hamming distance` `        ``// of every rotation` `        ``for` `(``int` `i = ``1``; i < n; i++) {` `            ``int` `currHam = ``0``;` `            ``for` `(``int` `j = i, k = ``0``; j < (i + n); j++, k++)` `                ``if` `(brr[j] != arr[k])` `                    ``currHam++;`   `            ``// We can never get more than n.` `            ``if` `(currHam == n)` `                ``return` `n;`   `            ``maxHam = Math.max(maxHam, currHam);` `        ``}`   `        ``return` `maxHam;` `    ``}`   `    ``// driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``2``, ``4``, ``6``, ``8` `};` `        ``int` `n = arr.length;` `        ``System.out.print(maxHamming(arr, n));` `    ``}` `}`   `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python3 code to Find another array` `# such that the hamming distance ` `# from the original array is maximum`   `# Return the maximum hamming ` `# distance of a rotation` `def` `maxHamming( arr , n ):`   `    ``# arr[] to brr[] two times so` `    ``# that we can traverse through ` `    ``# all rotations.` `    ``brr ``=` `[``0``] ``*` `(``2` `*` `n ``+` `1``)` `    ``for` `i ``in` `range``(n):` `        ``brr[i] ``=` `arr[i]` `    ``for` `i ``in` `range``(n):` `        ``brr[n``+``i] ``=` `arr[i]` `    `  `    ``# We know hamming distance ` `    ``# with 0 rotation would be 0.` `    ``maxHam ``=` `0` `    `  `    ``# We try other rotations one by` `    ``# one and compute Hamming ` `    ``# distance of every rotation` `    ``for` `i ``in` `range``(``1``, n):` `        ``currHam ``=` `0` `        ``k ``=` `0` `        ``for` `j ``in` `range``(i, i ``+` `n):` `            ``if` `brr[j] !``=` `arr[k]:` `                ``currHam ``+``=` `1` `                ``k ``=` `k ``+` `1` `        `  `        ``# We can never get more than n.` `        ``if` `currHam ``=``=` `n:` `            ``return` `n` `        `  `        ``maxHam ``=` `max``(maxHam, currHam)` `    `  `    ``return` `maxHam`   `# driver program` `arr ``=` `[``2``, ``4``, ``6``, ``8``]` `n ``=` `len``(arr)` `print``(maxHamming(arr, n))`   `# This code is contributed by "Sharad_Bhardwaj".`

## C#

 `// C# program to Find another array` `// such that the hamming distance ` `// from the original array is maximum` `using` `System;`   `class` `GFG {` `    `  `    ``// Return the maximum hamming` `    ``// distance of a rotation` `    ``static` `int` `maxHamming(``int` `[]arr, ``int` `n)` `    ``{` `        `  `        ``// arr[] to brr[] two times so that` `        ``// we can traverse through all rotations.` `        ``int` `[]brr=``new` `int``[2 * n + 1];` `        `  `        ``for` `(``int` `i = 0; i < n; i++){` `            ``brr[i] = arr[i];` `            ``brr[n+i] = arr[i];` `        ``}` `    `  `        ``// We know hamming distance with ` `        ``// 0 rotation would be 0.` `        ``int` `maxHam = 0; ` `    `  `        ``// We try other rotations one by one ` `        ``// and compute Hamming distance` `        ``// of every rotation` `        ``for` `(``int` `i = 1; i < n; i++)` `        ``{` `            ``int` `currHam = 0;` `            ``for` `(``int` `j = i, k=0; j < (i + n); ` `                                    ``j++, k++) ` `                ``if` `(brr[j] != arr[k])` `                    ``currHam++;` `    `  `            ``// We can never get more than n. ` `            ``if` `(currHam == n)` `                ``return` `n;` `    `  `            ``maxHam = Math.Max(maxHam, currHam);` `        ``}` `    `  `        ``return` `maxHam;` `    ``} ` `    `  `    ``// driver code` `    ``public` `static` `void` `Main ()` `    ``{` `        ``int` `[]arr = {2, 4, 6, 8}; ` `        ``int` `n = arr.Length;` `        ``Console.Write(maxHamming(arr, n)); ` `    ``}` `}`   `// This code is contributed by vt_m.`

## PHP

 ``

## Javascript

 ``

Output

`4`

Time Complexity: O(n2), Where n is the size of the given array
Auxiliary Space: O(n)

### Approach 2 (Constant Space):

The idea is to compare elements of the original array sequence with its rotated versions. The rotated versions of the array are achieved using shifted index method where you compare elements at the original index with elements on the shifted index, without requiring any extra space.

Illustration:

Given array arr[]={2, 4, 6, 8}. count=0. We will use modulo operation to compare the two different indexes of the same array.

• In first iteration : {2, 4, 6, 8} & {2 ,4, 6, 8} , count=1
• In second iteration : {2, 4, 6, 8} & {2 ,4, 6, 8} , count=2
• In third iteration : {2, 4, 6, 8} & {2 ,4, 6, 8} , count=3
• In fourth iteration : {2, 4, 6, 8} & {2 ,4, 6, 8} , count=4
• count = size of original array, hence output is 4

Follow the steps below for the above idea:

We will perform rotation on the array and for each rotation, we will check if the value of the array at any index i ,  matches with the value of index j. Where j determines the rotation and i as the actual index for which the comparison has to be made.

• j = 1,2,3 … , n-1 & i= 0, 1, 2 , … ,n-1,  n is the size of our array.
• If arr[i] not equal to arr[(i+j)%n] we will increase our counter value
• Else if the values don’t match, we don’t have to perform any operation
• Inside the checking loop, we will also have to keep a check if the value of counter = size of the original array, as it is the maximum value that we can obtain. If the condition matches, we may return the value. This condition optimizes our code.

Below is the implementation of the above approach:

## C++

 `// C++ program to Find another array` `// such that the hamming distance ` `// from the original array is maximum`   `// requires O(n*n) time and O(1) extra space;` `#include ` `using` `namespace` `std;`   `// Return the maximum hamming distance of a rotation` `int` `maxHamming(``int` `arr[], ``int` `n){` `    ``int` `hmmd;` `      ``// outer loop for how much rotation` `    ``for``(``int` `j = 1; j < n; j++){ ` `        ``hmmd = 0;` `          ``//inner loop to compare elements with elements on shifted index` `        ``for``(``int` `i = 0 ; i < n; i++){` `            ``if``(arr[i] != arr[(i + j) % n])` `                ``hmmd++;` `        ``}` `          ``//max possible hamming distance is n, no need to check further` `        ``if``(hmmd == n)` `            ``return` `n;` `    ``}` `    ``return` `hmmd;` `}`   `// driver program` `int` `main() ` `{` `    ``int` `arr[] = {2, 4, 6, 8};    ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);` `    ``cout << maxHamming(arr, n);    ` `    ``return` `0;` `}`   `// This method is contributed by nehalrandive`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;`   `class` `GFG ` `{` `  `  `// Java program to Find another array` `// such that the hamming distance ` `// from the original array is maximum`   `// requires O(n*n) time and O(1) extra space;`   `// Return the maximum hamming distance of a rotation` `static` `int` `maxHamming(``int` `arr[], ``int` `n){` `        `  `    ``int` `hmmd = ``0``;` `        `  `    ``// outer loop for how much rotation` `    ``for``(``int` `j = ``1``; j < n; j++){ ` `        `  `        ``hmmd = ``0``;` `      `  `        ``// inner loop to compare elements with elements on shifted index` `        ``for``(``int` `i = ``0` `; i < n; i++){` `            ``if``(arr[i] != arr[(i + j) % n])` `                ``hmmd++;` `        ``}` `      `  `        ``// max possible hamming distance is n, no need to check further` `        ``if``(hmmd == n)` `            ``return` `n;` `    ``}` `    ``return` `hmmd;` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``int` `arr[] = {``2``, ``4``, ``6``, ``8``};    ` `    ``int` `n = arr.length;` `    ``System.out.println(maxHamming(arr, n));   ` `}` `}`   `// This code is contributed by shinjanpatra`

## Python3

 `# Python3 program to Find another array` `# such that the hamming distance ` `# from the original array is maximum`   `# requires O(n*n) time and O(1) extra space;`   `# Return the maximum hamming distance of a rotation` `def` `maxHamming(arr, n):` `    `  `    ``# outer loop for how much rotation` `    ``hmmd ``=` `0`   `    ``for` `j ``in` `range``(``1``,n):` `        ``hmmd ``=` `0` `        ``#inner loop to compare elements with elements on shifted index` `        ``for` `i ``in` `range``(n):` `            ``if``(arr[i] !``=` `arr[(i ``+` `j) ``%` `n]):` `                ``hmmd ``+``=` `1` `        `  `            ``#max possible hamming distance is n, no need to check further` `        ``if``(hmmd ``=``=` `n):` `            ``return` `n` `    ``return` `hmmd`   `# driver program` `arr ``=` `[``2``, ``4``, ``6``, ``8``]` `n ``=` `len``(arr)` `print``(maxHamming(arr, n))    `     `# This code is contributed by shinjanpatra`

## C#

 `// C# program to Find another array` `// such that the hamming distance ` `// from the original array is maximum`   `// requires O(n*n) time and O(1) extra space;using System;` `using` `System;` `class` `GFG` `{`   `  ``// Return the maximum hamming distance of a rotation` `  ``static` `int` `maxHamming(``int``[] arr, ``int` `n)` `  ``{`   `    ``int` `hmmd = 0;`   `    ``// outer loop for how much rotation` `    ``for` `(``int` `j = 1; j < n; j++)` `    ``{`   `      ``hmmd = 0;`   `      ``// inner loop to compare elements with elements on shifted index` `      ``for` `(``int` `i = 0; i < n; i++)` `      ``{` `        ``if` `(arr[i] != arr[(i + j) % n])` `          ``hmmd++;` `      ``}`   `      ``// max possible hamming distance is n, no need to check further` `      ``if` `(hmmd == n)` `        ``return` `n;` `    ``}` `    ``return` `hmmd;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int``[] arr = { 2, 4, 6, 8 };` `    ``int` `n = arr.Length;` `    ``Console.Write(maxHamming(arr, n));` `  ``}` `}`   `// This code is contributed by saurabh_jaiswal.`

## Javascript

 ``

## PHP

 ` ``\$hmmd``) {` `            ``\$hmmd` `= ``\$temp_hmmd``;` `        ``}` `    ``}` `    ``return` `\$hmmd``;` `}`   `\$arr` `= ``array``(2, 4, 6, 8);` `\$n` `= ``count``(``\$arr``);` `echo` `maxHamming(``\$arr``, ``\$n``);`   `?>`

Output

`4`

Time Complexity: O(n2), Where n is the size of the given array
Auxiliary Space: O(1)

### Approach 3 (Using list comprehension) :

We can find the maximum hamming distance using a different approach by taking advantage of list comprehension in python. In this method, we divide the job into 3 separate functions.

• hamming_distance(x : list, y : list): This method returns the hamming distance for two lists passed as parameters. The idea is to count the positions at which elements are different at the same index in two lists x and y where x is the original array taken in input and y is one of it rotations.
• Initialize a variable count from 0.
• Run a loop from starting index 0 to last index (n-1) where n is the length of the list.
• For each iteration check if element of x and element at index i (0<=i<=n-1) is same or not. If they are the same, increment the counter.
• After the loop is completed, return the count(by definition this is the hamming distance for given arrays or strings)
• rotate_by_one(arr : list): This method rotates the array (passed in argument ) in anti-clockwise direction by 1 position. For e.g. if array [1,1,4,4] is passed, this method returns [1,4,4,5,1].
• The idea is to copy the 1st element of the array and save it in a variable (say x).
• Then iterate the array from 0 to n-2 and copy every i+1th value at the ith position. Now assign x to the last index.
• max_hamming_distance(arr: list): This method finds the maximum hamming distance for a given array and its rotations. Follow the below steps in this method.
• We copy this array in a new array (say a) and initialize a variable max.
• Now, after every n rotations, we get the original array. So we need to find the hamming distance for the original array with it’s n-1 rotations and store the current maximum in a variable(say max).
• Run loop for n-1 iterations. For each iteration.

Follow the steps below for the above idea:

1. Get the next rotation of arr by calling the method ‘rotate_by_one’.
2. Call method hamming distance() and pass an original array (a) and current rotation of an (arr) and store the current hamming distance returned in a variable (say curr_h_dist).
3. Check if the value of curr_h_dist is greater than the value of max. If yes, assign the value of curr_h_dist to max_h.
4. Repeat steps 1-3 till the loop terminates.
5. Return maximum hamming distance (max_h)

Below is the implementation of the above idea:

## C++

 `#include ` `#include ` `#include `   `using` `namespace` `std;`   `// Function to find the hamming distance` `// for two vectors` `int` `hammingDistance(vector<``int``> x, vector<``int``> y) {` `int` `count = 0;` `for` `(``int` `i = 0; i < x.size(); i++) {` `if` `(x[i] != y[i]) {` `count++;` `}` `}` `return` `count;` `}`   `// Function to rotate the given vector` `// in anti-clockwise direction by 1` `void` `rotateByOne(vector<``int``>& arr) {` `int` `x = arr[0];` `for` `(``int` `i = 0; i < arr.size() - 1; i++) {` `arr[i] = arr[i + 1];` `}` `arr[arr.size() - 1] = x;` `}`   `// Function maxHammingDistance to find` `// the maximum hamming distance for given vector` `int` `max_hamming_distance(vector<``int``> arr) {` `int` `maxH = -9999999;` `int` `n = arr.size();` `vector<``int``> a(arr);` `for` `(``int` `i = 1; i < n; i++) {` `    ``rotateByOne(arr);` `    ``cout << ``"Array after "` `<< i << ``" rotation : "``;` `    ``for` `(``int` `j = 0; j < n; j++) {` `        ``cout << arr[j] << ``" "``;` `    ``}` `    ``cout << endl;`   `    ``int` `currHDist = hammingDistance(a, arr);` `    ``cout << ``"Hamming Distance with "` `<< i << ``" rotations: "` `<< currHDist << endl;`   `    ``if` `(currHDist > maxH) {` `        ``maxH = currHDist;` `    ``}` `    ``cout << endl;` `}` `return` `maxH;` `}`   `int` `main() {` `vector<``int``> arr = {3, 0, 6, 4, 3};` `cout << ``"Original Array : "``;` `for` `(``int` `i = 0; i < arr.size(); i++) {` `cout << arr[i] << ``" "``;` `}` `cout << endl;` `cout << ``"Maximum Hamming Distance: "` `<< max_hamming_distance(arr) << endl;` `return` `0;` `}`

## Java

 `// Java code to find maximum of an array with it's rotations`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find the hamming distance` `    ``// for two lists/strings` `    ``public` `static` `int` `hammingDistance(``int``[] x, ``int``[] y)` `    ``{` `        ``// Initialize count` `        ``int` `count = ``0``;`   `        ``// Run loop for size of x(or y)` `        ``// as both as same length` `        ``for` `(``int` `i = ``0``; i < x.length; i++) {` `            ``// Check if corresponding elements` `            ``// at same index are not equal` `            ``if` `(x[i] != y[i]) {` `                ``// Increment the count every` `                ``// time above condition satisfies` `                ``count++;` `            ``}` `        ``}` `        ``// Return the hamming distance` `        ``// for given pair of lists or strings` `        ``return` `count;` `    ``}`   `    ``// Function to rotate the given array` `    ``// in anti-clockwise direction by 1` `    ``public` `static` `void` `rotateByOne(``int``[] arr)` `    ``{` `        ``// Store 1st element in a variable` `        ``int` `x = arr[``0``];`   `        ``// Update each ith element (0<=i<=n-2)` `        ``// with it's next value` `        ``for` `(``int` `i = ``0``; i < arr.length - ``1``; i++) {` `            ``arr[i] = arr[i + ``1``];` `        ``}`   `        ``// Assign 1st element to the last index` `        ``arr[arr.length - ``1``] = x;` `    ``}`   `    ``// Function maxHammingDistance to find` `    ``// the maximum hamming distance for given array` `    ``public` `static` `int` `max_hamming_distance(``int``[] arr)` `    ``{` `        ``// Initialize a variable to store` `        ``// maximum hamming distance` `        ``int` `maxH = Integer.MIN_VALUE;`   `        ``// Store size of the given array` `        ``// in a variable n` `        ``int` `n = arr.length;`   `        ``// Initialize a new array` `        ``int``[] a = Arrays.copyOf(arr, arr.length);`   `        ``// Run loop for i=0 to i=n-1 for n-1 rotations` `        ``for` `(``int` `i = ``1``; i < n; i++) {` `            ``// Find the next rotation` `            ``rotateByOne(arr);` `            ``System.out.println(``"Array after "` `+ i` `                               ``+ ``" rotation : "` `                               ``+ Arrays.toString(arr));`   `            ``// Store hamming distance of current` `            ``// rotation with original array` `            ``int` `currHDist = hammingDistance(a, arr);` `            ``System.out.println(``"Hamming Distance with "` `+ i` `                               ``+ ``" rotations: "` `                               ``+ currHDist);`   `            ``// Check if current hamming distance` `            ``// is greater than max hamming distance` `            ``if` `(currHDist > maxH) {` `                ``// If yes, assign value of current` `                ``// hamming distance to max hamming distance` `                ``maxH = currHDist;` `            ``}` `            ``System.out.println();` `        ``}` `        ``// Return maximum hamming distance` `        ``return` `maxH;` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``3``, ``0``, ``6``, ``4``, ``3` `};` `        ``long` `start = System.currentTimeMillis();` `        ``System.out.println();` `        ``System.out.println(``"Original Array : "` `                           ``+ Arrays.toString(arr));` `        ``System.out.println();` `        ``System.out.println(``"Maximum Hamming Distance: "` `                           ``+ max_hamming_distance(arr));` `        ``long` `end = System.currentTimeMillis();` `        ``System.out.println(``"Execution Time = "` `                           ``+ (end - start));` `    ``}` `}`   `// This code is contributed by lokeshmvs21.`

## Python3

 `# Python code to find maximum` `# of an array with it's rotations` `import` `time`   `# Function hamming distance to find ` `# the hamming distance for two lists/strings` `def` `hamming_distance(x: ``list``, y: ``list``):` `  `  `    ``# Initialize count` `    ``count ``=` `0` `    `  `    ``# Run loop for size of x(or y) ` `    ``# as both as same length` `    ``for` `i ``in` `range``(``len``(x)):` `      `  `        ``# Check if corresponding elements ` `        ``# at same index are not equal` `        ``if``(x[i] !``=` `y[i]):` `          `  `            ``# Increment the count every ` `            ``# time above condition satisfies` `            ``count ``+``=` `1` `            `  `    ``# Return the hamming distance ` `    ``# for given pair of lists or strings` `    ``return` `count`     `# Function to rotate the given array ` `# in anti-clockwise direction by 1` `def` `rotate_by_one(arr: ``list``):` `  `  `    ``# Store 1st element in a variable` `    ``x ``=` `arr[``0``]` `    `  `    ``# Update each ith element (0<=i<=n-2) ` `    ``# with it's next value` `    ``for` `i ``in` `range``(``0``, ``len``(arr)``-``1``):` `        ``arr[i] ``=` `arr[i``+``1``]` `      `  `    ``# Assign 1st element to the last index` `    ``arr[``len``(arr)``-``1``] ``=` `x`     `# Function max_hamming_distance to find ` `# the maximum hamming distance for given array` `def` `max_hamming_distance(arr: ``list``):` `  `  `    ``# Initialize a variable to store ` `    ``# maximum hamming distance` `    ``max_h ``=` `-``10000000000` `    `  `    ``# Store size of the given array ` `    ``# in a variable n` `    ``n ``=` `len``(arr)` `    `  `    ``# Initialize a new array` `    ``a ``=` `[]` `    `  `    ``# Copy the original array in new array` `    ``for` `i ``in` `range``(n):` `        ``a.append(arr[i])` `        `  `    ``# Run loop for i=0 to i=n-1 for n-1 rotations` `    ``for` `i ``in` `range``(``1``, n):` `      `  `        ``# Find the next rotation` `        ``rotate_by_one(arr)` `        ``print``(``"Array after %d rotation : "` `%` `(i), arr)` `        `  `        ``# Store hamming distance of current ` `        ``# rotation with original array` `        ``curr_h_dist ``=` `hamming_distance(a, arr)` `        ``print``(``"Hamming Distance with %d rotations: %d"` `%` `                                        ``(i, curr_h_dist))` `        `  `        ``# Check if current hamming distance ` `        ``# is greater than max hamming distance` `        ``if` `curr_h_dist > max_h:` `          `  `            ``# If yes, assign value of current ` `            ``# hamming distance to max hamming distance` `            ``max_h ``=` `curr_h_dist` `            `  `        ``print``(``'\n'``)` `    ``# Return maximum hamming distance` `    ``return` `max_h`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `  `  `    ``arr ``=` `[``3``, ``0``, ``6``, ``4``, ``3``]` `    ``start ``=` `time.time()` `    ``print``(``'\n'``)` `    ``print``(``"Original Array : "``, arr)` `    ``print``(``'\n'``)` `    ``print``(``"Maximum Hamming Distance: "``, max_hamming_distance(arr))` `    ``end ``=` `time.time()` `    ``print``(f``"Execution Time = {end - start}"``)` `# This code is contributed by Vivek_Kumar_Sinha`

## Javascript

 `function` `hammingDistance(x, y) {` `  ``let count = 0;` `  ``for` `(let i = 0; i < x.length; i++) {` `    ``if` `(x[i] !== y[i]) {` `      ``count++;` `    ``}` `  ``}` `  ``return` `count;` `}`   `function` `rotateByOne(arr) {` `  ``const x = arr[0];` `  ``for` `(let i = 0; i < arr.length - 1; i++) {` `    ``arr[i] = arr[i + 1];` `  ``}` `  ``arr[arr.length - 1] = x;` `}`   `function` `maxHammingDistance(arr) {` `  ``let maxH = -Infinity;` `  ``const n = arr.length;` `  ``const a = [...arr];` `  ``for` `(let i = 1; i < n; i++) {` `    ``rotateByOne(arr);` `    ``console.log(`Array after \${i} rotation: \${arr.join(``' '``)}`);` `    ``const currHDist = hammingDistance(a, arr);` `    ``console.log(`Hamming Distance ``with` `\${i} rotations: \${currHDist}`);` `    ``if` `(currHDist > maxH) {` `      ``maxH = currHDist;` `    ``}` `    ``console.log(``''``);` `  ``}` `  ``return` `maxH;` `}`   `const arr = [3, 0, 6, 4, 3];` `console.log(`Original Array: \${arr.join(``' '``)}`);` `console.log(`Maximum Hamming Distance: \${maxHammingDistance(arr)}`);`

## C#

 `// C# code to find maximum of an array with it's rotations` `using` `System;` `using` `System.Linq;`   `public` `class` `GFG {`   `  ``// Function to find the hamming distance` `  ``// for two lists/strings` `  ``public` `static` `int` `HammingDistance(``int``[] x, ``int``[] y)` `  ``{` `    ``// Initialize count` `    ``int` `count = 0;`   `    ``// Run loop for size of x(or y)` `    ``// as both as same length` `    ``for` `(``int` `i = 0; i < x.Length; i++) {` `      ``// Check if corresponding elements` `      ``// at same index are not equal` `      ``if` `(x[i] != y[i]) {` `        ``// Increment the count every` `        ``// time above condition satisfies` `        ``count++;` `      ``}` `    ``}` `    ``// Return the hamming distance` `    ``// for given pair of lists or strings` `    ``return` `count;` `  ``}`   `  ``// Function to rotate the given array` `  ``// in anti-clockwise direction by 1` `  ``public` `static` `void` `RotateByOne(``int``[] arr)` `  ``{` `    ``// Store 1st element in a variable` `    ``int` `x = arr[0];`   `    ``// Update each ith element (0<=i<=n-2)` `    ``// with it's next value` `    ``for` `(``int` `i = 0; i < arr.Length - 1; i++) {` `      ``arr[i] = arr[i + 1];` `    ``}`   `    ``// Assign 1st element to the last index` `    ``arr[arr.Length - 1] = x;` `  ``}`   `  ``// Function maxHammingDistance to find` `  ``// the maximum hamming distance for given array` `  ``public` `static` `int` `MaxHammingDistance(``int``[] arr)` `  ``{` `    ``// Initialize a variable to store` `    ``// maximum hamming distance` `    ``int` `maxH = ``int``.MinValue;`   `    ``// Store size of the given array` `    ``// in a variable n` `    ``int` `n = arr.Length;`   `    ``// Initialize a new array` `    ``int``[] a = arr.ToArray();`   `    ``// Run loop for i=0 to i=n-1 for n-1 rotations` `    ``for` `(``int` `i = 1; i < n; i++) {` `      ``// Find the next rotation` `      ``RotateByOne(arr);` `      ``Console.WriteLine(` `        ``"Array after "` `+ i + ``" rotation : ["` `        ``+ ``string``.Join(``", "``, arr) + ``"]"``);`   `      ``// Store hamming distance of current` `      ``// rotation with original array` `      ``int` `currHDist = HammingDistance(a, arr);` `      ``Console.WriteLine(``"Hamming Distance with "` `+ i` `                        ``+ ``" rotations: "` `+ currHDist);`   `      ``// Check if current hamming distance` `      ``// is greater than max hamming distance` `      ``if` `(currHDist > maxH) {` `        ``// If yes, assign value of current` `        ``// hamming distance to max hamming distance` `        ``maxH = currHDist;` `      ``}` `      ``Console.WriteLine();` `    ``}` `    ``// Return maximum hamming distance` `    ``return` `maxH;` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``int``[] arr = { 3, 0, 6, 4, 3 };` `    ``var` `start = DateTime.Now;` `    ``Console.WriteLine();` `    ``Console.WriteLine(``"Original Array : ["` `                      ``+ ``string``.Join(``", "``, arr) + ``"]"``);` `    ``Console.WriteLine();` `    ``Console.WriteLine(``"Maximum Hamming Distance: "` `                      ``+ MaxHammingDistance(arr));` `    ``var` `end = DateTime.Now;` `    ``Console.WriteLine(``"Execution Time = "` `                      ``+ (end - start));` `  ``}` `}`   `// This code is contributed by lokeshmvs21.`

Output

```Original Array :  [3, 0, 6, 4, 3]

Array after 1 rotation :  [0, 6, 4, 3, 3]
Hamming Distance with 1 rotations: 4

Array after 2 rotation :  [6, 4, 3, 3, 0]
Hamming Distance with 2 rotations: 5

Array after 3 rotation :  [4, 3, 3, 0, 6]
Hamming Distance with 3 rotations: 5

Array after 4 rotation :  [3, 3, 0, 6, 4]
Hamming Distance with 4 rotations: 4

Maximum Hamming Distance:  5
Execution Time = 6.985664367675781e-05```

My Personal Notes arrow_drop_up
Related Articles