Open In App

Php Program to Find element at given index after a number of rotations

Improve
Improve
Like Article
Like
Save
Share
Report

An array consisting of N integers is given. There are several Right Circular Rotations of range[L..R] that we perform. After performing these rotations, we need to find element at a given index.
Examples : 
 

Input : arr[] : {1, 2, 3, 4, 5}
ranges[] = { {0, 2}, {0, 3} }
index : 1
Output : 3
Explanation : After first given rotation {0, 2}
arr[] = {3, 1, 2, 4, 5}
After second rotation {0, 3}
arr[] = {4, 3, 1, 2, 5}
After all rotations we have element 3 at given
index 1.

 

Method : Brute-force The brute force approach is to actually rotate the array for all given ranges, finally return the element in at given index in the modified array.
Method : Efficient We can do offline processing after saving all ranges. 
Suppose, our rotate ranges are : [0..2] and [0..3] 
We run through these ranges from reverse.
After range [0..3], index 0 will have the element which was on index 3. 
So, we can change 0 to 3, i.e. if index = left, index will be changed to right. 
After range [0..2], index 3 will remain unaffected.
So, we can make 3 cases : 
If index = left, index will be changed to right. 
If index is not bounds by the range, no effect of rotation. 
If index is in bounds, index will have the element at index-1.
Below is the implementation : 
 

For better explanation:-

10 20 30 40 50

Index: 1

Rotations: {0,2} {1,4} {0,3}

Answer: Index 1 will have 30 after all the 3 rotations in the order {0,2} {1,4} {0,3}.

We performed {0,2} on A and now we have a new array A1.

We performed {1,4} on A1 and now we have a new array A2.

We performed {0,3} on A2 and now we have a new array A3.

Now we are looking for the value at index 1 in A3.

But A3 is {0,3} done on A2.

So index 1 in A3 is index 0 in A2.

But A2 is {1,4} done on A1.

So index 0 in A2 is also index 0 in A1 as it does not lie in the range {1,4}.

But A1 is {0,2} done on A.

So index 0 in A1 is index 2 in A.

On observing it, we are going deeper into the previous rotations starting from the latest rotation.

{0,3}

|

{1,4}

|

{0,2}

This is the reason we are processing the rotations in reverse order.

Please note that we are not rotating the elements in the reverse order, just processing the index from reverse.

Because if we actually rotate in reverse order, we might get a completely different answer as in case of rotations the order matters. 

C++




#include <iostream>
#include <vector>
 
// Function to compute the element at given index
int findElement(std::vector<int>& arr, std::vector<std::vector<int>>& ranges, int rotations, int index) {
    for (int i = rotations - 1; i >= 0; i--) {
        // Range[left...right]
        int left = ranges[i][0];
        int right = ranges[i][1];
 
        // Rotation will not have any effect
        if (left <= index && right >= index) {
            if (index == left)
                index = right;
            else
                index--;
        }
    }
 
    // Returning new element
    return arr[index];
}
 
// Driver Code
int main() {
    std::vector<int> arr = {1, 2, 3, 4, 5};
 
    // No. of rotations
    int rotations = 2;
 
    // Ranges according to 0-based indexing
    std::vector<std::vector<int>> ranges = {{0, 2}, {0, 3}};
 
    int index = 1;
 
    std::cout << findElement(arr, ranges, rotations, index) << std::endl;
 
    return 0;
}
// this code is contributed by utkarsh


Java




import java.util.Arrays;
 
public class Main {
 
    // Function to compute the element at given index
    static int findElement(int[] arr, int[][] ranges, int rotations, int index) {
        for (int i = rotations - 1; i >= 0; i--) {
            // Range[left...right]
            int left = ranges[i][0];
            int right = ranges[i][1];
 
            // Rotation will not have any effect
            if (left <= index && right >= index) {
                if (index == left)
                    index = right;
                else
                    index--;
            }
        }
 
        // Returning new element
        return arr[index];
    }
 
    // Driver Code
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
 
        // No. of rotations
        int rotations = 2;
 
        // Ranges according to 0-based indexing
        int[][] ranges = {{0, 2}, {0, 3}};
 
        int index = 1;
 
        System.out.println(findElement(arr, ranges, rotations, index));
    }
}


Python




def find_element(arr, ranges, rotations, index):
    for i in range(rotations - 1, -1, -1):
        # Range[left...right]
        left = ranges[i][0]
        right = ranges[i][1]
 
        # Rotation will not have any effect
        if left <= index <= right:
            if index == left:
                index = right
            else:
                index -= 1
 
    # Returning new element
    return arr[index]
 
# Driver Code
arr = [1, 2, 3, 4, 5]
 
# No. of rotations
rotations = 2
 
# Ranges according to 0-based indexing
ranges = [[0, 2], [0, 3]]
 
index = 1
 
print(find_element(arr, ranges, rotations, index))


C#




using System;
using System.Collections.Generic;
 
class Program
{
    // Function to compute the element at the given index
    static int FindElement(List<int> arr, List<List<int>> ranges, int rotations, int index)
    {
        for (int i = rotations - 1; i >= 0; i--)
        {
            // Range[left...right]
            int left = ranges[i][0];
            int right = ranges[i][1];
 
            // Rotation will not have any effect
            if (left <= index && right >= index)
            {
                if (index == left)
                    index = right;
                else
                    index--;
            }
        }
 
        // Returning the new element
        return arr[index];
    }
 
    // Driver Code
    static void Main()
    {
        List<int> arr = new List<int> { 1, 2, 3, 4, 5 };
 
        // No. of rotations
        int rotations = 2;
 
        // Ranges according to 0-based indexing
        List<List<int>> ranges = new List<List<int>> { new List<int> { 0, 2 }, new List<int> { 0, 3 } };
 
        int index = 1;
 
        Console.WriteLine(FindElement(arr, ranges, rotations, index));
    }
}


Javascript




// Function to compute the element at given index
function findElement(arr, ranges, rotations, index) {
    for (let i = rotations - 1; i >= 0; i--) {
        // Range[left...right]
        let left = ranges[i][0];
        let right = ranges[i][1];
 
        // Rotation will not have any effect
        if (left <= index && right >= index) {
            if (index === left)
                index = right;
            else
                index--;
        }
    }
 
    // Returning new element
    return arr[index];
}
 
// Driver Code
let arr = [1, 2, 3, 4, 5];
 
// No. of rotations
let rotations = 2;
 
// Ranges according to 0-based indexing
let ranges = [[0, 2], [0, 3]];
 
let index = 1;
 
console.log(findElement(arr, ranges, rotations, index));


PHP




<?php
// PHP code to rotate an array
// and answer the index query
 
// Function to compute the
// element at given index
function findElement($arr, $ranges,
                     $rotations, $index)
{
    for ($i = $rotations - 1;
         $i >= 0; $i--)
    {
 
        // Range[left...right]
        $left = $ranges[$i][0];
        $right = $ranges[$i][1];
 
        // Rotation will not
        // have any effect
        if ($left <= $index &&
            $right >= $index)
        {
            if ($index == $left)
                $index = $right;
            else
                $index--;
        }
    }
 
    // Returning new element
    return $arr[$index];
}
 
// Driver Code
$arr = array(1, 2, 3, 4, 5);
 
// No. of rotations
$rotations = 2;
 
// Ranges according
// to 0-based indexing
$ranges = array(array(0, 2),
                array(0, 3));
 
$index = 1;
 
echo findElement($arr, $ranges,
                 $rotations, $index);
 
// This code is contributed by ajit
?>


Output : 

3

Time Complexity: O(N), where N represents the given number of rotations.

Auxiliary Space: O(1), no extra space is required, so it is a constant.

Please refer complete article on Find element at given index after a number of rotations for more details!
 



Last Updated : 20 Feb, 2024
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads