Kth character from the Nth string obtained by the given operations

Given two positive integers N and K, the task is to find the K^th character of a string obtained by performing the following operation on a string S( initially “A”) N times.

Every i^th operation generates following string (S_i): 
S_i = S_{i – 1} + ‘B’ + rev(comp(S_{i – 1})) 
where, 
comp() denotes the complement of string i.e., A is changed to B and B is changed to A. 
and rev() returns the reverse of a string.

Examples:

Input: N = 3, K = 1 
Output: A 
Explanation:
Initially, after first operation, S₁ = “A” 
After 2^nd operation, S₂ = “ABB” 
After 3^rd operation, S₃ = “ABBBAAB” 
The first character of S₃ is ‘A’. 
Input: N = 2, K = 3 
Output: B

Approach: The idea is to use recursion to generate the new string from the previously generated string and to repeat the process until N operations are performed. Below are the steps:

1. Initialize two string prev as “A” and curr as an empty string.
2. If N = 1 then returns prev otherwise perform below operation.
3. Iterate a loop (N – 1) times, each time update curr as prev + “B”.
4. Reverse the string prev.
5. Again update the string curr string as curr + prev.
6. Update string prev as curr.
7. After the above steps return the (K – 1)th character of the string curr.

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 Kth character
// from recursive string
char findKthChar(int n, int k)
{
    string prev = "A";
    string cur = "";

    // If N is 1 then return A
    if (n == 1) {
        return 'A';
    }

    // Iterate a loop and generate
    // the recursive string
    for (int i = 2; i <= n; i++) {

        // Update current string
        cur = prev + "B";

        // Change A to B and B to A
        for (int i = 0;
             i < prev.length(); i++) {

            if (prev[i] == 'A') {
                prev[i] = 'B';
            }
            else {
                prev[i] = 'A';
            }
        }

        // Reverse the previous string
        reverse(prev.begin(), prev.end());
        cur += prev;
        prev = cur;
    }

    // Return the kth character
    return cur[k - 1];
}

// Driver Code
int main()
{
    int N = 4;
    int K = 3;

    cout << findKthChar(N, K);
    return 0;
}

Java

// Java program for
// the above approach
import java.util.*;
class GFG{

// String reverse
static String reverse(String input)
{
  char[] a = input.toCharArray();
  int l, r = a.length - 1;
  for (l = 0; l < r; l++, r--)
  {
    char temp = a[l];
    a[l] = a[r];
    a[r] = temp;
  }
  return String.valueOf(a);
}

// Function to return Kth character
// from recursive String
static char findKthChar(int n,
                        int k)
{
  String prev = "A";
  String cur = "";

  // If N is 1 then return A
  if (n == 1)
  {
    return 'A';
  }

  // Iterate a loop and generate
  // the recursive String
  for (int j = 2; j <= n; j++)
  {
    // Update current String
    cur = prev + "B";

    // Change A to B and B to A
    for (int i = 0; i < prev.length(); i++)
    {
      if (prev.charAt(i) == 'A')
      {
        prev.replace(prev.charAt(i), 'B');
      }
      else
      {
        prev.replace(prev.charAt(i), 'A');
      }
    }

    // Reverse the previous String
    prev = reverse(prev);
    cur += prev;
    prev = cur;
  }

  // Return the kth character
  return cur.charAt(k);
}

// Driver Code
public static void main(String[] args)
{
  int N = 4;
  int K = 3;
  System.out.print(findKthChar(N, K));
}
}

// This code is contributed by Rajput-Ji

Python3

# Python3 program for the above approach

# Function to return Kth character
# from recursive string
def findKthChar(n, k):

    prev = "A"
    cur = ""

    # If N is 1 then return A
    if (n == 1):
        return 'A'

    # Iterate a loop and generate
    # the recursive string
    for i in range(2, n + 1):

        # Update current string
        cur = prev + "B"

        # Change A to B and B to A
        temp1 = [y for y in prev]

        for i in range(len(prev)):
            if (temp1[i] == 'A'):
                temp1[i] = 'B'
            else:
                temp1[i] = 'A'

        # Reverse the previous string
        temp1 = temp1[::-1]
        prev = "".join(temp1)
        cur += prev
        prev = cur

    # Return the kth character
    return cur[k - 1]

# Driver Code
if __name__ == '__main__':

    N = 4
    K = 3

    print(findKthChar(N, K))

# This code is contributed by mohit kumar 29

C#

// C# program for
// the above approach
using System;
class GFG{

// String reverse
static String reverse(String input)
{
  char[] a = input.ToCharArray();
  int l, r = a.Length - 1;
  for (l = 0; l < r; l++, r--)
  {
    char temp = a[l];
    a[l] = a[r];
    a[r] = temp;
  }
  return String.Join("", a);
}

// Function to return Kth character
// from recursive String
static char findKthChar(int n,
                        int k)
{
  String prev = "A";
  String cur = "";

  // If N is 1 then return A
  if (n == 1)
  {
    return 'A';
  }

  // Iterate a loop and generate
  // the recursive String
  for (int j = 2; j <= n; j++)
  {
    // Update current String
    cur = prev + "B";

    // Change A to B and B to A
    for (int i = 0; i < prev.Length; i++)
    {
      if (prev[i] == 'A')
      {
        prev.Replace(prev[i], 'B');
      }
      else
      {
        prev.Replace(prev[i], 'A');
      }
    }

    // Reverse the previous String
    prev = reverse(prev);
    cur += prev;
    prev = cur;
  }

  // Return the kth character
  return cur[k];
}

// Driver Code
public static void Main(String[] args)
{
  int N = 4;
  int K = 3;
  Console.Write(findKthChar(N, K));
}
}

// This code is contributed by Rajput-Ji

Javascript

<script>
    // Javascript program for the above approach

    // String reverse
    function reverse(input)
    {
      let a = input.split('');
      let l, r = a.length - 1;
      for (l = 0; l < r; l++, r--)
      {
        let temp = a[l];
        a[l] = a[r];
        a[r] = temp;
      }
      return a.join("");
    }

    // Function to return Kth character
    // from recursive String
    function findKthChar(n, k)
    {
      let prev = "A";
      let cur = "";

      // If N is 1 then return A
      if (n == 1)
      {
        return 'A';
      }

      // Iterate a loop and generate
      // the recursive String
      for (let j = 2; j <= n; j++)
      {
        // Update current String
        cur = prev + "B";

        // Change A to B and B to A
        for (let i = 0; i < prev.length; i++)
        {
          if (prev[i] == 'A')
          {
            prev[prev[i]] = 'B';
          }
          else
          {
            prev[prev[i]] = 'A';
          }
        }

        // Reverse the previous String
        prev = reverse(prev);
        cur += prev;
        prev = cur;
      }

      // Return the kth character
      return cur[k];
    }

    let N = 4;
    let K = 3;
    document.write(findKthChar(N, K));

  // This code is contributed by mukesh07.
</script>

Output:

B

Time Complexity: O(N²)
Auxiliary Space: O(1)