def twins(a, b):
    result = []
    for first, second in zip(a, b):
        if sorted(first[::2]) == sorted(second[::2]) and sorted(first[1::2]) == sorted(second[1::2]):
            result.append('Yes')
        else:
            result.append('No')
    return result

Twin linked ✅

Unique subarray code ✅

Infosys ✅

long long solve(int n,vector<int>v){
    long long ans=0;
   sort(v.begin(),v.end());
   for(int i=1;i<n;i++){
    if(v[i]<=v[i-1]){
        v[i]=v[i-1]+1;
    }

   }
  ans=accumulate(v.begin(),v.end(),0);
  
    return ans;
}

Minimum unique sum

split string
Infosys ✅

import java.io.*;
import java.util.*;

public class Main {
    public static String trim(String str) {
        return str.trim();
    }

    public static int solve(int N, List<Integer> A) {
        int totalSum = A.stream().mapToInt(Integer::intValue).sum();
        int leftSum = 0;
        int equilibriumCount = 0;
       
        for (int i = 0; i < N; ++i) {
            int rightSum = totalSum - leftSum - A.get(i);
            if (leftSum == rightSum) {
                equilibriumCount++;
            }
            leftSum += A.get(i);
        }
       
        return equilibriumCount;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       
        String inputLine = br.readLine();
        int N = Integer.parseInt(trim(inputLine));

        List<Integer> A = new ArrayList<>();
        for (int j = 0; j < N; j++) {
            inputLine = br.readLine();
            A.add(Integer.parseInt(trim(inputLine)));
        }
       
        int result = solve(N, A);
        System.out.println(result);
    }
}


//Equilbrium path (try)

Music melodies
Python 3✅

Shortest String ✅

XR forming ✅

Equilibrium point ✅

Musical ✅

Short string ✅

Periodic strings ✅

Best Alternate ✅

Dividing Array ✅

Dividing Array all passed ✅

Lighting Lamp ✅

vector<int>findSubsequence(vector<int>arr) {
  map<int, vector<int>> ind;
    for (int i = 0; i < arr.size(); ++i) {
        ind[arr[i]].push_back(i);
    }
   
    vector<int> res;
    res.push_back(-1);
   
    for (auto &[_, v] : ind) {
        if (v.size() <= 1) continue;
       
        int cnt = 0;
        for (auto it : v) {
            if (res.back() > it) continue;
            cnt++;
            res.push_back(it);
            if (cnt == v.size() - 1) break;
        }
       
        if (cnt < v.size() - 1) {
            return { -1 };
        }
    }
   
    vector<int> fres;
    for (int i = 1; i < res.size(); ++i) {
        fres.push_back(arr[res[i]]);
    }
   
    return fres;

} 

findSubsequence

Lindkdin all passed ✅

import java.util.*;

public class AnagramSubsequenceFinder {
   
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
       
        String S = sc.nextLine();
       
        int N = sc.nextInt();
        sc.nextLine();
        String[] W = new String[N];
        for (int i = 0; i < N; i++) {
            W[i] = sc.nextLine();
        }
       
        int[] freqS = getFrequency(S);
       
        int count = 0;
        for (String w : W) {
            if (isValidAnagramSubsequence(freqS, w)) {
                count++;
            }
        }
       
        System.out.println(count);
    }
   
    private static int[] getFrequency(String S) {
        int[] freq = new int[26];
        for (char c : S.toCharArray()) {
            freq[c - 'a']++;
        }
        return freq;
    }

    private static boolean isValidAnagramSubsequence(int[] freqS, String w) {
        int[] freqW = new int[26];
        for (char c : w.toCharArray()) {
            freqW[c - 'a']++;
        }
       
        for (int i = 0; i < 26; i++) {
            if (freqW[i] > freqS[i]) {
                return false;
            }
        }
       
        return true;
    }
}


// Minimal substring length