Moody Hiring Associate Software Engineer

Link to apply 🔗
https://careers.moodys.com/associate-software-engineer/job/28145168?

Backend Internship @ HackerEarth

Link to apply 🔗
https://www.linkedin.com/jobs/view/3942099363/

Bijak is hiring Business Analyst Intern

For 2024 grads

Location - Gurugram

https://www.linkedin.com/posts/nikhilsoni09_intern-activity-7203670032474677249-xnFx?utm_source=share&utm_medium=member_android

Hudle is hiring Flutter Developer

For 2024, 2023 grads

https://www.linkedin.com/posts/ashwanisng_flutter-developer-activity-7203668688007225344-wvNX?utm_source=share&utm_medium=member_android

Nurix is hiring Full Stack Engineer

For 2023, 2022, 2021 grads

https://www.linkedin.com/posts/anujkrmodi_startups-hiring-genai-activity-7203689224812859392-_W3f

EXL is hiring for Junior Business Analyst.

Experience: 0+ yrs

Skills: SQL, Python/R, Power BI

Notice period: Immediate joining

Share your resume at bhupesh.khurana@exlservice.com

Swageazy is seeking a driven and enthusiastic Sr. Associate - Enterprise Sales.
Experience - Fresher ( who has recently graduated).

Job location - HSR, Bangalore
Salary - Up to 5.5 lpa

Interested candidates can share their resume on ankita@swageazy.com

Vaken Hiring Freshers -

https://docs.google.com/forms/d/e/1FAIpQLSdVpjJnxA4UfpXKLanm7unMJeDFwdvtzscp4KUIyjOF5NPM0A/viewform

Company Name: Oracle

🛄 Job Title: Software Developer

✍🏻 YOE: 0-2 years

➡️ Apply: https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/jobsearch/job/231334

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

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 ✅