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

unordered_map<int, string> stringMap;

void addString(int id, char c) {
    stringMap[id] = string(1, c);
}

void concatStrings(int id1, int id2, int id3) {
    stringMap[id3] = stringMap[id1] + stringMap[id2];
    stringMap.erase(id1);
    stringMap.erase(id2);
}

void reverseString(int id) {
    reverse(stringMap[id].begin(), stringMap[id].end());
}

void getCharacter(int id, int k) {
    cout << stringMap[id][k - 1] << endl;
}

void solve() {
    int q;
    cin >> q;

    while (q--) {
        int type;
        cin >> type;

        if (type == 1) {
            int id;
            char c;
            cin >> id >> c;
            addString(id, c);
        } else if (type == 2) {
            int id1, id2, id3;
            cin >> id1 >> id2 >> id3;
            concatStrings(id1, id2, id3);
        } else if (type == 3) {
            int id;
            cin >> id;
            reverseString(id);
        } else if (type == 4) {
            int id, k;
            cin >> id >> k;
            getCharacter(id, k);
        }
    }
}

int main() {
    solve();
    return 0;
}

String pool
Rubrik ✅

class KeyHierarchy:
    def __init__(self):
        self.gen = [1] 

    def rotate(self):
        self.gen.append(1)  

    def rekey(self):
        for i in range(len(self.gen)):
            self.gen[i] += 1

    def query(self, fam):
        if 1 <= fam <= len(self.gen):
            return self.gen[fam - 1]
        return 0  

def processOp(operations):
    kh = KeyHierarchy()
    results = []

    for op in operations:
        if op == 'Ro':
            kh.rotate()
        elif op == 'Re':
            kh.rekey()
        elif op.startswith('Q'):
            family = int(op.split()[1])
            results.append(kh.query(family))

    return results

Key hierarchy ✅

from collections import defaultdict

class BinaryTree:
    def __init__(self, n):
        self.n = n
        self.tree = defaultdict(list)
        self.values = [0] * (n + 1)
    
    def add_edge(self, u, v):
        self.tree[u].append(v)
        self.tree[v].append(u)
    
    def dfs(self, node, parent, depth, max_depth, increment):
        if depth > max_depth:
            return
        
        self.values[node] += increment
        
        for child in self.tree[node]:
            if child != parent:
                self.dfs(child, node, depth + 1, max_depth, increment)
    
    def update(self, ui, di, xi):
        self.dfs(ui, -1, 0, di, xi)

def solve(n, queries):
    tree = BinaryTree(n)
    
    for i in range(2, n + 1):
        parent = i // 2
        tree.add_edge(parent, i)
    
    for ui, di, xi in queries:
        tree.update(ui, di, xi)
    
    return tree.values[1:]

Binary Tree updates ✅

Hexaware Technologies Limited invites you to Superset to apply
for its Hexaware || 
2025 passout only
Complete the registration and apply!

Deadline to Apply: Aug 31, 2025 12:00 AM

Apply link : https://app.joinsuperset.com/join/#/signup/student?jp=033fcedb-1649-4dd5-bf7f-38f1772f1171

def proBinary(s):
    n = len(s)
    x = 0
    y = 0
    flip = 0
    
    for i in range(n):
        bit = int(s[i])
        x = (x << 1) | bit
        flip = (flip << 1) | (1 - bit)
    
    y = flip
    return f"{x} {y}"

Texas ✅

def find_unsorted_subarray_length(nums):
    n = len(nums)

    left = 0
    while left < n - 1 and nums[left] <= nums[left + 1]:
        left += 1

    if left == n - 1:
        return 0

    right = n - 1
    while right > 0 and nums[right] >= nums[right - 1]:
        right -= 1

    min_val = min(nums[left:right + 1])
    max_val = max(nums[left:right + 1])

    while left > 0 and nums[left - 1] > min_val:
        left -= 1

    while right < n - 1 and nums[right + 1] < max_val:
        right += 1

    length = right - left + 1

    return length

nums_input = input()
nums_list = list(map(int, nums_input.split()))

output1 = find_unsorted_subarray_length(nums_list)
print(output1)

Arrange the heights
Apple ✅

#include <iostream>
#include <vector>

using namespace std;
#define ll long long

void solve(string x) {
    ll n = x.size();
    vector<vector<ll>> dp(n, vector<ll>(n, 0));

    for (ll i = 0; i < n; i++) {
        dp[i][i] = 1;
    }

    for (ll k = 1; k < n; k++) {
        for (ll i = 0; i < n - k; i++) {
            ll j = i + k;
            if (x[i] == x[j]) {
                dp[i][j] = 2 + dp[i + 1][j - 1];
            } else {
                dp[i][j] = max(dp[i][j - 1], dp[i + 1][j]);
            }
        }
    }

    ll ans = 0;

    for (ll i = 0; i < n; i++) {
        for (ll j = 0; j < n - 1; j++) {
            ans = max(ans, dp[i][j] * dp[j + 1][n - 1]);
        }
    }

    cout << ans;
}

int main() {
    string input;
    cin >> input;

    solve(input);

    return 0;
}

Game of sequence reverse
Apple ✅

#include <iostream>
#include <string>
using namespace std;
bool isPalindrome(long long n) {
    string s = to_string(n);
    int len = s.length();
    for (int i = 0; i < len / 2; ++i) {
        if (s[i] != s[len - i - 1]) {
            return false;
        }
    }
    return true;
}
long long getNextPalindrome(long long N) {
    while (true) {
        ++N;
        if (isPalindrome(N)) {
            return N;
        }
    }
}
int main() {
    long long N;
    cin >> N;
    long long result = getNextPalindrome(N);
    cout << result;
    return 0;
}

Ascendion ✅

def getSeatsAllocation(arr):
    n = len(arr)
    ppl = [[] for i in range(2 * n + 4)]
   
    for i, x in enumerate(arr):
        ppl[x].append(i)

    h = []
    ans = [-1] * n
   
    for pos in range(1, 2 * n + 1):
        for i in ppl[pos]:
            heapq.heappush(h, (-pos, i))
       
        if len(h) > 0:
            ans[heapq.heappop(h)[1]] = pos
   
    return ans

BNY(Intern)✅

import java.util.*;

public class StockPrediction {

    public List<Integer> predict(List<Integer> stockData, List<Integer> queries) {
        List<Integer> result = new ArrayList<>();
        int n = stockData.size();
        
        TreeSet<Integer> treeSet = new TreeSet<>(stockData);
        
        if (treeSet.size() == 1) {
            Collections.fill(result, -1);
            return result;
        }
        
        for (int query : queries) {
            int stockPrice = stockData.get(query - 1);
            
            if (treeSet.first() >= stockPrice) {
                result.add(-1);
                continue;
            }
            
            int nearestDay = -1;
            int left = query - 2; 
            int right = query;
            while (left >= 0 || right < n) {
                if (left >= 0 && stockData.get(left) < stockPrice) {
                    nearestDay = left + 1; 
                    break;
                }
                if (right < n && stockData.get(right) < stockPrice) {
                    nearestDay = right + 1; 
                    break;
                }
                left--;
                right++;
            }
            
            result.add(nearestDay);
        }
        
        return result;
    }

BNY(intern)✅