Company – DeepThought Edutech Ventures Private Limited
Role – Business Analytics Intern
Exp. – Fresher
Apply Here – https://internshala.com/internship/detail/work-from-home-part-time-business-analytics-internship-at-deepthought-edutech-ventures-private-limited1725760545?utm_source=cp_link&referral=web_share

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

Hi all,
We are hiring for an M Tech VLSI freshers for the Bangalore location. If anyone is interested, Kindly drop your CV to kurigilaramya@juntrantech.com
Qualification: MTech in VLSI design/Embedded/Tele Communication/ECE
Pass out Year : >2023 & 2024
Good communication skills
Notice period_0-30 days

Company: Rapydlaunch | B2B SaaS Marketplace
Role: SDE Intern (MERN stack)
Batch: 2026 (CS/IT)
Apply: sending your resume to aman@rapydlaunch.com or abhishek@rapydlaunch.com (Founder’s email)

https://motorolasolutions.wd5.myworkdayjobs.com/Careers/job/Bangalore-India/Internship-Trainee_R48108/apply/autofillWithResume?source=Linkedin

Motorola Solutions hiring Intern Trainee

Company: Zomato
Role: Multiple (Intern till senior engineers)
Skillset: AI/ML (GenAI , LLMs)
Apply: Send an email with a brief on your work, projects, and your resume to genaihiring@zomato.com

int findMaximumLength(vector<int>& nums){
    int n = nums.size();
    if (n == 0)
        return 0;

    vector<long long> prefix(n), last(n), dp(n, 1);

    prefix[0] = nums[0];
    for (int i = 1; i < n; i++) {
        prefix[i] = prefix[i - 1] + nums[i];
    }

    last[0] = nums[0];

    for (int i = 1; i < n; i++) {
        bool found = false;
        for (int j = i - 1; j >= 0; j--) {
            if (prefix[i] >= last[j] + prefix[j]) {
                dp[i] = dp[j] + 1;
                last[i] = prefix[i] - prefix[j];
                found = true;
                break;
            }
        }

        if (!found){
            last[i] = prefix[i];
        }
    }

    return dp[n - 1];
}
Subarray Sum operation ✅
Airtel

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

using namespace std;

const int MAXN = 1e5 + 5;

class SegmentTree {
private:
    vector<int> tree, lazy;
    int n;

    void build(int node, int start, int end) {
        if (start == end) {
            tree[node] = 0;
            return;
        }
        int mid = (start + end) / 2;
        build(2 * node, start, mid);
        build(2 * node + 1, mid + 1, end);
        tree[node] = max(tree[2 * node], tree[2 * node + 1]);
    }

    void push(int node, int start, int end) {
        if (lazy[node] != 0) {
            tree[node] += lazy[node];
            if (start != end) {
                lazy[2 * node] += lazy[node];
                lazy[2 * node + 1] += lazy[node];
            }
            lazy[node] = 0;
        }
    }

    void update(int node, int start, int end, int l, int r, int val) {
        push(node, start, end);
        if (start > r || end < l) return;
        if (l <= start && end <= r) {
            lazy[node] += val;
            push(node, start, end);
            return;
        }
        int mid = (start + end) / 2;
        update(2 * node, start, mid, l, r, val);
        update(2 * node + 1, mid + 1, end, l, r, val);
        tree[node] = max(tree[2 * node], tree[2 * node + 1]);
    }

    pair<int, int> query(int node, int start, int end, int l, int r) {
        push(node, start, end);
        if (start > r || end < l) return {-1, -1};
        if (l <= start && end <= r) return {tree[node], start};
        int mid = (start + end) / 2;
        pair<int, int> left = query(2 * node, start, mid, l, r);
        pair<int, int> right = query(2 * node + 1, mid + 1, end, l, r);
        if (left.first >= right.first) return left;
        return right;
    }

public:
    SegmentTree(int size) : n(size) {
        tree.resize(4 * n);
        lazy.resize(4 * n);
        build(1, 0, n - 1);
    }

    void update(int l, int r, int val) {
        update(1, 0, n - 1, l, r, val);
    }

    pair<int, int> query(int l, int r) {
        return query(1, 0, n - 1, l, r);
    }
};

void solve(int N, int Q, vector<vector<int>>& queries) {
    SegmentTree st(N + 1);

    for (const auto& query : queries) {
        int type = query[0];
        if (type == 1 || type == 2) {
            int L = query[1], R = query[2];
            st.update(L, R, 1);
        } else if (type == 3) {
            int C = query[1];
            pair<int, int> result = st.query(C, N);
            cout << result.second << '\n';
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
   
    int T;
    cin >> T;

    while (T--) {
        int N, Q;
        cin >> N >> Q;

        vector<vector<int>> queries(Q);
        for (int i = 0; i < Q; ++i) {
            int type;
            cin >> type;
            if (type == 1 ) {
                int L=1, R;
                cin >> R;
                queries[i] = {type, L, R};
            }
            else if (type == 2) {
                int L, R=N;
                cin >> L ;
                queries[i] = {type, L, R};
            }
             else {
                int C;
                cin >> C;
                queries[i] = {type, C};
            }
        }

        solve(N, Q, queries);
    }

    return 0;
}

Maximum Product Sales ✅

Company Name: Morgan Stanley
Role: Technology Spring Analyst Program (Intern)
Batch eligible: 2025 grads only
Duration: 6 months

Apply: https://www.morganstanley.com/careers/students-graduates/opportunities/17980

Company Name: Morgan Stanley
Role: Technology Summer Analyst Program (Intern)
Batch eligible: 2026 grads only
Duration: 2 months

Apply: https://www.morganstanley.com/careers/students-graduates/opportunities/17979

public class Solution {
    public static int countOfElement(int[] listInput1, int[] listInput2) {
        HashSet<Integer> set1 = new HashSet<>();
        HashSet<Integer> set2 = new HashSet<>();

     
        for (int num : listInput1) {
            set1.add(num);
        }

       
        for (int num : listInput2) {
            set2.add(num);
        }

      
        int count = 0;
        for (int num : listInput1) {
            if (!set2.contains(num)) {
                count++;
            }
        }
        for (int num : listInput2) {
            if (!set1.contains(num)) {
                count++;
            }
        }

        return count;
    }
}

class UserMainCode(object):
    @classmethod
    def qualifyingScore(cls, total_scores, num_top_scores, scores, weights):
        weighted_scores = [score -weight for score, weight in zip(scores, weights)]
        weighted_scores.sort(reverse=True)
        top_scores_sum = sum(weighted_scores[:num_top_scores])
        if top_scores_sum >= 35:
            return f"Qualified {top_scores_sum}"
        else:
            return f"Disqualified {top_scores_sum}"

Qualifying Score ✅

class UserMainCode(object):
    @classmethod
    def hikeTrial(cls, input1):
        mod = 10000007
        input1 = input1.upper()
        n, m = input1.split()
        n = int(n)
        multi = {'D': 70, 'P': 100, 'Y': 10}
        result = (n * multi[m]) % mod
        return result

Money Conversion ✅
Optum

void replaceValues(int SIZE, int arr[])
{
    int i=0;
    while(i<SIZE){
        if(SIZE%2==0){
            arr[i]=0;
        }
        else{
            arr[i]=1;
        }
        i+=1;
    }
}

Morgan Stanley ✅

def sameElementCount(size, inputList):
    return sum(inputList[i] % 2 == 0 and inputList[i] == inputList[i + 1] for i in range(size - 1))

Morgan Stanley ✅

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

using namespace std;

int ss(int a, vector<int>& b, int c, int s) {
    sort(b.begin(), b.end());
    int count = 0;
    for (int i = 0; i < a; ++i) {
        int current_capacity = b[i];
                int low = c - current_capacity;
        int high = s - current_capacity;
        
        auto left_index = lower_bound(b.begin() + i + 1, b.end(), low);
        auto right_index = upper_bound(b.begin() + i + 1, b.end(), high);
        
        // Count valid pairs
        count += distance(left_index, right_index);
    }

    return count;
}

int main() {
    int a;  
    cin >> a;
    
    vector<int> b(a);
    for (int i = 0; i < a; ++i) {
        cin >> b[i];
    }
    
    int c, s; 
    cin >> c >> s;
    
    cout << ss(a, b, c, s) << endl;

    return 0;
}

MS electic power✅
Morgan Stanley

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

using namespace std;

class node {
public:
    long long ind;
    char c;
    long long t; 

    node() {}

    node(long long ind, char c, long long t) {
        this->ind = ind;
        this->c = c;
        this->t = t;
    }
};

bool cmp(const node &a, const node &b) {
    return a.ind < b.ind;
}

vector<string> fun(int n, vector<pair<int, char>> messages) {
    vector<node> v(n);
    for (int i = 0; i < n; i++) {
        long long ind = messages[i].first;
        char c = messages[i].second;
        long long t = i; 
        node temp(ind, c, t);
        v[i] = temp;
    }

    sort(v.begin(), v.end(), cmp);

    vector<pair<long long, string>> check; 
    vector<string> ans;

    for (int i = 0; i < n; i++) {
        if (v[i].c == '*') {
            int j = i + 1;
            while (j < n && v[j].c != '*' && v[j - 1].ind + 1 == v[j].ind) j++;
            if (j < n && v[j].c == '*') {
                long long mx = 0; 
                string temp = "";
                for (int k = i + 1; k < j; k++) temp.push_back(v[k].c);
                for (int k = i; k <= j; k++) mx = max(mx, v[k].t);
                check.push_back({mx, temp});
            }
        }
    }

    sort(check.begin(), check.end(), [](const pair<long long, string> &a, const pair<long long, string> &b) {
        return a.first > b.first; 
    });

    for (const auto &entry : check) ans.push_back(entry.second);

    return ans;
}

int main() {
    vector<pair<int, char>> in = {{693232583, '*'}, {1, '*'}, {2, 'a'}, {693232585, '*'}, {3, '*'}, {693232584, 'w'}};
    int n = in.size();

    vector<string> result = fun(n, in);

    for (const string &str : result) {
        cout << str << endl;
    }

    return 0;
}

Message passing ✅
Morgan Stanley

Times internet is hiring software engineer
Exp : 0-1 years

Link : https://www.linkedin.com/feed/update/urn:li:activity:7239244367142469634

Idea Forage is hiring Engineer

For 2022, 2023, 2024 grads
Location: Bangalore

https://app.webbtree.com/company/ideaforge/jobs/engineer-i-e569b3?utm_campaign=linkedin_ll_jobs_apply&utm_source=linkedin_ll&utm_medium=organic