Skip to main content

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
Last updated on by Kalkicode




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.

New Comment