/* package codechef; // don't place package name! */
 
import java.util.*;
import java.lang.*;
import java.io.*;

package java102;

public class simplecalc {

public static void main(String[] args) {

t = int(input())
a,b=0,0
prevp1,prevp2 = 0,0
while(t>0):
    l = list(map(int,input().split()))

Actually BIT supports max/min queries and continuous sum( a[i] ~ a[i+L] ==> +x) queries.

We can implement by using 2 BIT.

Oops, should have reread my reply before posting, thanks for the correction.

'Almost every solution you can do with Segment Tree can also be done with Binary Index Trees.' Its true the other way round because BIT only supports sum queries

/* package codechef; // don't place package name! */
 
import java.util.*;
import java.lang.*;
import java.io.*;

Below is my code for this problem using python.

from collections import Counter
n1,n2,n3=map(int,input().split())
VList=[]

My code complexity O(nlogn).

def bs(start,end,key):
  while(start<end):
    mid=(start+end)//2
    if key>=arr[mid][0]:
      start=start+1

def binary_search(arr,key,l):
    low=l
    high=len(arr)-1
    while(low<=high):
        mid=(high+low)//2

Can you please explain the reason behind taking the upper limit for binary search n (and not n-1)?

In my case taking upper limit to n-1 gives segmentat...

/* package codechef; // don't place package name! */
 
import java.util.*;
import java.lang.*;
import java.io.*;

ok

n,h=map(int,input().split())

stacks=list(map(int,input().split()))

command=tuple(map(int,input().split()))

i=0

/* package codechef; // don't place package name! */
 
import java.util.*;
import java.lang.*;
import java.io.*;

Solved with the use of stack to balance and calculate all parameters

#include<bits/stdc++.h>
#include <math.h>
using namespace std;

Can maximum nesting depth be equal to maximum no. of symbols between two brackets in this problem.