# Find a rotation with maximum hamming distance

Here given code implementation process.

``````// C Program
// Find a rotation with maximum hamming distance
#include <stdio.h>

#include <string.h>

// Calculates the maximum hamming distance of a rotating array
void hammingDistance(int arr[], int size)
{
// Define resultant variables
int result = 0;
int counter = 0;
// Loop controlling variables
int i = 0;
int j = 0;
int k = 0;
// Outer loop execute 1..(n-1) times
for (i = 1; i < size && counter < size; i++)
{
counter = 0;
// Perform [i] right side rotation and calculates the new hamming distance
for (j = i, k = 0; j < size + i; j++, k++)
{
if (arr[k] != arr[j % size])
{
// When rotating element are different
counter++;
}
}
if (result < counter)
{
// Get a new result
result = counter;
}
}
// Display calculated result
printf(" Max Hamming Distance : %d \n", result);
}
int main()
{
int arr[] = {
1 , 3 , 3 , 3 , 3 , 7
};
// Get the size
int size = sizeof(arr) / sizeof(arr[0]);
/*
array = {1, 3, 3, 3, 3, 7}

1-st rotation
==================
{3, 3, 3, 3, 7, 1} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  0  1   1 = 3 Hamming distance
---------------------
result = 3

2-nd rotation
==================
{3, 3, 3, 7, 1, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  1  1   1 = 4 Hamming distance
---------------------
result = 4

3-rd rotation
==================
{3, 3, 7, 1, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  1  1  0  1 = 4 Hamming distance
---------------------
result = 4

4-th rotation
==================
{3, 7, 1, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  1  1  0  0  1 = 4 Hamming distance
---------------------
result = 4

5-th rotation
{1, 1, 3, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
0  1  0  0  0  1 = 2 Hamming distance
---------------------
result = 4
*/
hammingDistance(arr, size);
return 0;
}``````

#### Output

`` Max Hamming Distance : 4``
``````/*
Java Program
Find a rotation with maximum hamming distance
*/
public class Calculation
{
// Calculates the maximum hamming distance of a rotating array
public void hammingDistance(int[] arr, int size)
{
// Define resultant variables
int result = 0;
int counter = 0;
// Loop controlling variables
int i = 0;
int j = 0;
int k = 0;
// Outer loop execute 1..(n-1) times
for (i = 1; i < size && counter < size; i++)
{
counter = 0;
// Perform [i] right side rotation and calculates the new hamming distance
for (j = i, k = 0; j < size + i; j++, k++)
{
if (arr[k] != arr[j % size])
{
// When rotating element are different
counter++;
}
}
if (result < counter)
{
// Get a new result
result = counter;
}
}
// Display calculated result
System.out.print(" Max Hamming Distance : " + result + " \n");
}
public static void main(String[] args)
{
Calculation op = new Calculation();
int[] arr = {
1 , 3 , 3 , 3 , 3 , 7
};
// Get the size
int size = arr.length;
/*
array = {1, 3, 3, 3, 3, 7}

1-st rotation
==================
{3, 3, 3, 3, 7, 1} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  0  1   1 = 3 Hamming distance
---------------------
result = 3

2-nd rotation
==================
{3, 3, 3, 7, 1, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  1  1   1 = 4 Hamming distance
---------------------
result = 4

3-rd rotation
==================
{3, 3, 7, 1, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  1  1  0  1 = 4 Hamming distance
---------------------
result = 4

4-th rotation
==================
{3, 7, 1, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  1  1  0  0  1 = 4 Hamming distance
---------------------
result = 4

5-th rotation
{1, 1, 3, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
0  1  0  0  0  1 = 2 Hamming distance
---------------------
result = 4

*/
op.hammingDistance(arr, size);
}
}``````

#### Output

`` Max Hamming Distance : 4``
``````// Include header file
#include <iostream>

using namespace std;
/*
C++ Program
Find a rotation with maximum hamming distance
*/
class Calculation
{
public:
// Calculates the maximum hamming distance of a rotating array
void hammingDistance(int arr[], int size)
{
// Define resultant variables
int result = 0;
int counter = 0;
// Loop controlling variables
int i = 0;
int j = 0;
int k = 0;
// Outer loop execute 1..(n-1) times
for (i = 1; i < size && counter < size; i++)
{
counter = 0;
// Perform [i] right side rotation and calculates the new hamming distance
for (j = i, k = 0; j < size + i; j++, k++)
{
if (arr[k] != arr[j % size])
{
// When rotating element are different
counter++;
}
}
if (result < counter)
{
// Get a new result
result = counter;
}
}
// Display calculated result
cout << " Max Hamming Distance : " << result << " \n";
}
};
int main()
{
Calculation op = Calculation();
int arr[] = {
1 , 3 , 3 , 3 , 3 , 7
};
// Get the size
int size = sizeof(arr) / sizeof(arr[0]);
/*
array = {1, 3, 3, 3, 3, 7}

1-st rotation
==================
{3, 3, 3, 3, 7, 1} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  0  1   1 = 3 Hamming distance
---------------------
result = 3

2-nd rotation
==================
{3, 3, 3, 7, 1, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  1  1   1 = 4 Hamming distance
---------------------
result = 4

3-rd rotation
==================
{3, 3, 7, 1, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  1  1  0  1 = 4 Hamming distance
---------------------
result = 4

4-th rotation
==================
{3, 7, 1, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  1  1  0  0  1 = 4 Hamming distance
---------------------
result = 4

5-th rotation
{1, 1, 3, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
0  1  0  0  0  1 = 2 Hamming distance
---------------------
result = 4

*/
op.hammingDistance(arr, size);
return 0;
}``````

#### Output

`` Max Hamming Distance : 4``
``````// Include namespace system
using System;
/*
C# Program
Find a rotation with maximum hamming distance
*/
public class Calculation
{
// Calculates the maximum hamming distance of a rotating array
public void hammingDistance(int[] arr, int size)
{
// Define resultant variables
int result = 0;
int counter = 0;
// Loop controlling variables
int i = 0;
int j = 0;
int k = 0;
// Outer loop execute 1..(n-1) times
for (i = 1; i < size && counter < size; i++)
{
counter = 0;
// Perform [i] right side rotation and calculates the new hamming distance
for (j = i, k = 0; j < size + i; j++, k++)
{
if (arr[k] != arr[j % size])
{
// When rotating element are different
counter++;
}
}
if (result < counter)
{
// Get a new result
result = counter;
}
}
// Display calculated result
Console.Write(" Max Hamming Distance : " + result + " \n");
}
public static void Main(String[] args)
{
Calculation op = new Calculation();
int[] arr = {
1 , 3 , 3 , 3 , 3 , 7
};
// Get the size
int size = arr.Length;
/*
array = {1, 3, 3, 3, 3, 7}

1-st rotation
==================
{3, 3, 3, 3, 7, 1} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  0  1   1 = 3 Hamming distance
---------------------
result = 3

2-nd rotation
==================
{3, 3, 3, 7, 1, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  1  1   1 = 4 Hamming distance
---------------------
result = 4

3-rd rotation
==================
{3, 3, 7, 1, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  1  1  0  1 = 4 Hamming distance
---------------------
result = 4

4-th rotation
==================
{3, 7, 1, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  1  1  0  0  1 = 4 Hamming distance
---------------------
result = 4

5-th rotation
{1, 1, 3, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
0  1  0  0  0  1 = 2 Hamming distance
---------------------
result = 4

*/
op.hammingDistance(arr, size);
}
}``````

#### Output

`` Max Hamming Distance : 4``
``````<?php
/*
Php Program
Find a rotation with maximum hamming distance
*/
class Calculation
{
// Calculates the maximum hamming distance of a rotating array
public	function hammingDistance( & \$arr, \$size)
{
// Define resultant variables
\$result = 0;
\$counter = 0;
// Loop controlling variables
\$i = 0;
\$j = 0;
\$k = 0;
// Outer loop execute 1..(n-1) times
for (\$i = 1; \$i < \$size && \$counter < \$size; \$i++)
{
\$counter = 0;
// Perform [i] right side rotation and calculates the new hamming distance
for (\$j = \$i, \$k = 0; \$j < \$size + \$i; \$j++, \$k++)
{
if (\$arr[\$k] != \$arr[\$j % \$size])
{
// When rotating element are different
\$counter++;
}
}
if (\$result < \$counter)
{
// Get a new result
\$result = \$counter;
}
}
// Display calculated result
echo " Max Hamming Distance : ". \$result ." \n";
}
}

function main()
{
\$op = new Calculation();
\$arr = array(1, 3, 3, 3, 3, 7);
// Get the size
\$size = count(\$arr);
/*
array = {1, 3, 3, 3, 3, 7}

1-st rotation
==================
{3, 3, 3, 3, 7, 1} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  0  1   1 = 3 Hamming distance
---------------------
result = 3

2-nd rotation
==================
{3, 3, 3, 7, 1, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  1  1   1 = 4 Hamming distance
---------------------
result = 4

3-rd rotation
==================
{3, 3, 7, 1, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  1  1  0  1 = 4 Hamming distance
---------------------
result = 4

4-th rotation
==================
{3, 7, 1, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  1  1  0  0  1 = 4 Hamming distance
---------------------
result = 4

5-th rotation
{1, 1, 3, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
0  1  0  0  0  1 = 2 Hamming distance
---------------------
result = 4

*/
\$op->hammingDistance(\$arr, \$size);
}
main();``````

#### Output

`` Max Hamming Distance : 4``
``````/*
Node Js Program
Find a rotation with maximum hamming distance
*/
class Calculation
{
// Calculates the maximum hamming distance of a rotating array
hammingDistance(arr, size)
{
// Define resultant variables
var result = 0;
var counter = 0;
// Loop controlling variables
var i = 0;
var j = 0;
var k = 0;
// Outer loop execute 1..(n-1) times
for (i = 1; i < size && counter < size; i++)
{
counter = 0;
// Perform [i] right side rotation and calculates the new hamming distance
for (j = i, k = 0; j < size + i; j++, k++)
{
if (arr[k] != arr[j % size])
{
// When rotating element are different
counter++;
}
}
if (result < counter)
{
// Get a new result
result = counter;
}
}
// Display calculated result
process.stdout.write(" Max Hamming Distance : " + result + " \n");
}
}

function main()
{
var op = new Calculation();
var arr = [1, 3, 3, 3, 3, 7];
// Get the size
var size = arr.length;
/*
array = {1, 3, 3, 3, 3, 7}

1-st rotation
==================
{3, 3, 3, 3, 7, 1} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  0  1   1 = 3 Hamming distance
---------------------
result = 3

2-nd rotation
==================
{3, 3, 3, 7, 1, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  1  1   1 = 4 Hamming distance
---------------------
result = 4

3-rd rotation
==================
{3, 3, 7, 1, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  1  1  0  1 = 4 Hamming distance
---------------------
result = 4

4-th rotation
==================
{3, 7, 1, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  1  1  0  0  1 = 4 Hamming distance
---------------------
result = 4

5-th rotation
{1, 1, 3, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
0  1  0  0  0  1 = 2 Hamming distance
---------------------
result = 4

*/
op.hammingDistance(arr, size);
}
main();``````

#### Output

`` Max Hamming Distance : 4``
``````#  Python 3 Program
#  Find a rotation with maximum hamming distance

class Calculation :
#  Calculates the maximum hamming distance of a rotating array
def hammingDistance(self, arr, size) :
#  Define resultant variables
result = 0
counter = 0
#  Loop controlling variables
i = 1
j = 0
k = 0
#  Outer loop execute 1..(n-1) times
while (i < size and counter < size) :
counter = 0
#  Perform [i] right side rotation and calculates the new hamming distance
j = i
k = 0
while (j < size + i) :
if (arr[k] != arr[j % size]) :
#  When rotating element are different
counter += 1

j += 1
k += 1

if (result < counter) :
#  Get a new result
result = counter

i += 1

#  Display calculated result
print(" Max Hamming Distance : ", result ," ")

def main() :
op = Calculation()
arr = [1, 3, 3, 3, 3, 7]
#  Get the size
size = len(arr)
#
# 		array = 1, 3, 3, 3, 3, 7
# 		1-st rotation
# 		==================
# 		3, 3, 3, 3, 7, 1 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		1  0  0  0  1   1 = 3 Hamming distance
# 		---------------------
# 		result = 3
# 		2-nd rotation
# 		==================
# 		3, 3, 3, 7, 1, 3 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		1  0  0  1  1   1 = 4 Hamming distance
# 		---------------------
# 		result = 4
# 		3-rd rotation
# 		==================
# 		3, 3, 7, 1, 3, 3 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		1  0  1  1  0  1 = 4 Hamming distance
# 		---------------------
# 		result = 4
#
# 		4-th rotation
# 		==================
# 		3, 7, 1, 3, 3, 3 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		1  1  1  0  0  1 = 4 Hamming distance
# 		---------------------
# 		result = 4
# 		5-th rotation
# 		1, 1, 3, 3, 3, 3 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		0  1  0  0  0  1 = 2 Hamming distance
# 		---------------------
# 		result = 4

op.hammingDistance(arr, size)

if __name__ == "__main__": main()``````

#### Output

`` Max Hamming Distance :  4``
``````#   Ruby Program
#   Find a rotation with maximum hamming distance

class Calculation
#  Calculates the maximum hamming distance of a rotating array
def hammingDistance(arr, size)
#  Define resultant variables
result = 0
counter = 0
#  Loop controlling variables
i = 1
j = 0
k = 0
#  Outer loop execute 1..(n-1) times
while (i < size && counter < size)
counter = 0
#  Perform [i] right side rotation and calculates the new hamming distance
j = i
k = 0
while (j < size + i)
if (arr[k] != arr[j % size])
#  When rotating element are different
counter += 1
end

j += 1
k += 1
end

if (result < counter)
#  Get a new result
result = counter
end

i += 1
end

#  Display calculated result
print(" Max Hamming Distance : ", result ," \n")
end

end

def main()
op = Calculation.new()
arr = [1, 3, 3, 3, 3, 7]
#  Get the size
size = arr.length
#
# 		array = 1, 3, 3, 3, 3, 7
# 		1-st rotation
# 		==================
# 		3, 3, 3, 3, 7, 1 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		1  0  0  0  1   1 = 3 Hamming distance
# 		---------------------
# 		result = 3
# 		2-nd rotation
# 		==================
# 		3, 3, 3, 7, 1, 3 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		1  0  0  1  1   1 = 4 Hamming distance
# 		---------------------
# 		result = 4
# 		3-rd rotation
# 		==================
# 		3, 3, 7, 1, 3, 3 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		1  0  1  1  0  1 = 4 Hamming distance
# 		---------------------
# 		result = 4
#
# 		4-th rotation
# 		==================
# 		3, 7, 1, 3, 3, 3 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		1  1  1  0  0  1 = 4 Hamming distance
# 		---------------------
# 		result = 4
# 		5-th rotation
# 		1, 1, 3, 3, 3, 3 Rotated array
# 		1, 3, 3, 3, 3, 7 Actual array
# 		---------------------
# 		0  1  0  0  0  1 = 2 Hamming distance
# 		---------------------
# 		result = 4

op.hammingDistance(arr, size)
end

main()``````

#### Output

`````` Max Hamming Distance : 4
``````
``````/*
Scala Program
Find a rotation with maximum hamming distance
*/
class Calculation
{
// Calculates the maximum hamming distance of a rotating array
def hammingDistance(arr: Array[Int], size: Int): Unit = {
// Define resultant variables
var result: Int = 0;
var counter: Int = 0;
// Loop controlling variables
var i: Int = 1;
var j: Int = 0;
var k: Int = 0;
// Outer loop execute 1..(n-1) times
while (i < size && counter < size)
{
counter = 0;
// Perform [i] right side rotation and calculates the new hamming distance
j = i;
k = 0;
while (j < size + i)
{
if (arr(k) != arr(j % size))
{
// When rotating element are different
counter += 1;
}
j += 1;
k += 1;
}
if (result < counter)
{
// Get a new result
result = counter;
}
i += 1;
}
// Display calculated result
print(" Max Hamming Distance : " + result + " \n");
}
}
object Main
{
def main(args: Array[String]): Unit = {
var op: Calculation = new Calculation();
var arr: Array[Int] = Array(1, 3, 3, 3, 3, 7);
// Get the size
var size: Int = arr.length;
/*
array = {1, 3, 3, 3, 3, 7}

1-st rotation
==================
{3, 3, 3, 3, 7, 1} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  0  1   1 = 3 Hamming distance
---------------------
result = 3

2-nd rotation
==================
{3, 3, 3, 7, 1, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  1  1   1 = 4 Hamming distance
---------------------
result = 4

3-rd rotation
==================
{3, 3, 7, 1, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  1  1  0  1 = 4 Hamming distance
---------------------
result = 4

4-th rotation
==================
{3, 7, 1, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  1  1  0  0  1 = 4 Hamming distance
---------------------
result = 4

5-th rotation
{1, 1, 3, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
0  1  0  0  0  1 = 2 Hamming distance
---------------------
result = 4

*/
op.hammingDistance(arr, size);
}
}``````

#### Output

`` Max Hamming Distance : 4``
``````/*
Swift 4 Program
Find a rotation with maximum hamming distance
*/
class Calculation
{
// Calculates the maximum hamming distance of a rotating array
func hammingDistance(_ arr: [Int], _ size: Int)
{
// Define resultant variables
var result: Int = 0;
var counter: Int = 0;
// Loop controlling variables
var i: Int = 1;
var j: Int = 0;
var k: Int = 0;
// Outer loop execute 1..(n-1) times
while (i < size && counter < size)
{
counter = 0;
// Perform [i]right side rotation and calculates the new hamming distance
j = i;
k = 0;
while (j < size + i)
{
if (arr[k] != arr[j % size])
{
// When rotating element are different
counter += 1;
}
j += 1;
k += 1;
}
if (result < counter)
{
// Get a new result
result = counter;
}
i += 1;
}
// Display calculated result
print(" Max Hamming Distance : ", result ," ");
}
}
func main()
{
let op: Calculation = Calculation();
let arr: [Int] = [1, 3, 3, 3, 3, 7];
// Get the size
let size: Int = arr.count;
/*
array = {1, 3, 3, 3, 3, 7}

1-st rotation
==================
{3, 3, 3, 3, 7, 1} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  0  1   1 = 3 Hamming distance
---------------------
result = 3

2-nd rotation
==================
{3, 3, 3, 7, 1, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  1  1   1 = 4 Hamming distance
---------------------
result = 4

3-rd rotation
==================
{3, 3, 7, 1, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  1  1  0  1 = 4 Hamming distance
---------------------
result = 4

4-th rotation
==================
{3, 7, 1, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  1  1  0  0  1 = 4 Hamming distance
---------------------
result = 4

5-th rotation
{1, 1, 3, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
0  1  0  0  0  1 = 2 Hamming distance
---------------------
result = 4

*/
op.hammingDistance(arr, size);
}
main();``````

#### Output

`` Max Hamming Distance :  4``
``````/*
Kotlin Program
Find a rotation with maximum hamming distance
*/
class Calculation
{
// Calculates the maximum hamming distance of a rotating array
fun hammingDistance(arr: Array<Int>, size: Int): Unit
{
// Define resultant variables
var result: Int = 0;
var counter: Int = 0;
// Loop controlling variables
var i: Int = 1;
var j: Int ;
var k: Int ;
// Outer loop execute 1..(n-1) times
while (i<size && counter<size)
{
counter = 0;
// Perform [i] right side rotation and calculates the new hamming distance
j = i;
k = 0;
while (j < size + i)
{
if (arr[k] != arr[j % size])
{
// When rotating element are different
counter += 1;
}
j += 1;
k += 1;
}
if (result<counter)
{
// Get a new result
result = counter;
}
i += 1;
}
// Display calculated result
print(" Max Hamming Distance : " + result + " \n");
}
}
fun main(args: Array<String>): Unit
{
var op: Calculation = Calculation();
var arr: Array<Int> = arrayOf(1, 3, 3, 3, 3, 7);
// Get the size
var size: Int = arr.count();
/*
array = {1, 3, 3, 3, 3, 7}

1-st rotation
==================
{3, 3, 3, 3, 7, 1} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  0  1   1 = 3 Hamming distance
---------------------
result = 3

2-nd rotation
==================
{3, 3, 3, 7, 1, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  0  1  1   1 = 4 Hamming distance
---------------------
result = 4

3-rd rotation
==================
{3, 3, 7, 1, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  0  1  1  0  1 = 4 Hamming distance
---------------------
result = 4

4-th rotation
==================
{3, 7, 1, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
1  1  1  0  0  1 = 4 Hamming distance
---------------------
result = 4

5-th rotation
{1, 1, 3, 3, 3, 3} Rotated array
{1, 3, 3, 3, 3, 7} Actual array
---------------------
0  1  0  0  0  1 = 2 Hamming distance
---------------------
result = 4

*/
op.hammingDistance(arr, size);
}``````

#### Output

`` Max Hamming Distance : 4``

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.