Queries to find kth greatest character in a range with updates (Easy Task)

// Java code for the approach

import java.util.*;

public class GFG {
    // Function to print the Kth greatest character
    public static char printCharacter(String str, int L,
                                      int R, int K)
    {
        // Extract the substring from [L, R]
        String substr = str.substring(L - 1, R);

        // Sort the substring in non-increasing order
        char[] charArr = substr.toCharArray();
        Arrays.sort(charArr);
        String sortedStr = new String(charArr);
        String revStr = new StringBuilder(sortedStr)
                            .reverse()
                            .toString();

        // return the Kth character
        return revStr.charAt(K - 1);
    }

    // Function to update the Jth character of the string
    public static void updateString(StringBuilder str,
                                    int J, char C)
    {
        // Update the Jth character
        str.setCharAt(J - 1, C);
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Given string
        String str = "abcddef";

        // Count of queries
        int Q = 3;

        // Queries
        System.out.println(printCharacter(str, 1, 2, 2));
        StringBuilder sb = new StringBuilder(str);
        updateString(sb, 4, 'g');
        str = sb.toString();
        System.out.println(printCharacter(str, 1, 5, 4));
    }
}

// Java Program to implement
// the above approach
//include "bits/stdJava.h"
import java.util.*;
class GFG{

// Function to find the kth greatest
// character from the strijng
static char find_kth_largest(char []str, 
                             int k)
{
  // Sorting the String in
  // non-increasing Order
  Arrays.sort(str);
  reverse(str);
  return str[k - 1];
}
  static char[] reverse(char a[]) 
  {
    int i, n = a.length;
    char t;
    for (i = 0; i < n / 2; i++) 
    {
      t = a[i];
      a[i] = a[n - i - 1];
      a[n - i - 1] = t;
    }
    return a;
}
  
// Function to print the K-th character
// from the subString S[l] .. S[r]
static char printCharacter(String str, int l,
                           int r, int k)
{
  // 0-based indexing
  l = l - 1;
  r = r - 1;

  // SubString of str from the
  // indices l to r.
  String temp = str.substring(l, r - l + 1);

  // Extract kth Largest character
  char ans = 
    find_kth_largest(temp.toCharArray(), k);

  return ans;
}

// Function to replace character at
// pos of str by the character s
static void updateString(char []str, 
                         int pos, char s)
{
  // Index of S to be updated.
  int index = pos - 1;
  char c = s;

  // Character to be replaced
  // at index in S
  str[index] = c;
}

// Driver Code
public static void main(String[] args)
{
  // Given String
  String str = "abcddef";

  // Count of queries
  int Q = 3;

  // Queries
  System.out.print(printCharacter(str, 1, 
                                  2, 2) + "\n");
  updateString(str.toCharArray(), 4, 'g');
  System.out.print(printCharacter(str, 1, 
                                  5, 4) + "\n");
}
}

// This code is contributed by shikhasingrajput 

// Java Program to implement
// the above approach

//include "bits/stdJava.h"
import java.util.*;
class GFG{

// Maximum Size of a String
static int maxn = 100005;

// Fenwick Tree to store the
// frequencies of 26 alphabets
static int [][]BITree = new int[26][maxn];

// Size of the String.
static int N;

// Function to update Fenwick Tree for
// Character c at index val
static void update_BITree(int index, 
                          char C, int val)
{
  while (index <= N) 
  {
    // Add val to current node
    // Fenwick Tree
    BITree[C - 'a'][index] += val;

    // Move index to parent node
    // in update View
    index += (index & -index);
  }
}

// Function to get sum of frequencies
// of character c till index
static int sum_BITree(int index, char C)
{

  // Stores the sum
  int s = 0;
  while (index > 0) 
  {
    // Add current element of
    // Fenwick tree to sum
    s += BITree[C - 'a'][index];

    // Move index to parent node
    // in getSum View
    index -= (index & -index);
  }
  return s;
}

// Function to create the Fenwick tree
static void buildTree(String str)
{
  for (int i = 1; i <= N; i++) 
  {
    update_BITree(i, str.charAt(i), 1);
  }
  System.out.println();
}

// Function to print the kth largest
// character in the range of l to r
static char printCharacter(String str, int l,
                           int r, int k)
{
  // Stores the count of
  // characters
  int count = 0;

  // Stores the required
  // character
  char ans = 0;

  for (char C = 'z'; C >= 'a'; C--) 
  {
    // Calculate frequency of
    // C in the given range
    int times = sum_BITree(r, C) - 
      sum_BITree(l - 1, C);

    // Increase count
    count += times;

    // If count exceeds K
    if (count >= k) 
    {
      // Required character
      // found
      ans = C;
      break;
    }
  }
  return ans;
}

// Function to update character
// at pos by character s
static void updateTree(String str, 
                       int pos, char s)
{
    // 0 based index system
    int index = pos;
    update_BITree(index, 
                  str.charAt(index), -1);
    str = str.substring(0, index) + s + 
          str.substring(index + 1);
    update_BITree(index, s, 1);
}

// Driver Code
public static void main(String[] args)
{
  String str = "abcddef";
  N = str.length();

  // Makes the String 1-based indexed
  str = '/' + str;

  // Number of queries
  int Q = 3;

  // Construct the Fenwick Tree
  buildTree(str);

  System.out.print(printCharacter(str, 1, 
                                  2, 2) + "\n");
  updateTree(str, 4, 'g');
  System.out.print(printCharacter(str, 1, 
                                  5, 4) + "\n");

}
}

// This code is contributed by shikhasingrajput