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

int main() {
    int num_items, num_groups;
    cin >> num_items >> num_groups;

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

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

    sort(items.rbegin(), items.rend());

    int max_profit = 0;
    int idx = 0;
    for (int i = 0; i < num_groups; ++i) {
        int group_size = group_sizes[i];
        while (idx < num_items && group_size > 0) {
            max_profit += items[idx];
            idx++;
            group_size--;
        }
    }

    cout << max_profit << endl;

    return 0;
}

seat booking sprinkler

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

int main()
{
    int numElements;
    cin >> numElements;
    vector<int64_t> minCost(numElements + 2, 0x3f3f3f3f3f3f3f3f);
    minCost[0] = 0;
    vector<int> range(numElements + 2), elementCost(numElements + 2);

    for (int i = 1; i <= numElements + 1; i++)
    {
        cin >> range[i];
    }
    for (int i = 1; i <= numElements + 1; i++)
    {
        cin >> elementCost[i];
    }

    for (int i = 1; i <= numElements + 1; i++)
    {
        if (range[i] == 0)
            continue;

        int nextIdx = min(i + range[i], numElements + 1);
        int prevIdx = max(i - range[i] - 1, 0);
        int64_t prevElementCost = elementCost[prevIdx];
        for (int j = prevIdx + 1; j <= nextIdx; j++)
        {
            minCost[j] = min(minCost[j], minCost[prevIdx] + elementCost[i]);
        }
    }

    cout << ((minCost[numElements + 1] < 0x3f3f3f3f3f3f3f3f) ? minCost[numElements + 1] : -1) << "\n";
}

Garden

#include <iostream>
using namespace std;

int findMaximum(int a, int b)
{
    return a > b ? a : b;
}

int findMinimum(int a, int b)
{
    return a < b ? a : b;
}

int main()
{
    int numRows, numCols;
    cin >> numRows >> numCols;

    int maximumValue = -0x3f3f3f3f;
    int result = -0x3f3f3f3f;
    for (int i = 0; i < numRows; i++)
    {
        for (int j = 0; j < numCols; j++)
        {
            int cellValue;
            cin >> cellValue;
            int currentDifference = maximumValue - cellValue;
            result = findMaximum(result, currentDifference);
            maximumValue = findMaximum(maximumValue, cellValue);
        }
    }
    cout << result << "\n";
}

(dhoni sir) 2 tc fail

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

int main()
{
    int numElements;
    cin >> numElements;
    char prevChar, currentChar;
    cin >> currentChar;
    string result;

    for (int i = 2; i <= numElements; i++)
    {
        prevChar = currentChar;
        cin >> currentChar;
        if (currentChar == '*')
        {
            continue;
        }
        if (currentChar == '_' || currentChar == 'D')
        {
            if (prevChar == '*')
            {
                result.push_back('J');
            }
            else
            {
                result.push_back('W');
            }
        }
    }
    if (numElements == 1)
    {
        result = 'W';
    }
    cout << result << endl;
}

LOST IN WOODS

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

using pii = pair<int, int>;
#define ll long long
#define test_cases  \
    int t;           \
    cin >> t;        \
    while (t--)
#define read_array              \
    int arr[n];                 \
    for (int i = 0; i < n; i++) \
    cin >> arr[i]

bool comparePair(pii p1, pii p2)
{
    if (p1.first < p2.first)
        return false;
    else if (p1.first > p2.first)
        return true;
    return p1.second < p2.second;
}

void findSolution()
{
    int numElements;
    cin >> numElements;
    int k;
    cin >> k;
    read_array;
    for (int i = 0; i < numElements; i++)
        arr[i] %= k;
    vector<int> ans;
    for (int i = 0; i < numElements; i++)
        if (arr[i] == 0)
            ans.push_back(i + 1);
    vector<pii> v(numElements);
    for (int i = 0; i < numElements; i++)
        v[i].first = arr[i], v[i].second = i + 1;
    sort(v.begin(), v.end(), comparePair);
    for (auto i : v)
        if (i.first != 0)
            ans.push_back(i.second);
    for (int k : ans)
        cout << k << ' ';
    cout << endl;
}

signed main()
{
    test_cases
    findSolution();
    return 0;
}

CF B

4 failing in this not full

this is full ac

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

int calculateMaxRewards(int numDays, vector<int>& rewardValues, vector<int>& rewardReductions, vector<int>& rewardDays) {
    vector<int> maxRewards(numDays + 1, 0);

    for (int i = 1; i <= numDays; ++i) {
        maxRewards[i] = rewardValues[i - 1];
        for (int j = 1; j < i; ++j) {
            int remainingDays = rewardDays[i - j - 1] - (i - j);
            if (remainingDays > 0) {
                maxRewards[i] = max(maxRewards[i], maxRewards[j] + rewardValues[i - 1] - rewardReductions[i - 1] * remainingDays);
            }
        }
    }

    int overallMaxReward = 0;
    for (int i = 1; i <= numDays; ++i) {
        overallMaxReward = max(overallMaxReward, maxRewards[i]);
    }

    return overallMaxReward;
}

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

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

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

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

    int maxReward = calculateMaxRewards(numDays, rewardValues, rewardReductions, rewardDays);
    cout << maxReward << endl;

    return 0;
}

credentials partial

unordered_map<string, int> memo;

int minCost(const vector<int>& lst, int x, int y, int pos, int curr, int count) {
    int minm = INT_MAX;
    string key = to_string(pos) + "|" + to_string(count);

    if (memo.find(key) != memo.end()) {
        return memo[key];
    }

    if (pos >= lst.size() && count == 0) {
        return curr;
    }

    if (pos >= lst.size()) {
        return minm;
    }

    if (count == 0) {
        return curr;
    }

    int c = minCost(lst, x, y, pos + y, lst[pos] + curr, count - 1);
    int s = minCost(lst, x, y, pos + 1, 0, x);
    minm = min(minm, min(c, s));
    memo[key] = minm;
    return minm;
}

int minRehabCost(const vector<int>& lst, int x, int y) {
    memo.clear();
    return minCost(lst, x, y, 0, 0, x);
} 

Microsoft rehab

int solution(int N, vector<int>& A, vector<int>& B) {
    vector<vector<int>> graph(N);
    vector<int> edgesCount(N, 0);

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

    queue<int> q;
    for (int i = 0; i < N; i++) {
        if (edgesCount[i] <= 1) {
            q.push(i);
        }
    }

    int seconds = 0;
    while (!q.empty()) {
        int size = q.size();
        while (size > 0) {
            int vertex = q.front();
            q.pop();
            for (int neighbor : graph[vertex]) {
                if (edgesCount[neighbor] > 0) {
                    edgesCount[neighbor]--;
                    if (edgesCount[neighbor] == 1) {
                        q.push(neighbor);
                    }
                }
            }
            edgesCount[vertex] = 0;
            size--;
        }
        seconds++;
    }

    return seconds;
}

minimum time Microsoft

https://t.me/oadiscussion

Join here for question and free help of oa

Ttl Genpact make sure to remove plag

Genpact code are repeating so make sure to save it somewhere and mcq too

https://t.me/oahelp

Make sure to share the channel phir yahi se utha kar ye scammers bech dete ha dusre grp mai...also will motivate me too post more solutions❤️

#define ll long long

int mod = 1e9 + 7;

ll calcpower(ll x, ll n)
{
    if (n == 1)
    {
        return x;
    }
    ll temp = calcpower(x, n / 2);
    if (n & 1)
    {
        return ((((x * temp) % mod) * temp) % mod);
    }
    return (temp * temp) % mod;
}

// Fermat's Little Theorem : a^p=a mod(p)  =>   a^(p-2)=(a^-1)mod(p)
ll modinv(ll num)
{
    return calcpower(num, mod - 2);
}

// Z-Algorithm
vector<int> calculateZ(string &s)
{
    vector<int> z(s.size(), 0);
    int l = 0;
    int r = 0;
    for (int k = 1; k < s.size(); k++)
    {
        if (k > r)
        {
            l = r = k;
            while (r < s.size() && s[r] == s[r - l])
            {
                r++;
            }
            z[k] = r - l;
            r--;
        }
        else
        {
            int k1 = k - l;
            if (z[k1] < r - k + 1)
            {
                z[k] = z[k1];
            }
            else
            {
                l = k;
                while (r < s.size() && s[r] == s[r - l])
                {
                    r++;
                }
                z[k] = r - l;
                r--;
            }
        }
    }
    return z;
}

int numberOfWays(string s, string t, long long k)
{
    if (s.size() != t.size())
    {
        return 0;
    }
    string temp = t;
    temp += '$';
    temp += s;
    temp += s;

    vector<int> z = calculateZ(temp);
    vector<long long> v;
    int n = s.size();
    if (k % 2 == 0)
    {
        v.resize(n, (((calcpower(n - 1, k) - 1) * modinv(n)) % mod));
        v[0] += 1;
        v[0] %= mod;
    }
    else
    {
        v.resize(n, (((calcpower(n - 1, k) + 1) * modinv(n)) % mod));
        v[0] -= 1;
        v[0] += mod;
        v[0] %= mod;
    }

    int ans = 0;
    for (int i = 0; i < z.size(); i++)
    {
        if (z[i] == t.size())
        {
            if (i - t.size() - 1 >= 0 && i - t.size() - 1 < n)
            {
                ans += v[i - t.size() - 1];
            }
            ans %= mod;
        }
    }

    return ans % mod;
}

int getNumWays(string src, string target, int k)
{
    return numberOfWays(src, target, k);
}

NLP atlassian

int countAnalogousArrays(vector<int>& arr, int lower, int higher) { 
    int max = std::numeric_limits<int>::min();  
    int n = lower; 
    for (int i = 0; i < arr.size(); i++) { 
        int k = arr[i]; 
        int k1 = n - k; 
 
        if (k1 > higher || k1 < lower) { 
            return 0; 
        } 
 
        n = k1; 
        max = std::max(max, n); 
    } 
 
    max = higher - max + 1; 
 
    return max; 
}

analogus array atlassian

long getMaximumScore(vector<int> v)
{
    int n=v.size();
    map<int,vector<int>> mp; 
    for(int i=0;i<n;i++)
    {
       mp[v[i]-i].push_back(v[i]);
    }
    long ans=0;
    for(auto v:mp)
    {
        long sum=0;
        for(auto it: v.second)
        {
            sum+=it;
        }
        ans=max(sum,ans);
    }
    return ans;

}

max score atlassian

int n = a.size();
sort(a.begin(),a.end());
int s = 0;
int e = a[n-1]-a[0];
int ans = 0;
while(s<=e){
int mid = s+(e-s)/2;
int mi = a[0];
int count = 1;
bool f = true;
for(int i=1; i<n; i++){
if((a[i]-mi)<=mid){
count++;
}
else{
if(count<m) f = false;
else{
count = 1;
mi = a[i];
}
}
}
if(count<m) f = false;
if(f==false){
s = mid+1;
}
else{
ans = mid;
e = mid-1;
}
}
return ans;

array division Deshaw
9/15

ll solve(vector<int> &arr){
    int n=arr.size();
    vector<ll> pf(n),sf(n);
    pf[0]=arr[0];
    sf[n-1]=arr[n-1];
    for(int i=1;i<n;i++) pf[i]=arr[i]+pf[i-1];
    for(int i=n-2;i>=0;i--) sf[i]=arr[i]+sf[i+1];
    ll sm=0,mn=0;
    ll mx=-1e18;
    for(int i=0;i<n;i++){
        sm+=arr[i];
        if(sm>0) sm=0;
        mn=min(mn,sm);
        mx=max(mx,pf[i]-2*mn-(i<n-1?sf[i+1]:0));
    }
    return mx;
}

subarrays Deshaw

    int l=0,r=1e14;
    while(l<r){
        int mid=(l+r+1)>>1;
        int ans=1;
        int pr=0;
        for(int i=0;i<n;i++){
            if(pr>starts[i]+d){
                ans=0;
            }else{
                pr=max(pr+mid,starts[i]);
            }
        }
        if(ans){
            l=mid;
        }else{
            r=mid-1;
        }
    }
    return l;

Range selection deshaw

2/15