Open In App

Queries for rotation and Kth character of the given string in constant time

Last Updated : 01 Jun, 2022
Comments
Improve
Suggest changes
Like Article
Like
Report

Given a string str, the task is to perform the following type of queries on the given string: 
 

  1. (1, K): Left rotate the string by K characters.
  2. (2, K): Print the Kth character of the string.


Examples: 
 

Input: str = "abcdefgh", q[][] = {{1, 2}, {2, 2}, {1, 4}, {2, 7}} 
Output: 


Query 1: str = "cdefghab" 
Query 2: 2nd character is d 
Query 3: str = "ghabcdef" 
Query 4: 7th character is e
Input: str = "abc", q[][] = {{1, 2}, {2, 2}} 
Output: 

 


 


Approach: The main observation here is that the string doesn't need to be rotated in every query instead we can create a pointer ptr pointing to the first character of the string and which can be updated for every rotation as ptr = (ptr + K) % N where K the integer by which the string needs to be rotated and N is the length of the string. Now for every query of the second type, the Kth character can be found by str[(ptr + K - 1) % N].
Below is the implementation of the above approach: 
 

C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

#define size 2

// Function to perform the required
// queries on the given string
void performQueries(string str, int n,
                    int queries[][size], int q)
{

    // Pointer pointing to the current starting
    // character of the string
    int ptr = 0;

    // For every query
    for (int i = 0; i < q; i++) {

        // If the query is to rotate the string
        if (queries[i][0] == 1) {

            // Update the pointer pointing to the
            // starting character of the string
            ptr = (ptr + queries[i][1]) % n;
        }
        else {

            int k = queries[i][1];

            // Index of the kth character in the
            // current rotation of the string
            int index = (ptr + k - 1) % n;

            // Print the kth character
            cout << str[index] << "\n";
        }
    }
}

// Driver code
int main()
{
    string str = "abcdefgh";
    int n = str.length();

    int queries[][size] = { { 1, 2 }, { 2, 2 }, 
                            { 1, 4 }, { 2, 7 } };
    int q = sizeof(queries) / sizeof(queries[0]);

    performQueries(str, n, queries, q);

    return 0;
}
Java
// Java implementation of the above approach
import java.util.*;
class GFG 
{
static int size = 2;

// Function to perform the required
// queries on the given string
static void performQueries(String str, int n,
                           int queries[][], int q)
{

    // Pointer pointing to the current 
    // starting character of the string
    int ptr = 0;

    // For every query
    for (int i = 0; i < q; i++) 
    {

        // If the query is to rotate the string
        if (queries[i][0] == 1)
        {

            // Update the pointer pointing to the
            // starting character of the string
            ptr = (ptr + queries[i][1]) % n;
        }
        else 
        {
            int k = queries[i][1];

            // Index of the kth character in the
            // current rotation of the string
            int index = (ptr + k - 1) % n;

            // Print the kth character
            System.out.println(str.charAt(index));
        }
    }
}

// Driver code
public static void main(String[] args)
{
    String str = "abcdefgh";
    int n = str.length();

    int queries[][] = { { 1, 2 }, { 2, 2 }, 
                        { 1, 4 }, { 2, 7 } };
    int q = queries.length;

    performQueries(str, n, queries, q);
}
} 

// This code is contributed by 29AjayKumar
Python3
# Python3 implementation of the approach 
size = 2

# Function to perform the required 
# queries on the given string 
def performQueries(string, n, queries, q) : 

    # Pointer pointing to the current starting 
    # character of the string 
    ptr = 0; 

    # For every query 
    for i in range(q) :

        # If the query is to rotate the string 
        if (queries[i][0] == 1) : 

            # Update the pointer pointing to the 
            # starting character of the string 
            ptr = (ptr + queries[i][1]) % n; 
            
        else :

            k = queries[i][1]; 

            # Index of the kth character in the 
            # current rotation of the string 
            index = (ptr + k - 1) % n; 

            # Print the kth character 
            print(string[index]); 

# Driver code 
if __name__ == "__main__" : 

    string = "abcdefgh"; 
    n = len(string); 

    queries = [[ 1, 2 ], [ 2, 2 ], 
               [ 1, 4 ], [ 2, 7 ]]; 
    q = len(queries); 

    performQueries(string, n, queries, q); 
    
# This code is contributed by AnkitRai01
C#
// C# implementation of the approach
using System;
    
class GFG 
{
static int size = 2;

// Function to perform the required
// queries on the given string
static void performQueries(String str, int n,
                           int [,]queries, int q)
{

    // Pointer pointing to the current 
    // starting character of the string
    int ptr = 0;

    // For every query
    for (int i = 0; i < q; i++) 
    {

        // If the query is to rotate the string
        if (queries[i, 0] == 1)
        {

            // Update the pointer pointing to the
            // starting character of the string
            ptr = (ptr + queries[i, 1]) % n;
        }
        else
        {
            int k = queries[i, 1];

            // Index of the kth character in the
            // current rotation of the string
            int index = (ptr + k - 1) % n;

            // Print the kth character
            Console.WriteLine(str[index]);
        }
    }
}

// Driver code
public static void Main(String[] args)
{
    String str = "abcdefgh";
    int n = str.Length;

    int [,]queries = { { 1, 2 }, { 2, 2 }, 
                       { 1, 4 }, { 2, 7 } };
    int q = queries.GetLength(0);

    performQueries(str, n, queries, q);
}
}

// This code is contributed by PrinciRaj1992
JavaScript
<script>

// Javascript implementation of the approach

var size = 2;

// Function to perform the required
// queries on the given string
function performQueries(str, n, queries, q)
{

    // Pointer pointing to the current starting
    // character of the string
    var ptr = 0;

    // For every query
    for (var i = 0; i < q; i++) {

        // If the query is to rotate the string
        if (queries[i][0] == 1) {

            // Update the pointer pointing to the
            // starting character of the string
            ptr = (ptr + queries[i][1]) % n;
        }
        else {

            var k = queries[i][1];

            // Index of the kth character in the
            // current rotation of the string
            var index = (ptr + k - 1) % n;

            // Print the kth character
            document.write( str[index] + "<br>");
        }
    }
}

// Driver code
var str = "abcdefgh";
var n = str.length;
var queries = [ [ 1, 2 ], [ 2, 2 ], 
                        [ 1, 4 ], [ 2, 7 ] ];
var q = queries.length;
performQueries(str, n, queries, q);

</script> 

Output: 
d
e

 

Time Complexity: O(Q), Where Q is the number of queries
Auxiliary Space: O(1)


Next Article
Article Tags :
Practice Tags :

Similar Reads