QA Intern at HappyFox

Internship Details:

Full-time Paid Internship
Internship duration: 6 months
Mode of work: Work from office (Guindy, Chennai)
Full time opportunity will be available to interns with good performance

APPLY - https://happyfox.hire.trakstar.com/jobs/fk0xy99

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

class TreeNode {
public:
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) {
        data = val;
        left = nullptr;
        right = nullptr;
    }
};

class Solution {
public:
    bool checkPath(TreeNode* root, int dest) {
        if (!root) {
            return false;
        }

        queue<TreeNode*> q;
        q.push(root);

        while (!q.empty()) {
            TreeNode* current = q.front();
            q.pop();

            if (!current->left && !current->right && current->data == dest) {
                return true;
            }

            if (current->left) {
                current->left->data += current->data;
                q.push(current->left);
            }
            if (current->right) {
                current->right->data += current->data;
                q.push(current->right);
            }
        }

        return false;
    }

    TreeNode* takeLevelOrder() {
        int rootData;
        cin >> rootData;

        if (rootData == -1) {
            return nullptr;
        }

        TreeNode* root = new TreeNode(rootData);
        queue<TreeNode*> q;
        q.push(root);

        while (!q.empty()) {
            TreeNode* current = q.front();
            q.pop();

            int leftChild, rightChild;
            cin >> leftChild >> rightChild;

            if (leftChild != -1) {
                current->left = new TreeNode(leftChild);
                q.push(current->left);
            }

            if (rightChild != -1) {
                current->right = new TreeNode(rightChild);
                q.push(current->right);
            }
        }

        return root;
    }
};

int main() {
    Solution solution;

    int dest;
    cin >> dest;
    TreeNode* root = solution.takeLevelOrder();

    bool result = solution.checkPath(root, dest);

    cout << (result ? "True" : "False") << endl;

    return 0;
}

Zeta ✅

Hotstar is hiring Product Design Intern
🙂 Experience: Fresher
📌 Location: Bangalore
📤 Share with your friends & colleagues
👉 Apply: https://jobs.lever.co/hotstar/1d648f52-4e43-4102-8856-87ca5562a6f2

Goldman Sachs is hiring Summer Analyst
🙂 Experience: Fresher
📤 Share with your friends & colleagues
👉 Apply: https://goldmansachs.tal.net/vx/lang-en-GB/mobile-0/brand-2/candidate/so/pm/1/pl/1/opp/2-Summer-Analyst-Summer-Associate-Internship-programs/en-GB

long long solve(int n, int** A) {
    vector<pair<int, int>> vp;
    vp.push_back({-1, 0});

    for (int i = 0; i < n; i += 1) {
        vp.push_back({A[i][1], A[i][2]});
    }

    sort(vp.begin(), vp.end());

    auto check = [&] (int mid) {
        long long dishes = 0;

        for (int i = 1; i <= n; i += 1) {
            dishes += static_cast<long long>(vp[i].first - vp[i - 1].first) * mid;
            if (vp[i].second > dishes)
                return false;
            else
                dishes -= vp[i].second;
        }

        return true;
    };

    int l = 0, r = 1e9;

    while (r - l > 1) {
        int mid = (l + r) / 2;
        if (!check(mid))
            l = mid;
        else
            r = mid;
    }

    return r;
}

Chef and ordering ✅

def Solve(N, K):
    slots = [0] * K
    current_bag = 1
    current_slot = 0

    while N > 0:
        bags_to_distribute = min(N, current_bag)
        slots[current_slot] += bags_to_distribute
        N -= bags_to_distribute
        current_bag += 1
        current_slot = (current_slot + 1) % K

    return slots

N = int(input())
K = int(input())

result = Solve(N, K)
print(" ".join(map(str, result)))

Airport Baggage ✅

Intern - Data Research (Looking for 2023 graduates/ BCA/MCA/Bsc-Csc/ BE/ Btech) at Forbes Advisor

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

Company Name: Groww

Role: SDE 1 - Frontend (Kotlin)

Eligibility: if you have some experience or some projects you can apply.

Apply: https://docs.google.com/forms/d/e/1FAIpQLScpmEJxBOw38o9QEnqKKbrjXggXnzsnQic6GeuxkuuIKmB3OQ/viewform

Wipro Direct Interview for Analyst Role.

Must Attend this Drive Everyone either you are technical or Non-technical background.

bool check(string s, string t, vector<int>& order, int mid) {
    int n = s.size(), m = t.size();
    vector<int> pos(n);
    for (int i = 0; i < mid; ++i) {
        pos[order[i] - 1] = -1;
    }
    for (int i = mid; i < n; ++i) {
        pos[order[i] - 1] = i;
    }
    int j = 0;
    for (int i = 0; i < n && j < m; ++i) {
        if (pos[i] != -1 && s[i] == t[j]) {
            ++j;
        }
    }
    return j == m;
}

int solve(string s, string t, vector<int>& order) {
    int low = 0, high = s.size();
    while (low < high) {
        int mid = low + (high - low + 1) / 2;
        if (check(s, t, order, mid)) {
            low = mid;
        } else {
            high = mid - 1;
        }
    }
    return low;
}

String Search ✅

Job description nowadays,

we're looking for a junior developer with the experience of a senior developer, offering an intern’s salary:(

🚨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++