C++ Program to Find the Frequency of Elements in an Array

C++ Program to Find the Mth element of the Array after K left rotations

Last Updated : 14 Oct, 2022

Given non-negative integers K, M, and an array arr[] with N elements find the M^th element of the array after K left rotations.

Examples:

Input: arr[] = {3, 4, 5, 23}, K = 2, M = 1
Output: 5
Explanation:
The array after first left rotation a₁[ ] = {4, 5, 23, 3}
The array after second left rotation a₂[ ] = {5, 23, 3, 4}
st element after 2 left rotations is 5.

Input: arr[] = {1, 2, 3, 4, 5}, K = 3, M = 2
Output: 5
Explanation:
The array after 3 left rotation has 5 at its second position.

Naive Approach: The idea is to Perform Left rotation operation K times and then find the M^th element of the final array.

Time Complexity: O(N * K)
Auxiliary Space: O(N)

Efficient Approach:

If the array is rotated N times it returns the initial array again.
For example, a[ ] = {1, 2, 3, 4, 5}, K=5 then the array after 5 left rotation a₅[ ] = {1, 2, 3, 4, 5}.
Therefore, the elements in the array after Kth rotation is the same as the element at index K%N in the original array.
The Mth element of the array after K left rotations is

{ (K + M - 1) % N }th

element in the original array.

Below is the implementation of the above approach:

C++

// C++ program for the above approach 
#include <bits/stdc++.h> 
using namespace std; 

// Function to return Mth element of 
// array after k left rotations 
int getFirstElement(int a[], int N, 
                    int K, int M) 
{ 
    // The array comes to original state 
    // after N rotations 
    K %= N; 

    // Mth element after k left rotations 
    // is (K+M-1)%N th element of the 
    // original array 
    int index = (K + M - 1) % N; 

    int result = a[index]; 

    // Return the result 
    return result; 
} 

// Driver Code 
int main() 
{ 
    // Array initialization 
    int a[] = { 3, 4, 5, 23 }; 

    // Size of the array 
    int N = sizeof(a) / sizeof(a[0]); 

    // Given K rotation and Mth element 
    // to be found after K rotation 
    int K = 2, M = 1; 

    // Function call 
    cout << getFirstElement(a, N, K, M); 
    return 0; 
}

Output:

Time complexity: O(1)
Auxiliary Space: O(1)

Find the Mth element of the Array after K left rotations

C++ Program to Find the Frequency of Elements in an Array

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

C++ Program to Check if it is possible to sort the array after rotating it

Given an array of size N, the task is to determine whether its possible to sort the array or not by just one shuffle. In one shuffle, we can shift some contiguous elements from the end of the array and place it in the front of the array.For eg: A = {2, 3, 1, 2}, we can shift {1, 2} from the end of t

C++ Program to Find the Frequency of Elements in an Array

In C++, arrays are a type of data structure that can store a fixed-size sequential collection of elements of the same type. In this article, we will learn how to find the frequency of elements in an array in C++. Example: Input: Array: {1, 2, 3, 4, 2, 1, 3, 2, 4, 5} Output: Element: 1, Frequency: 2

C++ Program to Count of rotations required to generate a sorted array

Given an array arr[], the task is to find the number of rotations required to convert the given array to sorted form.Examples: Input: arr[] = {4, 5, 1, 2, 3}Â Output: 2Â Explanation:Â Sorted array {1, 2, 3, 4, 5} after 2 anti-clockwise rotations. Input: arr[] = {2, 1, 2, 2, 2}Â Output: 1Â Explanation:Â So

C++ Program to Print array after it is right rotated K times

Given an Array of size N and a values K, around which we need to right rotate the array. How to quickly print the right rotated array?Examples :Â Â Input: Array[] = {1, 3, 5, 7, 9}, K = 2. Output: 7 9 1 3 5 Explanation: After 1st rotation - {9, 1, 3, 5, 7} After 2nd rotation - {7, 9, 1, 3, 5} Input:

C++ Program to Print all possible rotations of a given Array

Given an integer array arr[] of size N, the task is to print all possible rotations of the array.Examples: Input: arr[] = {1, 2, 3, 4} Output: {1, 2, 3, 4}, {4, 1, 2, 3}, {3, 4, 1, 2}, {2, 3, 4, 1} Explanation: Initial arr[] = {1, 2, 3, 4} After first rotation arr[] = {4, 1, 2, 3} After second rotat

C++ Program for Search an element in a sorted and rotated array

An element in a sorted array can be found in O(log n) time via binary search. But suppose we rotate an ascending order sorted array at some pivot unknown to you beforehand. So for instance, 1 2 3 4 5 might become 3 4 5 1 2. Devise a way to find an element in the rotated array in O(log n) time.Â Exam

C++ Program to Modify given array to a non-decreasing array by rotation

Given an array arr[] of size N (consisting of duplicates), the task is to check if the given array can be converted to a non-decreasing array by rotating it. If it's not possible to do so, then print "No". Otherwise, print "Yes". Examples: Input: arr[] = {3, 4, 5, 1, 2}Output: YesExplanation:Â After

C++ Program to Check if it is possible to make array increasing or decreasing by rotating the array

Given an array arr[] of N distinct elements, the task is to check if it is possible to make the array increasing or decreasing by rotating the array in any direction.Examples: Input: arr[] = {4, 5, 6, 2, 3} Output: Yes Array can be rotated as {2, 3, 4, 5, 6}Input: arr[] = {1, 2, 4, 3, 5} Output: No

C++ Program to Maximum sum of i*arr[i] among all rotations of a given array

Given an array arr[] of n integers, find the maximum that maximizes the sum of the value of i*arr[i] where i varies from 0 to n-1. Examples: Input: arr[] = {8, 3, 1, 2} Output: 29 Explanation: Lets look at all the rotations, {8, 3, 1, 2} = 8*0 + 3*1 + 1*2 + 2*3 = 11 {3, 1, 2, 8} = 3*0 + 1*1 + 2*2 +

C++ Program to Count rotations required to sort given array in non-increasing order

Given an array arr[] consisting of N integers, the task is to sort the array in non-increasing order by minimum number of anti-clockwise rotations. If it is not possible to sort the array, then print "-1". Otherwise, print the count of rotations. Examples: Input: arr[] = {2, 1, 5, 4, 3}Output: 2Expl