int kadanes(vector<int> vs){
    int n=vs.size();
    int maxsum=INT_MIN;
    int sum=0;
    for(int i=0;i<n;i++){
        sum+=vs[i];
        maxsum=max(maxsum,sum);
        if(sum<0) sum=0;
    }
    return maxsum;
}


int solve(vector<int> vs,int impactfactor){
    int maxsum=kadanes(vs);
    return maxsum*impactfactor;
}

Amazon ✅

Company Name: Rupeek
Role: IT Intern
Batch: 2024 passouts

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

Note: Apply ASAP! It can get closed anytime soon.

Make Best use of this opportunity

Company name: Spyne
Role: SDE Intern
Batch Eligible: 2025 passouts
Location: Gurgaon, India
https://spyneai.keka.com/careers/jobdetails/45578

📌FIS Global Hiring Interns

Batch: 2025 Passouts

💻Apply Link: https://careers.fisglobal.com/us/en/job/JR0285527/Intern-IT-Trainee-FIS-University-Program-2025

📌Siemens is hiring!
Position: Graduate Trainee Engineer

Experience: Freshers
Location: Bangalore, India (Hybrid)

💻Apply Now: https://jobs.siemens.com/careers/job/563156121684879?microsite=siemens.com

long howManySwaps(vector<int> arr) {
    auto mergeAndCount = [](vector<int>& arr, int left, int mid, int right) -> long {
        vector<int> temp(right - left + 1);
        int i = left, j = mid + 1, k = 0;
        long swaps = 0;
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
                swaps += (mid - i + 1);
            }
        }
        while (i <= mid) temp[k++] = arr[i++];
        while (j <= right) temp[k++] = arr[j++];
        for (int p = 0; p < temp.size(); p++) {
            arr[left + p] = temp[p];
        }

        return swaps;
    };
    function<long(vector<int>&, int, int)> mergeSortAndCount = [&](vector<int>& arr, int left, int right) -> long {
        long swaps = 0;
        if (left < right) {
            int mid = left + (right - left) / 2;
            swaps += mergeSortAndCount(arr, left, mid);
            swaps += mergeSortAndCount(arr, mid + 1, right);
            swaps += mergeAndCount(arr, left, mid, right);
        }
        return swaps;
    };
    return mergeSortAndCount(arr, 0, arr.size() - 1);
}

Wayfair ✅

def solve(arr):
    arr.sort()
    n = len(arr)
    e = arr[n // 2]
    a = sum(abs(x - e) for x in arr)
    return a

Qulatech ✅

Company Name : Swiggy
Role : Associate Software Engineer
Batch : 2024/2023/2022 passouts

Link : https://docs.google.com/forms/d/1E029cjZV8Em6zPC0YJYAMDDP_NjPtDkwufqHfvkVG2E/viewform?edit_requested=true&pli=1

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
  int n; cin >> n;
  vector<int> arr(n);
  for (int i = 0; i < n; i++) {
    cin >> arr[i];
  }

  vector<vector<int>>dp(n + 2, vector<int>(2));
  dp[1][1] = arr[0];
  for (int i = 2; i <= n; ++i)
  {
    dp[i][0] = max({dp[i - 1][1], dp[i - 1][0]});
    dp[i][1] = arr[i - 1] + max({dp[i - 1][0], dp[i - 2][0], dp[i - 2][1]});
  }

  cout << max(dp[n][1], dp[n][0]) << endl;
  return 0;
}

Kickdrum ✅

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

    int solution(int n,vector<int>&a){ 
     vector<int> p,neg; 
    for(int i = 0; i < n; i++) { 
        if(a[i] >= 0) { 
            p.push_back(a[i]); 
        } else { 
            neg.push_back(abs(a[i])); 
        } 
    } 

    sort(p.begin(), p.end()); 
    sort(neg.begin(), neg.end()); 
     
    int ans1=0; 
    int prev=0; 
    int cnt=n; 
    for(auto ele:p){ 
       int dis=ele-prev; 
       ans1+=dis*cnt; 
       prev=ele; 
       cnt--; 
    } 
    prev=0; 
    if(p.size()>0){ 
        int len2=p.size(); 
        prev=p[len2-1]; 
    } 

     
    for(int i=0;i<neg.size();i++){ 
        if(i==0){ 
            int dis= prev + neg[i]; 
            ans1+=dis*cnt; 
            cnt--; 
            prev=neg[i]; 
            continue; 
        } 
        int dis=neg[i]-prev; 
        ans1+=dis*cnt; 
        prev=neg[i]; 
        cnt--; 
    } 

    cnt=n; 
    int ans2=0; 

    prev=0; 
    for(auto ele:neg){ 
        int dis=ele-prev; 
        ans2+=dis*cnt; 
        prev=ele; 
        cnt--; 
    } 

    for(int i=0;i<p.size();i++){ 
        if(i==0){ 
            int dis= prev + p[i]; 
            ans2+=dis*cnt; 
            cnt--; 
            prev=p[i]; 
            continue; 
        } 
        int dis=p[i]-prev; 
        ans2+=dis*cnt; 
        prev=p[i]; 
        cnt--; 
    } 

    return min(ans1,ans2); 
}

int main() {
    int n;
    cin >> n;
    vector<int> a(n);

    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }

    cout << solution(n, a) << endl;

    return 0;
}

kickdrum ✅

#include <bits/stdc++.h>
using namespace std;
int findMinimumMoves(int C, int N) {
    vector<vector<int>> dp(C + 1, vector<int>(N + 1, 0));
    for (int n = 0; n <= N; n++) dp[1][n] = n;
    for (int c = 1; c <= C; c++) dp[c][0] = 0;
    for (int c = 2; c <= C; c++) {
        for (int n = 1; n <= N; n++) {
            int low = 1, high = n, result = n;
            while (low <= high) {
                int mid = (low + high) / 2;
                int breakCase = dp[c-1][mid-1];  
                int noBreakCase = dp[c][n-mid];  
                int worstCase = 1 + max(breakCase, noBreakCase);
                result = min(result, worstCase);
                if (breakCase > noBreakCase) {
                    high = mid - 1;
                } else {
                    low = mid + 1;
                }
            }
            dp[c][n] = result;
        }
    }

    return dp[C][N];
}

int main() {
    int C, N;
    cin >> C >> N;
    cout << findMinimumMoves(C, N) << endl;
    return 0;
}

Kickdrum ✅

#include<cstdio>
const int N=2e5+1;
long long r;
int i,j,k,n,a[N],f[N][2];
int t,en[N],fa[N],nxt[N];
void dfs(int u,int p)
{
int w=a[u]>>k&1,i=fa[u],v;
for(f[u][w]=1,f[u][w^1]=0;i;i=nxt[i])if((v=en[i])!=p)
{
dfs(v,u);
r+=(1ll*f[v][0]*f[u][1]+1ll*f[v][1]*f[u][0])<<k;
f[u][1]+=f[v][w^1],f[u][0]+=f[v][w];
}
}
int main()
{
scanf("%d",&n);
for(i=1;i<=n;r+=a[i++])
scanf("%d",a+i);
for(k=1;k<n;++k)
{
scanf("%d%d",&i,&j);
en[++t]=j,nxt[t]=fa[i],fa[i]=t;
en[++t]=i,nxt[t]=fa[j],fa[j]=t;
}
for(k=19;~k;--k)dfs(1,0);
printf("%I64d",r);
}

Titan ✅

📌Cybage Software is hiring for Software Engineer
Experience: 0 - 1 year
Expected Salary: 6-12 LPA
Apply here: https://www.linkedin.com/jobs/view/4080212254/?alternateChannel=search

📌Cargoa is hiring for Junior Full-Stack Developer
Experience: 0 - 1 year
Expected Salary: 3 LPA
Apply here: https://forms.microsoft.com/pages/responsepage.aspx?id=aJQTBBVzyEumXuMRdJrJIB0fvyqGGKxFlToyI_4r9UJUREQ0QUIzSUtRSlk1VUY4V1RCM0lHTThYRC4u&route=shorturl

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

using namespace std;

int maxMinDistance(vector<int>& x, int k) {
    sort(x.begin(), x.end());
    int low = 0, high = x.back() - x.front();
    int result = 0;

    while (low <= high) {
        int mid = (low + high) / 2;
        int count = 1;
        int lastPoint = x[0];

        for (int point : x) {
            if (point - lastPoint >= mid) {
                count++;
                lastPoint = point;
            }
        }

        if (count >= k) {
            result = mid;
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }

    return result;
}

//Optimal points selection ✅

https://forms.office.com/pages/responsepage.aspx?id=eDMbMYqOXkujP-gKPYumClSsrm1sEv1BmOXg5_0vsfxUODdYWFdHM01ZRlJHWVVFN1FUOE5DMTBSTS4u&route=shorturl

MBA 2024