Cognizant Mass Hiring

https://app.joinsuperset.com/join/#/signup/student/jobprofiles/b643e525-c83b-4505-9a10-a666be44f249

🚀 Exciting Internship Opportunity at T-Systems! 🚀
Are you a 2024 graduate looking to kickstart your career with hands-on industry experience? 🌟 T-Systems is hiring interns for various exciting roles.
✅ Who can apply?
Graduates with 60% or more throughout their 10th, 12th, Graduation/Post Graduation.
Degree in BCS, BSc, MSc, MCA, BE, BTech, or MBA.
Passout year: 2024 only

🏙 Locations: Pune or Bangalore
🕒 Internship Duration: 3-6 months

Apply here: https://smrtr.io/nvkHg

https://boards.greenhouse.io/thetradedesk/jobs/4435073007?gh_src=1c01b2067us&source=LinkedIn

2025 and 2026 are eligible

https://jobs.revvity.com/en/job/-/-/20539/70766350240

Apply Using referral

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int K = sc.nextInt(); 
        int N = sc.nextInt(); 
        int[] commands = new int[N];
        for (int i = 0; i < N; i++) {
            commands[i] = sc.nextInt(); 
        }
        int[] dx = {0, 1, 0, -1};  
        int[] dy = {1, 0, -1, 0}; 
        int x = 0, y = 0;  
        int dir = 0;  
        int totalX = 0, totalY = 0;
        for (int i = 0; i < N; i++) {
            x += commands[i] * dx[dir];
            y += commands[i] * dy[dir];
            dir = (dir + 1) % 4;
        }
        totalX = x;
        totalY = y;
        int finalX = totalX * K;
        int finalY = totalY * K;
        System.out.println(Math.abs(finalX) + Math.abs(finalY));

        sc.close();
    }
}

Autonomous Car AI✅
Intuit

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
                int N = sc.nextInt();
        
        char[] colors = {'R', 'O', 'Y', 'G', 'B', 'I', 'V'};
                Set<Character> usedColors = new HashSet<>();
                for (int i = 0; i < N; i++) {
            int canNumber = sc.nextInt();
            char color = colors[(canNumber - 1) % 7];
            usedColors.add(color);
        }
    System.out.println(usedColors.size());
        
        sc.close();
    }
}

Colors of the Rainbow ✅
Intuit

https://boards.greenhouse.io/thetradedesk/jobs/4435073007?gh_src=1c01b2067us&source=LinkedIn

2025 and 2026 are eligible

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;
int findMinSum(const vector<int>& arr, int z, int k) {
    int n = arr.size();
    int minSum = k + 1; 
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            for (int a = 0; a <= k; ++a) {
                int rem = z - a * arr[i];
                if (rem < 0) break; 
                if (rem % arr[j] == 0) {
                    int b = rem / arr[j];
                    if (a + b <= k) {
                        minSum = min(minSum, a + b);
                    }
                }
            }
        }
    }

    return (minSum <= k) ? minSum : -1;
}

vector<int> solve(const vector<int>& arr, const vector<int>& query, int k) {
    vector<int> result;

    for (int z : query) {
        int minSum = findMinSum(arr, z, k);
        result.push_back(minSum);
    }

    return result;
}

Solving linear Equation✅

#include <bits/stdc++.h>
using namespace std;

using ll = long long; 
const ll INF = LLONG_MAX;

vector<ll> dijkstra(int n, int src, const vector<vector<pair<int, int>>>& adj) {
    vector<ll> dist(n, INF);
    dist[src] = 0;
    priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<>> pq;
    pq.push({0, src});

    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();

        if (d > dist[u]) continue;

        for (auto [v, cost] : adj[u]) {
            if (dist[u] + cost < dist[v]) {
                dist[v] = dist[u] + cost;
                pq.push({dist[v], v});
            }
        }
    }

    return dist;
}

vector<vector<ll>> shortest(int nodes, const vector<int>& deliveries, const vector<vector<pair<int, int>>>& adj) {
    int k = deliveries.size();
    vector<vector<ll>> dist(k, vector<ll>(nodes));

    for (int i = 0; i < k; ++i) {
        dist[i] = dijkstra(nodes, deliveries[i], adj);
    }

    return dist;
}

ll minTime(int nodes, int k, const vector<ll>& startDist, const vector<vector<ll>>& dist, const vector<int>& deliveries) {
    vector<vector<ll>> dp(1 << k, vector<ll>(k, INF));

    for (int i = 0; i < k; ++i) {
        dp[1 << i][i] = startDist[deliveries[i]];
    }

    for (int mask = 0; mask < (1 << k); ++mask) {
        for (int i = 0; i < k; ++i) {
            if (mask & (1 << i)) {
                for (int j = 0; j < k; ++j) {
                    if (!(mask & (1 << j))) {
                        dp[mask | (1 << j)][j] = min(dp[mask | (1 << j)][j], dp[mask][i] + dist[i][deliveries[j]]);
                    }
                }
            }
        }
    }

    ll minTime = INF;
    for (int i = 0; i < k; ++i) {
        minTime = min(minTime, dp[(1 << k) - 1][i] + dist[i][0]);
    }

    return minTime;
}

long long getMinimumTime(int n, vector<int> from, vector<int> to, vector<int> weight, vector<int> del) {
    int m = from.size(); 
    vector<vector<pair<int, int>>> adj(n);

    for (int i = 0; i < m; ++i) {
        adj[from[i]].emplace_back(to[i], weight[i]);
        adj[to[i]].emplace_back(from[i], weight[i]);
    }

    vector<ll> start = dijkstra(n, 0, adj);
    vector<vector<ll>> dist = shortest(n, del, adj);

    ll mini = minTime(n, del.size(), start, dist, del);
    return (mini == INF) ? -1 : mini;
}

Optimizing Delivery ✅