Company – IIDE Education Private Limited
Role – Data Analyst Internship
Exp. – Fresher
Apply Here – https://internshala.com/internship/detail/data-analyst-internship-in-mumbai-at-iide-education-private-limited1720264879?utm_source=cp_link&referral=web_share

Company – Blackcoffer
Role – Data Science Internship
Exp. – Fresher
Apply Here – https://internshala.com/internship/details/work-from-home-data-science-internship-at-blackcoffer1720199867?utm_source=cp_link&referral=web_share

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

Company – White Gold Bullion Private Limited
Role – Mis Executive
Exp. – 0-3 yrs
Apply Here – https://www.foundit.in/job/mis-executive-white-gold-bullion-private-limited-bengaluru-bangalore-31074671?searchId=b0b11ba6-607b-4d50-91c9-b823e3ce49dd

Company – Blockchain for the Next Billion
Role – Data Analyst
Exp. – 0-5 yrs
Apply Here – https://www.linkedin.com/jobs/view/3966385446

Cogntix is hiring for Full Stack Engineer Intern | Hybrid Opportunity | 2023/2024 passout | 50k per month


https://docs.google.com/forms/d/e/1FAIpQLSc9AWJrl_zbV9VtNIWJj_n6EafHrR1-is_OdNY8BjIcZuX4TQ/viewform?usp=sf_link

class Solution {
public:
  int minOperations(vector<int>& nums, int x, int y) {
    int l = 0;
    int r = ranges::max(nums);

    while (l < r) {
      const int m = (l + r) / 2;
      if (isPossible(nums, x, y, m))
        r = m;
      else
        l = m + 1;
    }

    return l;
  }

private:
  bool isPossible(const vector<int>& nums, int x, int y, int m) {
    long long additionalOps = 0;
    for (const int num : nums)
      additionalOps += max(0LL, (num - 1LL * y * m + x - y - 1) / (x - y));
    return additionalOps <= m;
  }
};

Citadel ✅

bool isposs(vector<int>thr,vector<int>cost,int m,int budget){
    int co=0;
    for(int i=0;i<thr.size();i++){
        if(thr[i]<m){
            if((m-thr[i])%thr[i]==0)co+=((m-thr[i])/thr[i])*cost[i];
           else
            co+=(((m-thr[i])/thr[i])+1)*cost[i];
           
        }
        if(co>budget)return 0;
    }
    return 1;
}
int getMaximumThroughput(vector<int> throughput, vector<int> scaling_cost, int budget) {
priority_queue<int>pq;
int l=0;
// for(auto it:throughput)l=max(l,it);
int r=1e9;
int ans=0;
cout<<isposs(throughput,scaling_cost,6,budget);
while(l<=r){
   int mid=(l+r)/2;
   if(isposs(throughput,scaling_cost,mid,budget)){
       l=mid+1;
       ans=mid;
   }
   else r=mid-1;
}
return ans;
}

Citadel ✅

Micron ✅

We Are Hiring for 0-2 years!!!

Join us   to start your career in Investment banking.

Looking for BCom/M.com/BBA/BAF/BMS & BE/B.Tech (2022/2023/2024) Freshers or maximum 2years of experience.

Notice : 0-15/30 days


Please come prepared on : Capital Market, Derivative and it's types, Investment Banking, Types of market, KYC, AML, Accounting principles   .


Don't miss this opportunity to showcase your skills!

Email your resume to - Mrunal.Gore01.C@eclerx.com

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

const int mod = 1e9+7;
const int N = 1e5 + 5;
const int K = 18;

vector<int> get(vector<int> d){
    map<int, int> cnt, swp;
    for(int i = 0; i < d.size(); i++){
        cnt[d[i]]++;
    }
    vector<int> miss;
    for(int i = 1; i <= d.size(); i++){
        if(!cnt[i]) miss.pb(i);
    }

    vector<int> ans = d;
    int ind = 0;
    for(int i = 0; i < d.size(); i++){
        if(cnt[d[i]] > 1 || d[i] > d.size()){
            if(d[i] < miss[ind] && !swp[d[i]]){
                swp[d[i]] = 1;
            }
            else{
                ans[i] = miss[ind];
                ind++;
                cnt[d[i]]--;
            }
        }
    }

    return ans;
}


int32_t main(){
    cin.tie(0); cout.tie(0);
    ios_base::sync_with_stdio(false);
    int n;
    cin>>n;
    vector<int> a(n);
    for(int i = 0; i < n; i++){
        cin>>a[i];
    }

    vector<int> ans = get(a);
    for(int i = 0; i < n; i++){
        cout<<ans[i]<<endl;
    }
    return 0;
}

DE Shaw ✅

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

using namespace std;

void topologicalSort(int node, vector<bool>& visited, stack<int>& topoStack, const vector<vector<int>>& adj) {
    visited[node] = true;
    for (int neighbor : adj[node]) {
        if (!visited[neighbor]) {
            topologicalSort(neighbor, visited, topoStack, adj);
        }
    }
    topoStack.push(node);
}

int getMaxPhotoBeauty(int city_nodes, const vector<int>& photo_beauty, const vector<pair<int, int>>& edges) {
    vector<vector<int>> adj(city_nodes + 1);
    for (const auto& edge : edges) {
        adj[edge.first].push_back(edge.second);
    }

    stack<int> topoStack;
    vector<bool> visited(city_nodes + 1, false);

    for (int i = 1; i <= city_nodes; ++i) {
        if (!visited[i]) {
            topologicalSort(i, visited, topoStack, adj);
        }
    }

    vector<int> dp(city_nodes + 1, 0);
    for (int i = 1; i <= city_nodes; ++i) {
        dp[i] = photo_beauty[i - 1];
    }

    int max_beauty = 0;

    while (!topoStack.empty()) {
        int node = topoStack.top();
        topoStack.pop();

        for (int neighbor : adj[node]) {
            if (dp[neighbor] < dp[node] + photo_beauty[neighbor - 1]) {
                dp[neighbor] = dp[node] + photo_beauty[neighbor - 1];
            }
        }

        max_beauty = max(max_beauty, dp[node]);
    }

    return max_beauty;
}

DE Shaw ✅

int findMaxUses(vector<int>& costs, vector<int>& uses, int budget) {
    int n = costs.size();
   
    if (n < 2) {
        return -1;
    }
   
    vector<pair<int, int>> ft;
    for (int i = 0; i < n; ++i) {
        ft.push_back({costs[i], uses[i]});
    }
   
    sort(ft.begin(), ft.end());
    int maxUses = -1;

    int i = 0;
    while (i < n) {
        int j = i + 1;
        while (j < n) {
            int totalCost = ft[i].first + ft[j].first;
           
            if (totalCost <= budget) {
                int totalUses = ft[i].second + ft[j].second;
                maxUses = max(maxUses, totalUses);
                ++j;
            } else {
                break;
            }
        }
        ++i;
    }
   
    return maxUses;
}

DE Shaw ✅

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
int dfs(int node, vector<int>& likes, vector<int>& visited, vector<int>& stack, vector<int>& index, int& counter) {
    if (visited[node] == 2) {
        return 0;
    }
    if (visited[node] == 1) {
        return counter - index[node];
    }
    visited[node] = 1;
    stack.push_back(node);
    index[node] = counter++;
    int cycle_length = dfs(likes[node], likes, visited, stack, index, counter);
    if (cycle_length) {
        return cycle_length;
    }
    stack.pop_back();
    visited[node] = 2;
    counter--;
   
    return 0;
}
int maxCEOsAttend(int num, vector<int>& likes) {
    vector<int> visited(num, 0);
    vector<int> stack;
    vector<int> index(num, 0);
    int counter = 0;
    int max_cycle_length = 0;
    for (int i = 0; i < num; ++i) {
        if (!visited[i]) {
            int cycle_length = dfs(i, likes, visited, stack, index, counter);
            max_cycle_length = max(max_cycle_length, cycle_length);
        }
    }
    return max_cycle_length;
}
int main() {
    int num;
    cin >> num;
    vector<int> likes(num);
    for (int i = 0; i < num; ++i) {
        cin >> likes[i];
        likes[i]--;
    }
    cout << maxCEOsAttend(num, likes) << endl;
    return 0;
}