๐—–๐—ฆ ๐—”๐—น๐—ด๐—ผ ๐Ÿ’ป ๐ŸŒ ใ€Ž๐—–๐—ผ๐—บ๐—ฝ๐—ฒ๐˜๐—ถ๐˜๐—ถ๐˜ƒ๐—ฒ ๐—ฃ๐—ฟ๐—ผ๐—ด๐—ฟ๐—ฎ๐—บ๐—บ๐—ถ๐—ป๐—ดใ€
9.57K subscribers
5.58K photos
3 videos
95 files
9.94K links
๐ŸšฉMain Group - @SuperExams
๐Ÿ“Job Updates - @FresherEarth

๐Ÿ”ฐAuthentic Coding Solutions(with Outputs)
โš ๏ธDaily Job Updates
โš ๏ธHackathon Updates & Solutions

Buy ads: https://telega.io/c/cs_algo
Download Telegram
#include <bits/stdc++.h>
using namespace std;
void solve() {
    int T;
    cin >> T;
    while (T--) {
        int n, x;
        cin >> n >> x;
        vector<int> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        vector<int> remainderCount(x, 0);
        for (int i = 0; i < n; i++) {
            remainderCount[a[i] % x]++;
        }
        int pairs = 0;
        pairs += remainderCount[0] / 2;
        for (int r = 1; r <= x / 2; r++) {
            if (r == x - r) {
                pairs += remainderCount[r] / 2;
            } else {
                int minCount = min(remainderCount[r], remainderCount[x - r]);
                pairs += minCount;
                remainderCount[r] -= minCount;
                remainderCount[x - r] -= minCount;
            }
        }
        cout << pairs * 2 << endl;
    }
}

int main() {
    solve();
    return 0;
}


christmas celebration โœ…
๐—–๐—ฆ ๐—”๐—น๐—ด๐—ผ ๐Ÿ’ป ๐ŸŒ ใ€Ž๐—–๐—ผ๐—บ๐—ฝ๐—ฒ๐˜๐—ถ๐˜๐—ถ๐˜ƒ๐—ฒ ๐—ฃ๐—ฟ๐—ผ๐—ด๐—ฟ๐—ฎ๐—บ๐—บ๐—ถ๐—ป๐—ดใ€
Photo
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll solve(ll n, ll m, vector<vector<string>>& c) {
    vector<vector<ll>> g1(n), g2(n);
    vector<ll> d1(n, 0), d2(n, 0);
    for (const auto& t : c) {
    if (t[0] == "x") {
    ll a = stoll(t[1]) - 1;
    ll b = stoll(t[2]) - 1;
    g1[a].push_back(b);
    d1[b]++;
    } else if (t[0] == "y") {
    ll a = stoll(t[1]) - 1;
    ll b = stoll(t[2]) - 1;
    g2[a].push_back(b);
    d2[b]++;
        }
    }

    auto ts = [&](vector<vector<ll>>& g, vector<ll>& d) -> vector<ll> {
    queue<ll> q;
    for (ll i = 0; i < n; i++) {
    if (d[i] == 0) q.push(i);
    }
    vector<ll> o;
    while (!q.empty()) {
    ll u = q.front();
    q.pop();
    o.push_back(u);
    for (ll v : g[u]) {
    d[v]--;
    if (d[v] == 0) q.push(v);
        }
        }
    return o.size() == n ? o : vector<ll>();
    };

    vector<ll> o1 = ts(g1, d1);
    vector<ll> o2 = ts(g2, d2);
    if (o1.empty() || o2.empty()) return -1;
    vector<ll> r(n, 0), cols(n, 0);
    for (ll i = 0; i < n; i++) {
    for (ll v : g1[o1[i]]) {
    r[v] = max(r[v], r[o1[i]] + 1);
    }
    }
    for (ll i = 0; i < n; i++) {
    for (ll v : g2[o2[i]]) {
    cols[v] = max(cols[v], cols[o2[i]] + 1);
        }
    }
    ll max_r = *max_element(r.begin(), r.end()) + 1;
    ll max_cols = *max_element(cols.begin(), cols.end()) + 1;
    return max_r + max_cols;
}
int main() {
    ll n, m;
    cin >> n >> m;
    vector<vector<string>> c(m, vector<string>(3));
    for (ll i = 0; i < m; i++) {
        cin >> c[i][0] >> c[i][1] >> c[i][2];
    }
    cout << solve(n, m, c) << endl;
    return 0;
}


Stay inside Circle โœ…
๐Ÿ‘1
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll maxcoins(ll A[], ll siz) {
    ll nums[siz + 2];
    ll n = 1;
    for (ll i = 0; i < siz; i++) {
    if (A[i] > 0) {
    nums[n] = A[i];
    n++;
    }
    }
    nums[0] = nums[n] = 1;
    n++;
    ll dp[n][n] = {};
    for (ll j = 2; j < n; j++) {
    for (ll left = 0; left < n - j; left++) {
    ll right = left + j;
    for (ll i = left + 1; i < right; i++) {
    if (left == 0 && right == n - 1)
    dp[left][right] = max(nums[left] * nums[i] * nums[right] + dp[left][i] + dp[i][right], dp[left][right]);
    else
    dp[left][right] = max(nums[left] * nums[right] + dp[left][i] + dp[i][right], dp[left][right]);
            }
        }
    }

    return dp[0][n - 1];
}

int main() {
    ll T;
    cin >> T;
    for (ll t = 1; t <= T; t++) {
    ll siz;
    cin >> siz;
    ll A[siz];
    for (ll i = 0; i < siz; i++) {
    cin >> A[i];
    }
    ll ans = maxcoins(A, siz);
    cout << "#" << t << ans << endl;
    }

    return 0;
}


Samsung โœ…
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;

int solution(const vector<int>& start, const vector<int>& dest, const vector<int>& limit) {
    int N = start.size();
    int K = limit.size();
    int totalCost = 0, maxStation = 0;

    for (int i = 0; i < N; ++i) {
        maxStation = max(maxStation, max(start[i], dest[i]));
        totalCost += abs(start[i] - dest[i]) * 2 + 1;
    }

    if (maxStation >= K) return -1;
    return min(totalCost, limit[maxStation]);
}


MS Task 1โœ…
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;

void dfs(int node, unordered_map<int, vector<pair<int, int>>>& graph, vector<bool>& visited, int& count) {
    visited[node] = true;
    for (auto& neighbor : graph[node]) {
        int nextNode = neighbor.first;
        int direction = neighbor.second;
        if (!visited[nextNode]) {
            count += direction;
            dfs(nextNode, graph, visited, count);
        }
    }
}

int solution(vector<int> A, vector<int> B) {
    unordered_map<int, vector<pair<int, int>>> graph;
    int N = max(*max_element(A.begin(), A.end()), *max_element(B.begin(), B.end()));

    for (int i = 0; i < A.size(); i++) {
        graph[A[i]].push_back({B[i], 1});
        graph[B[i]].push_back({A[i], 0});
    }

    vector<bool> visited(N + 1, false);
    int count = 0;
    dfs(0, graph, visited, count);

    return count;
}


MS Task 2โœ…
#include<bits/stdc++.h>
using namespace std;

long min_moves(long l, long r, long k, long a, long b) {
    if (abs(b - a) % k != 0) return -1;
    return abs(b - a) / k;
}

int main() {
    long l, r, k, a, b;
    cin >> l >> r >> k >> a >> b;
    cout << min_moves(l, r, k, a, b) << endl;
    return 0;
}


Infosys โœ…
#include <bits/stdc++.h>


using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int N;
        cin >> N;
        vector<long long> A(N);
        for (int i = 0; i < N; ++i) {
            cin >> A[i];
        }
        sort(A.begin(), A.end());
        long long sum = 0;
        int pairs = N / 2;
        for (int i = 0; i < pairs; ++i) {
            sum += A[N - 1 - i] - A[i];
        }
        cout << sum << endl;
    }
    return 0;
}

Maximum score
Google โœ…
#include <bits/stdc++.h>
using namespace std;

int main() {
    int N;
    cin >> N;
    vector<long long> a(N);
    for (int i = 0; i < N; i++) {
        cin >> a[i];
    }
    sort(a.begin(), a.end());
   
    vector<long long> prefix_sum(N + 1, 0);
    for (int i = 0; i < N; i++) {
        prefix_sum[i + 1] = prefix_sum[i] + a[i];
    }
   
    vector<long long> suffix_sum(N + 1, 0);
    for (int i = N - 1; i >= 0; i--) {
        suffix_sum[i] = suffix_sum[i + 1] + a[i];
    }
   
    vector<long long> sum_left(N + 1, 0);
    for (int k = 1; k <= N; k++) {
        int m = (k - 1) / 2;
        long long median = a[m];
        long long sum_prev = prefix_sum[m + 1];
        long long sum_next = prefix_sum[k] - sum_prev;
        sum_left[k] = median * (m + 1) - sum_prev + (sum_next - median * (k - (m + 1)));
    }
   
    vector<long long> sum_right(N + 1, 0);
    for (int m = 1; m <= N; m++) {
        int median_pos = (m - 1) / 2;
        int median_idx = (N - m) + median_pos;
        long long median = a[median_idx];
        long long sum_prev = suffix_sum[N - m] - suffix_sum[median_idx + 1];
        long long sum_next = suffix_sum[median_idx + 1];
        int left_count = median_idx - (N - m) + 1;
        int right_count = m - left_count;
        sum_right[m] = median * left_count - sum_prev + (sum_next - median * right_count);
    }
   
    long long ans = LLONG_MAX;
    for (int k = 1; k < N; k++) {
        ans = min(ans, sum_left[k] + sum_right[N - k]);
    }
   
    cout << ans << endl;
   
    return 0;
}
Work division โœ…
Google
โค1
#include <iostream>
#include <string>
using namespace std;

string newPassword(string a, string b) {
        string result;
        int minLength = min(a.size(), b.size());

        for (int i = 0; i < minLength; ++i) {
            result += a[i];
            result += b[i];
        }

        if (a.size() > minLength) {
            result += a.substr(minLength);
        } else if (b.size() > minLength) {
            result += b.substr(minLength);
        }

        return result;
    }

int main() {
    string a, b;
    getline(cin, a);
    getline(cin, b);

    cout << newPassword(a, b) << endl;
    return 0;
}

Password Creation โœ…
๐—–๐—ฆ ๐—”๐—น๐—ด๐—ผ ๐Ÿ’ป ๐ŸŒ ใ€Ž๐—–๐—ผ๐—บ๐—ฝ๐—ฒ๐˜๐—ถ๐˜๐—ถ๐˜ƒ๐—ฒ ๐—ฃ๐—ฟ๐—ผ๐—ด๐—ฟ๐—ฎ๐—บ๐—บ๐—ถ๐—ป๐—ดใ€
Photo
#include <bits/stdc++.h>


using namespace std;

int solve(int x1, int y1, int x2, int y2, int xc, int yc, int R) {
    int R_squared = R * R;
    int x_min = max(x1, xc - R);
    int x_max = min(x2, xc + R);
   
    if (x_min > x_max) {
        return 0;
    }
   
    int count = 0;
    for (int x = x_min; x <= x_max; ++x) {
        int dx = x - xc;
        int dx_squared = dx * dx;
        int remaining = R_squared - dx_squared;
       
        if (remaining < 0) {
            continue;
        }
       
        int ry = static_cast<int>(sqrt(remaining));
        int y_min_circle = yc - ry;
        int y_max_circle = yc + ry;
       
        int y_min = max(y1, y_min_circle);
        int y_max = min(y2, y_max_circle);
       
        if (y_min > y_max) {
            continue;
        }
       
        count += (y_max - y_min + 1);
    }
   
    return count;
}

int main() {
    int x1, y1, x2, y2, xc, yc, R;
    cin >> x1 >> y1 >> x2 >> y2;
    cin >> xc >> yc >> R;
    cout << solve(x1, y1, x2, y2, xc, yc, R) << endl;
    return 0;
}
conditional coordinates โœ…
๐—–๐—ฆ ๐—”๐—น๐—ด๐—ผ ๐Ÿ’ป ๐ŸŒ ใ€Ž๐—–๐—ผ๐—บ๐—ฝ๐—ฒ๐˜๐—ถ๐˜๐—ถ๐˜ƒ๐—ฒ ๐—ฃ๐—ฟ๐—ผ๐—ด๐—ฟ๐—ฎ๐—บ๐—บ๐—ถ๐—ป๐—ดใ€
Photo
#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> arr(n);
    for (int i = 0; i < n; ++i) {
        cin >> arr[i];
    }
    int k;
    cin >> k;

    bool all_positive = true;
    for (int x : arr) {
        if (x < 0) {
            all_positive = false;
            break;
        }
    }
    if (all_positive) {
        cout << endl;
        return 0;
    }

    vector<int> steps;
    vector<int> tmp = arr;

    for (int i = 0; i < n - 1; ++i) {
        if (tmp[i] < 0) {
            tmp[i] *= -1;
            tmp[i + 1] *= -1;
            steps.push_back(i + 1); // Convert to 1-based index
        }
    }

    if (tmp.back() < 0) {
        tmp.back() *= -1;
        steps.push_back(n);
    }

    if (steps.size() > k) {
        cout << -1 << endl;
    } else {
        for (size_t i = 0; i < steps.size(); ++i) {
            if (i > 0) cout << " ";
            cout << steps[i];
        }
        cout << endl;
    }

    return 0;
}
Flipkart โœ…
๐Ÿ‘2
๐—–๐—ฆ ๐—”๐—น๐—ด๐—ผ ๐Ÿ’ป ๐ŸŒ ใ€Ž๐—–๐—ผ๐—บ๐—ฝ๐—ฒ๐˜๐—ถ๐˜๐—ถ๐˜ƒ๐—ฒ ๐—ฃ๐—ฟ๐—ผ๐—ด๐—ฟ๐—ฎ๐—บ๐—บ๐—ถ๐—ป๐—ดใ€
Photo
#include <bits/stdc++.h>
using namespace std;

int main(){
  
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, Smax;
    if(!(cin >> N >> Smax)) return 0;
    vector<char> id(N);
    vector<int> E(N), R(N);
    for(int i = 0; i < N; i++){
        cin >> id[i] >> E[i] >> R[i];
    }

    vector<vector<int>> dp(N+1, vector<int>(Smax+1, 0));
    for(int i = 1; i <= N; i++){
        for(int w = 0; w <= Smax; w++){
            dp[i][w] = dp[i-1][w];
            if(w >= E[i-1])
                dp[i][w] = max(dp[i][w], dp[i-1][w - E[i-1]] + R[i-1]);
        }
    }

    int bestReward = dp[N][Smax];
    if(bestReward == 0){
        cout << -1 << "\n";
        return 0;
    }

    vector<int> chosen;
    int w = Smax;
    for(int i = N; i >= 1; i--){
        if(dp[i][w] != dp[i-1][w]){
            // task i-1 was used
            chosen.push_back(i-1);
            w -= E[i-1];
        }
    }
    reverse(chosen.begin(), chosen.end()); 

    int totalEffort = 0;
    for(int idx : chosen) totalEffort += E[idx];

    for(size_t i = 0; i < chosen.size(); i++){
        if(i) cout << ' ';
        cout << id[chosen[i]];
    }
    cout << "\n";
    cout << totalEffort << ' ' << bestReward << "\n";
    return 0;
}
๐—–๐—ฆ ๐—”๐—น๐—ด๐—ผ ๐Ÿ’ป ๐ŸŒ ใ€Ž๐—–๐—ผ๐—บ๐—ฝ๐—ฒ๐˜๐—ถ๐˜๐—ถ๐˜ƒ๐—ฒ ๐—ฃ๐—ฟ๐—ผ๐—ด๐—ฟ๐—ฎ๐—บ๐—บ๐—ถ๐—ป๐—ดใ€
Photo
#include <iostream>
#include <vector>
#include <unordered_map>
#include <climits>
using namespace std;

int budget;
vector<int> bestpath;

void dfs(int curr, int spent, unordered_map<int, vector<pair<int, int>>> &graph,
         vector<bool> &visited, vector<int> &path, vector<int> &retCost) {
    if (curr == 1 && path.size() > 1 && spent <= budget) {
        if (path.size() > bestpath.size()) {
            bestpath = path;
        }
    }
    for (auto &[nei, cost] : graph[curr]) {
        int total = spent + cost + (nei == 1 ? 0 : retCost[nei]);
        if ((!visited[nei] || (nei == 1 && path.size() > 1)) && total <= budget) {
            bool was = visited[nei];
            visited[nei] = true;
            path.push_back(nei);
            dfs(nei, spent + cost, graph, visited, path, retCost);
            path.pop_back();
            if (!was) visited[nei] = false;
        }
    }
}

vector<int> dijkstra(int n, unordered_map<int, vector<pair<int, int>>> &graph) {
    vector<int> dist(n + 1, INT_MAX);
    vector<bool> visited(n + 1, false);
    dist[1] = 0;

    for (int i = 1; i <= n; ++i) {
        int u = -1;
        for (int j = 1; j <= n; ++j)
            if (!visited[j] && (u == -1 || dist[j] < dist[u]))
                u = j;
        if (dist[u] == INT_MAX) break;
        visited[u] = true;
        for (auto &[v, w] : graph[u]) {
            if (dist[v] > dist[u] + w)
                dist[v] = dist[u] + w;
        }
    }
    return dist;
}

void optimalPath(int N, int M, int price, int *source, int *dest, int *weight) {
    unordered_map<int, vector<pair<int, int>>> graph;
    budget = price;
    bestpath.clear();

    for (int i = 0; i < M; ++i) {
        graph[source[i]].push_back({dest[i], weight[i]});
        graph[dest[i]].push_back({source[i], weight[i]});
    }

    vector<int> retCost = dijkstra(N, graph);
    vector<bool> visited(N + 1, false);
    vector<int> path = {1};
    visited[1] = true;

    dfs(1, 0, graph, visited, path, retCost);

    for (int v : bestpath)
        cout << v << " ";
    cout << endl;
}
โค2