We can simple use a vector to store the sizes of stack, the minimum ascending order series we can form is 0,1,2,3,4....n We can keep a buffer for extra elements, that means set a[0] = 0 and add the remaining value to the buffer. a[i] -= i; and buffer += a[i] — i;

if at any point our buffer becomes negative that will mean that particular sequence till that point isn't possible, and since that is the minimal series that means it isn't possible to form a valid sequence for those set of stacks.

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef vector<ll> vi;

#define nl cout << "\n"
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

int main()
{
    fast;
    ll t = 1;
    cin >> t;
    while (t--) // each testcase
    {
        ll n;
        cin >> n;
        vi a(n);
        for (int i = 0; i < n; i++) { cin >> a[i]; }
        ll buffer = 0;
        int i = 0;
        while (i != n)
        {
            if (a[i] >= i)
            {
                buffer += a[i] - i;
            }
            else
            {
                ll x = i - a[i];
                a[i] += x;
                buffer -= x;
            }
            if (buffer < 0)
            {
                break;
            }
            i++;
        }
        cout << (i == n ? "YES" : "NO");
        nl;
    }
    return 0;
}

Simply sort the array remove duplicates, now we find the differences between every 2 consequtive elements, with this we have found the max range, now consider this and the distance between the starting point to first candy and ending point to last candy the max of these 3 values will be our result.

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;


int main()
{
    fast;
    ll t = 1;
    // cin >> t;
    while (t--)
    {
        ll n, l;
        cin >> n >> l;
        vector<ll> a(n);


        for (int i = 0; i < n; i++)
        {
            cin >> a[i];
        }

        sort(all(a));
        a.resize(unique(a.begin(), a.end()) - a.begin());

        if (a.size() == 1)
        {
            ll x = a[0];
            cout << max(x - 0, l - x);
            return 0;
        }
        vector<ll> b;
        for (int i = 0; i < a.size(); i++)
        {
            if (i != 0)
            {
                b.push_back(a[i] - a[i - 1]);
            }
        }
        sort(all(b));
        double ans = (double)b[b.size() - 1] / 2;
        double endpoints = max(a[0] - 0, l - a[a.size() - 1]);
        cout << setprecision(14);
        cout << max(endpoints, ans) << endl;
    }
    return 0;
}

https://i.imgur.com/3gGShey.png

If you try finding all the binary format and their corresponding values you will notice that those values are basically equal to their first set bits. __ Simple enough right ?

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;


int main()
{
    fast;

    ll x, y;
    cin >> x >> y;

    cout << 1 + __builtin_ctzll(y);

    return 0;
}

This is a very famous standard problem, try reading about it here https://www.geeksforgeeks.org/check-for-balanced-parentheses-in-an-expression/

I have also attached my own solution please have a look if you having problems.

gist -> simple adding the left bracket in the stack and popping when the right is encountered. we pop from the stack.

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;


int main()
{
    fast;
    string s;
    cin >> s;
    stack<char> st;
    set<char> left = { '(','{','[','<' };
    int n = s.length();
    ll cnt = 0;
    for (int i = 0; i < n; i++)
    {
        if (left.count(s[i]))
        {
            st.push(s[i]);
        }
        else
        {
            if (st.empty())
            {
                cout << "Impossible" << endl;
                return 0;
            }
            if (st.top() + 0 == s[i] - 1 || st.top() + 0 == s[i] - 2)
            {
                st.pop();
            }
            else
            {
                cnt++;
                st.pop();
            }
        }
    }
    if (st.empty())
    {
        cout << cnt;
    }
    else
    {
        cout << "Impossible" << endl;
    }

    return 0;
}

Since only entries in array are binary digits, all 0s must be before 1s. So we can use two pointers to interchange 0s to 1s and count the operations. The maintain 2 pointers the left pointer will be looking for the first 1 and the right pointer will be looking for the first 0. if they both don't cross each other, then simply replace. loop ends if left pointer becomes greater than right pointer or they become equal.

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;


int main()
{
    fast;
    ll t = 1;
    cin >> t;
    while (t--)
    {
        ll n;
        cin >> n;
        vi a(n);
        for (int i = 0; i < n; i++)
        {
            cin >> a[i];
        }

        if (is_sorted(all(a))) { cout << 0; }
        else
        {
            ll ans = 0;
            ll l = 0, r = n - 1;
            while (l != r)
            {
                if (a[l] == 0) { l++; }
                else if (a[r] == 1) { r--; }
                else if (a[l] == 1 && a[r] == 0)
                {
                    a[l] = 0;
                    a[r] = 1;
                    ans++;
                }
            }
            if (is_sorted(all(a))) { cout << ans; }
        }
        nl;

    }
    return 0;
}

import java.util.*;


public class Rebellion {
	public static void main(String[]args){

        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t>0){
            int n = sc.nextInt();
            int[] arr = new int[n];
            for(int i = 0;i<n;i++) arr[i] = sc.nextInt();
            int p1 = 0;
            int p2 = n-1;
            int ans = 0;
            while(p1<p2){
                if(arr[p1] == 0){
                    p1++;
                    continue;
                }
                if(arr[p2] == 1){
                    p2--;
                    continue;
                }
                if(arr[p1] ==  1 && arr[p2] ==  0){
                    ans++;
                    p1++;
                    p2--;
                }
            }
            System.out.println(ans);
            t--;
        }
	}
}

There are 2 approaches to solve this problem.

DataStructure approach

We use a dequeue, it stands for a double ended queue. Use it to keep on removing the first or last element and maintain to variables for each of the player. repeat this process till the deque is empty.

2 pointer approach

Same as the above approach instead of the data structure, we just keep to pointers at the start and the end and do the same process.

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;


int main()
{
    fast;
    ll n;
    cin >> n;
    deque<ll> a(n);
    for (int i = 0; i < n; i++) { cin >> a[i]; }
    ll one = 0, two = 0;
    while (!a.empty())
    {
        if (a.front() > a.back())
        {
            one += a.front();
            a.pop_front();
        }
        else
        {
            one += a.back();
            a.pop_back();
        }
        if (!a.empty())
        {
            if (a.front() > a.back())
            {
                two += a.front();
                a.pop_front();
            }
            else
            {
                two += a.back();
                a.pop_back();
            }
        }

    }
    cout << one << " " << two;
    nl;

    return 0;
}

// Author: Aditya Tyagi
import java.util.*;

public class serejaDima {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] cards = new int[n];
        for(int i = 0; i < n; i++) cards[i] = sc.nextInt();

        int p1 = 0, p2 = n-1;
        int s = 0, d = 0;
        int count = 0;
        while(p1 <= p2){
            if(count % 2 == 0){
                if(cards[p1] < cards[p2]){
                    s+= cards[p2];
                    p2--;
                }
                else{
                    s+=cards[p1];
                    p1++;
                }
            }
            else{
                if(cards[p1] < cards[p2]){
                    d+= cards[p2];
                    p2--;
                }
                else{
                    d += cards[p1];
                    p1++;
                }
            }
            count++;
        }
        System.out.print(s + " " + d);
    }
}  

4 hours = 240 minutes
time taken to get the party = x
so, 240-x is the time we have for solving problems.

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;


int main()
{
    fast;
    ll n, k;
    cin >> n >> k;
    int x = (240 - k);
    ll ans = -1;
    for (int i = 1; i <= n; i++)
    {
        if (x >= 5 * i)
        {
            x -= 5 * i;
            ans = i;
        }
        else { break; }
    }
    cout << ans;
    nl;
    return 0;
}

// Author: Aditya Tyagi
import java.io.*;
import java.util.*;

public class nyHurry {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] cummFreq = new int[11];
        for(int i= 1;i<11;i++){
            cummFreq[i] = i*5;
            cummFreq[i] += cummFreq[i-1];
        }
        int target = 240-k;
        System.out.println(Math.min(n, binarySearch(cummFreq, target)));
    }
    public static int binarySearch(int[] arr, int key) {
        int left = 0;
        int right = arr.length-1;
        while(left<right){
            int mid = left + (right-left)/2;
            if(arr[mid] == key) return mid;
            else if(arr[mid] > key) right = mid;
            else if(arr[mid] < key)left = mid+1;
        }
        return left-1;
    }
}

Sort the array. Perform binary search and look for the query. Look for the upper bound in the query. Print the index for every query.

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;

#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

typedef long long int ll;
typedef vector<ll> vi;

int main()
{
    fast;

    ll n;
    cin >> n;
    vi a(n);
    for (int i = 0; i < n; i++) { cin >> a[i]; }
    sort(all(a));
    ll q;
    cin >> q;

    while (q--)
    {
        ll k;
        cin >> k;
        cout << upper_bound(all(a), k) - a.begin();
        nl;
    }

    return 0;
}

// Author: Aditya Tyagi
import java.util.*;

public class interestingDrink {
	public static void main(String[]args){

		Scanner sc = new Scanner(System.in);
		int n=sc.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++) arr[i]=sc.nextInt();
		Arrays.sort(arr);
		int q = sc.nextInt();
		while(q-->0){
			int x = sc.nextInt();
			int start = 0, end = n-1; 

			int ans = -1; 
			while (start <= end){
                int mid = (start + end) / 2;
                if (arr[mid] <= x) start = mid + 1;
                else{ 
                    ans = mid; 
                    end = mid - 1; 
                }
            }
            if(ans!=-1) System.out.println(ans);
            else System.out.println(n);
        }	
	}
}


	  	   	   		  	 	   			   	 	

if a's value is fixed then b = cuberootof(x³ — a³)
we can create a list containing all the cubes of values from 1 to 10000. Then take values from this list and subtract it from x³. then perform binary search in this list since it contains all the cubes our value of b must be present in the list.

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;

int main()
{
    fast;
    ll t = 1;
    cin >> t;
    while (t--)
    {
        ll n;
        cin >> n;
        vi a(10000);
        for (long long i = 1; i < 10000; i++)
        {
            a[i] = i * i * i;
        }
        bool ok = false;
        ll i = 0;
        if (binary_search(all(a), n)) { cout << "NO"; }
        else
        {
            while (!ok && i < 9999)
            {
                ll temp = n - a[i];
                ok = binary_search(all(a), temp);
                i++;
            }
            if (ok) { cout << "YES"; }
            else { cout << "NO"; }
        }nl;

    }
    return 0;
}

// Author: Aditya Tyagi
import java.util.*;

public class sumOfCubes {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();

        for (int i = 0; i < t; i++) {
            long x = sc.nextLong();
            if (isSumOfCubes(x))
                System.out.println("YES");
            else
                System.out.println("NO");
        }
    }

    private static boolean isSumOfCubes(long x) {
        Map<Long, Long> memo = new HashMap<>();

        for (long i = 1; i*i*i <= x; i++) {
            long m = i*i*i;
            memo.put(m, i);
            long n = x - m;
            if (memo.containsKey(n)) return true;
        }
        return false;
    }

}

We simply initialize an array with the first element always equal to zero, because if the size of the string is 1 then there will be index satisfying s[i] = s[i+1].
then simply iterate over the string if the char is equal to the previous char then increment the previous arr value and store it in the current position. This is the prefix sum method, since we are calculating the values of all the prefix one by one.
s = ..#...#
prefixarr = [0,1,1,1,2,3,3]
if the query is 2,4 . our ans will be prefixarr[4] — prefixarr[2]
This is a very powerful techniques so solving problems and quiet often asked in job interviews and low rated contest.

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;

int main()
{
    fast;
    string s;
    cin >> s;
    ll z = s.length();
    vi a(z);
    for (int i = 0; i < z; i++)
    {
        if (i == 0) { a[i] = 0; }
        else if (s[i] == s[i - 1]) { a[i] = a[i - 1] + 1; }
        else { a[i] = a[i - 1]; }
    }
    ll n;
    cin >> n;
    while (n--)
    {
        ll x, y;
        cin >> x >> y;
        cout << a[y - 1] - a[x - 1];
        nl;
    }
    return 0;
}

// Author: Aditya Tyagi
import java.util.*;

public class IIlyaAndQueries {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		String str=sc.next();
		int m = sc.nextInt();

		int count=0;
		int[] a=new int[100001];
		
		for(int i=1;i<str.length();i++){
			if(str.charAt(i)==str.charAt(i-1)){
				count++;
			}
			a[i]=count;
		}
		
		StringBuilder ans = new StringBuilder();  
		while(m-->0){
			int l=sc.nextInt();
			int r=sc.nextInt();
			ans.append(Math.abs(a[r-1]-a[l-1])+"\n");
		}
		System.out.println(ans);
	}
}

Fact: Low rated problems with queries are mostly solved via prefix sum. (sometimes via dynamic programming , segment trees, etc)

Sort sequence v to obtain sequence u.
Sorting can be done in using quicksort O(n log (n))
Now we are interested in the sum of a interval of a given sequence.
This can be done by calculating the prefix sum of the sequence beforehand.

Preprocessing takes O(n) time, and answering a query is only O(1). The total complexity would be .

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;

int main()
{
    fast;
    ll n;
    cin >> n;
    vi a(n);
    vi prea(n);
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
        if (i != 0)
        {
            prea[i] = a[i] + prea[i - 1];
        }
        else
        {
            prea[0] = a[0];
        }
    }


    vi b = a;
    sort(all(b));
    vi preb(n);
    preb[0] = b[0];
    for (int i = 0; i < n; i++)
    {
        if (i != 0)
            preb[i] = b[i] + preb[i - 1];
    }

    ll q;
    cin >> q;
    while (q--)
    {
        ll x, y, z;
        cin >> x >> y >> z;

        if (x == 1)
        {
            cout << prea[z - 1] - prea[y - 1] + a[y - 1];
            nl;
        }
        else if (x == 2)
        {
            cout << preb[z - 1] - preb[y - 1] + b[y - 1];
            nl;
        }
    }
    return 0;
}

The problem can be divided into two classic ones:

1.Count the number of pairs ai+aj≤r;
2.Count the number of pairs ai+aj≤l−1.

Now it might be obvious to use prefix sum.

Let A — be the answer to the first problem, and B — be the answer to the second problem. Then A−B
is the answer to the original problem.
The new problem can be solved by binary search. Iterate over the first element of the pair. Then you need to count the number of elements such that aj≤r−ai. If you sort the array, this value can be calculated by running a single binary search.

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rapido ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl "\n"


void solve()
{
    int n; int l; int r; cin >> n >> l >> r;
    vector<int>arr(n);
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    sort(arr.begin(), arr.end());
    int ans = 0;
    for (int i = 0; i < n; i++)
        ans += lower_bound(arr.begin(), arr.begin() + i, l - arr[i]) - upper_bound(arr.begin(), arr.begin() + i, r - arr[i]);

    cout << abs(ans) << endl;

}

int32_t main()
{
    rapido;
    int t = 1;
    cin >> t;
    while (t--)
        solve();
}

Refer to Problem C on link. Explained beautifully by BledDest

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;


#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);


typedef long long int ll;
typedef vector<ll> vi;

int main()
{
    fast;
    ll t = 1;
    cin >> t;
    while (t--)
    {
        ll n;
        cin >> n;

        vi a(n), b(n);
        vi c(n), d(n);
        vi x(n);
        for (int i = 0; i < n; i++) { cin >> a[i]; }
        for (int i = 0; i < n; i++) { cin >> b[i]; }
        ll j = 0;
        for (int i = 0; i < n; i++)
        {
            while (b[j] < a[i])
            {
                j++;
            }
            if (b[j] > a[i])
            {
                c[i] = b[j] - a[i];
            }
        }

        x[n - 1] = b[n - 1];
        for (int i = n - 1; i >= 0; i--)
        {
            if (b[i] >= a[i + 1])
            {
                if (i == n - 2)
                {
                    x[i] = b[i + 1];
                }
                else
                {
                    x[i] = x[i + 1];
                }
            }
            else
            {
                x[i] = b[i];
            }
        }

        for (int i = 0; i < n; i++)
        {
            d[i] = x[i] - a[i];
        }
        for (int i = 0; i < n; i++)
        {
            cout << c[i] << " ";
        }
        nl;
        for (int i = 0; i < n; i++)
        {
            cout << d[i] << " ";
        }
        nl;
    }
    return 0;
}

A problem will be solved by the team if there are atleast two 1s in a row. count this for every row i.e n times.

    // Aur Bhai Dekhne aagaye ;)
    // Author: Abhijit Mishra 
    #include <bits/stdc++.h>
    using namespace std;
     
     
    #define nl cout << "\n"
    #define all(x) x.begin(), x.end()
    #define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
     
     
    typedef long long int ll;
    typedef vector<ll> vi;
     
     
    int main()
    {
        fast;
        ll n;
        cin >> n;
        ll a, b, c;
        ll ans = 0;
        for (int i = 0; i < n; i++)
        {
            cin >> a >> b >> c;
            if (a + b + c >= 2)
            {
                ans++;
            }
        }
        cout << ans;
        nl;
     
        return 0;
    }

If the sum is even initially then we select the even packets because if we remove a packet containing an even number of pens the sum of the remaining is even therefore no fights so the ans will be the number of even packets.

If the sum is odd initially then we select the odd packets because if we remove a packet containing an odd number of pens the sum of the remaining is even therefore no fights so the ans will be the number of even packets.

    // Aur Bhai Dekhne aagaye ;)
    // Author: Abhijit Mishra 
    #include <bits/stdc++.h>
    using namespace std;
     
     
    #define nl cout << "\n"
    #define all(x) x.begin(), x.end()
    #define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
     
     
    typedef long long int ll;
    typedef vector<ll> vi;
     
     
    int main()
    {
        fast;
        ll n = 1;
        cin >> n;
        vi a(n);
        ll even = 0, odd = 0;
        for (int i = 0; i < n; i++)
        {
            cin >> a[i];
            if (a[i] & 1) { odd++; }
            else { even++; }
        }
        if (odd & 1)
        {
            cout << odd;
        }
        else
        {
            cout << even;
        }
        nl;
     
        return 0;
    }

If there are two elements with the same value, then the answer is NO, because neither of these values is less than the other.
Otherwise, the answer is YES, since we can just sort the array.
The time complexity is O(nlogn) or O(n) depending on the implementation.

    // Aur Bhai Dekhne aagaye ;)
    // Author: Abhijit Mishra 
    #include <bits/stdc++.h>
    using namespace std;
     
     
    #define nl cout << "\n"
    #define all(x) x.begin(), x.end()
    #define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
     
     
    typedef long long int ll;
    typedef vector<ll> vi;
     
     
    int main()
    {
        fast;
        ll t = 1;
        cin >> t;
        while (t--)
        {
            ll n;
            cin >> n;
            set <ll>a;
            for (int i = 0; i < n; i++)
            {
                ll temp;
                cin >> temp;
                a.insert(temp);
            }
            if (a.size() == n)
            {
                cout << "YES";
            }
            else
            {
                cout << "NO";
            }
            nl;
     
        }
        return 0;
    }

Every character in strings aa, aaa, bb and bbb has at least one character adjacent to it that is the same. So, if there is an isolated character in our string (a character that has no neighbors equal to it), we cannot build it.

It's easy to see that in the other case, we can build the string: we can split it into blocks of consecutive equal characters, and since there are no isolated characters, each block will have at least 2 characters, so it can be formed from strings of length 2 and/or 3 consisting of equal characters.

So, the problem is reduced to checking if each character has a neighbor equal to it.

    // Aur Bhai Dekhne aagaye ;)
    // Author: Abhijit Mishra 
    #include <bits/stdc++.h>
    using namespace std;
     
     
    #define nl cout << "\n"
    #define all(x) x.begin(), x.end()
    #define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
     
     
    typedef long long int ll;
    typedef vector<ll> vi;
     
     
    int main()
    {
        fast;
        ll t = 1;
        cin >> t;
        while (t--)
        {
            string s;
            cin >> s;
            bool ans = true;
            for (int i = 0; i < s.length(); i++)
            {
                if ((i == 0 || s[i] != s[i - 1]) && (i == s.length() - 1 || s[i] != s[i + 1]))
                {
                    ans = false;
                }
            }
            ans ? cout << "YES" : cout << "NO";
            nl;
        }
        return 0;
    }

Count the number of 1's from both the sequences, if the number of ones in both the sequence is same then we can simply rearrange the sequence. else we take the absolute value of the difference + 1 (rearrangement)

    // Aur Bhai Dekhne aagaye ;)
    // Author: Abhijit Mishra 
    #include <bits/stdc++.h>
    using namespace std;
     
     
    #define nl cout << "\n"
    #define all(x) x.begin(), x.end()
    #define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
     
     
    typedef long long int ll;
    typedef vector<ll> vi;
     
     
    int main()
    {
        fast;
        ll t = 1;
        cin >> t;
        while (t--)
        {
            ll n;
            cin >> n;
            ll inc = 0;
            ll suma = 0, sumb = 0;
            vi a(n), b(n);
            for (int i = 0; i < n; i++) { cin >> a[i]; suma += a[i]; }
            for (int i = 0; i < n; i++) { cin >> b[i]; sumb += b[i]; }
            for (int i = 0; i < n; i++) { if (a[i] != b[i]) { inc++; } }
            if (suma == sumb)
            {
                (inc == 0) ? cout << "0" : cout << "1";
            }
            else
            {
                cout << min(abs(suma - sumb) + 1, inc);
            }
            nl;
     
        }
        return 0;
    }

Draw the grid graph as the problem said.
Just a few basics of your programming language. It's easy.

        // Aur Bhai Dekhne aagaye ;)
    // Author: Abhijit Mishra 
    #include <bits/stdc++.h>
    using namespace std;
     
     
    #define nl cout << "\n"
    #define all(x) x.begin(), x.end()
    #define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
     
     
    typedef long long int ll;
    typedef vector<ll> vi;
     
     
    int main()
    {
        fast;
        ll n;
        cin >> n;
     
        for (int i = 0; i < n; i++)
        {
     
            int t = 0;
            int m = n / 2;
            if (i > m) t = i - m;
            else t = m - i;
            for (int j = 0; j < t; j++) { cout << '*'; };
            for (int j = 0; j < n - t - t; j++) { cout << "D"; }
            for (int j = 0; j < t; j++) { cout << '*'; };
            nl;
        }
     
        return 0;
    }

First, let's say that appending the number with p zeros is the same as multiplying it by 10^p

The given numbers are so large that they can't fit into any reasonable integer type. Even if you use a language with unlimited length integers (python, for example) or store the numbers in strings, you should still face the time limit issue. So let's learn to shrink the numbers a bit.

Note that the result of the comparison of two numbers doesn't change if you divide both numbers by the same positive number. So we can keep dividing both numbers by 10 until one of them is not divisible anymore. Let's also ignore the trailing zeros in x1 and x2 and leave them as is. If the first number is appended with p1 zeros and the second numbers is appended with p2 zeros, we can subtract min(p1,p2) from both values, effectively dividing both numbers by 10min(p1,p2)

This way, one of the numbers becomes short enough to fit into an integer type (because it has p=0 and x is only up to 10^6). The other number might still be large enough.

However, if it's really large, we can instantly say that it's larger than another one. Say, if its p is at least 7. This number it at least 10^7 and the other number is at most 10^6 Otherwise, we can calculate this number as well and compare the values normally.

Overall complexity: O(1) per testcase.

Credits: BledDest

    // Aur Bhai Dekhne aagaye ;)
    // Author: Abhijit Mishra 
    #include <bits/stdc++.h>
    using namespace std;
     
     
    #define nl cout << "\n"
    #define all(x) x.begin(), x.end()
    #define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
     
     
    typedef long long int ll;
    typedef vector<ll> vi;
     
     
    int main()
    {
        fast;
        ll t = 1;
        cin >> t;
        while (t--)
        {
            ll x1, p1, x2, p2;
            cin >> x1 >> p1 >> x2 >> p2;
     
            ll mi = min(p1, p2);
            p1 -= mi;
            p2 -= mi;
            if (p1 >= 7)
            {
                cout << ">";
                nl;
            }
            else if (p2 >= 7)
            {
                cout << "<";
                nl;
            }
            else
            {
                for (int i = 0; i < p1; i++) { x1 *= 10; }
                for (int i = 0; i < p2; i++) { x2 *= 10; }
                if (x1 > x2)
                {
                    cout << ">";
                    nl;
                }
                else if (x2 > x1)
                {
                    cout << "<";
                    nl;
                }
                else
                {
                    cout << "=";
                    nl;
                }
            }
        }
        return 0;
    }

Imagine that all elements of a are distinct. This way, sorting a in increasing order will fix the order of b

If b turns out sorted in a non-decreasing order, then the answer exists. Otherwise, it doesn't. To obtain the sequence of swaps, you can sort a with any comparison-based sorting algorithm you want: even bubble sort will not exceed the allowed number of swaps.

What changes if a has repeated elements? Distinct elements are still ordered among themselves, but now there are also blocks of equal elements. For each block, look into the corresponding values in b. Obviously, these have to be sorted in a non-decreasing order. Rearrange them as they should be.

In fact, this is exactly the same as sorting the sequence of pairs (ai,bi) with a default comparator — first by ai, then by bi

Since we fixed the wanted order, we can proceed with the same steps we made in a distinct case.

Overall complexity: O(nlogn) or O(n2) per testcase. Credits: BledDest

    // Aur Bhai Dekhne aagaye ;)
    // Author: Abhijit Mishra 
    #include <bits/stdc++.h>
    using namespace std;
     
     
    #define nl cout << "\n"
    #define all(x) x.begin(), x.end()
    #define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
     
     
    typedef long long int ll;
    typedef vector<ll> vi;
     
     
    int main()
    {
        fast;
        ll t = 1;
        cin >> t;
        while (t--)
        {
            int n;
            cin >> n;
            vector<int> a(n);
            for (int i = 0; i < n; i++)
            {
                cin >> a[i];
            }
            vector<int> b(n);
            for (int i = 0; i < n; i++)
            {
                cin >> b[i];
            }
            vector<pair<int, int>> p(n);
            for (int i = 0; i < n; i++)
            {
                p[i] = make_pair(a[i], b[i]);
            }
            sort(a.begin(), a.end());
            sort(b.begin(), b.end());
            vector<pair<int, int>> res;
            bool fail = false;
            for (int i = 0; i < n; i++)
            {
                for (int j = i; j < n; j++)
                {
                    if (p[j] == make_pair(a[i], b[i]))
                    {
                        swap(p[i], p[j]);
                        if (i != j)
                        {
                            res.emplace_back(i, j);
                        }
                        break;
                    }
                }
                if (p[i] != make_pair(a[i], b[i]))
                {
                    fail = true;
                    break;
                }
            }
            if (fail)
            {
                cout << -1 << '\n';
            }
            else
            {
                cout << res.size() << '\n';
                for (auto &p : res)
                {
                    cout << p.first + 1 << " " << p.second + 1 << "\n";
                }
            }
        }
        return 0;
    }

First the sequence will increase then decrease then increase again.

You can find the first position where the sequences start decreasing from the beginning. Call it L. You can find the first position where the sequences start increasing from the end. Call it R.

Now we just need to reverse the segment between a[L] to a[R].

Let us define L to be smallest index such that A[i]! = i. Let us also define R to be largest index such that A[i]! = i.

Note that if there is no such L and R, it means that array is sorted already. So answer will be "yes", we can simply reverse any of the 1 length consecutive segment.

Otherwise we will simply reverse the array from [L, R]. After the reversal, we will check whether the array is sorted or not.

Complexity: O(nlogn)

        // Aur Bhai Dekhne aagaye ;)
    // Author: Abhijit Mishra 
    #include <bits/stdc++.h>
    using namespace std;
     
     
    #define nl cout << "\n"
    #define all(x) x.begin(), x.end()
    #define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
     
     
    typedef long long int ll;
    typedef vector<ll> vi;
     
     
    bool ispal(vector<ll> a)
    {
        bool ok = true;
        ll n = a.size();
        for (int i = 0; i < n; i++)
        {
            if (a[i] != a[n - 1 - i])
            {
                ok = false;
            }
        }
        return ok;
    }
     
     
    int main()
    {
        fast;
        ll n;
        cin >> n;
     
        vi a(n);
        ll cnt = 0;
        bool ok = false;
        bool ama = true;
     
        for (int i = 0; i < n; i++) { cin >> a[i]; }
        int l = 0;
        while (l + 1 < n && a[l] < a[l + 1])
        {
            ++l;
        }
        int r = l + 1;
        while (r < n && a[r] < a[r - 1])
        {
            ++r;
        }
        reverse(a.begin() + l, a.begin() + r);
        for (int i = 1; i < n; ++i)
        {
            if (a[i] < a[i - 1])
            {
                puts("no");
                return 0;
            }
        }
     
        cout << "yes\n";
     
        cout << l + 1 << " " << r;
     
        return 0;
    }

Sort the array. if all the numbers are less than 0 or greater than 0, simply multiply the 5 biggest elements. else if the array is containing both negative and positive number then calculate all the possible permutation of the 5 largest and 5 smallest elements. (smallest referring to high magnitude negative numbers.)

// Aur Bhai Dekhne aagaye ;)
// Author: Abhijit Mishra 
#include <bits/stdc++.h>
using namespace std;
 
 
#define nl cout << "\n"
#define all(x) x.begin(), x.end()
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
 
 
typedef long long int ll;
typedef vector<ll> vi;
 
 
int main()
{
    fast;
    ll t = 1;
    cin >> t;
    while (t--)
    {
        int n; cin >> n;
        vi a;
 
        for (int i = 0; i < n; i++)
        {
            ll x; cin >> x;
            a.push_back(x);
        }
 
        ll ans = INT64_MIN;
 
        sort(all(a));
 
        for (int i = 0; i < 6; i++)
        {
            ll cur = 1;
            for (int x = 0; x < i; x++)
            {
                cur *= a[x];
            }
            for (int x = 0; x < 5 - i; x++)
            {
                cur *= a[n - 1 - x];
            }
            ans = max(ans, cur);
        }
 
        cout << ans;
        nl;
    }
    return 0;
}