def isEvenOdd(m, strings):
    if m == 0:
        return sum(len(s) for s in strings) % 2 == 0
    
    evenCount = sum(all((ord(c) - ord('a')) % 2 == 0 for c in s) for s in strings)
    return evenCount % 2 == 0

OddEven
Atlassian ✅

long long mincost(vector<int> &pods, vector<int> &cost) {  
    map<int, multiset<int>> mp;  

    for (int i = 0; i < pods.size(); i++) {  
        mp[pods[i]].insert(cost[i]);  
    }  

    long ans = 0;  
    long curr = (*mp.begin()).first;  
    long sm = 0;  
    multiset<int> se;  

    while (true) {  
        if (se.size() == 0) {  
            if (mp.lower_bound(curr) == mp.end()) break;  
            curr = (*mp.lower_bound(curr)).first;  
        }  

        if (mp.find(curr) != mp.end())  
            for (auto &x : mp[curr]) {  
                se.insert(x);  
                sm += x;  
            }  

        auto it = se.end();  
        it--;  
        sm -= *it;  
        ans += sm;  
        se.erase(it);  
        curr++;  
    }  

    return ans;  
}

mincost ✅
Atlassian

def calculateEvenOdd(m, s):
    ts = 0
    MOD = 2  
    for string in s:
        sv = 1
        for char in string:
            sv *= pow(ord(char), m, MOD) 
            sv %= MOD  
        ts += sv
        ts %= MOD  

    return 'EVEN' if ts % 2 == 0 else 'ODD'

Atlassian ✅
String

https://www.linkedin.com/posts/sakshivar_hi-connections-microsoft-is-hiring-interns-activity-7243234597105229824-_O8c?utm_source=share&utm_medium=member_desktop

Hi connections, Microsoft is hiring interns!

🔍 Position: Data Science Internship Opportunities
🎓 Eligible Batch: 2026 graduates



🔗 Apply here: https://lnkd.in/ghtGCBAd

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

int getswaptime(string &a)
{
int i = 0, n = a.length();
int curr=0, prev=0;
int ones = 0;

while(i<n)
{
   if(a[i]=='1')
   {
       prev = i;
       curr = i;
       i++;
       ones++;
       break;
   }
   i++;
}

while(i<n)
{
   
    if(a[i]=='1')
    {
       if(i-ones)
        curr = max(prev+1,i-ones);

        ones++;
    }

    i++;
    prev = curr;
}

return curr;
}

Prade in Hackerland ✅

`c++
#include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
    set<int> dividers;  and y)
    multiset<int> lengths;
    SegmentTree(int full_length) {
        dividers.insert(0);
        dividers.insert(full_length);
        lengths.insert(full_length);
    }
    void add_divider(int pos) {
        if (dividers.find(pos) != dividers.end()) return;
        auto it = dividers.lower_bound(pos);
        int right = *it;
        it--;
        int left = *it;
        lengths.erase(lengths.find(right - left));
        lengths.insert(pos - left);
        lengths.insert(right - pos);
        dividers.insert(pos);
    }
    int get_max_length() {
        return *lengths.rbegin();
    }
};
vector<int> solve(int n, int m, int q, vector<vector<int>> queries) {
    SegmentTree x_tree(n);
    SegmentTree y_tree(m);
    vector<int> result;
    for (int i = 0; i < q; i++) {
        int type = queries[i][0];
        int pos = queries[i][1];
        if (type == 1) {
            x_tree.add_divider(pos);
        } else if (type == 2) {
            y_tree.add_divider(pos);
        }
        int max_x = x_tree.get_max_length();
        int max_y = y_tree.get_max_length();
        result.push_back(max_x * max_y);
    }
    return result;
}
int main() {
    int n, m, q;
    cin >> n >> m >> q;
    vector<vector<int>> queries(q, vector<int>(2));
    for (int i = 0; i < q; i++) {
        cin >> queries[i][0] >> queries[i][1];
    }
    vector<int> result = solve(n, m, q, queries);
    for (int area : result) {
        cout << area << " ";
    }
    cout << endl;
    return 0;
}

Largest text area
Ge Vernova ✅

def getMinDecrement(a, m):
    l, r = 1, max(a)
    while l < r:
        x = (l + r) // 2
        if sum((i + x - 1) // x for i in a) <= m:
            r = x
        else:
            l = x + 1
    return l

Decrement Operations ✅
DE Shaw

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

string getMinimalString(string s) {
    string p; 
    stack<char> e; 
    int n = s.size();
    int i = 0; 
    char m = *min_element(s.begin(), s.end());
    while (i < n) {
        while (i < n && s[i] != m) {
            e.push(s[i]);
            i++;
        }
        p += s[i];
        i++;
        if (i < n) {
            m = *min_element(s.begin() + i, s.end());
        }
        while (!e.empty() && (i == n || e.top() <= m)) {
            p += e.top();
            e.pop();
        }
    }
    while (!e.empty()) {
        p += e.top();
        e.pop();
    }
    return p;
}

Minimal String ✅
DE Shaw

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

#define vl vector<long long> 
#define debug(x) cerr << #x << " = " << x << endl

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

    int m = arr.size();
    vector<vector<int>> dp(m + 1, vector<int>(m + 1, 1e9));
    dp[0][0] = 0;

    // DP logic to fill the table
    for (int i = 1; i <= m; i++) {
        for (int j = 0; j <= m; j++) {
            dp[i][j] = dp[i - 1][j];
            if (j == 0) {
                continue;
            }
            int s = dp[i - 1][j - 1] + arr[i - 1];
            if (s <= i - j) {
                dp[i][j] = min(dp[i][j], s);
            }
        }
    }

    for (int j = m; j >= 0; j--) {
        if (dp[m][j] < 1e9) {
            cout << m - j << endl;
            return 0;
        }
    }

    return 0;
}

maximum profit✅

string solve(string s) {
    string pre, post;
    deque<char> sDeque(s.begin(), s.end());

    char minChar = *min_element(sDeque.begin(), sDeque.end());

    while (!sDeque.empty()) {

        pre.push_back(sDeque.front());
        sDeque.pop_front();

       
        if (!sDeque.empty() && pre.back() == minChar) {
            minChar = *min_element(sDeque.begin(), sDeque.end());
        }

        while (!pre.empty() && (sDeque.empty() || pre.back() <= minChar)) {
            post.push_back(pre.back());
            pre.pop_back();
        }
    }

    while (!pre.empty()) {
        post.push_back(pre.back());
        pre.pop_back();
    }

    return post;
}

Minimal String
DE Shaw ✅

#include <iostream>
#include <vector>
#include <string>
using namespace std;
string findOriginalCode(string alteredCode, string standardCode) {
    vector<int> freq(10, 0);
    for (char ch : alteredCode) {
        freq[ch - '0']++;
    }
    string result = "";
    bool foundLarger = false; 
    for (int i = 0; i < alteredCode.size(); ++i) {
        int stdDigit = standardCode[i] - '0';
        int start = foundLarger ? 0 : stdDigit;
        bool placed = false;
        for (int d = start; d < 10; ++d) {
            if (freq[d] > 0) {
                if (d == 0 && i == 0 && alteredCode.size() > 1) {
                    for (int k = 1; k < 10; ++k) {
                        if (freq[k] > 0) {
                            result += (k + '0');
                            freq[k]--;
                            placed = true;
                            foundLarger = true;
                            break;
                        }
                    }
                    if (!placed) return "-1"; 
                    break;
                }
                result += (d + '0');
                freq[d]--;
                if (d > stdDigit) {
                    foundLarger = true;
                }
                placed = true;
                break;
            }
        }
        if (!placed) {
            return "-1";
        }
    }

    return result;
}

Find Original Code ✅
DE Shaw

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

struct Project {
    int remaining_employees;
    int index;
   
    bool operator<(const Project& other) const {
        return remaining_employees > other.remaining_employees;
    }
};

int getMaxBonus(vector<int> max_employees, vector<int> bonus, int m) {
    int n = max_employees.size();
    priority_queue<Project> pq;
    vector<int> current_employees(n, 1);
   
    for (int i = 0; i < n; ++i) {
        int remaining = max_employees[i] - 1;
        pq.push({remaining, i});
    }

    while (m-- && !pq.empty()) {
        Project top = pq.top();
        pq.pop();
       
        int idx = top.index;
        int remaining = top.remaining_employees;
       
        int assign = max(1, current_employees[idx] / 2);
        current_employees[idx] += assign;
        remaining -= assign;

        if (current_employees[idx] < max_employees[idx]) {
            pq.push({remaining, idx});
        }
    }
   
    int total_bonus = 0;
    for (int i = 0; i < n; ++i) {
        if (current_employees[i] >= max_employees[i]) {
            total_bonus += bonus[i];
        }
    }
   
    return total_bonus;
}

Employee Assignment ✅