#define ll long long
using namespace std;
ll solve(ll A, ll B) {
    ll rounds = 0;
    while (A != B) {
        if (A > B) {
            A = A - B;
        } else {
            B = B - A;
        }
        rounds++;
    }
    return rounds;
}

int main() {
    ll A, B;
    cin >> A >> B;
    ll rounds = solve(A, B);
    cout << rounds << endl;
    return 0;
}

Flipkart ✅

import heapq

def dijkstra_with_cycle(nodes, roads_from, roads_to, roads_weight, start):
    n = len(nodes)
    distances = [float('inf')] * n
    prev_node = [-1] * n
    visited = [False] * n
    pq = [(0, start)]

    while pq:
        dist, node = heapq.heappop(pq)
        if visited[node]:
            continue
        visited[node] = True
        for i in range(len(roads_from)):
            if roads_from[i] == node:
                neighbor = roads_to[i]
                weight = roads_weight[i]
                if distances[node] + weight < distances[neighbor]:
                    distances[neighbor] = (distances[node] if node != start else 0) + weight
                    prev_node[neighbor] = node
                    heapq.heappush(pq, (distances[neighbor], neighbor))
                elif neighbor == start and distances[node] + weight < distances[start]:
                    distances[start] = distances[node] + weight
                    prev_node[start] = node
    return distances[start] if distances[start] != float('inf') else 0

Minimum Distance to reach home ✅

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

struct edge {
    int u, v, w;
    bool operator<(const edge& rhs) const {
        return w > rhs.w;
    }
};

vector<int> parent, rank_;

int find(int i) {
    if (i != parent[i])
        parent[i] = find(parent[i]);
    return parent[i];
}

void union_set(int i, int j) {
    int ri = find(i), rj = find(j);
    if (ri != rj) {
        if (rank_[ri] > rank_[rj])
            swap(ri, rj);
        parent[ri] = rj;
        if (rank_[ri] == rank_[rj])
            rank_[rj]++;
    }
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> cost(n);
    for (int i = 0; i < n; i++)
        cin >> cost[i];
    vector<edge> edges(m);
    for (int i = 0; i < m; i++) {
        cin >> edges[i].u >> edges[i].v >> edges[i].w;
        edges[i].u--; edges[i].v--;
    }
    parent.resize(n);
    rank_.resize(n);
    for (int i = 0; i < n; i++)
        parent[i] = i;
    priority_queue<edge> pq;
    for (int i = 0; i < n; i++)
        for (int j = i+1; j < n; j++)
            pq.push({i, j, cost[i] + cost[j]});
    for (auto& e : edges)
        pq.push(e);
    int total_cost = 0;
    while (!pq.empty()) {
        edge e = pq.top();
        pq.pop();
        if (find(e.u) != find(e.v)) {
            total_cost += e.w;
            union_set(e.u, e.v);
        }
    }
    cout << total_cost << endl;
    return 0;
}

Connect the country 2✅

#include <vector>
#include <map>
#include <algorithm>

const long INF = LONG_MAX / 10;

long dfs(int i, const vector<int>& cost, int timeSoFar, const vector<int>& time, vector<map<int, long>>& memo) {
    int n = cost.size();
    if (i == n) return timeSoFar >= 0 ? 0 : INF;
    if (timeSoFar >= n - i) return 0;
    if (memo[i].count(timeSoFar)) return memo[i][timeSoFar];
    long resPaid = cost[i] + dfs(i + 1, cost, timeSoFar + time[i], time, memo); // paid server
    long resFree = dfs(i + 1, cost, timeSoFar - 1, time, memo); // free server
    memo[i][timeSoFar] = min(resPaid, resFree);
    return memo[i][timeSoFar];
}

long getMinCost(const vector<int>& cost, const vector<int>& time) {
   
    vector<map<int, long>> memo(cost.size());
    return dfs(0, cost, 0, time, memo);
}

Task Scheduling✅

def largestArea(samples):
    R = len(samples)
    C = len(samples[0])
    S = [[0] * C for _ in range(R)]
    M = [[0] * C for _ in range(R)]

    for d in range(R):
        for b in range(C):
            M[d][b] = samples[d][b]

    for i in range(R):
        S[i][0] = M[i][0]

    for j in range(C):
        S[0][j] = M[0][j]

    for i in range(1, R):
        for j in range(1, C):
            if M[i][j] == 1:
                S[i][j] = min(S[i][j-1], min(S[i-1][j], S[i-1][j-1])) + 1
            else:
                S[i][j] = 0

    max_of_s = S[0][0]
    max_i = 0
    max_j = 0
    for i in range(R):
        for j in range(C):
            if max_of_s < S[i][j]:
                max_of_s = S[i][j]
                max_i = i
                max_j = j

    return abs(max_i - max_of_s) - max_i

Product Defects ✅

https://app.joinsuperset.com/join/#/signup/student/jobprofiles/a35e2ea9-6219-423b-80e9-bbbc40297cfe

Last Date : 17 April ✅

Company – DueToHQ
Role – Business Analytics Internship
Exp. – Fresher
Apply Here – https://internshala.com/internship/details/work-from-home-business-analytics-internship-at-duetohq1713164431?utm_source=cp_link&referral=web_share

Company – PapaSiddhi
Role – Machine Learning Development
Exp. – Fresher
Apply Here – https://internshala.com/internship/details/machine-learning-development-internship-in-udaipur-at-papasiddhi1713153810?utm_source=cp_link&referral=web_share

Company – Ozibook Tech Solutions Private Limited
Role – Data Analytics Internship
Exp. – Fresher
Apply Here – https://internshala.com/internship/details/work-from-home-part-time-data-analytics-internship-at-ozibook-tech-solutions-private-limited1713066596?utm_source=cp_link&referral=web_share

ll solve(vector<ll>& a) {
    unordered_map<ll, ll> c;
    ll l = 0, r = 0;
    ll m = 0;
    while (r < a.size()) {
        c[a[r]]++;
        while (c.size() > 2) {
            if (--c[a[l]] == 0) {
                c.erase(a[l]);
            }
            l++;
        }
        m = max(m, r - l + 1);
        r++;
    }
    return m;
}

Longest Subarray ✅

https://www.onlinegdb.com/8LldNBw1J

Blacklisted IP✅

Sequence Sum
JPMC✅

Travel and Tour Company ✅

Maruti Suzuki All India Hiring Test:

Role: Assistant Manager

Graduation Year: 2022

Degree: B.Tech / M.Tech

Eligible Branches: Mechanical, Automobile, Civil, Electrical, Electronics, Mechatronics and Tool & Die

Age: 21 to 27 years

Work Experience: 12 to 22 months

Selection Process:
1. Profile Shortlisting
2. Online Test (Technical, Aptitude & Psychometric)
3. Personal Interview (Technical + HR)
4. Offer
5. Medical Test
6. Joining

B.Tech CTC: 10.34 LPA (8.3 LPA - Fixed)
M.Tech CTC: 10.99 LPA (8.85 LPA Fixed)

Location: PAN - India

Apply Link: https://maruti.app.param.ai/jobs/all-india-hiring-ait-2024-btech-and-mtech


Last Date to Apply: 21st April 2024

private static double[] calculateMovingAverage(int[] array, int K) {
        double[] smoothedArray = new double[array.length - K + 1];
        double sum = 0;

      
        for (int i = 0; i < K; i++) {
            sum += array[i];
        }

      
        for (int i = 0; i <= array.length - K; i++) {
            if (i > 0) {
              
                sum = sum - array[i - 1] + array[i + K - 1];
            }
            smoothedArray[i] = sum / K;
        }

        return smoothedArray;
    }

Moving Averages✅

Company Name: Global Payments

🛄 Job Title: Associate Software Engineer

✍🏻 YOE: 0-1 years


➡️ Apply: https://jobs.globalpayments.com/en/jobs/r0048707/associate-software-engineer/

Please do share in your college grps and in case you are applying please react on this post:) 😇❤️