Find element at given index after a number of rotations

Here given code implementation process.

// C program 
// Find element at given index after a number of rotations
#include <stdio.h>

//Function which is display array elements
void display(int arr[], int size)
{
    for (int i = 0; i < size; ++i)
    {
        printf("%d  ", arr[i]);
    }
    printf("\n");
}
//Function which is swapping two array elements of given location
void swapElement(int arr[], int i, int j)
{
    // Get i location element
    int temp = arr[i];
    // Set new values
    arr[i] = arr[j];
    arr[j] = temp;
}
//Function which is Reversing given array elements 
void reverseElement(int arr[], int a, int b)
{
    int front = a;
    int tail = b;
    while (front < tail)
    {
        //Swap the array elements
        swapElement(arr, front, tail);
        front++;
        tail--;
    }
}
// Find the location element after various rotation
void rotatedElement(int arr[], int ranges[][2], int step, int n, int location)
{
    if(location < 0 || location >= n)
    {
        // When get invalid location
        return;
    }
    // This auxiliary array are used to hold information of rotations
    int auxiliary[n];

    // Loop controlling variables
    int i = 0;
    int a = 0;
    int b = 0;

    // Assign value of actual array in auxiliary array
    for (i = 0; i < n; ++i)
    {
        auxiliary[i] = arr[i];
    }


    for (i = 0; i < step; ++i)
    {
        a = ranges[i][0];
        b = ranges[i][1];

        if(a >= 0 && a < n &&  b >= 0 && b < n )
        {
            // Rotate Operation 
            reverseElement(auxiliary,a,b-1); 
            reverseElement(auxiliary,a,b); 
        }
        else
        {
            printf("\n Ranges (%d-%d) not valid\n",a,b);
            return;
        }
    }
    printf("\n Location at %d is : %d",location,auxiliary[location]);
   
}
int main()
{
    
    int arr[] = { 1, 2, 3, 4, 5, 6 }; 

    // Get the size of array
    int n = sizeof(arr)/sizeof(arr[0]);


    int ranges1[][2] = { {1, 3}, { 0, 3 }, {2, 4}, {1, 4}, {0, 3} };
    int ranges2[][2] = { {0, 4}, { 1, 5 }, {2, 4}, {1, 4}, {2, 5}, {1,3} };
    
    // Get the size of range
    int step = sizeof(ranges1) / sizeof(ranges1[0]) ; 

    /*

        1, 2, 3, 4, 5 , 6 <- Actual Array
        
        Rotations (1, 3) 
        1  4  2  3  5  6 

        Rotations (0, 3) 
        3  1  4  2  5  6 

        Rotations (2, 4) 
        3  1  5  4  2  6 

        Rotations (1, 4) 
        3  2  1  5  4  6  

        Rotations (0, 3) 
        5  3  2  1  4  6  
    
        location = 1

        O/P = 3
    */ 
    rotatedElement(arr,ranges1,step, n, 1); 

    /*

        1, 2, 3, 4, 5 , 6 <- Actual Array
        -----------------
        Rotations (0, 4) 
        5  1  2  3  4  6  

        Rotations (1, 5) 
        5  6  1  2  3  4  

        Rotations (2, 4) 
        5  6  3  1  2  4  

        Rotations (1, 4) 
        5  2  6  3  1  4  

        Rotations (2, 5) 
        5  2  4  6  3  1  

        Rotations (1, 3) 
        5  6  2  4  3  1 

        location = 3

        O/P = 4

    */
    step = sizeof(ranges2) / sizeof(ranges2[0]) ; 
    rotatedElement(arr,ranges2,step, n, 3);
    return 0;
}

Output

 Location at 1 is : 3
 Location at 3 is : 4
/*
   Java Program
   Find element at given index after a number of rotations
*/
public class SearchElement
{
//Function which is display array elements
public void display(int[] arr, int size)
{
    for (int i = 0; i < size; ++i)
    {
        System.out.print("  " + arr[i] );
    }
    System.out.print("\n");
}
//Function which is swapping two array elements of given location
public void swapElement(int[] arr, int i, int j)
{
    // Get i location element
    int temp = arr[i];
    // Set new values
    arr[i] = arr[j];
    arr[j] = temp;
}
//Function which is Reversing given array elements 
public void reverseElement(int[] arr, int a, int b)
{
    int front = a;
    int tail = b;
    while (front < tail)
    {
        //Swap the array elements
        swapElement(arr, front, tail);
        front++;
        tail--;
    }
}
// Find the location element after various rotation
public void rotatedElement(int[] arr, int[][] ranges, int step, int n, int location)
{
    if (location < 0 || location >= n)
    {
        // When get invalid location
        return;
    }
    // This auxiliary array are used to hold information of rotations
    int[] auxiliary = new int[n];
    // Loop controlling variables
    int i = 0;
    int a = 0;
    int b = 0;
    // Assign value of actual array in auxiliary array
    for (i = 0; i < n; ++i)
    {
        auxiliary[i] = arr[i];
    }
    for (i = 0; i < step; ++i)
    {
        a = ranges[i][0];
        b = ranges[i][1];
        if (a >= 0 && a < n && b >= 0 && b < n)
        {
            // Rotate Operation 
            reverseElement(auxiliary, a, b - 1);
            reverseElement(auxiliary, a, b);
        }
        else
        {
            System.out.print("\n Ranges (" + a + "-" + b + ") not valid\n");
            return;
        }
    }
    System.out.print("\n Location at " + location + " is : " + auxiliary[location]);
}
    
    public static void main(String[] args)
    {
    SearchElement task = new SearchElement();
    int[] arr = {
        1 , 2 , 3 , 4 , 5 , 6
    };
    // Get the size of array
    int n = arr.length;
    int [][]ranges1 = { {1, 3}, { 0, 3 }, {2, 4}, {1, 4}, {0, 3} };
    int [][]ranges2 = { {0, 4}, { 1, 5 }, {2, 4}, {1, 4}, {2, 5}, {1,3} };
    // Get the size of range
    int step = ranges1.length;
    /*
        1, 2, 3, 4, 5 , 6 <- Actual Array
        
        Rotations (1, 3) 
        1  4  2  3  5  6 

        Rotations (0, 3) 
        3  1  4  2  5  6 

        Rotations (2, 4) 
        3  1  5  4  2  6 

        Rotations (1, 4) 
        3  2  1  5  4  6  

        Rotations (0, 3) 
        5  3  2  1  4  6  

        location = 1

        O/P = 3
    */
    task.rotatedElement(arr, ranges1, step, n, 1);
    /*

        1, 2, 3, 4, 5 , 6 <- Actual Array
        -----------------
        Rotations (0, 4) 
        5  1  2  3  4  6  

        Rotations (1, 5) 
        5  6  1  2  3  4  

        Rotations (2, 4) 
        5  6  3  1  2  4  

        Rotations (1, 4) 
        5  2  6  3  1  4  

        Rotations (2, 5) 
        5  2  4  6  3  1  

        Rotations (1, 3) 
        5  6  2  4  3  1 

        location = 3

        O/P = 4

    */
    step = ranges2.length;
    task.rotatedElement(arr, ranges2, step, n, 3);
    }
}

Output

 Location at 1 is : 3
 Location at 3 is : 4
// Include header file
#include <iostream>

using namespace std;
/*
   C++ Program
   Find element at given index after a number of rotations
*/
class SearchElement
{
	public:
		//Function which is display array elements
		void display(int arr[], int size)
		{
			for (int i = 0; i < size; ++i)
			{
				cout << "  " << arr[i];
			}
			cout << "\n";
		}
	//Function which is swapping two array elements of given location
	void swapElement(int arr[], int i, int j)
	{
		// Get i location element
		int temp = arr[i];
		// Set new values
		arr[i] = arr[j];
		arr[j] = temp;
	}
	//Function which is Reversing given array elements
	void reverseElement(int arr[], int a, int b)
	{
		int front = a;
		int tail = b;
		while (front < tail)
		{
			//Swap the array elements
			this->swapElement(arr, front, tail);
			front++;
			tail--;
		}
	}
	// Find the location element after various rotation
	void rotatedElement(int arr[], int ranges[][2], int step, int n, int location)
	{
		// When get invalid location
		if (location < 0 || location >= n)
		{
			return;
		}
		// This auxiliary array are used to hold information of rotations
		int auxiliary[n];
		// Loop controlling variables
		int i = 0;
		int a = 0;
		int b = 0;
		// Assign value of actual array in auxiliary array
		for (i = 0; i < n; ++i)
		{
			auxiliary[i] = arr[i];
		}
		for (i = 0; i < step; ++i)
		{
			a = ranges[i][0];
			b = ranges[i][1];
			if (a >= 0 && a < n && b >= 0 && b < n)
			{
				// Rotate Operation
				this->reverseElement(auxiliary, a, b - 1);
				this->reverseElement(auxiliary, a, b);
			}
			else
			{
				cout << "\n Ranges (" << a << "-" << b << ") not valid\n";
				return;
			}
		}
		cout << "\n Location at " << location << " is : " << auxiliary[location];
	}
};
int main()
{
	SearchElement task = SearchElement();
	int arr[] = {
		1 , 2 , 3 , 4 , 5 , 6
	};
	// Get the size of array
	int n = sizeof(arr) / sizeof(arr[0]);
	int ranges1[][2] = {
		{
			1 , 3
		} , {
			0 , 3
		} , {
			2 , 4
		} , {
			1 , 4
		} , {
			0 , 3
		}
	};
	int ranges2[][2] = {
		{
			0 , 4
		} , {
			1 , 5
		} , {
			2 , 4
		} , {
			1 , 4
		} , {
			2 , 5
		} , {
			1 , 3
		}
	};
	// Get the size of range
	int step = sizeof(ranges1) / sizeof(ranges1[0]);
	/*
	        1, 2, 3, 4, 5 , 6 <- Actual Array
	        
	        Rotations (1, 3) 
	        1  4  2  3  5  6 

	        Rotations (0, 3) 
	        3  1  4  2  5  6 

	        Rotations (2, 4) 
	        3  1  5  4  2  6 

	        Rotations (1, 4) 
	        3  2  1  5  4  6  

	        Rotations (0, 3) 
	        5  3  2  1  4  6  

	        location = 1

	        O/P = 3
	    */
	task.rotatedElement(arr, ranges1, step, n, 1);
	/*

	        1, 2, 3, 4, 5 , 6 <- Actual Array
	        -----------------
	        Rotations (0, 4) 
	        5  1  2  3  4  6  

	        Rotations (1, 5) 
	        5  6  1  2  3  4  

	        Rotations (2, 4) 
	        5  6  3  1  2  4  

	        Rotations (1, 4) 
	        5  2  6  3  1  4  

	        Rotations (2, 5) 
	        5  2  4  6  3  1  

	        Rotations (1, 3) 
	        5  6  2  4  3  1 

	        location = 3

	        O/P = 4

	    */
	step = sizeof(ranges2) / sizeof(ranges2[0]);
	task.rotatedElement(arr, ranges2, step, n, 3);
	return 0;
}

Output

 Location at 1 is : 3
 Location at 3 is : 4
// Include namespace system
using System;
/*
   C# Program
   Find element at given index after a number of rotations
*/
public class SearchElement
{
    //Function which is display array elements
    public void display(int[] arr, int size)
    {
        for (int i = 0; i < size; ++i)
        {
            Console.Write("  " + arr[i]);
        }
        Console.Write("\n");
    }
    //Function which is swapping two array elements of given location
    public void swapElement(int[] arr, int i, int j)
    {
        // Get i location element
        int temp = arr[i];
        // Set new values
        arr[i] = arr[j];
        arr[j] = temp;
    }
    //Function which is Reversing given array elements
    public void reverseElement(int[] arr, int a, int b)
    {
        int front = a;
        int tail = b;
        while (front < tail)
        {
            //Swap the array elements
            swapElement(arr, front, tail);
            front++;
            tail--;
        }
    }
    // Find the location element after various rotation
    public void rotatedElement(int[] arr, int[,] ranges, int step, int n, int location)
    {
        // When get invalid location
        if (location < 0 || location >= n)
        {
            return;
        }
        // This auxiliary array are used to hold information of rotations
        int[] auxiliary = new int[n];
        // Loop controlling variables
        int i = 0;
        int a = 0;
        int b = 0;
        // Assign value of actual array in auxiliary array
        for (i = 0; i < n; ++i)
        {
            auxiliary[i] = arr[i];
        }
        for (i = 0; i < step; ++i)
        {
            a = ranges[i,0];
            b = ranges[i,1];
            if (a >= 0 && a < n && b >= 0 && b < n)
            {
                // Rotate Operation
                reverseElement(auxiliary, a, b - 1);
                reverseElement(auxiliary, a, b);
            }
            else
            {
                Console.Write("\n Ranges (" + a + "-" + b + ") not valid\n");
                return;
            }
        }
        Console.Write("\n Location at " + location + " is : " + auxiliary[location]);
    }
    public static void Main(String[] args)
    {
        SearchElement task = new SearchElement();
        int[] arr = {
            1 , 2 , 3 , 4 , 5 , 6
        };
        // Get the size of array
        int n = arr.Length;
        int[,] ranges1 = { {1, 3}, { 0, 3 }, {2, 4}, {1, 4}, {0, 3} };
        int[,] ranges2 = { {0, 4}, { 1, 5 }, {2, 4}, {1, 4}, {2, 5}, {1,3} };
        // Get the size of range
        int step = ranges1.GetLength(0);
        /*
            1, 2, 3, 4, 5 , 6 <- Actual Array
            
            Rotations (1, 3) 
            1  4  2  3  5  6 

            Rotations (0, 3) 
            3  1  4  2  5  6 

            Rotations (2, 4) 
            3  1  5  4  2  6 

            Rotations (1, 4) 
            3  2  1  5  4  6  

            Rotations (0, 3) 
            5  3  2  1  4  6  

            location = 1

            O/P = 3
        */
        task.rotatedElement(arr, ranges1, step, n, 1);
        /*

        1, 2, 3, 4, 5 , 6 <- Actual Array
        -----------------
        Rotations (0, 4) 
        5  1  2  3  4  6  

        Rotations (1, 5) 
        5  6  1  2  3  4  

        Rotations (2, 4) 
        5  6  3  1  2  4  

        Rotations (1, 4) 
        5  2  6  3  1  4  

        Rotations (2, 5) 
        5  2  4  6  3  1  

        Rotations (1, 3) 
        5  6  2  4  3  1 

        location = 3

        O/P = 4

    */
        step = ranges2.GetLength(0);
        task.rotatedElement(arr, ranges2, step, n, 3);
    }
}

Output

 Location at 1 is : 3
 Location at 3 is : 4
<?php
/*
   Php Program
   Find element at given index after a number of rotations
*/
class SearchElement
{
    //Function which is display array elements
    public  function display( & $arr, $size)
    {
        for ($i = 0; $i < $size; ++$i)
        {
            echo "  ". $arr[$i];
        }
        echo "\n";
    }
    //Function which is swapping two array elements of given location
    public  function swapElement( & $arr, $i, $j)
    {
        // Get i location element
        $temp = $arr[$i];
        // Set new values
        $arr[$i] = $arr[$j];
        $arr[$j] = $temp;
    }
    //Function which is Reversing given array elements
    public  function reverseElement( & $arr, $a, $b)
    {
        $front = $a;
        $tail = $b;
        while ($front < $tail)
        {
            //Swap the array elements
            $this->swapElement($arr, $front, $tail);
            $front++;
            $tail--;
        }
    }
    // Find the location element after various rotation
    public  function rotatedElement( & $arr, & $ranges, $step, $n, $location)
    {
        // When get invalid location
        if ($location < 0 || $location >= $n)
        {
            return;
        }
        // This auxiliary array are used to hold information of rotations
        $auxiliary = array_fill(0, $n, 0);
        // Loop controlling variables
        $i = 0;
        $a = 0;
        $b = 0;
        // Assign value of actual array in auxiliary array
        for ($i = 0; $i < $n; ++$i)
        {
            $auxiliary[$i] = $arr[$i];
        }
        for ($i = 0; $i < $step; ++$i)
        {
            $a = $ranges[$i][0];
            $b = $ranges[$i][1];
            if ($a >= 0 && $a < $n && $b >= 0 && $b < $n)
            {
                // Rotate Operation
                $this->reverseElement($auxiliary, $a, $b - 1);
                $this->reverseElement($auxiliary, $a, $b);
            }
            else
            {
                echo "\n Ranges (". $a ."-". $b .") not valid\n";
                return;
            }
        }
        echo "\n Location at ". $location ." is : ". $auxiliary[$location];
    }
}

function main()
{
    $task = new SearchElement();
    $arr = array(1, 2, 3, 4, 5, 6);
    // Get the size of array
    $n = count($arr);
    $ranges1 = array(
        array(1, 3), 
        array(0, 3), 
        array(2, 4), 
        array(1, 4), 
        array(0, 3)
    );
    $ranges2 = array(
        array(0, 4), 
        array(1, 5), 
        array(2, 4), 
        array(1, 4), 
        array(2, 5), 
        array(1, 3)
    );
    // Get the size of range
    $step = count($ranges1);
    /*
        1, 2, 3, 4, 5 , 6 <- Actual Array
        
        Rotations (1, 3) 
        1  4  2  3  5  6 

        Rotations (0, 3) 
        3  1  4  2  5  6 

        Rotations (2, 4) 
        3  1  5  4  2  6 

        Rotations (1, 4) 
        3  2  1  5  4  6  

        Rotations (0, 3) 
        5  3  2  1  4  6  

        location = 1

        O/P = 3
    */
    $task->rotatedElement($arr, $ranges1, $step, $n, 1);
    /*

        1, 2, 3, 4, 5 , 6 <- Actual Array
        -----------------
        Rotations (0, 4) 
        5  1  2  3  4  6  

        Rotations (1, 5) 
        5  6  1  2  3  4  

        Rotations (2, 4) 
        5  6  3  1  2  4  

        Rotations (1, 4) 
        5  2  6  3  1  4  

        Rotations (2, 5) 
        5  2  4  6  3  1  

        Rotations (1, 3) 
        5  6  2  4  3  1 

        location = 3

        O/P = 4

    */
    $step = count($ranges2);
    $task->rotatedElement($arr, $ranges2, $step, $n, 3);
}
main();

Output

 Location at 1 is : 3
 Location at 3 is : 4
/*
   Node Js Program
   Find element at given index after a number of rotations
*/
class SearchElement
{
    //Function which is display array elements
    display(arr, size)
    {
        for (var i = 0; i < size; ++i)
        {
            process.stdout.write("  " + arr[i]);
        }
        process.stdout.write("\n");
    }
    //Function which is swapping two array elements of given location
    swapElement(arr, i, j)
    {
        // Get i location element
        var temp = arr[i];
        // Set new values
        arr[i] = arr[j];
        arr[j] = temp;
    }
    //Function which is Reversing given array elements
    reverseElement(arr, a, b)
    {
        var front = a;
        var tail = b;
        while (front < tail)
        {
            //Swap the array elements
            this.swapElement(arr, front, tail);
            front++;
            tail--;
        }
    }
    // Find the location element after various rotation
    rotatedElement(arr, ranges, step, n, location)
    {
        // When get invalid location
        if (location < 0 || location >= n)
        {
            return;
        }
        // This auxiliary array are used to hold information of rotations
        var auxiliary = Array(n).fill(0);
        // Loop controlling variables
        var i = 0;
        var a = 0;
        var b = 0;
        // Assign value of actual array in auxiliary array
        for (i = 0; i < n; ++i)
        {
            auxiliary[i] = arr[i];
        }
        for (i = 0; i < step; ++i)
        {
            a = ranges[i][0];
            b = ranges[i][1];
            if (a >= 0 && a < n && b >= 0 && b < n)
            {
                // Rotate Operation
                this.reverseElement(auxiliary, a, b - 1);
                this.reverseElement(auxiliary, a, b);
            }
            else
            {
                process.stdout.write("\n Ranges (" + a + "-" + b + ") not valid\n");
                return;
            }
        }
        process.stdout.write("\n Location at " + location + " is : " + auxiliary[location]);
    }
}

function main()
{
    var task = new SearchElement();
    var arr = [1, 2, 3, 4, 5, 6];
    // Get the size of array
    var n = arr.length;
    var ranges1 = [
        [1, 3] , [0, 3] , [2, 4] , [1, 4] , [0, 3]
    ];
    var ranges2 = [
        [0, 4] , [1, 5] , [2, 4] , [1, 4] , [2, 5] , [1, 3]
    ];
    // Get the size of range
    var step = ranges1.length;
    /*
        1, 2, 3, 4, 5 , 6 <- Actual Array
        
        Rotations (1, 3) 
        1  4  2  3  5  6 

        Rotations (0, 3) 
        3  1  4  2  5  6 

        Rotations (2, 4) 
        3  1  5  4  2  6 

        Rotations (1, 4) 
        3  2  1  5  4  6  

        Rotations (0, 3) 
        5  3  2  1  4  6  

        location = 1

        O/P = 3
    */
    task.rotatedElement(arr, ranges1, step, n, 1);
    /*

        1, 2, 3, 4, 5 , 6 <- Actual Array
        -----------------
        Rotations (0, 4) 
        5  1  2  3  4  6  

        Rotations (1, 5) 
        5  6  1  2  3  4  

        Rotations (2, 4) 
        5  6  3  1  2  4  

        Rotations (1, 4) 
        5  2  6  3  1  4  

        Rotations (2, 5) 
        5  2  4  6  3  1  

        Rotations (1, 3) 
        5  6  2  4  3  1 

        location = 3

        O/P = 4

    */
    step = ranges2.length;
    task.rotatedElement(arr, ranges2, step, n, 3);
}
main();

Output

 Location at 1 is : 3
 Location at 3 is : 4
# 
#    Python 3 Program
#    Find element at given index after a number of rotations

class SearchElement :
	# Function which is display array elements
	def display(self, arr, size) :
		i = 0
		while (i < size) :
			print("  ", arr[i], end = "")
			i += 1
		
		print(end = "\n")
	
	# Function which is swapping two array elements of given location
	def swapElement(self, arr, i, j) :
		#  Get i location element
		temp = arr[i]
		#  Set new values
		arr[i] = arr[j]
		arr[j] = temp
	
	# Function which is Reversing given array elements
	def reverseElement(self, arr, a, b) :
		front = a
		tail = b
		while (front < tail) :
			# Swap the array elements
			self.swapElement(arr, front, tail)
			front += 1
			tail -= 1
		
	
	#  Find the location element after various rotation
	def rotatedElement(self, arr, ranges, step, n, location) :
		#  When get invalid location
		if (location < 0 or location >= n) :
			return
		
		#  This auxiliary array are used to hold information of rotations
		auxiliary = [0] * (n)
		#  Loop controlling variables
		i = 0
		a = 0
		b = 0
		#  Assign value of actual array in auxiliary array
		i = 0
		while (i < n) :
			auxiliary[i] = arr[i]
			i += 1
		
		i = 0
		while (i < step) :
			a = ranges[i][0]
			b = ranges[i][1]
			if (a >= 0 and a < n and b >= 0 and b < n) :
				#  Rotate Operation
				self.reverseElement(auxiliary, a, b - 1)
				self.reverseElement(auxiliary, a, b)
			else :
				print("\n Ranges (", a ,"-", b ,") not valid")
				return
			
			i += 1
		
		print("\n Location at ", location ," is : ", auxiliary[location], end = "")
	

def main() :
	task = SearchElement()
	arr = [1, 2, 3, 4, 5, 6]
	#  Get the size of array
	n = len(arr)
	ranges1 = [
		[1, 3] , [0, 3] , [2, 4] , [1, 4] , [0, 3]
	]
	ranges2 = [
		[0, 4] , [1, 5] , [2, 4] , [1, 4] , [2, 5] , [1, 3]
	]
	#  Get the size of range
	step = len(ranges1)
	# 
	# 		       1, 2, 3, 4, 5 , 6 <- Actual Array
	# 		       
	# 		       Rotations (1, 3) 
	# 		       1  4  2  3  5  6 
	# 		       Rotations (0, 3) 
	# 		       3  1  4  2  5  6 
	# 		       Rotations (2, 4) 
	# 		       3  1  5  4  2  6 
	# 		       Rotations (1, 4) 
	# 		       3  2  1  5  4  6  
	# 		       Rotations (0, 3) 
	# 		       5  3  2  1  4  6  
	# 		       location = 1
	# 		       O/P = 3
	# 		   
	
	task.rotatedElement(arr, ranges1, step, n, 1)
	# 
	# 		       1, 2, 3, 4, 5 , 6 <- Actual Array
	# 		       -----------------
	# 		       Rotations (0, 4) 
	# 		       5  1  2  3  4  6  
	# 		       Rotations (1, 5) 
	# 		       5  6  1  2  3  4  
	# 		       Rotations (2, 4) 
	# 		       5  6  3  1  2  4  
	# 		       Rotations (1, 4) 
	# 		       5  2  6  3  1  4  
	# 		       Rotations (2, 5) 
	# 		       5  2  4  6  3  1  
	# 		       Rotations (1, 3) 
	# 		       5  6  2  4  3  1 
	# 		       location = 3
	# 		       O/P = 4
	# 		   
	
	step = len(ranges2)
	task.rotatedElement(arr, ranges2, step, n, 3)

if __name__ == "__main__": main()

Output

 Location at  1  is :  3
 Location at  3  is :  4
#  Ruby Program
#  Find element at given index after a number of rotations

class SearchElement 
	# Function which is display array elements
	def display(arr, size) 
		i = 0
		while (i < size) 
			print("  ", arr[i])
			i += 1
		end

		print("\n")
	end

	# Function which is swapping two array elements of given location
	def swapElement(arr, i, j) 
		#  Get i location element
		temp = arr[i]
		#  Set new values
		arr[i] = arr[j]
		arr[j] = temp
	end

	# Function which is Reversing given array elements
	def reverseElement(arr, a, b) 
		front = a
		tail = b
		while (front < tail) 
			# Swap the array elements
			self.swapElement(arr, front, tail)
			front += 1
			tail -= 1
		end

	end

	#  Find the location element after various rotation
	def rotatedElement(arr, ranges, step, n, location) 
		#  When get invalid location
		if (location < 0 || location >= n) 
			return
		end

		#  This auxiliary array are used to hold information of rotations
		auxiliary = Array.new(n) {0}
		#  Loop controlling variables
		i = 0
		a = 0
		b = 0
		#  Assign value of actual array in auxiliary array
		i = 0
		while (i < n) 
			auxiliary[i] = arr[i]
			i += 1
		end

		i = 0
		while (i < step) 
			a = ranges[i][0]
			b = ranges[i][1]
			if (a >= 0 && a < n && b >= 0 && b < n) 
				#  Rotate Operation
				self.reverseElement(auxiliary, a, b - 1)
				self.reverseElement(auxiliary, a, b)
			else 
				print("\n Ranges (", a ,"-", b ,") not valid\n")
				return
			end

			i += 1
		end

		print("\n Location at ", location ," is : ", auxiliary[location])
	end

end

def main() 
	task = SearchElement.new()
	arr = [1, 2, 3, 4, 5, 6]
	#  Get the size of array
	n = arr.length
	ranges1 = [
		[1, 3] , [0, 3] , [2, 4] , [1, 4] , [0, 3]
	]
	ranges2 = [
		[0, 4] , [1, 5] , [2, 4] , [1, 4] , [2, 5] , [1, 3]
	]
	#  Get the size of range
	step = ranges1.length
	# 
	# 		       1, 2, 3, 4, 5 , 6 <- Actual Array
	# 		       
	# 		       Rotations (1, 3) 
	# 		       1  4  2  3  5  6 
	# 		       Rotations (0, 3) 
	# 		       3  1  4  2  5  6 
	# 		       Rotations (2, 4) 
	# 		       3  1  5  4  2  6 
	# 		       Rotations (1, 4) 
	# 		       3  2  1  5  4  6  
	# 		       Rotations (0, 3) 
	# 		       5  3  2  1  4  6  
	# 		       location = 1
	# 		       O/P = 3
	# 		   
	
	task.rotatedElement(arr, ranges1, step, n, 1)
	# 
	# 		       1, 2, 3, 4, 5 , 6 <- Actual Array
	# 		       -----------------
	# 		       Rotations (0, 4) 
	# 		       5  1  2  3  4  6  
	# 		       Rotations (1, 5) 
	# 		       5  6  1  2  3  4  
	# 		       Rotations (2, 4) 
	# 		       5  6  3  1  2  4  
	# 		       Rotations (1, 4) 
	# 		       5  2  6  3  1  4  
	# 		       Rotations (2, 5) 
	# 		       5  2  4  6  3  1  
	# 		       Rotations (1, 3) 
	# 		       5  6  2  4  3  1 
	# 		       location = 3
	# 		       O/P = 4
	# 		   
	
	step = ranges2.length
	task.rotatedElement(arr, ranges2, step, n, 3)
end

main()

Output

 Location at 1 is : 3
 Location at 3 is : 4
/*
   Scala Program
   Find element at given index after a number of rotations
*/
class SearchElement
{
    //Function which is display array elements
    def display(arr: Array[Int], size: Int): Unit = {
        var i: Int = 0;
        while (i < size)
        {
            print("  " + arr(i));
            i += 1;
        }
        print("\n");
    }
    //Function which is swapping two array elements of given location
    def swapElement(arr: Array[Int], i: Int, j: Int): Unit = {
        // Get i location element
        var temp: Int = arr(i);
        // Set new values
        arr(i) = arr(j);
        arr(j) = temp;
    }
    //Function which is Reversing given array elements
    def reverseElement(arr: Array[Int], a: Int, b: Int): Unit = {
        var front: Int = a;
        var tail: Int = b;
        while (front < tail)
        {
            //Swap the array elements
            this.swapElement(arr, front, tail);
            front += 1;
            tail -= 1;
        }
    }
    // Find the location element after various rotation
    def rotatedElement(arr: Array[Int], ranges: Array[Array[Int]], step: Int, n: Int, location: Int): Unit = {
        // When get invalid location
        if (location < 0 || location >= n)
        {
            return;
        }
        // This auxiliary array are used to hold information of rotations
        var auxiliary: Array[Int] = Array.fill[Int](n)(0);
        // Loop controlling variables
        var i: Int = 0;
        var a: Int = 0;
        var b: Int = 0;
        // Assign value of actual array in auxiliary array
        i = 0;
        while (i < n)
        {
            auxiliary(i) = arr(i);
            i += 1;
        }
        i = 0;
        while (i < step)
        {
            a = ranges(i)(0);
            b = ranges(i)(1);
            if (a >= 0 && a < n && b >= 0 && b < n)
            {
                // Rotate Operation
                this.reverseElement(auxiliary, a, b - 1);
                this.reverseElement(auxiliary, a, b);
            }
            else
            {
                print("\n Ranges (" + a + "-" + b + ") not valid\n");
                return;
            }
            i += 1;
        }
        print("\n Location at " + location + " is : " + auxiliary(location));
    }
}
object Main
{
    def main(args: Array[String]): Unit = {
        var task: SearchElement = new SearchElement();
        var arr: Array[Int] = Array(1, 2, 3, 4, 5, 6);
        // Get the size of array
        var n: Int = arr.length;
        var ranges1: Array[Array[Int]] = Array(
            Array(1, 3), 
            Array(0, 3), 
            Array(2, 4), 
            Array(1, 4), 
            Array(0, 3)
        );
        var ranges2: Array[Array[Int]] = Array(
            Array(0, 4), 
            Array(1, 5), 
            Array(2, 4), 
            Array(1, 4), 
            Array(2, 5), 
            Array(1, 3)
        );
        // Get the size of range
        var step: Int = ranges1.length;
        /*
           1, 2, 3, 4, 5 , 6 <- Actual Array
           
           Rotations (1, 3) 
           1  4  2  3  5  6 

           Rotations (0, 3) 
           3  1  4  2  5  6 

           Rotations (2, 4) 
           3  1  5  4  2  6 

           Rotations (1, 4) 
           3  2  1  5  4  6  

           Rotations (0, 3) 
           5  3  2  1  4  6  

           location = 1

           O/P = 3
       */
        task.rotatedElement(arr, ranges1, step, n, 1);
        /*

           1, 2, 3, 4, 5 , 6 <- Actual Array
           -----------------
           Rotations (0, 4) 
           5  1  2  3  4  6  

           Rotations (1, 5) 
           5  6  1  2  3  4  

           Rotations (2, 4) 
           5  6  3  1  2  4  

           Rotations (1, 4) 
           5  2  6  3  1  4  

           Rotations (2, 5) 
           5  2  4  6  3  1  

           Rotations (1, 3) 
           5  6  2  4  3  1 

           location = 3

           O/P = 4

       */
        step = ranges2.length;
        task.rotatedElement(arr, ranges2, step, n, 3);
    }
}

Output

 Location at 1 is : 3
 Location at 3 is : 4
/*
   Swift 4 Program
   Find element at given index after a number of rotations
*/
class SearchElement
{
    //Function which is display array elements
    func display(_ arr: [Int], _ size: Int)
    {
        var i: Int = 0;
        while (i < size)
        {
            print("  ", arr[i], terminator: "");
            i += 1;
        }
        print(terminator: "\n");
    }
    //Function which is swapping two array elements of given location
    func swapElement(_ arr: inout[Int], _ i: Int, _ j: Int)
    {
        // Get i location element
        let temp: Int = arr[i];
        // Set new values
        arr[i] = arr[j];
        arr[j] = temp;
    }
    //Function which is Reversing given array elements
    func reverseElement(_ arr: inout[Int], _ a: Int, _ b: Int)
    {
        var front: Int = a;
        var tail: Int = b;
        while (front < tail)
        {
            //Swap the array elements
            self.swapElement(&arr, front, tail);
            front += 1;
            tail -= 1;
        }
    }
    // Find the location element after various rotation
    func rotatedElement(_ arr: [Int], _ ranges: [[Int]], _ step: Int, _ n: Int, _ location: Int)
    {
        // When get invalid location
        if (location < 0 || location >= n)
        {
            return;
        }
        // This auxiliary array are used to hold information of rotations
        var auxiliary: [Int] = Array(repeating: 0, count: n);
        // Loop controlling variables
        var i: Int = 0;
        var a: Int = 0;
        var b: Int = 0;
        // Assign value of actual array in auxiliary array
        i = 0;
        while (i < n)
        {
            auxiliary[i] = arr[i];
            i += 1;
        }
        i = 0;
        while (i < step)
        {
            a = ranges[i][0];
            b = ranges[i][1];
            if (a >= 0 && a < n && b >= 0 && b < n)
            {
                // Rotate Operation
                self.reverseElement(&auxiliary, a, b - 1);
                self.reverseElement(&auxiliary, a, b);
            }
            else
            {
                print("\n Ranges (", a ,"-", b ,") not valid");
                return;
            }
            i += 1;
        }
        print("\n Location at ", location ," is : ", auxiliary[location], terminator: "");
    }
}
func main()
{
    let task: SearchElement = SearchElement();
    let arr: [Int] = [1, 2, 3, 4, 5, 6];
    // Get the size of array
    let n: Int = arr.count;
    let ranges1: [[Int]] = [[1, 3] , [0, 3] , [2, 4] , [1, 4] , [0, 3]];
    let ranges2: [[Int]] = [[0, 4] , [1, 5] , [2, 4] , [1, 4] , [2, 5] , [1, 3]];
    // Get the size of range
    var step: Int = ranges1.count;
    /*
       1, 2, 3, 4, 5 , 6 <- Actual Array
       
       Rotations (1, 3) 
       1  4  2  3  5  6 

       Rotations (0, 3) 
       3  1  4  2  5  6 

       Rotations (2, 4) 
       3  1  5  4  2  6 

       Rotations (1, 4) 
       3  2  1  5  4  6  

       Rotations (0, 3) 
       5  3  2  1  4  6  

       location = 1

       O/P = 3
   */
    task.rotatedElement(arr, ranges1, step, n, 1);
    /*

       1, 2, 3, 4, 5 , 6 <- Actual Array
       -----------------
       Rotations (0, 4) 
       5  1  2  3  4  6  

       Rotations (1, 5) 
       5  6  1  2  3  4  

       Rotations (2, 4) 
       5  6  3  1  2  4  

       Rotations (1, 4) 
       5  2  6  3  1  4  

       Rotations (2, 5) 
       5  2  4  6  3  1  

       Rotations (1, 3) 
       5  6  2  4  3  1 

       location = 3

       O/P = 4

   */
    step = ranges2.count;
    task.rotatedElement(arr, ranges2, step, n, 3);
}
main();

Output

 Location at  1  is :  3
 Location at  3  is :  4
/*
   Kotlin Program
   Find element at given index after a number of rotations
*/
class SearchElement
{
    //Function which is display array elements
    fun display(arr: Array<Int>, size: Int): Unit
    {
        var i: Int = 0;
        while (i<size)
        {
            print("  " + arr[i]);
            i += 1;
        }
        print("\n");
    }
    //Function which is swapping two array elements of given location
    fun swapElement(arr: Array<Int>, i: Int, j: Int): Unit
    {
        // Get i location element
        var temp: Int = arr[i];
        // Set new values
        arr[i] = arr[j];
        arr[j] = temp;
    }
    //Function which is Reversing given array elements
    fun reverseElement(arr: Array<Int>, a: Int, b: Int): Unit
    {
        var front: Int = a;
        var tail: Int = b;
        while (front<tail)
        {
            //Swap the array elements
            this.swapElement(arr, front, tail);
            front += 1;
            tail -= 1;
        }
    }
    // Find the location element after various rotation
    fun rotatedElement(arr: Array<Int>, ranges: Array<Array<Int>> , step: Int, n: Int, location: Int): Unit
    {
        // When get invalid location
        if (location<0 || location>= n)
        {
            return;
        }
        // This auxiliary array are used to hold information of rotations
        var auxiliary: Array<Int> = Array(n)
        {
            0
        };
        // Loop controlling variables
        var i: Int = 0;
        var a: Int ;
        var b: Int ;
        // Assign value of actual array in auxiliary array
        while (i<n)
        {
            auxiliary[i] = arr[i];
            i += 1;
        }
        i = 0;
        while (i<step)
        {
            a = ranges[i][0];
            b = ranges[i][1];
            if (a>= 0 && a<n && b>= 0 && b<n)
            {
                // Rotate Operation
                this.reverseElement(auxiliary, a, b - 1);
                this.reverseElement(auxiliary, a, b);
            }
            else
            {
                print("\n Ranges (" + a + "-" + b + ") not valid\n");
                return;
            }
            i += 1;
        }
        print("\n Location at " + location + " is : " + auxiliary[location]);
    }
}
fun main(args: Array<String>): Unit
{
    var task: SearchElement = SearchElement();
    var arr: Array<Int> = arrayOf(1, 2, 3, 4, 5, 6);
    // Get the size of array
    var n: Int = arr.count();
    var ranges1: Array<Array<Int>> = arrayOf(
        arrayOf(1, 3), 
        arrayOf(0, 3), 
        arrayOf(2, 4), 
        arrayOf(1, 4), 
        arrayOf(0, 3)
    );
    var ranges2: Array<Array<Int>> = arrayOf(
        arrayOf(0, 4), 
        arrayOf(1, 5), 
        arrayOf(2, 4), 
        arrayOf(1, 4), 
        arrayOf(2, 5), 
        arrayOf(1, 3)
    );
    // Get the size of range
    var step: Int = ranges1.count();
    /*
       1, 2, 3, 4, 5 , 6 <- Actual Array
       
       Rotations (1, 3) 
       1  4  2  3  5  6 

       Rotations (0, 3) 
       3  1  4  2  5  6 

       Rotations (2, 4) 
       3  1  5  4  2  6 

       Rotations (1, 4) 
       3  2  1  5  4  6  

       Rotations (0, 3) 
       5  3  2  1  4  6  

       location = 1

       O/P = 3
   */
    task.rotatedElement(arr, ranges1, step, n, 1);
    /*

       1, 2, 3, 4, 5 , 6 <- Actual Array
       -----------------
       Rotations (0, 4) 
       5  1  2  3  4  6  

       Rotations (1, 5) 
       5  6  1  2  3  4  

       Rotations (2, 4) 
       5  6  3  1  2  4  

       Rotations (1, 4) 
       5  2  6  3  1  4  

       Rotations (2, 5) 
       5  2  4  6  3  1  

       Rotations (1, 3) 
       5  6  2  4  3  1 

       location = 3

       O/P = 4

   */
    step = ranges2.count();
    task.rotatedElement(arr, ranges2, step, n, 3);
}

Output

 Location at 1 is : 3
 Location at 3 is : 4


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