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

int solution(const vector<int>& A, const vector<int>& B) {
    int N = A.size();

     vector<vector<int>> dp(2, vector<int>(N));
    dp[0][0] = A[0];
    dp[1][0] = max(A[0], B[0]);

    for (int j = 1; j < N; ++j) {
        dp[0][j] = max(dp[0][j - 1], A[j]);
        dp[1][j] = min(max(dp[0][j], B[j]), max(dp[1][j - 1], B[j]));
    }

    return dp[1][N - 1];
}

Amex ✅

#include <iostream>
#include <set>
#include <iomanip>
#include <sstream>
using namespace std;
bool isInteresting(const string& timeStr) {
    set<char> uniqueDigits;
        for (char ch : timeStr) {
        if (ch != ':') { 
            uniqueDigits.insert(ch);
        }
    }
        return uniqueDigits.size() <= 2;
}
void incrementTime(int& hh, int& mm, int& ss) {
    ss++;
    if (ss == 60) {
        ss = 0;
        mm++;
    }
    if (mm == 60) {
        mm = 0;
        hh++;
    }
    if (hh == 24) {
        hh = 0;
    }
}
string timeToString(int hh, int mm, int ss) {
    ostringstream oss;
    oss << setw(2) << setfill('0') << hh << ":"
        << setw(2) << setfill('0') << mm << ":"
        << setw(2) << setfill('0') << ss;
    return oss.str();
}
int solve(const string& S, const string& T) {
    int shh = stoi(S.substr(0, 2));
    int smm = stoi(S.substr(3, 2));
    int sss = stoi(S.substr(6, 2));
    int ehh = stoi(T.substr(0, 2));
    int emm = stoi(T.substr(3, 2));
    int ess = stoi(T.substr(6, 2));
    int interestingCount = 0;
        while (true) {
        string currentTime = timeToString(shh, smm, sss);
                if (isInteresting(currentTime)) {
            interestingCount++;
        }
                if (shh == ehh && smm == emm && sss == ess) {
            break;
        }
                incrementTime(shh, smm, sss);
    }
    
    return interestingCount;
}

Amex ✅

long long solve(int n, int** A) {
    vector<pair<int, int>> vp;
    vp.push_back({-1, 0});

    for (int i = 0; i < n; i += 1) {
        vp.push_back({A[i][1], A[i][2]});
    }

    sort(vp.begin(), vp.end());

    auto check = [&] (int mid) {
        long long dishes = 0;

        for (int i = 1; i <= n; i += 1) {
            dishes += static_cast<long long>(vp[i].first - vp[i - 1].first) * mid;
            if (vp[i].second > dishes)
                return false;
            else
                dishes -= vp[i].second;
        }

        return true;
    };

    int l = 0, r = 1e9;

    while (r - l > 1) {
        int mid = (l + r) / 2;
        if (!check(mid))
            l = mid;
        else
            r = mid;
    }

    return r;
}

Chef and ordering ✅

from math import ceil

def getMinDifference(n, e1, t1, e2, c):
    res = float('inf')
    
    energy_list = [e1 * i for i in range(n + 1)]

    for i in range(n + 1):
        lift = i * t1
        energy = energy_list[i]

        if energy < (n - i) * e2:
            continue

        steps = 0
        
        steps_list = [ceil(c / energy) for _ in range(n - i)]
        energy -= sum(steps_list) * e2

        res = min(res, abs(lift - sum(steps_list)))

    return res

Meesho ✅

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

const int MOD = 1e9 + 7;
int dp[20][200][200][2];
vector<int> getDigits(int x) {
    vector<int> digits;
    while (x > 0) {
        digits.push_back(x % 10);
        x /= 10;
    }
    reverse(digits.begin(), digits.end());
    return digits;
}
int digitDP(int pos, int sumEven, int sumOdd, int tight, const vector<int>& digits) {
    if (pos == digits.size()) {
        return (sumEven % 2 == sumOdd % 2) ? 1 : 0;
    }
    if (dp[pos][sumEven][sumOdd][tight] != -1) {
        return dp[pos][sumEven][sumOdd][tight];
    }

    int limit = tight ? digits[pos] : 9;
    int res = 0;
    for (int digit = 0; digit <= limit; ++digit) {
        int newTight = (tight && (digit == digits[pos]));
        if (pos % 2 == 0) { 
            res = (res + digitDP(pos + 1, sumEven + digit, sumOdd, newTight, digits)) % MOD;
        } else { 
            res = (res + digitDP(pos + 1, sumEven, sumOdd + digit, newTight, digits)) % MOD;
        }
    }
    return dp[pos][sumEven][sumOdd][tight] = res;
}
int countNumbersWithSameParityOfSums(int x) {
    if (x <= 0) return 0;
    
    vector<int> digits = getDigits(x);
    memset(dp, -1, sizeof(dp));
    return digitDP(0, 0, 0, 1, digits);
}
int findParityCountInRange(int a, int b) {
    int result_b = countNumbersWithSameParityOfSums(b);
    int result_a = countNumbersWithSameParityOfSums(a);
        return (result_b - result_a + MOD) % MOD;
}

Meesho ✅

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
const int MOD = 1e9 + 7;
int getExpressionSums(string num) {
    int n = num.size();
    long long res = 0;
    for (int mask = 0; mask < (1 << (n - 1)); ++mask) {
        string s = "";  
        s += num[0]; 
        for (int i = 0; i < n - 1; ++i) {
            if (mask & (1 << i)) {
                s += '+';  
            }
            s += num[i + 1];  
        }
        long long current_sum = 0;
        string temp = "";
        for (char c : s) {
            if (c == '+') {
                current_sum += stoll(temp); 
                temp = "";
            } else {
                temp += c;  
            }
        }
        current_sum += stoll(temp);  

        res = (res + current_sum) % MOD;  
    }

    return res;
}

Meesho ✅

Coupan is hiring for Software Engineer ( Offcampus )

Experience Required: Fresher (0 to 4 years)

Batch Eligible: 2020/ 2021/  2022/  2023/  2024

CTC: 10 LPA to 22 LPA

Job Type: Full Time
Location: Pune/Hyderabad

Apply Here : https://careers.coupa.com/career-description/66f3c112-530f-40dc-b6bf-1d179df2d535

Email your Resume at: svidyagar@intraedge.com

Email: kalpana.wadhwani@scriptshub.net

Apply: https://winman.in/jobs/resume.aspx

Bolt.Earth is hiring IOS Developer Intern

For 2024, 2025, 2026 grads
Location: Bangalore

https://www.linkedin.com/jobs/view/4020997792

https://www.linkedin.com/posts/hinamika-jain_joinourteam-qaengineer-qainterns-activity-7238896001250402305-oDuL?utm_source=share&utm_medium=member_desktop

🚀 Apna Mart 𝗶𝘀 𝗛𝗶𝗿𝗶𝗻𝗴 𝗤𝗔 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝘀 𝗮𝗻𝗱 𝗜𝗻𝘁𝗲𝗿𝗻𝘀! 🚀

Apna Mart is seeking for QA Engineers and QA interns to join our dynamic team! If you’re passionate about delivering high-quality softwares and making a real impact, this is the role for you.

Key Requirements:

- Develop and execute comprehensive test plans and cases
- Collaborate closely with development teams to ensure high-quality product delivery
- Identify and track defects, working closely with developers for resolution
- Stay up-to-date with the latest QA methodologies and technologies
- Excellent analytical and problem-solving skills
- Collaborative mindset and attention to detail
- Strong experience in manual and automation testing for web and mobile applications

Ready to elevate your QA career? Apply now and join us for something exciting! 🌟

How to Apply for QA Engineer:
📧 Email your resume to: hinamika.jain@apnamart.in
Subject: [Current Designation] + [YOE in QA] + [Current Base]
(Example: QAE + 2 YOE + 7 LPA)

How to Apply for QA Intern:
📧 Email your resume to: hinamika.jain@apnamart.in
Subject: QAI

Acuver Consulting Hiring Java Fresher

https://wellfound.com/l/2zXfYE

https://www.linkedin.com/jobs/view/4019940929

Delta4 Infotech Hiring Junior/Fresher Frontend Developer

Arcadia is hiring Associate Product Manager

For 2021, 2022, 2023 grads
Location: Chennai

https://job-boards.greenhouse.io/arcadiacareers/jobs/7623447002

#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;

int dp[1010][2][2][2];

int findParityCountInRange(string a, string b)
{

    function<int(int, int, int, int, string &)> f = [&](int pos, int even, int odd, int tight, string &s) -> int
    {
        if (pos == s.size())
            return (even == odd) ? 1 : 0;

        int &ans = dp[pos][even][odd][tight];
        if (ans != -1)
            return ans;

        ans = 0;
        int limit = tight ? (s[pos] - '0') : 9;

        for (int digit = 0; digit <= limit; ++digit)
        {
            int newTight = tight && (digit == (s[pos] - '0'));
            if (pos & 1)
                ans = (ans + f(pos + 1, even, (odd + digit) % 2, newTight, s)) % MOD;
            else
                ans = (ans + f(pos + 1, (even + digit) % 2, odd, newTight, s)) % MOD;
        }

        return ans;
    };

    memset(dp, -1, sizeof dp);
    int ansA = f(0, 0, 0, 1, a);
    memset(dp, -1, sizeof dp);
    int ansB = f(0, 0, 0, 1, b);

    return (ansB - ansA + MOD) % MOD;
}

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

    cout << findSameParityIntegers(a, b) << endl;

    return 0;
}

Meesho ✅

Amazon Hiring !!
Role - sde 1
Exp - 1 year non internship

Link - https://www.amazon.jobs/jobs/2766986/sde-i

Company Name: Turing
Role: Delivery Data Analyst
Batch eligible: 2024 grads

Apply: https://job-boards.greenhouse.io/turing/jobs/5281628004?gh_src=ac0ca9344us

Company Name: Barclays
Role: Software Engineer
Batch eligible: 2023 and 2024 grads

Apply: https://search.jobs.barclays/job/-/-/13015/69503571184?src=JB-12860