vector<int> BobnBot(int N, int M, vector<vector<int>> games, int Q, vector<vector<int>> queries) {
    vector<int> result;
    for (const auto& query : queries) {
        vector<int> cleaned_query;
        for (int num : query) {
            if (num != -1) {
                cleaned_query.push_back(num);
            } else {
                break;
            }
        }
        int match_count = 0;
        for (const auto& game : games) {
            bool match = true;
            for (size_t i = 0; i < cleaned_query.size(); ++i) {
                if (game[i] != cleaned_query[i]) {
                    match = false;
                    break;
                }
            }
            if (match) {
                ++match_count;
            }
        }

        result.push_back(match_count);
    }

    return result;
}

The bot and the game ✅

vector<string> areAlmostEquivalent(vector<string>& s, vector<string>& t) {
    vector<string> result;
    auto countCharacters = [](const string& str) {
        vector<int> count(26, 0);
        for (char c : str) {
            count[c - 'a']++;
        }
        return count;
    };
    for (size_t i = 0; i < s.size(); ++i) {
        const string& str_s = s[i];
        const string& str_t = t[i];
  
        vector<int> count_s = countCharacters(str_s);
        vector<int> count_t = countCharacters(str_t);

        bool isAlmostEquivalent = true;
        for (int j = 0; j < 26; ++j) {
            if (abs(count_s[j] - count_t[j]) > 3) {
                isAlmostEquivalent = false;
                break;
            }
        }

        if (isAlmostEquivalent) {
            result.push_back("YES");
        } else {
            result.push_back("NO");
        }
    }
   
    return result;
}

Almost Equivalent strings ✅

Relatable 😂

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int minStones(vector<int>& xstart, vector<int>& xend) {
    int n = xstart.size();
    vector<pair<int, int>> intervals;
    for (int i = 0; i < n; ++i) {
        intervals.push_back({xend[i], xstart[i]});
    }
    sort(intervals.begin(), intervals.end());
    int stones = 0;
    int lastSmashed = -1;
    for (const auto& interval : intervals) {
        int start = interval.second;
        int end = interval.first;
       
        if (start > lastSmashed) {
            stones++;
            lastSmashed = end; 
        }
    }
    return stones;
}

vector<int> suitableLocations(vector<int>& center, long d) {
    auto feasible = & {
        long total = 0;
        for (int point : center) {
            total += abs(mid - point) * 2;
        }
        return total <= d;
    };
    auto binarySearchRight = & {
        int low = start;
        int high = end;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (feasible(mid)) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return low - 1;
    };
    auto binarySearchLeft = & {
        int low = start;
        int high = end;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (feasible(mid)) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return low;
    };
    vector<int> suitablePoints;
    int rightLimit = binarySearchRight(0, *max_element(center.begin(), center.end()) + d);
    int leftLimit = binarySearchLeft(*min_element(center.begin(), center.end()) - d, -1);
    for (int i = leftLimit; i <= rightLimit; ++i) {
        suitablePoints.push_back(i);
    }
    return suitablePoints;
}

Amazon ✅

int totalDist(vector<int>& c, int x) {
    int d = 0;
    for (int i : c) d += 2 * abs(i - x);
    return d;
}

int suitableLocations(vector<int>& c, long long d) {
    sort(c.begin(), c.end());
    auto td = & { return totalDist(c, x); };
    int m = c.size() / 2, l = m, r = m;
    while (td(l) <= d) l -= 1;
    while (td(r) <= d) r += 1;
    return max(0, r - l - 1);
}

Amazon ✅

long wt = 0, ct = 0;
        for (int i = 0; i < N; i++) {
            if (patients[i][0] > ct) {
                ct = patients[i][0];
            }
            wt += ct + patients[i][1] - patients[i][0];
            ct += patients[i][1];
        }
        return wt / N;

Doctor ✅

Profit
Python 3✅
Wiley Edge

Resource Power Code ✅
Wiley Edge

Company Name: Urban Company

🛄 Job Title: SDE 1
✍🏻 YOE: Freshers to 2 years experience


➡️ Apply: https://www.linkedin.com/jobs/view/3942098649

Please do share in your college grps and in case you are applying please react on this post:) 😇❤️

Homelane is hiring SDE Intern

For 2024, 2025, 2026 grads

https://homelanecareers.skillate.com/jobs/55021

Chocolate Stack ✅
Wiley Edge

Swiggy | Software Engineer | 0-2 YoE

https://www.linkedin.com/posts/ram-kumar-308122173_hiring-associate-software-activity-7204147422023835648-kcS0

Form link from the post: https://docs.google.com/forms/d/1yRnfoOJKjdlvFjnoYXvnrVHlb8V-CbQLUu4P265qFeY/viewform

Abstrabit Technologies is hiring Full Stack Engineer

For 2024, 2023, 2022 grads

Location - Remote

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

Amazon is hiring Freshers!
Position: Business Analyst Intern
Qualification: Bachelor's/ Master’s Degree
Salary: Up to 8 LPA (Expected)
Experience: Freshers
Location: Bangalore, India

📌Apply Link: https://www.amazon.jobs/en/jobs/2662463/business-analyst-intern-row-sharp-team?cmpid=DA_INAD200785B

https://tatatechnologies.ripplehire.com/candidate/?token=FhhbYCnaWz3KYmeysFdD&lang=en&ref=LI01#apply/job/588227

*Fresher opening*

Hexaview Technologies Inc. hiring for QA (Freshers ) for
Noida location.

Send cv at ghulam.kashif@hexaviewtech.com (Sub: QA Fresher)
Position:-Software Quality Engineer (Fresher)
Location:- Noida
Eligibility Criteria - B. Tech/MCA/M.Tech -2021/2022
Job Description :
Software Quality Engineer Role:
Requirement:
Oops concepts
Testing understanding
Web and mobile testing concepts
SQL
Coding
Analytical skills
Communication
Attitude
Develop comprehensive test plans, test cases, and test scripts
based on software requirements and design documents.
Execute test cases and record test results, ensuring adherence
to established quality standards.
Collaborate with cross-functional teams, including developers,
product managers, and stakeholders, to understand project
requirements and drive quality improvements.
Conduct performance, scalability, and security testing to ensure
software stability and compliance.
Continuously improve testing processes and methodologies to
increase efficiency and effectiveness.