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

const int MOD = 1e9 + 7;

int F(int i, int k, int n, vector<int> &level, vector<int> &dp) {
    if (i == n) return 1;
    if (dp[i] != -1) return dp[i];
    int ans = 0, odds = 0;
    vector<int> hash(n + 10, 0);
    for (int j = i; j < n; j++) {
        if (++hash[level[j]] % 2 == 0) odds -= 1;
        else odds += 1;
        if (odds <= k) {
            ans = (ans + F(j + 1, k, n, level, dp)) % MOD;
        }
    }
    return dp[i] = ans;
}

int countValidPartitions(vector<int> level, int k) {
    int n = level.size();
    vector<int> dp(n, -1);
    return F(0, k, n, level, dp);
}

DE Shaw ✅

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

int getMaxMedian(vector<int> lower_bound, vector<int> upper_bound, long int max_sum) {
    int n = lower_bound.size();
    long long curr_sum = 0;
    for (int i = 0; i < n; ++i) {
        curr_sum += lower_bound[i] + upper_bound[i];
    }
    int num_elements = 2 * n;
    long long target_sum = curr_sum + max_sum;
    sort(upper_bound.begin(), upper_bound.end());
    int median_index = num_elements / 2;
    int left = 1, right = INT_MAX;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        long long sum = 0;
        for (int i = 0; i < n; ++i) {
            if (upper_bound[i] <= mid) {
                sum += upper_bound[i];
            } else {
                sum += mid;
            }
        }
        if (sum <= target_sum) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return right;
}

int main() {
    int n;
    cin >> n;
    vector<int> lower_bound(n);
    vector<int> upper_bound(n);
    for (int i = 0; i < n; ++i) {
        cin >> lower_bound[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> upper_bound[i];
    }
    long int max_sum;
    cin >> max_sum;
    int max_median = getMaxMedian(lower_bound, upper_bound, max_sum);
    cout << max_median << endl;
    return 0;
}

DE Shaw ✅

#include <iostream>
#include <vector>

using namespace std;

int findSingleSock(vector<int>& socks) {
    int result = 0;
    for (int num : socks) {
        result ^= num;
    }
    return result;
}

int main() {
    int N;
    cin >> N;

    vector<int> socks(N);
    for (int i = 0; i < N; ++i) {
        cin >> socks[i];
    }

    int singleSock = findSingleSock(socks);
    cout << singleSock << endl;

    return 0;
}

Missing sock ✅

def sort_words(N):
    words = N.split(", ")
    sorted_words = sorted(words)
    result = ", ".join(sorted_words)
    return result

Words in dictionary ✅

#define ll long long
#define MAXN 100005
#define INF 1000000007

using namespace std;

void removeDuplicates(vector<string>& words) {
    unordered_set<string> seen;
    vector<string> result;

    for (const string& word : words) {
        if (seen.find(word) == seen.end()) {
            result.push_back(word);
            seen.insert(word);
        }
    }

    for (const string& word : result) {
        cout << word << " ";
    }
    cout << "\n";
}

int main() {
    ll t;
    cin >> t;

    while (t--) {
        ll n;
        cin >> n;

        vector<string> words(n);
        for (ll i = 0; i < n; i++) {
            cin >> words[i];
        }

        removeDuplicates(words);
    }

    return 0;
}

Flipkart ✅

def probability_comparison(L1, R1, L2, R2):
    alice_wins = 0
    for i in range(L1, R1+1):
        for j in range(L2, R2+1):
            if i > j:
                alice_wins += 1
   
    total_outcomes = (R1 - L1 + 1) * (R2 - L2 + 1)
   
    if alice_wins > total_outcomes / 2:
        return "YES"
    else:
        return "NO"
L1, R1, L2, R2 = map(int, input().split())
print(probability_comparison(L1, R1, L2, R2))

Flipkart ✅

#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 ✅