Company Name: Clearfeed
Role: Software Engineer Intern

Batch eligible: 2025 grads only
Apply: https://clearfeed.keka.com/careers/jobdetails/798

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

using namespace std;
long long anser(vector<int>& arr, int i, vector<long long>& dp) {
      if (i >= arr.size()) {
        return -1;
    }
    if (dp[i] != -1) {
        return dp[i];
    }
    int ans=anser(arr,i+1,dp);
    return max(ans,max(ans|arr[i],arr[i]));
}
long long answer(vector<int>& arr) {
    int n = arr.size();
    vector<long long> dp(n, -1);
    return anser(arr, 0, dp);
}

OR BIT✅

#include <iostream>
#include <vector>
using namespace std;
pair<int, int> urgent(const vector<int>& arr, int n) {
    vector<int> freq(n + 1, 0);
    int duplicate = -1, missing = -1;
    for (int i = 0; i < n; i++) {
        freq[arr[i]]++;
    }
    for (int i = 1; i <= n; i++) {
        if (freq[i] == 0) {
            missing = i;
        } else if (freq[i] > 1) {
            duplicate = i;
        }
    }
    if (duplicate != -1 && missing != -1) {
        return {duplicate, missing};
    } else {
        return {-1, -1};
    }
}

Messed Up Array ✅

Gammaprep is hiring for Multiple roles

Remote Opportunity
8 - 9 LPA CTC

Apply Here : https://wellfound.com/jobs/3086112-data-analyst-at-gammaprep-com

#include <iostream>
#include <vector>
using namespace std;

void solve(int N, const vector<int>& L, const vector<int>& R) {
    vector<pair<int, int>> available_slots;
        if (L[0] > 0) {
        available_slots.push_back({0, L[0]});
    }
        for (int i = 1; i < N; ++i) {
        if (R[i-1] < L[i]) {
            available_slots.push_back({R[i-1], L[i]});
        }
    }
        if (R[N-1] < 1000000000) {
        available_slots.push_back({R[N-1], 1000000000});
    }
   
    if (available_slots.empty()) {
        cout << "-1 -1" << endl;
    } else {
        for (const auto& slot : available_slots) {
            cout << slot.first << " " << slot.second << " ";
        }
        cout << endl;
    }
}

Available Time Frames ✅

Company Name : Siemens

Scholarship for first year students from Government Colleges.

Entire Tuition Fee covered + Internship at Siemens also

Link : https://www.siemens.com/in/en/company/sustainability/corporate-citizenship/siemens-scholarship-program.html

Last Date is September 15. Apply early.

Share with first year students from your college.

Zomato is hiring for Data Analyst role

Apply Form : https://forms.gle/dCber7wAqzgr5adv5

QBrainX is hiring for ServiceNow Opportunity for 2018 to 2023 passouts

Send resume to : sona.sekar@qbrainx.com

Rapido Intern Product Management

https://docs.google.com/forms/d/e/1FAIpQLSfuJQjLs0vPGkJTuUY7j-AX0cx0sSLJGM8XpDw-MpoVh6Pc7A/viewform

Python Developer Trainee

Location : Pune

Interested candidate send your Resume
aghaavte@inferyx.com

Deadline 3 September

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

Company Name : UST Global
D3 Hackathon 2024

Batch : All Engineering - BTech and MTech

Prizes worth 19 Lakhs to be won + PPO for top performers

Link to register : https://p.hck.re/hDC6

Last Date to register is September 4.

Send your reume to: fresher-jobs@mitrahsoft.com
Contact: 9092480924

Zomato Hiring Data Analyst

https://docs.google.com/forms/d/e/1FAIpQLSfL6qJfdBsMW6MZsJdKrqJW1EwaA7CGX6knZKz-O69mYiey8Q/viewform

Infosys brings a great opportunity for recent MBA graduates from the batch of 2023 & 2024.

https://surveys.infosysapps.com/r/a/InfosysMBAOffcampus

#include <iostream>
#include <vector>
#include <functional>
#include <array>

using namespace std;

using ll = long long;
ll maxValue(ll a, ll b) {
    return (a > b) ? a : b;
}

int getMinServers(int n, vector<int> f, vector<int> t, vector<int> w, vector<int> v) {
    vector<ll> size(n), maxDistance(n);
    vector<vector<array<ll, 2>>> adjacencyList(n);

    for (ll i = 0; i < f.size(); i++) {
        f[i]--;
        t[i]--;
        adjacencyList[f[i]].push_back({t[i], w[i]});
        adjacencyList[t[i]].push_back({f[i], w[i]});
    }

    ll answer = 0;

    function<void(ll, ll)> dfs1 = [&](ll u, ll parent) {
        size[u] = 1;
        ll idx = 0;
        while (idx < adjacencyList[u].size()) {
            ll vertex = adjacencyList[u][idx][0];
            ll weight = adjacencyList[u][idx][1];
            if (vertex != parent) {
                maxDistance[vertex] = maxValue(maxDistance[u] + weight, weight);
                dfs1(vertex, u);
                size[u] += size[vertex];
            }
            idx++;
        }
    };

    function<void(ll, ll)> dfs2 = [&](ll u, ll parent) {
        if (u != 0 && maxDistance[u] > v[u]) {
            answer += size[u];
        } else {
            ll idx = 0;
            while (idx < adjacencyList[u].size()) {
                ll vertex = adjacencyList[u][idx][0];
                if (vertex != parent) {
                    dfs2(vertex, u);
                }
                idx++;
            }
        }
    };

    dfs1(0, -1);
    dfs2(0, -1);

    return answer;
}

Cisco ✅
Minserver

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

int solve(int i, vector<int>& lst, int ad, const vector<int>& machineCount, const vector<int>& finalMachineCount, int shiftingCost) {
    int n = machineCount.size();
    if (i == n) {
        int res = ad;
        for (int k = 0; k < 3; ++k) {
            res += abs(lst[k] - finalMachineCount[k]);
        }
        return res;
    }
   
    int res = INT_MAX;
    res = min(res, solve(i + 1, lst, ad, machineCount, finalMachineCount, shiftingCost));
   
    for (int j = 0; j < 3; ++j) {
        lst[j] += machineCount[i];
        if (lst[j] - machineCount[i] != 0) {
            res = min(res, solve(i + 1, lst, ad + shiftingCost, machineCount, finalMachineCount, shiftingCost));
        } else {
            res = min(res, solve(i + 1, lst, ad, machineCount, finalMachineCount, shiftingCost));
        }
        lst[j] -= machineCount[i];
    }
   
    return res;
}

int getMinimumCost(const vector<int>& machineCount, const vector<int>& finalMachineCount, int shiftingCost) {
    vector<int> lst(3, 0);
    return solve(0, lst, 0, machineCount, finalMachineCount, shiftingCost);
}

GetMinimum Cost✅
Cisco