🚨JOB OPENING UPDATE🚨

Company – S&P Global
Role – Data Quality Analyst
Exp. – Fresher
Apply Here – https://careers.spglobal.com/jobs/295211?lang=en-us&utm_source=indeed&utm_source=indeed

Company – Shell
Role – Lead BI Analyst – Data Engineering
Exp. – Fresher
Apply Here – https://jobs.shell.com/job/bengaluru/lead-bi-analyst-data-engineering/25244/59453151280?codes=1-INDEED

Company – Ericsson
Role – Data Engineer
Exp. – Fresher
Apply Here – https://jobs.ericsson.com/careers/job/563121757378324?domain=ericsson.com&jobPipeline=Indeed

Company – FXCM
Role – Business Intelligence Analyst
Exp. – Fresher
Apply Here – https://fxcm-hr.my.salesforce-sites.com/recruit/fRecruit__ApplyJob?vacancyNo=VN982&sid=37


Company – Cheeron Life
Role – Data Analyst Trainee
Exp. – 0-1 yrs
Apply Here – https://www.naukri.com/job-listings-data-analyst-trainee-cheeron-life-surat-gujarat-0-to-1-years-121023010939?src=jobsearchDesk&sid=17043459554449609&xp=1&px=1&nignbevent_src=jobsearchDeskGNB

Company – Zcts
Role – Data Analyst Trainee
Exp. – 0-1 yrs
Apply Here – https://www.naukri.com/job-listings-data-analyst-trainee-da-trainee-zcts-coimbatore-0-to-1-years-301223903794?src=jobsearchDesk&sid=17043459554449609&xp=2&px=1&nignbevent_src=jobsearchDeskGNB

Company – Comcast Corporation
Role – Machine Learning Intern
Exp. – 0-2 yrs
Apply Here – https://jobs.comcast.com/jobs/description/regular?external_or_internal=External&job_id=R364614&source=ind_orga_at&jobPipeline=Indeed

Company – SatSure Analytics India
Role – Data Scientist Intern
Exp. – Fresher
Apply Here – https://satsure.keka.com/careers/jobdetails/26859

Company – Add Innovations Private Limited
Role – Deep Learning Intern
Exp. – Fresher
Apply Here – https://smartapply.indeed.com/beta/indeedapply/form/contact-info

ALL THE BEST💙

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

unordered_map<int, vector<int>> g;

void create(vector<int>& p) {
    for (int i = 1; i < p.size(); i++) {
        g[p[i]].push_back(i);
    }
}

int dfs(int s, vector<int>& w, int oH, int uH, int a, vector<int>& v) {
    if (g.find(s) == g.end()) {
        if (w[s] == a) {
            v[s] = oH;
            return oH;
        }
        return 0;
    }

    int p = 0;
    if (w[s] == a) {
        p = oH;
    }
    for (int t : g[s]) {
        p += dfs(t, w, oH, uH, a, v);
    }
    v[s] = p;
    return p;
}

void solve(vector<int>& p, vector<int>& w, int oH, int uH) {
    g.clear();

    vector<int> h(w.size(), 0);
    vector<int> u(w.size(), 0);

    create(p);
    dfs(0, w, oH, uH, 1, h);
    dfs(0, w, uH, oH, -1, u);

    int ans = INT_MAX;
    int pen = u[0];
    for (int i = 0; i < w.size(); i++) {
        ans = min(ans, h[i] + (pen - u[i]));
    }
    cout << ans << endl;
}

Hydrate the nodes ✅

#include <iostream>
#include <vector>
#include <unordered_map>

class Main {
public:
    static long getZeroBitSubarrays(const std::vector<int>& arr) {
        int n = arr.size();
        long totalSubarrayCount = static_cast<long>(n) * (n + 1) / 2;
        long nonzeroSubarrayCount = 0;
        std::unordered_map<int, int> windowBitCounts;
        int leftIdx = 0;

        for (int rightIdx = 0; rightIdx < n; rightIdx++) {
            int rightElement = arr[rightIdx];

            if (rightElement == 0) {
                windowBitCounts.clear();
                leftIdx = rightIdx + 1;
                continue;
            }

            std::vector<int> setBitIndices = getSetBitIndices(rightElement);
            for (int index : setBitIndices) {
                windowBitCounts[index]++;
            }

            while (leftIdx < rightIdx && isBitwiseAndZero(rightIdx - leftIdx + 1, windowBitCounts)) {
                for (int index : getSetBitIndices(arr[leftIdx])) {
                    windowBitCounts[index]--;
                    if (windowBitCounts[index] == 0) {
                        windowBitCounts.erase(index);
                    }
                }
                leftIdx++;
            }

            nonzeroSubarrayCount += (rightIdx - leftIdx + 1);
        }

        return totalSubarrayCount - nonzeroSubarrayCount;
    }

private:
    static std::vector<int> getSetBitIndices(int x) {
        std::vector<int> setBits;
        int pow2 = 1;
        int exponent = 0;

        while (pow2 <= x) {
            if ((pow2 & x) != 0) {
                setBits.push_back(exponent);
            }

            exponent++;
            pow2 *= 2;
        }

        return setBits;
    }

    static bool isBitwiseAndZero(int windowLength, const std::unordered_map<int, int>& bitCounts) {
        for (const auto& entry : bitCounts) {
            if (entry.second >= windowLength) {
                return false;
            }
        }
        return true;
    }
};

DE Shaw ✅
C++

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

int solve(vector<vector<int>>& s, vector<vector<int>>& t) {
    int n = s.size();

    auto h = [](const vector<vector<int>>& i) -> size_t {
        size_t v = 0;
        for (const auto& r : i) {
            for (int p : r) {
                v = v * 2 + p;
            }
        }
        return v;
    };

    auto is = [](const vector<vector<int>>& a, const vector<vector<int>>& b) -> bool {
        return a == b;
    };

    queue<pair<vector<vector<int>>, int>> q;
    unordered_set<size_t> v;

    q.push({s, 0});
    v.insert(h(s));

    while (!q.empty()) {
        auto [c, fl] = q.front();
        q.pop();

        if (is(c, t)) {
            return fl;
        }

        for (int i = 0; i < n; ++i) {
           
            vector<vector<int>> nr = c;
            for (int j = 0; j < n; ++j) {
                nr[i][j] = 1 - nr[i][j];
            }
            size_t rh = h(nr);
            if (v.find(rh) == v.end()) {
                q.push({nr, fl + 1});
                v.insert(rh);
            }

           
            vector<vector<int>> nc = c;
            for (int j = 0; j < n; ++j) {
                nc[j][i] = 1 - nc[j][i];
            }
            size_t ch = h(nc);
            if (v.find(ch) == v.end()) {
                q.push({nc, fl + 1});
                v.insert(ch);
            }
        }
    }

    return -1;
}

DE Shaw✅

#include<bits/stdc++.h>
using namespace std;
class hm {
    unordered_map<int, int> m;
    int k = 0, v = 0;

public:
    void i(int x, int y) {
        x -= k;
        y -= v;
        m[x] = y;
    }

    int g(int x) {
        x -= k;
        if (m.find(x) == m.end()) {
            return -1;
        }
        return m[x] + v;
    }

    void ak(int x) {
        k += x;
    }

    void av(int y) {
        v += y;
    }
};

int solve(vector<string>& qt, vector<vector<int>>& q) {
    hm h;
    int s = 0;
    for (int i = 0; i < qt.size(); ++i) {
        if (qt[i] == "insert") {
            h.i(q[i][0], q[i][1]);
        } else if (qt[i] == "addToKey") {
            h.ak(q[i][0]);
        } else if (qt[i] == "addToValue") {
            h.av(q[i][0]);
        } else if (qt[i] == "get") {
            int v = h.g(q[i][0]);
            if (v != -1) {
                s += v;
            }
        }
    }
    return s;
}

Company Name: AMD

Role: Software System Designer

Batch eligible: 2022 and 2023 passouts

Apply: https://careers.amd.com/careers-home/jobs/37625?lang=en-us

Apply, if you’re interested 👍

Company Name : Walmart Global Tech

Role : Software Engineer - JAVA Full Stack Developer

Batch : 2023/2022 eligible for this. ( 8 months - 1.5 years of experience required)

Mail your resume to soudamini.raut@walmart.com

GeeksforGeeks is hiring For Technical Content Writer Intern. ✍️

What we are looking for:
- Available for 6 months in-office internship
- Having SEO Knowledge
- Creative Content
- Experience preferred

Location:- Noida

Join the Geeksforgeeks family and be part of something extraordinary! 📚 Fill The Forms Given Below To Apply 👇

https://lnkd.in/gZha5wWf

Hiring Data Analyst (Fresher/ 2023-24 Batch) at Razormet Technologies

Salary: ₹400,000/yr - ₹500,000/yr

https://www.linkedin.com/jobs/view/3798981663

ZeStream is hiring for several positions with any experience level

Apply here : https://lnkd.in/g6PTsQ6w

 

My Team at Meesho Is hiring for Business Analysts ( 0-2 YOE)
( Multiple Openings)

For referrals,
Interested Folks can apply through this google form:
https://lnkd.in/gY9vE5yb

int solve(int N, int A, int B, int C) {
    vector<int> dp(N + 1, INT_MIN);
    dp[0] = 0;
    for (int i = 1; i <= N; ++i) {
        if (i >= A) dp[i] = max(dp[i], dp[i - A] + 1);
        if (i >= B ) dp[i] = max(dp[i], dp[i - B] + 1);
        if (i >= C) dp[i] = max(dp[i], dp[i - C] + 1);
    }
    return dp[N];
}

Memory Distribution ✅

Quest Global is inviting applications from Engineering Graduates of Batch 2023, 2022 in Industrial Domains. Last Date to Apply: 10th January 2024

Click on the below link to register: https://forms.office.com/r/zytvedkhYw

Tata Capital is hiring for Quality Executive.

Experience :- 0 to 2 year's
Location :- Karnataka

Apply Now  - https://cutt.ly/zwHcWs3G