DOW Hiring Campus Internship 2024-2025 - Information Systems

https://dow.wd1.myworkdayjobs.com/ExternalCareers/job/Navi-Mumbai-IND/Campus-Internship-2024-2025---Information-Systems_R2054719?src=JB-14000

https://onlinegdb.com/wPRpQuo6u

Serializable Hash Map ✅

int findMaximumGreatness( vector<int>&arr) {
    int n = arr.size()
    vector<int>v = arr;
    sort(begin(v), end(v));
    sort(begin(arr), end(arr));
    int ans = 0;
    int i = n - 1, j = n - 1;
    while (i >= 0 && j >= 0) {
        if (v[i] > arr[j]) {
            ans++;
            i--;
            j--;
        }
        else {
            j--;
        }
    }
    return ans;
}

UKG ✅

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
const int MOD = 1000000007;
using namespace std;
void dfs(int node, const unordered_map<int, vector<pair<int, int>>>& tree, vector<long long>& magnitudes) {
    auto it = tree.find(node);
    if (it != tree.end()) {
        for (const auto& neighbor : it->second) {
            int next_node = neighbor.first;
            int weight = neighbor.second;
            magnitudes[next_node] = (magnitudes[node] * weight) % MOD;
            dfs(next_node, tree, magnitudes);
        }
    }
}

vector<int> findEquivalentMagnitude(int unit_nodes, vector<int> unit_from, vector<int> unit_to, vector<int> unit_weight, int x) {
    unordered_map<int, vector<pair<int, int>>> tree;
    for (int i = 0; i < unit_from.size(); ++i) {
        tree[unit_from[i]].emplace_back(unit_to[i], unit_weight[i]);
    }
    vector<long long> magnitudes(unit_nodes + 1, -1);
    magnitudes[1] = x;

    dfs(1, tree, magnitudes);

    vector<int> result(unit_nodes);
    for (int i = 1; i <= unit_nodes; ++i) {
        result[i - 1] = magnitudes[i];
    }

    return result;
}

UKG✅

Company Name: Zeta
Role: SDE 1 (Backend) and SDE 1 (Frontend)

Experience Required: 0-1 years
Apply:

1) Backend: https://jobs.lever.co/zeta/f7a35ddf-fb28-4098-886b-156460082cb7
2) Frontend: https://jobs.lever.co/zeta/719928df-d136-41a0-93e8-2ca93bad96ee

Company Name: Bentley
Role: Associate Software Quality Analyst (QA Profile)

Batch eligible: 2023 and 2024 grads

Apply: https://jobs.bentley.com/job/Kolkata-Associate-Software-Quality-Analyst/1175269200/

Email: hr@webinfinitesolutions.com
Contact: +919465532412

Send your updated resume at:
hr@trioangle.com

Company Name: The Trade Desk

Role: Software Engineering Intern

Batch eligible: 2025 grads (2026 grads can also try)

Apply: https://boards.greenhouse.io/thetradedesk/jobs/4435073007

public static int countMeetings(int[] firstDay, int[] lastDay) {
        int n = firstDay.length;
        TreeSet<Integer> availableDays = new TreeSet<>();
        for (int i = 1; i <= 100000; i++) {
            availableDays.add(i);
        }
       
        int count = 0;
        for (int i = 0; i < n; i++) {
            int start = firstDay[i];
            int end = lastDay[i];
            Integer day = availableDays.ceiling(start);
            if (day != null && day <= end) {
                count++;
                availableDays.remove(day);
            }
        }
       
        return count;
    }

Standard chartered ✅

WE'RE NOW ON DISCORD ❤

OUR Coding Community ✨

We've launched our new discord server, you all can join there ASAP

Here's the exclusive link 🔗

https://discord.gg/5YrwWzaF


Join fast. See you all ❤

class Investment:
    @staticmethod
    def times_of_investment(input1, input2):
        A = sum(input2)
        Res = 0
        while A % 2 == 0 and A != 0:
            A //= 2
            Res += 1
        return Res

Profit Group
OLA✅

Company Name: ADP
Role: Associate Software Engineer

Batch eligible: 2024 and 2025 grads

Apply: https://tech.adp.com/en/jobs/5001062749106/associate-software-engineer/

int mrt2(const string& st) {
    int n = st.length();
    vector<vector<int>> lst(n, vector<int>(n, 0));
    for (int i = 0; i < n; ++i)
        lst[i][i] = 1;

    for (int k = 2; k <= n; ++k) {
        for (int i = 0; i <= n - k; ++i) {
            int j = i + k - 1;
            if (st[i] == st[j]) {
                if (k == 2)
                    lst[i][j] = 2;
                else
                    lst[i][j] = lst[i + 1][j - 1] + 2;
            } else {
                lst[i][j] = max(lst[i + 1][j], lst[i][j - 1]);
            }
        }
    }
    return lst[0][n - 1];
}

int delete_op(const string& st) {
    int n = st.length();
    int lps = mrt2(st);
    return n - lps;
}

bool rearrange(const string& S) {
    unordered_map<char, int> freq;
    for (char c : S) {
        freq[c]++;
    }

    int odd_count = 0;
    for (auto& p : freq) {
        if (p.second % 2 == 1)
            odd_count++;
    }

    return odd_count <= 1;
}

vector<int> mrt(const string& S, const vector<pair<int, int>>& arr) {
    vector<int> res;
    for (auto& range : arr) {
        string temp = S.substr(range.first - 1, range.second - range.first + 1);
        int result = rearrange(temp) ? 0 : delete_op(temp);
        res.push_back(result);
    }
    return res;
}

String and queries
OLA✅

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int minimizeDiff(int a, vector<int>& b) {
    int c = b.size();
    int d = *max_element(b.begin(), b.end());
    int e = *min_element(b.begin(), b.end());
    if ((d - e) <= a) {
        return (d - e);
    }
    int f = (d + e) / 2;
    for (int g = 0; g < c; g++) {
        if (b[g] > f) {
            b[g] -= a;
        } else {
            b[g] += a;
        }
    }
    d = *max_element(b.begin(), b.end());
    e = *min_element(b.begin(), b.end());
    return (d - e);
}

ICE CREAM Sticks ✅
Intuit

Russian Doll ✅
Intuit