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

void Sieve(ll n, vector<ll>& primes) { 
    vector<bool> prime(n + 1, true); 
    for (ll p = 2; p * p <= n; p++) { 
        if (!prime[p]) continue; 
        for (ll i = p * p; i <= n; i += p) { 
            prime[i] = false; 
        } 
    } 
    for (ll i = 2; i <= n; i++) { 
        if (prime[i]) { 
            primes.push_back(i); 
        } 
    } 
} 

bool isPrime(ll n, vector<ll>& primes) { 
    auto it = find(primes.begin(), primes.end(), n); 
    return it != primes.end(); 
} 

void dfs(ll s, ll p, ll mod, vector<vector<ll>>& adj, vector<vector<ll>>& dp, vector<ll>& primes) { 
    for (ll i = 0; i < 25; i++) { 
        dp[s][i] = 1; 
    } 
    for (auto u : adj[s]) { 
        if (u != p) { 
            dfs(u, s, mod, adj, dp, primes); 
            for (ll i = 0; i < 25; i++) { 
                ll pos = 0; 
                for (ll j = 0; j < 25; j++) { 
                    if (!isPrime(primes[i] + primes[j], primes)) { 
                        pos = (pos + dp[u][j]) % mod; 
                    } 
                } 
                dp[s][i] = (dp[s][i] * pos) % mod; 
            } 
        } 
    } 
} 

long long Validasignment(int n, vector<vector<int>>& edges) { 
    ll mod = 1000000007; 
    vector<ll> primes; 
    Sieve(200, primes); 
    vector<vector<ll>> dp(n + 1, vector<ll>(25, 0)); 
    vector<vector<ll>> adj(n + 1); 
    for (int i = 0; i < n - 1; i++) { 
        adj[edges[i][0]].push_back(edges[i][1]); 
        adj[edges[i][1]].push_back(edges[i][0]); 
    } 
    dfs(1, -1, mod, adj, dp, primes); 
    ll ans = 0; 
    for (ll i = 0; i < 25; i++) { 
        ans = (ans + dp[1][i]) % mod; 
    } 
    return ans; 
}

Google ✅

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

int equalzeroandone(vector<int>v){
    int n=v.size();
    for(int i=0;i<n;i++){
        if(v[i]==0){
            v[i]=-1;
        }
    }
    int sum=0;
    int ans=-1;
   map<int,int>mp;
    for(int i=0;i<n;i++){
        sum+=v[i];
        if(sum==0){
            ans=i+1;
        }
        if(mp.find(sum)!=mp.end()){
            ans=max(ans,i-mp[sum]);
        }
        else{
            mp[sum]=i;
        }
    }
    return ans;
}

int main() {
    int n;
    cin>>n;
    vector<int>v(n);
    for(int i=0;i<n;i++){
        cin>>v[i];
    }
    cout<<equalzeroandone(v);
}

Equal number of zero
Infosys

largest subarray equal number
Infosys ✅

public static int findLargestSquareSize(List<List<Integer>> samples) {
   // Write your code here
      int R = samples.size();
        if (R == 0) return 0;
        int C = samples.get(0).size();
       
        int[][] S = new int[R][C];
        int[][] M = new int[R][C];
       
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                M[i][j] = samples.get(i).get(j);
            }
        }
       
        for (int i = 0; i < R; i++)
            S[i][0] = M[i][0];
        for (int j = 0; j < C; j++)
            S[0][j] = M[0][j];
       
        for (int i = 1; i < R; i++) {
            for (int j = 1; j < C; j++) {
                if (M[i][j] == 1) {
                    S[i][j] = Math.min(S[i][j - 1], Math.min(S[i - 1][j], S[i - 1][j - 1])) + 1;
                } else {
                    S[i][j] = 0;
                }
            }
        }
       
        int max_of_s = S[0][0];
        int max_i = 0;
        int max_j = 0;
       
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                if (max_of_s < S[i][j]) {
                    max_of_s = S[i][j];
                    max_i = i;
                    max_j = j;
                }
            }
        }
       
        return Math.abs((max_i - max_of_s) - max_i);
    }.

findLargestSquareSize

Linkdin ✅

vector<int>findSubsequence(vector<int>arr){
    map<int,int>m;
    vector<int>ans;
    int maxi=0;
    int n=arr.size();
    for(int i=0;i<n;i++){
        if(m[arr[i]]>0){
            if(arr[i]<maxi){
                return {-1};
            }
            else{
                maxi=max(maxi,arr[i]);
                ans.push_back(arr[i]);
            }
        }
        m[arr[i]]++;
    }
    return ans;
}

Find sequence✅

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 ✅