Global Logic is conducting Walkin for freshers

2024/2023/2022 passouts eligible

Register on the link below : https://www.globallogic.com/in/careers/associate-analyst-freshers-non-tech-irc234095/

Tech Edge Bootcamp:

Gain practical tech knowledge and skills required to get Job and Internship

It’s completely free to attend the bootcamp.

Register Now: https://bit.ly/4cZ0TBT

Last date to register: 16th july 7pm

Salesforce is hiring for Interns
2026 Passout

To get Referral follow these steps
In "How Did You Hear About Us" question
Select Referral and enter my Email s.sarkar@salesforce.com

GenC PWD Hiring 2023 & 2024 Batch

Apply link 👇

https://app.joinsuperset.com/join/#/signup/student/jobprofiles/07a89094-b25f-4041-b191-5bd8eb09a5aa

typedef long long ll;

pair<ll, ll> largestPowerof2(ll n)
{
ll ans = 0;
for (ll i = 30; i >= 0; i--) {
  if ((1LL << i) & n) {
   ans = i;
   break;
  }
}

ans = min(25LL, ans);
return { ans, 1LL << ans };
}

string solve(ll n)
{
string str = "abcdefghijklmnopqrstuvwxyz";
string ans = "";
while (n) {
  pair<ll, ll> a = largestPowerof2(n);
  ll pw = a.first;
  ll value = a.second;
  ans += str[pw];
  n -= value;
}
return ans;
}


ms task 2 ✅

Company – Manmachine Car Care Pvt. Ltd.
Role – Data Analyst
Exp. – Fresher
Apply Here – https://www.linkedin.com/jobs/view/3974179593

Company – Agoda
Role – Business Data Analyst
Exp. – Fresher
Apply Here – https://www.linkedin.com/jobs/view/3822845330

Company – Deutsche Bank
Role – Data Analyst (ASC), Associate
Exp. – 0-2 yrs
Apply Here – https://www.foundit.in/job/data-analyst-asc-associate-deutsche-bank-pune-india-31092016?searchId=c021504c-29f5-4075-9a52-03284b952892

Company – Genpact
Role – Associate, Data Analyst
Exp. – 0-2 yrs
Apply Here – https://www.foundit.in/job/associate-data-analyst-genpact-bengaluru-bangalore-31103435?searchId=c021504c-29f5-4075-9a52-03284b952892

Company – Thirumoolar Software
Role – Machine Learning Engineer
Exp. – Fresher
Apply Here – https://www.linkedin.com/jobs/view/3971796148

Company – Walmart
Role – Data Scientist III
Exp. – 0-2 yrs
Apply Here – https://www.foundit.in/job/data-scientist-iii-walmart-bengaluru-bangalore-india-31110692?searchId=2e1e6619-e60d-4cfd-9341-e0447e6683cc

Company – Medtronic LABS
Role – Data Scientist
Exp. – 0-2 yrs
Apply Here – https://www.foundit.in/job/data-scientist-medtronic-labs-bengaluru-bangalore-india-31102745?searchId=aed030a2-b8e3-48b1-8844-51dc56871b66

Company – Wolters Kluwer
Role – Data Scientist
Exp. – 0-2 yrs
Apply Here – https://www.foundit.in/job/data-scientist-wolters-kluwer-pune-india-31183197?searchId=bab7c0ad-85ed-44c7-be8b-8ad18d6330f7

Company – The Sleep Company
Role – Data Analytics Intern
Exp. – Fresher
Apply Here – https://www.linkedin.com/jobs/view/3975795269

e2openllc is hiring for Associate Software Engineer

2024/2023/2022 passouts
Bangalore

Apply Here :
https://boards.greenhouse.io/e2openllc/jobs/4363463101

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

struct Results {
    string sn;
    vector<string> c;
};

int rv(const string &cd) {
    unordered_map<string, int> ro = {
        {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7},
        {"8", 8}, {"9", 9}, {"10", 10}, {"J", 11}, {"Q", 12}, {"K", 13}, {"A", 14}
    };
    string r = cd.substr(0, cd.size() - 1);
    return ro[r];
}

pair<unordered_map<string, vector<string>>, unordered_map<char, vector<string>>>
pc(const vector<string> &cs) {
    unordered_map<string, vector<string>> rd;
    unordered_map<char, vector<string>> sd = {{'S', {}}, {'H', {}}, {'D', {}}, {'C', {}}};
    for (const auto &cd : cs) {
        string r = cd.substr(0, cd.size() - 1);
        char s = cd.back();
        rd[r].push_back(cd);
        sd[s].push_back(cd);
    }
    return {rd, sd};
}

Results f_sc(const vector<string> &cs) {
    auto it = max_element(cs.begin(), cs.end(), [](const string &a, const string &b) {
        return rv(a) < rv(b);
    });
    return {"single card", {*it}};
}

Results f_p(const unordered_map<string, vector<string>> &rd) {
    vector<vector<string>> ps;
    for (const auto &e : rd) {
        if (e.second.size() >= 2) {
            ps.push_back(e.second);
        }
    }
    if (!ps.empty()) {
        auto it = max_element(ps.begin(), ps.end(), [](const vector<string> &a, const vector<string> &b) {
            return rv(a[0]) < rv(b[0]);
        });
        return {"pair", {(*it)[0], (*it)[1]}};
    }
    return {"", {}};
}

Results f_t(const unordered_map<string, vector<string>> &rd) {
    vector<vector<string>> ts;
    for (const auto &e : rd) {
        if (e.second.size() >= 3) {
            ts.push_back(e.second);
        }
    }
    if (!ts.empty()) {
        auto it = max_element(ts.begin(), ts.end(), [](const vector<string> &a, const vector<string> &b) {
            return rv(a[0]) < rv(b[0]);
        });
        return {"triple", {(*it)[0], (*it)[1], (*it)[2]}};
    }
    return {"", {}};
}

Results f_fr(const vector<string> &cs) {
    vector<string> sc = cs;
    sort(sc.begin(), sc.end(), [](const string &a, const string &b) {
        return rv(a) < rv(b);
    });

    unordered_map<int, string> vtcd;
    for (const auto &cd : sc) {
        vtcd[rv(cd)] = cd;
    }

    for (int i = 14; i >= 5; --i) {
        if (vtcd.count(i) && vtcd.count(i - 1) && vtcd.count(i - 2) &&
            vtcd.count(i - 3) && vtcd.count(i - 4)) {
            return {"five in a row", {vtcd[i], vtcd[i - 1], vtcd[i - 2],
                                      vtcd[i - 3], vtcd[i - 4]}};
        }
    }
    return {"", {}};
}

Results f_s(const unordered_map<char, vector<string>> &sd) {
    vector<char> so = {'S', 'H', 'D', 'C'};
    for (char s : so) {
        if (sd.at(s).size() >= 5) {
            return {"suit", vector<string>(sd.at(s).begin(), sd.at(s).begin() + 5)};
        }
    }
    return {"", {}};
}

Results f_tp(const unordered_map<string, vector<string>> &rd) {
    vector<vector<string>> ts;
    vector<vector<string>> ps;
    for (const auto &e : rd) {
        if (e.second.size() >= 3) {
            ts.push_back(e.second);
        } else if (e.second.size() >= 2) {
            ps.push_back(e.second);
        }
    }
    if (!ts.empty() && !ps.empty()) {
        auto ht = max_element(ts.begin(), ts.end(), [](const vector<string> &a, const vector<string> &b) {
            return rv(a[0]) < rv(b[0]);
        });
        auto hp = max_element(ps.begin(), ps.end(), [](const vector<string> &a, const vector<string> &b) {
            return rv(a[0]) < rv(b[0]);
        });
        return {"a triple and a pair", {(*ht)[0], (*ht)[1], (*ht)[2], (*hp)[0], (*hp)[1]}};
    }
    return {"", {}};
}

Results sol(vector<string> &cs) {
    auto pcards = pc(cs);
    auto rd = pcards.first;
    auto sd = pcards.second;
   
    vector<Results> ps = {
        f_sc(cs),
        f_p(rd),
        f_t(rd),
        f_fr(cs),
        f_s(sd),
        f_tp(rd)
    };
   
    ps.erase(remove_if(ps.begin(), ps.end(), [](const Results &r) {
        return r.sn.empty();
    }), ps.end());
   
    unordered_map<string, int> so = {
        {"single card", 1},
        {"pair", 2},
        {"triple", 3},
        {"five in a row", 4},
        {"suit", 5},
        {"a triple and a pair", 6}
    };
   
    auto ss = max_element(ps.begin(), ps.end(), [&so](const Results &a, const Results &b) {
        return so[a.sn] < so[b.sn];
    });
   
    return *ss;
}


//ms task 1 ✅

def max_units(boxes, units_per_box, truck_size):
    products = list(zip(units_per_box, boxes))
    products.sort(reverse=True)
    max_units = 0
    for units, boxes in products:
        if truck_size >= boxes:
            max_units += units * boxes
            truck_size -= boxes 
        else:
            max_units += units * truck_size
            break
    return max_units

Efficient Shipping ✅

Affinsys AI Hiring for passionate Software Engineers (0-3 yrs exp)
Share your resume at baldeep@affinsys.com
Office Location : Whitefield Bangalore
Qualification- B.Tech CSE, IT, ECE
Experience Required: 0-3 years

Immediate joiners preferred
If you’re proficient in Python, and excited about implementing cutting-edge solutions, we want you in the team.

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;
}

DE Shaw ✅