Block swap algorithm for array rotation

Here given code implementation process.

// C program for 
// Block swap algorithm for array rotation
#include <stdio.h>

// This is display the given array elements
void printData(int arr[], int n)
{
	// Executing the loop through by the size of array
	for (int i = 0; i < n; ++i)
	{
		printf("  %d", arr[i]);
	}
	printf("\n");
}
// This is swapping given block elements
void swapSubArray(int arr[], int s, int e, int n)
{
	// Executing the loop through by the n 
	for (int i = 0; i < n; i++)
	{
		// Swap array element
		arr[s + i] = arr[s + i] + arr[e + i];
		arr[e + i] = arr[s + i] - arr[e + i];
		arr[s + i] = arr[s + i] - arr[e + i];
	}
}
void blockSwapAlgo(int arr[], int n, int k)
{
	if (k == 0 || k >= n)
	{
		// When k = 0 then result are not change
		// And k >= n is greater than or equal to size n
		return;
	}
	// Display given array
	printf("\n Before rotation  ");
	printf("\n Array : ");
	printData(arr, n);
	printf(" Given rotation k is : %d", k);
	int i = k;
	int j = n - k;
	while (i != j)
	{
		if (i < j)
		{
			// When i is less than j
			swapSubArray(arr, k - i, k + j - i, i);
			// Reduce i in j
			j = j - i;
		}
		else
		{
			// When j is less than i
			swapSubArray(arr, k - i, k, j);
			i = i - j;
		}
	}
	swapSubArray(arr, k - i, k, i);
	// Display resultant array
	printf("\n After rotation  ");
	printf("\n Array : ");
	printData(arr, n);
}
int main(int argc, char const *argv[])
{
	// Array of integer elements
	int arr[] = {
		8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0
	};
	// Get the number of elements
	int n = sizeof(arr) / sizeof(arr[0]);
	// Test case
	blockSwapAlgo(arr, n, 5);
	blockSwapAlgo(arr, n, 3);
	return 0;
}

input

 Before rotation
 Array :   8  7  6  5  4  3  2  1  0
 Given rotation k is : 5
 After rotation
 Array :   3  2  1  0  8  7  6  5  4

 Before rotation
 Array :   3  2  1  0  8  7  6  5  4
 Given rotation k is : 3
 After rotation
 Array :   0  8  7  6  5  4  3  2  1
/*
  Java Program for 
  Block swap algorithm for array rotation
*/
public class Rotation
{
	// This is display the given array elements
	public void printData(int[] arr, int n)
	{
		// Executing the loop through by the size of array
		for (int i = 0; i < n; ++i)
		{
			System.out.print(" " + arr[i]);
		}
		System.out.print("\n");
	}
	// This is swapping given block elements
	public void swapSubArray(int[] arr, int s, int e, int n)
	{
		// Executing the loop through by the n 
		for (int i = 0; i < n; i++)
		{
			// Swap array element
			arr[s + i] = arr[s + i] + arr[e + i];
			arr[e + i] = arr[s + i] - arr[e + i];
			arr[s + i] = arr[s + i] - arr[e + i];
		}
	}
	public void blockSwapAlgo(int[] arr, int n, int k)
	{
		if (k == 0 || k >= n)
		{
			// When k = 0 then result are not change
			// And k >= n is greater than or equal to size n
			return;
		}
		// Display given array
		System.out.println(" Before rotation ");
		System.out.println(" Array : ");
		printData(arr, n);
		System.out.println(" Given rotation k is : " + k);
		int i = k;
		int j = n - k;
		while (i != j)
		{
			if (i < j)
			{
				// When i is less than j
				swapSubArray(arr, k - i, k + j - i, i);
				// Reduce i in j
				j = j - i;
			}
			else
			{
				// When j is less than i
				swapSubArray(arr, k - i, k, j);
				i = i - j;
			}
		}
		swapSubArray(arr, k - i, k, i);
		// Display resultant array
		System.out.println(" After rotation ");
		System.out.println(" Array : ");
		printData(arr, n);
      	System.out.print("\n");
	}
	public static void main(String[] args)
	{
		Rotation task = new Rotation();
		// Array of integer elements
		int[] arr = {
			8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0
		};
		// Get the number of elements
		int n = arr.length;
		// Test case
		task.blockSwapAlgo(arr, n, 5);
		task.blockSwapAlgo(arr, n, 3);
	}
}

input

 Before rotation
 Array :
 8 7 6 5 4 3 2 1 0
 Given rotation k is : 5
 After rotation
 Array :
 3 2 1 0 8 7 6 5 4

 Before rotation
 Array :
 3 2 1 0 8 7 6 5 4
 Given rotation k is : 3
 After rotation
 Array :
 0 8 7 6 5 4 3 2 1
// Include header file
#include <iostream>
using namespace std;
/*
  C++ Program for 
  Block swap algorithm for array rotation
*/
class Rotation
{
	public:
		// This is display the given array elements
		void printData(int arr[], int n)
		{
			// Executing the loop through by the size of array
			for (int i = 0; i < n; ++i)
			{
				cout << " " << arr[i];
			}
			cout << "\n";
		}
	// This is swapping given block elements
	void swapSubArray(int arr[], int s, int e, int n)
	{
		// Executing the loop through by the n 
		for (int i = 0; i < n; i++)
		{
			// Swap array element
			arr[s + i] = arr[s + i] + arr[e + i];
			arr[e + i] = arr[s + i] - arr[e + i];
			arr[s + i] = arr[s + i] - arr[e + i];
		}
	}
	void blockSwapAlgo(int arr[], int n, int k)
	{
		if (k == 0 || k >= n)
		{
			// When k = 0 then result are not change
			// And k >= n is greater than or equal to size n
			return;
		}
		// Display given array
		cout << " Before rotation " << endl;
		cout << " Array : " << endl;
		this->printData(arr, n);
		cout << " Given rotation k is : " << k << endl;
		int i = k;
		int j = n - k;
		while (i != j)
		{
			if (i < j)
			{
				// When i is less than j
				this->swapSubArray(arr, k - i, k + j - i, i);
				// Reduce i in j
				j = j - i;
			}
			else
			{
				// When j is less than i
				this->swapSubArray(arr, k - i, k, j);
				i = i - j;
			}
		}
		this->swapSubArray(arr, k - i, k, i);
		// Display resultant array
		cout << " After rotation " << endl;
		cout << " Array : " << endl;
		this->printData(arr, n);
		cout << "\n";
	}
};
int main()
{
	Rotation *task = new Rotation();
	// Array of integer elements
	int arr[] = {
		8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0
	};
	// Get the number of elements
	int n = sizeof(arr) / sizeof(arr[0]);
	// Test case
	task->blockSwapAlgo(arr, n, 5);
	task->blockSwapAlgo(arr, n, 3);
	return 0;
}

input

 Before rotation
 Array :
 8 7 6 5 4 3 2 1 0
 Given rotation k is : 5
 After rotation
 Array :
 3 2 1 0 8 7 6 5 4

 Before rotation
 Array :
 3 2 1 0 8 7 6 5 4
 Given rotation k is : 3
 After rotation
 Array :
 0 8 7 6 5 4 3 2 1
// Include namespace system
using System;
/*
  Csharp Program for 
  Block swap algorithm for array rotation
*/
public class Rotation
{
	// This is display the given array elements
	public void printData(int[] arr, int n)
	{
		// Executing the loop through by the size of array
		for (int i = 0; i < n; ++i)
		{
			Console.Write(" " + arr[i]);
		}
		Console.Write("\n");
	}
	// This is swapping given block elements
	public void swapSubArray(int[] arr, int s, int e, int n)
	{
		// Executing the loop through by the n 
		for (int i = 0; i < n; i++)
		{
			// Swap array element
			arr[s + i] = arr[s + i] + arr[e + i];
			arr[e + i] = arr[s + i] - arr[e + i];
			arr[s + i] = arr[s + i] - arr[e + i];
		}
	}
	public void blockSwapAlgo(int[] arr, int n, int k)
	{
		if (k == 0 || k >= n)
		{
			// When k = 0 then result are not change
			// And k >= n is greater than or equal to size n
			return;
		}
		// Display given array
		Console.WriteLine(" Before rotation ");
		Console.WriteLine(" Array : ");
		this.printData(arr, n);
		Console.WriteLine(" Given rotation k is : " + k);
		int i = k;
		int j = n - k;
		while (i != j)
		{
			if (i < j)
			{
				// When i is less than j
				this.swapSubArray(arr, k - i, k + j - i, i);
				// Reduce i in j
				j = j - i;
			}
			else
			{
				// When j is less than i
				this.swapSubArray(arr, k - i, k, j);
				i = i - j;
			}
		}
		this.swapSubArray(arr, k - i, k, i);
		// Display resultant array
		Console.WriteLine(" After rotation ");
		Console.WriteLine(" Array : ");
		this.printData(arr, n);
		Console.Write("\n");
	}
	public static void Main(String[] args)
	{
		Rotation task = new Rotation();
		// Array of integer elements
		int[] arr = {
			8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0
		};
		// Get the number of elements
		int n = arr.Length;
		// Test case
		task.blockSwapAlgo(arr, n, 5);
		task.blockSwapAlgo(arr, n, 3);
	}
}

input

 Before rotation
 Array :
 8 7 6 5 4 3 2 1 0
 Given rotation k is : 5
 After rotation
 Array :
 3 2 1 0 8 7 6 5 4

 Before rotation
 Array :
 3 2 1 0 8 7 6 5 4
 Given rotation k is : 3
 After rotation
 Array :
 0 8 7 6 5 4 3 2 1
<?php
/*
  Php Program for 
  Block swap algorithm for array rotation
*/
class Rotation
{
	// This is display the given array elements
	public	function printData($arr, $n)
	{
		// Executing the loop through by the size of array
		for ($i = 0; $i < $n; ++$i)
		{
			echo " ".strval($arr[$i]);
		}
		echo "\n";
	}
	// This is swapping given block elements
	public	function swapSubArray($arr, $s, $e, $n)
	{
		// Executing the loop through by the n 
		for ($i = 0; $i < $n; $i++)
		{
			// Swap array element
			$arr[$s + $i] = $arr[$s + $i] + $arr[$e + $i];
			$arr[$e + $i] = $arr[$s + $i] - $arr[$e + $i];
			$arr[$s + $i] = $arr[$s + $i] - $arr[$e + $i];
		}
	}
	public	function blockSwapAlgo($arr, $n, $k)
	{
		if ($k == 0 || $k >= $n)
		{
			// When k = 0 then result are not change
			// And k >= n is greater than or equal to size n
			return;
		}
		// Display given array
		echo " Before rotation ".
		"\n";
		echo " Array : ".
		"\n";
		$this->printData($arr, $n);
		echo " Given rotation k is : ".strval($k).
		"\n";
		$i = $k;
		$j = $n - $k;
		while ($i != $j)
		{
			if ($i < $j)
			{
				// When i is less than j
				$this->swapSubArray($arr, $k - $i, $k + $j - $i, $i);
				// Reduce i in j
				$j = $j - $i;
			}
			else
			{
				// When j is less than i
				$this->swapSubArray($arr, $k - $i, $k, $j);
				$i = $i - $j;
			}
		}
		$this->swapSubArray($arr, $k - $i, $k, $i);
		// Display resultant array
		echo " After rotation ".
		"\n";
		echo " Array : ".
		"\n";
		$this->printData($arr, $n);
		echo "\n";
	}
}

function main()
{
	$task = new Rotation();
	// Array of integer elements
	$arr = array(8, 7, 6, 5, 4, 3, 2, 1, 0);
	// Get the number of elements
	$n = count($arr);
	// Test case
	$task->blockSwapAlgo($arr, $n, 5);
	$task->blockSwapAlgo($arr, $n, 3);
}
main();

input

 Before rotation
 Array :
 8 7 6 5 4 3 2 1 0
 Given rotation k is : 5
 After rotation
 Array :
 8 7 6 5 4 3 2 1 0

 Before rotation
 Array :
 8 7 6 5 4 3 2 1 0
 Given rotation k is : 3
 After rotation
 Array :
 8 7 6 5 4 3 2 1 0
/*
  Node JS Program for 
  Block swap algorithm for array rotation
*/
class Rotation
{
	// This is display the given array elements
	printData(arr, n)
	{
		// Executing the loop through by the size of array
		for (var i = 0; i < n; ++i)
		{
			process.stdout.write(" " + arr[i]);
		}
		process.stdout.write("\n");
	}
	// This is swapping given block elements
	swapSubArray(arr, s, e, n)
	{
		// Executing the loop through by the n 
		for (var i = 0; i < n; i++)
		{
			// Swap array element
			arr[s + i] = arr[s + i] + arr[e + i];
			arr[e + i] = arr[s + i] - arr[e + i];
			arr[s + i] = arr[s + i] - arr[e + i];
		}
	}
	blockSwapAlgo(arr, n, k)
	{
		if (k == 0 || k >= n)
		{
			// When k = 0 then result are not change
			// And k >= n is greater than or equal to size n
			return;
		}
		// Display given array
		console.log(" Before rotation ");
		console.log(" Array : ");
		this.printData(arr, n);
		console.log(" Given rotation k is : " + k);
		var i = k;
		var j = n - k;
		while (i != j)
		{
			if (i < j)
			{
				// When i is less than j
				this.swapSubArray(arr, k - i, k + j - i, i);
				// Reduce i in j
				j = j - i;
			}
			else
			{
				// When j is less than i
				this.swapSubArray(arr, k - i, k, j);
				i = i - j;
			}
		}
		this.swapSubArray(arr, k - i, k, i);
		// Display resultant array
		console.log(" After rotation ");
		console.log(" Array : ");
		this.printData(arr, n);
		process.stdout.write("\n");
	}
}

function main()
{
	var task = new Rotation();
	// Array of integer elements
	var arr = [8, 7, 6, 5, 4, 3, 2, 1, 0];
	// Get the number of elements
	var n = arr.length;
	// Test case
	task.blockSwapAlgo(arr, n, 5);
	task.blockSwapAlgo(arr, n, 3);
}
main();

input

 Before rotation
 Array :
 8 7 6 5 4 3 2 1 0
 Given rotation k is : 5
 After rotation
 Array :
 3 2 1 0 8 7 6 5 4

 Before rotation
 Array :
 3 2 1 0 8 7 6 5 4
 Given rotation k is : 3
 After rotation
 Array :
 0 8 7 6 5 4 3 2 1
#  Python 3 Program for 
#  Block swap algorithm for array rotation
class Rotation :
	#  This is display the given list elements
	def printData(self, arr, n) :
		i = 0
		#  Executing the loop through by the size of list
		while (i < n) :
			print(" ", arr[i], end = "")
			i += 1
		
		print(end = "\n")
	
	#  This is swapping given block elements
	def swapSubArray(self, arr, s, e, n) :
		i = 0
		#  Executing the loop through by the n 
		while (i < n) :
			#  Swap list element
			arr[s + i] = arr[s + i] + arr[e + i]
			arr[e + i] = arr[s + i] - arr[e + i]
			arr[s + i] = arr[s + i] - arr[e + i]
			i += 1
		
	
	def blockSwapAlgo(self, arr, n, k) :
		if (k == 0 or k >= n) :
			#  When k = 0 then result are not change
			#  And k >= n is greater than or equal to size n
			return
		
		#  Display given list
		print(" Before rotation ")
		print(" Array : ")
		self.printData(arr, n)
		print(" Given rotation k is : ", k)
		i = k
		j = n - k
		while (i != j) :
			if (i < j) :
				#  When i is less than j
				self.swapSubArray(arr, k - i, k + j - i, i)
				#  Reduce i in j
				j = j - i
			else :
				#  When j is less than i
				self.swapSubArray(arr, k - i, k, j)
				i = i - j
			
		
		self.swapSubArray(arr, k - i, k, i)
		#  Display resultant list
		print(" After rotation ")
		print(" Array : ")
		self.printData(arr, n)
		print(end = "\n")
	

def main() :
	task = Rotation()
	arr = [8, 7, 6, 5, 4, 3, 2, 1, 0]
	n = len(arr)
	#  Test case
	task.blockSwapAlgo(arr, n, 5)
	task.blockSwapAlgo(arr, n, 3)

if __name__ == "__main__": main()

input

 Before rotation
 Array :
  8  7  6  5  4  3  2  1  0
 Given rotation k is :  5
 After rotation
 Array :
  3  2  1  0  8  7  6  5  4

 Before rotation
 Array :
  3  2  1  0  8  7  6  5  4
 Given rotation k is :  3
 After rotation
 Array :
  0  8  7  6  5  4  3  2  1
#  Ruby Program for 
#  Block swap algorithm for array rotation
class Rotation 
	#  This is display the given array elements
	def printData(arr, n) 
		i = 0
		#  Executing the loop through by the size of array
		while (i < n) 
			print(" ", arr[i])
			i += 1
		end

		print("\n")
	end

	#  This is swapping given block elements
	def swapSubArray(arr, s, e, n) 
		i = 0
		#  Executing the loop through by the n 
		while (i < n) 
			#  Swap array element
			arr[s + i] = arr[s + i] + arr[e + i]
			arr[e + i] = arr[s + i] - arr[e + i]
			arr[s + i] = arr[s + i] - arr[e + i]
			i += 1
		end

	end

	def blockSwapAlgo(arr, n, k) 
		if (k == 0 || k >= n) 
			#  When k = 0 then result are not change
			#  And k >= n is greater than or equal to size n
			return
		end

		#  Display given array
		print(" Before rotation ", "\n")
		print(" Array : ", "\n")
		self.printData(arr, n)
		print(" Given rotation k is : ", k, "\n")
		i = k
		j = n - k
		while (i != j) 
			if (i < j) 
				#  When i is less than j
				self.swapSubArray(arr, k - i, k + j - i, i)
				#  Reduce i in j
				j = j - i
			else 
				#  When j is less than i
				self.swapSubArray(arr, k - i, k, j)
				i = i - j
			end

		end

		self.swapSubArray(arr, k - i, k, i)
		#  Display resultant array
		print(" After rotation ", "\n")
		print(" Array : ", "\n")
		self.printData(arr, n)
		print("\n")
	end

end

def main() 
	task = Rotation.new()
	#  Array of integer elements
	arr = [8, 7, 6, 5, 4, 3, 2, 1, 0]
	#  Get the number of elements
	n = arr.length
	#  Test case
	task.blockSwapAlgo(arr, n, 5)
	task.blockSwapAlgo(arr, n, 3)
end

main()

input

 Before rotation 
 Array : 
 8 7 6 5 4 3 2 1 0
 Given rotation k is : 5
 After rotation 
 Array : 
 3 2 1 0 8 7 6 5 4

 Before rotation 
 Array : 
 3 2 1 0 8 7 6 5 4
 Given rotation k is : 3
 After rotation 
 Array : 
 0 8 7 6 5 4 3 2 1

/*
  Scala Program for 
  Block swap algorithm for array rotation
*/
class Rotation()
{
	// This is display the given array elements
	def printData(arr: Array[Int], n: Int): Unit = {
		var i: Int = 0;
		// Executing the loop through by the size of array
		while (i < n)
		{
			print(" " + arr(i));
			i += 1;
		}
		print("\n");
	}
	// This is swapping given block elements
	def swapSubArray(arr: Array[Int], s: Int, e: Int, n: Int): Unit = {
		var i: Int = 0;
		// Executing the loop through by the n 
		while (i < n)
		{
			// Swap array element
			arr(s + i) = arr(s + i) + arr(e + i);
			arr(e + i) = arr(s + i) - arr(e + i);
			arr(s + i) = arr(s + i) - arr(e + i);
			i += 1;
		}
	}
	def blockSwapAlgo(arr: Array[Int], n: Int, k: Int): Unit = {
		if (k == 0 || k >= n)
		{
			// When k = 0 then result are not change
			// And k >= n is greater than or equal to size n
			return;
		}
		// Display given array
		println(" Before rotation ");
		println(" Array : ");
		printData(arr, n);
		println(" Given rotation k is : " + k);
		var i: Int = k;
		var j: Int = n - k;
		while (i != j)
		{
			if (i < j)
			{
				// When i is less than j
				swapSubArray(arr, k - i, k + j - i, i);
				// Reduce i in j
				j = j - i;
			}
			else
			{
				// When j is less than i
				swapSubArray(arr, k - i, k, j);
				i = i - j;
			}
		}
		swapSubArray(arr, k - i, k, i);
		// Display resultant array
		println(" After rotation ");
		println(" Array : ");
		printData(arr, n);
		print("\n");
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Rotation = new Rotation();
		// Array of integer elements
		var arr: Array[Int] = Array(8, 7, 6, 5, 4, 3, 2, 1, 0);
		// Get the number of elements
		var n: Int = arr.length;
		// Test case
		task.blockSwapAlgo(arr, n, 5);
		task.blockSwapAlgo(arr, n, 3);
	}
}

input

 Before rotation
 Array :
 8 7 6 5 4 3 2 1 0
 Given rotation k is : 5
 After rotation
 Array :
 3 2 1 0 8 7 6 5 4

 Before rotation
 Array :
 3 2 1 0 8 7 6 5 4
 Given rotation k is : 3
 After rotation
 Array :
 0 8 7 6 5 4 3 2 1
/*
  Swift 4 Program for 
  Block swap algorithm for array rotation
*/
class Rotation
{
	// This is display the given array elements
	func printData(_ arr: [Int], _ n: Int)
	{
		var i: Int = 0;
		// Executing the loop through by the size of array
		while (i < n)
		{
			print(" ", arr[i], terminator: "");
			i += 1;
		}
		print(terminator: "\n");
	}
	// This is swapping given block elements
	func swapSubArray(_ arr: inout[Int], _ s: Int, _ e: Int, _ n: Int)
	{
		var i: Int = 0;
		// Executing the loop through by the n 
		while (i < n)
		{
			// Swap array element
			arr[s + i] = arr[s + i] + arr[e + i];
			arr[e + i] = arr[s + i] - arr[e + i];
			arr[s + i] = arr[s + i] - arr[e + i];
			i += 1;
		}
	}
	func blockSwapAlgo(_ arr: inout[Int], _ n: Int, _ k: Int)
	{
		if (k == 0 || k >= n)
		{
			// When k = 0 then result are not change
			// And k >= n is greater than or equal to size n
			return;
		}
		// Display given array
		print(" Before rotation ");
		print(" Array : ");
		self.printData(arr, n);
		print(" Given rotation k is : ", k);
		var i: Int = k;
		var j: Int = n - k;
		while (i  != j)
		{
			if (i < j)
			{
				// When i is less than j
				self.swapSubArray(&arr, k - i, k + j - i, i);
				// Reduce i in j
				j = j - i;
			}
			else
			{
				// When j is less than i
				self.swapSubArray(&arr, k - i, k, j);
				i = i - j;
			}
		}
		self.swapSubArray(&arr, k - i, k, i);
		// Display resultant array
		print(" After rotation ");
		print(" Array : ");
		self.printData(arr, n);
		print(terminator: "\n");
	}
}
func main()
{
	let task: Rotation = Rotation();
	// Array of integer elements
	var arr: [Int] = [8, 7, 6, 5, 4, 3, 2, 1, 0];
	// Get the number of elements
	let n: Int = arr.count;
	// Test case
	task.blockSwapAlgo(&arr, n, 5);
	task.blockSwapAlgo(&arr, n, 3);
}
main();

input

 Before rotation
 Array :
  8  7  6  5  4  3  2  1  0
 Given rotation k is :  5
 After rotation
 Array :
  3  2  1  0  8  7  6  5  4

 Before rotation
 Array :
  3  2  1  0  8  7  6  5  4
 Given rotation k is :  3
 After rotation
 Array :
  0  8  7  6  5  4  3  2  1
/*
  Kotlin Program for 
  Block swap algorithm for array rotation
*/
class Rotation
{
	// This is display the given array elements
	fun printData(arr: Array < Int > , n: Int): Unit
	{
		var i: Int = 0;
		while (i < n)
		{
			print(" " + arr[i].toString());
			i += 1;
		}
		print("\n");
	}
	// This is swapping given block elements
	fun swapSubArray(arr: Array < Int > , s: Int, e: Int, n: Int): Unit
	{
		var i: Int = 0;
		while (i < n)
		{
			// Swap array element
			arr[s + i] = arr[s + i] + arr[e + i];
			arr[e + i] = arr[s + i] - arr[e + i];
			arr[s + i] = arr[s + i] - arr[e + i];
			i += 1;
		}
	}
	fun blockSwapAlgo(arr: Array < Int > , n: Int, k: Int): Unit
	{
		if (k == 0 || k >= n)
		{
			// When k = 0 then result are not change
			// And k >= n is greater than or equal to size n
			return;
		}
		// Display given array
		println(" Before rotation ");
		println(" Array : ");
		this.printData(arr, n);
		println(" Given rotation k is : " + k.toString());
		var i: Int = k;
		var j: Int = n - k;
		while (i != j)
		{
			if (i < j)
			{
				// When i is less than j
				this.swapSubArray(arr, k - i, k + j - i, i);
				// Reduce i in j
				j = j - i;
			}
			else
			{
				// When j is less than i
				this.swapSubArray(arr, k - i, k, j);
				i = i - j;
			}
		}
		this.swapSubArray(arr, k - i, k, i);
		// Display resultant array
		println(" After rotation ");
		println(" Array : ");
		this.printData(arr, n);
		print("\n");
	}
}
fun main(args: Array < String > ): Unit
{
	val task: Rotation = Rotation();
	// Array of integer elements
	val arr: Array < Int > = arrayOf(8, 7, 6, 5, 4, 3, 2, 1, 0);
	// Get the number of elements
	val n: Int = arr.count();
	// Test case
	task.blockSwapAlgo(arr, n, 5);
	task.blockSwapAlgo(arr, n, 3);
}

input

 Before rotation
 Array :
 8 7 6 5 4 3 2 1 0
 Given rotation k is : 5
 After rotation
 Array :
 3 2 1 0 8 7 6 5 4

 Before rotation
 Array :
 3 2 1 0 8 7 6 5 4
 Given rotation k is : 3
 After rotation
 Array :
 0 8 7 6 5 4 3 2 1


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







© 2021, kalkicode.com, All rights reserved