🚨Latest Job Opening Update🚨

Company – Lumosys
Role – Data Analyst
Exp. – Fresher
Apply Here – https://www.linkedin.com/jobs/view/3970590490

Company – Cushman & Wakefield
Role – Data Analyst
Exp. – Fresher
Apply Here – https://careers.cushmanwakefield.com/global/en/job/CUWAGLOBALR240308ENAPACEXTERNAL/Data-Analyst-Generalist?utm_source=linkedin&utm_medium=phenom-feeds

Company – Maxgen Technologies Private Limited
Role – DATA ANALYST INTERNSHIP
Exp. – Fresher
Apply Here – https://www.foundit.in/job/data-analyst-internship-at-pune-maxgen-technologies-private-limited-pune-aurangabad-31080862?searchId=024c17c0-43d0-4685-aa32-f7eff911576c

Company – Soul Ai
Role – Data Scientist
Exp. – Fresher
Apply Here – https://www.naukri.com/job-listings-data-scientist-soul-ai-hyderabad-0-to-0-years-080724010188?src=sortby&sid=17205139582078710_1&xp=6&px=1

Company – Soul Ai
Role – Data Engineer
Exp. – Fresher
Apply Here – https://www.naukri.com/job-listings-data-engineer-soul-ai-hyderabad-0-to-0-years-080724010135?src=sortby&sid=17205139582078710_1&xp=7&px=1

Company – PartnerFirms
Role – Data Engineer
Exp. – Fresher
Apply Here – https://www.linkedin.com/jobs/view/3967437296

Company – Citi
Role – Business Analytics Analyst
Exp. – 0-2 yrs
Apply Here – https://www.simplyhired.co.in/job/P_uzl7zlJZgSJBvCxnABn-Z6LhIh6x_tf2dyo9YFRarLi1y0nTBg

Company – Resolute AI Software Private Limited
Role – AI Engineer Intern
Exp. – Fresher
Apply Here – https://internshala.com/internship/details/work-from-home-ai-engineer-internship-at-resolute-ai-software-private-limited1720498515?utm_source=cp_link&referral=web_share

MiniOrange is hiring Fresher

Apply link 👇
https://www.miniorange.com/career/hiring-drive

LSEG is hiring Associate Software Engineer

For 2023, 2022 grads

Apply - https://refinitiv.wd3.myworkdayjobs.com/Careers/job/IND-BLR-Divyasree-Technopolis/Associate-Software-Engineer-Java-1-to-2-yrs-_R0088243

Graduate Roles at Capua, London

Visa Sponsorship Available

Salary: 30,000-40000 Euros

Batch: 2021-2026

https://tally.so/r/nrPk5l

Tech as well as Non-Tech Roles available

ll solve(vector<int>& heights) {
    int n = heights.size();
    vector<ll> left(n), right(n, n);
    stack<int> s;
    for (int i = 0; i < n; ++i) {
        while (!s.empty() && heights[s.top()] <= heights[i]) {
            right[s.top()] = i;
            s.pop();
        }
        left[i] = s.empty() ? -1 : s.top();
        s.push(i);
    }
    ll tot = 0;
    for (int i = 0; i < n; ++i) {
        tot += (i - left[i]) + (right[i] - i) - 1;
    }
    return tot;
}.

// CALCULATE REGION
MSCI ✅

#include <iostream>
#include <vector>
using namespace std;
const int MOD = 10000000;
int solve(int N, const string& a) {
    vector<vector<int>> dp(N, vector<int>(3, 0));
    if (a[0] != 'R') dp[0][0] = 1;
    if (a[0] != 'P') dp[0][1] = 1;
    if (a[0] != 'S') dp[0][2] = 1;
    for (int i = 1; i < N; ++i) {
        if (a[i] != 'R') {
            dp[i][0] = (dp[i-1][1] + dp[i-1][2]) % MOD;
        }
        if (a[i] != 'P') {
            dp[i][1] = (dp[i-1][0] + dp[i-1][2]) % MOD;
        }
        if (a[i] != 'S') {
            dp[i][2] = (dp[i-1][0] + dp[i-1][1]) % MOD;
        }
    }
    int ans = (dp[N-1][0] + dp[N-1][1] + dp[N-1][2]) % MOD;
    return ans;
}.

RocK paper scissors ✅

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;

const int MOD = 1e9 + 7;
const int MAXN = 101;

vector<int> primes;
vector<vector<int>> adj;
vector<vector<long long>> dp;
bool is_prime[MAXN];

void sieve() {
    fill(is_prime, is_prime + MAXN, true);
    is_prime[0] = is_prime[1] = false;
    for (int i = 2; i < MAXN; ++i) {
        if (is_prime[i]) {
            primes.push_back(i);
            for (int j = 2 * i; j < MAXN; j += i) {
                is_prime[j] = false;
            }
        }
    }
}

void preprocess(int N) {
    sieve();
    adj.clear();
    adj.resize(N);
    dp.clear();
    dp.assign(N, vector<long long>(primes.size(), 1));   
}

void dfs(int node, int par = -1) {
    for (int ne : adj[node]) {
        if (ne == par) continue;
        dfs(ne, node);       
       
        for (int i = 0; i < (int)primes.size(); i++) {
            long long t = 0;
            for (int j = 0; j < (int)primes.size(); j++) {
                if (is_prime[primes[i] + primes[j]]) continue;
                t += dp[ne][j];
                t %= MOD;
            }
            dp[node][i] *= t;
            dp[node][i] %= MOD;
        }
    }
}

int solve(int N, vector<vector<int>> edges) {
    preprocess(N);
   
    if (N == 1) return primes.size();
   
    for (vector<int> edge : edges) {
        adj[edge[0]].push_back(edge[1]);
        adj[edge[1]].push_back(edge[0]);    
    }
   
    dfs(0);
    long long ans = 0;
   
    for (int i = 0; i < (int)primes.size(); i++) {
        ans += dp[0][i];
        ans %= MOD;
    }
   
    return ans;
}

int main() {
    int N;
    cin >> N;
    vector<vector<int>> edges(N-1, vector<int>(2));
    for (int i = 0; i < N-1; i++) {
        cin >> edges[i][0] >> edges[i][1];
        edges[i][0]--;
        edges[i][1]--;
    }

    cout << solve(N, edges) << endl;
    return 0;
}
prime tree code ✅

def getMinimumCost(arr):
    n = len(arr)
    ans = 0
    max_diff = 0

    for i in range(n - 1):
        a, b = arr[i], arr[i + 1]
        max_diff = max(max_diff,abs(a-b))
        ans += ((a-b)** 2)

    if max_diff % 2 == 0:
        ans = ans -max_diff**2/2
    else:
        ans = ans-max_diff 2 + ((max_diff-1) / 2) 2 + ((max_diff+1) / 2) ** 2

    return int(ans) 

MINIMIZE ARRAY COST ✅

class Solution {
public:
    string oddString(vector<string>& words) {
        map<string,int> mp;int k = 3;
        for(int j = 0;j<words.size();j++){
            string temp;
            for(int i = 0;i<words[j].size()-1;i++) temp.push_back(words[j][i+1]-words[j][i]);
            mp[temp]+= k++;
            if(mp.size()==2 and j>2)return words[min(begin(mp)->second,next(begin(mp))->second)-3];

        }
        return words[min(begin(mp)->second,next(begin(mp))->second)-3];
    }
};

// ODD ONE OUT ✅

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

const int MOD = 1e9 + 7;

long long solve(vector<int>& A) {
    int N = A.size();
   
    vector<vector<int>> dp(N + 1, vector<int>(N + 1, 0));
   
    for (int L = 1; L <= N; ++L) {
        stack<int> stack;
        int trees = 0;
        for (int R = L; R <= N; ++R) {
            while (!stack.empty() && A[stack.top() - 1] < A[R - 1]) {
                stack.pop();
            }
            if (stack.empty()) {
                trees++;
            }
            stack.push(R);
            int max_trees = trees;
            if (R > L) {
                if (stack.size() > 1) {
                    max_trees = max(max_trees, trees - 1);
                } else {
                    max_trees = max(max_trees, trees);
                }
               
                if (R - L > trees) {
                    max_trees = max(max_trees, trees + 1);
                }
            }
           
            dp[L][R] = max_trees;
        }
    }
   
    long long result = 0;
    for (int i = 1; i <= N; ++i) {
        for (int j = i; j <= N; ++j) {
            result = (result + dp[i][j]) % MOD;
        }
    }
   
    return result;
}

int main() {
    int n; cin>>n;
    vector<int> A;
    for(int i = 0; i < n; ++i) cin>>A[i];
    cout << solve(A) << endl;
    return 0;
}

//So many trees

import java.util.Scanner;

public class Miain {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
       
        String S = scanner.nextLine();
       
        StringBuilder S1 = new StringBuilder();
        StringBuilder S2 = new StringBuilder();
       
        for (int i = 0; i < S.length(); i++) {
            if ((i + 1) % 2 == 0) {
                S1.append(S.charAt(i));
            } else {
                S2.append(S.charAt(i));
            }
        }
        System.out.println(S2.toString());
        System.out.println(S1.toString());
       
       
        scanner.close();
    }
}

vector<string> areAlmostEquivalent(vector<string>& s, vector<string>& t) {
    vector<string> result;
    auto countCharacters = [](const string& str) {
        vector<int> count(26, 0);
        for (char c : str) {
            count[c - 'a']++;
        }
        return count;
    };
    for (size_t i = 0; i < s.size(); ++i) {
        const string& str_s = s[i];
        const string& str_t = t[i];
  
        vector<int> count_s = countCharacters(str_s);
        vector<int> count_t = countCharacters(str_t);

        bool isAlmostEquivalent = true;
        for (int j = 0; j < 26; ++j) {
            if (abs(count_s[j] - count_t[j]) > 3) {
                isAlmostEquivalent = false;
                break;
            }
        }

        if (isAlmostEquivalent) {
            result.push_back("YES");
        } else {
            result.push_back("NO");
        }
    }
   
    return result;
}

// Almost equivalent String ✅