Alternate Prefix Sums
Adobe ✅

#include <cstdio>
#include <algorithm>

const int maxN = 2 * 1e7 + 5;
long long dp1[maxN], dp2[maxN], dp3[maxN];
long long ans, ans1, ans2, ans3, pom;
int n, idx, l[5000];

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &l[i]);
    }

    std::sort(l, l + n);

    for (int i = 0; i < n; i++) {
        dp1[l[i]]++;
    }

    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            dp2[l[i] + l[j]]++;
        }
    }

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (l[i] != l[i - 1]) {
                dp3[l[i]] += dp2[l[i] - l[j]];
                if (3 * l[j] == l[i]) {
                    dp3[l[i]] -= (dp1[l[j]] - 1);
                } else if (2 * l[j] < l[i]) {
                    dp3[l[i]] -= dp1[l[i] - 2 * l[j]];
                }
            }
        }
    }

    for (int i = 1; i < n; i++) {
        if (l[i] != l[i - 1]) {
            dp3[l[i]] = dp3[l[i]] / 3;
        }
    }

    ans = 0;
    for (int i = 1; i < n; i++) {
        if (l[i] != l[i - 1]) {
            ans += (dp1[l[i]] * (dp1[l[i]] - 1) * (dp1[l[i]] - 2) * dp3[l[i]]) / 6;
        }
    }

    for (int i = 1; i < n; i++) {
        if (l[i] != l[i - 1]) {
            idx = 0;
            pom = 0;
            ans2 = 0;
            ans3 = 0;

            while (2 * l[idx] < l[i]) {
                if (pom != l[idx]) {
                    pom = l[idx];
                    ans3 += (dp1[l[idx]] * (dp1[l[idx]] - 1) * dp1[l[i] - l[idx]] * (dp1[l[i] - l[idx]] - 1)) / 4;

                    if (l[i] % 2 == 0) {
                        ans3 += (dp1[l[idx]] * dp1[l[i] - l[idx]] * dp1[l[i] / 2] * (dp1[l[i] / 2] - 1)) / 2;
                        ans2 += dp1[l[idx]] * dp1[l[i] - l[idx]] * (dp2[l[i]] - (dp1[l[idx]] * dp1[l[i] - l[idx]]) - (dp1[l[i] / 2] * (dp1[l[i] / 2] - 1)) / 2);
                    } else {
                        ans2 += (dp1[l[idx]] * dp1[l[i] - l[idx]]) * (dp2[l[i]] - (dp1[l[idx]] * dp1[l[i] - l[idx]]));
                    }
                }
                idx++;
            }

            ans2 = ans2 / 2;
            ans2 += ans3;

            if (2 * l[idx] == l[i]) {
                ans2 += (dp1[l[idx]] * (dp1[l[idx]] - 1) * (dp1[l[idx]] - 2) * (dp1[l[idx]] - 3)) / 24;
            }
           
            ans1 += ans2 * (dp1[l[i]] * (dp1[l[i]] - 1)) / 2;
        }
    }

    ans += ans1;
    printf("%lld", ans);

    return 0;
}

Magical sticks ✅

def best_sum_downward_tree_path(parent, values):
    dp = [0] * len(parent)
    max_value = float('-inf')

    for i in range(len(parent)):
        p = parent[i]
        value = values[i]

        dp[i] = value if p == -1 else max(dp[p] + value, value)
        max_value = max(dp[i], max_value)

    return max_value

Best sum download Tree Path
Adobe ✅

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

int solution(vector<int>& A, vector<int>& B, int X, int Y) {
    int N = A.size();
    vector<int> dpA(N), dpB(N);

    // Initial condition: Start at position 0 on either line
    dpA[0] = A[0];
    dpB[0] = B[0];

    // Fill the dp arrays
    for (int i = 1; i < N; ++i) {
        dpA[i] = min(dpA[i - 1] + A[i], dpB[i - 1] + Y + A[i]);
        dpB[i] = min(dpB[i - 1] + B[i], dpA[i - 1] + X + B[i]);
    }

    // The result is the minimum time to complete the car on either line at the last position
    return min(dpA[N - 1], dpB[N - 1]);
}

int main() {
    int N, X, Y;
    cin >> N >> X >> Y;
    vector<int> A(N), B(N);
    for (int i = 0; i < N; ++i) {
        cin >> A[i];
    }
    for (int i = 0; i < N; ++i) {
        cin >> B[i];
    }
    cout << solution(A, B, X, Y) << endl;
    return 0;
}

def solution(numbers, zerosToOne):
    a = numbers.count(1)
    b = numbers.count(0)
    seconds = 0
    while True:
        if b >= zerosToOne:
            b -= zerosToOne
            a += 1
        elif a > 0:
            a -= 1
            b += 1
        else:
            break
        seconds += 1
   
    return seconds

#include <iostream>
#include <string>
using namespace std;
void solve(string X, int Y) {
    long long M = stoll(X);
    while (true) {
        if (to_string(M).find(X) == 0 && M % Y == 0) {
            cout << M << endl;
            return;
        }
        M++;
    }
}

int main() {
    string X;
    int Y;
    cin >> X >> Y;
    solve(X, Y);
    return 0;
}

Cars24 is looking for design interns

mail your resume : anjali.mishra@cars24.com

def key_generation(key_mode, roles):
    all_permissions = {
        "payments": ["read_settings", "read_intent", "write_settings", "create_intent", "confirm_intent",
                     "update_dispute", "create_dispute", "read_dispute", "create_refund", "cancel_refund", "read_refund"],
        "banking": ["read_settings", "read_intent", "write_settings", "create_intent", "confirm_intent"],
        "identity": ["read_settings", "read_intent", "write_settings", "create_intent", "confirm_intent"],
        "climate": ["read_settings", "read_intent", "write_settings", "create_intent", "confirm_intent"],
        "capital": ["read_settings", "read_intent", "write_settings", "create_intent", "confirm_intent"]
    }
   
    read_permissions = {
        "payments": ["read_settings", "read_intent", "read_dispute", "read_refund"],
        "banking": ["read_settings", "read_intent"],
        "identity": ["read_settings", "read_intent"],
        "climate": ["read_settings", "read_intent"],
        "capital": ["read_settings", "read_intent"]
    }
   
    roles_dict = {
        "admin": set(),
        "admin_readonly": set()
    }
   
    for product, perms in all_permissions.items():
        roles_dict["admin"].update([f"{product}.{perm}" for perm in perms])
   
    for product, perms in read_permissions.items():
        roles_dict["admin_readonly"].update([f"{product}.{perm}" for perm in perms])
   
    for product in all_permissions.keys():
        roles_dict[product] = set([f"{product}.{perm}" for perm in all_permissions[product]])
   
    user_permissions = set()
    for role in roles:
        if role in roles_dict:
            user_permissions.update(roles_dict[role])
   
    if key_mode == "permissions":
        for permission in sorted(user_permissions):
            print(permission)

Permissions and Roles ✅

return pow(2,n*(n-1)/2);

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void dfs(int v, const vector<vector<int>>& adjList, vector<bool>& visited) {
    visited[v] = true;

    for (int adjV : adjList[v]) {
        if (!visited[adjV]) {
            dfs(adjV, adjList, visited);
        }
    }
}
vector<int> solve(int flightNodes, const vector<int>& flightFrom, const vector<int>& flightTo, int m, const vector<int>& initiallyDelayed, int k) {
    vector<vector<int>> adjList(flightNodes);
    for (int i = 0; i < m; ++i) {
        adjList[flightFrom[i] - 1].push_back(flightTo[i] - 1);
    }
    vector<bool> visited(flightNodes, false);
    for (int i = 0; i < k; ++i) {
        if (!visited[initiallyDelayed[i] - 1]) {
            dfs(initiallyDelayed[i] - 1, adjList, visited);
        }
    }
    vector<int> delayedFlights;
    for (int i = 0; i < flightNodes; ++i) {
        if (visited[i]) {
            delayedFlights.push_back(i + 1);
        }
    }

    sort(delayedFlights.begin(), delayedFlights.end());
    return delayedFlights;
}

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

vector<int> solve(int N, int M, vector<int>& ans) {
    vector<int> res;
    res.reserve(M);

    priority_queue<pair<long long, int>,
        vector<pair<long long, int>>, 
        greater<pair<long long, int>>> pq;

    for (int i = 1; i <= N; ++i) {
        pq.push(make_pair(0LL, i));
    }

    for (int it : ans) {
        pair<long long, int> top = pq.top();
        pq.pop();

        long long load = top.first;
        int x = top.second;

        res.push_back(x);
        pq.push(make_pair(load + it, x));
    }

    return res;
}

int main(){
  ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    int n=2,m=2;
    vector<int> ans={5,5};
    vector<int> ans1=solve(n,m,ans);
    for(int i=0;i<ans1.size();i++) cout<<ans1[i]<<" ";

}

Servers ✅