Company Name: HSBC
Role: Software Engineer

Batch eligible: 2023 and 2024 grads

Apply: https://mycareer.hsbc.com/en_GB/external/PipelineDetail/Software-Engineer/222604

Company Name: Walmart
Role: Software Engineer 2

Batch eligible: 2023 and 2024 grads

Apply: https://walmart.wd5.myworkdayjobs.com/en-US/WalmartExternal/job/XMLNAME--IND--SOFTWARE-ENGINEER-II_R-1903463

P.S: In Walmart SDE 2 is for freshers (Apply kro)

#include <iostream>
#define ll long long
using namespace std;
int main(){
  int t; cin>>t;
  while(t-->0){
    ll n, x, y; cin>>n>>x>>y;
    x--; y--;
    if(x>y){
      swap(x, y);
    }
    if(x==y){
      cout<<max(x, n-1-y)<<endl;
      continue;
    }
    ll ans = 1e9;
    for(int i=x; i<=y; i++){
      ll minix = min((i-x),x);
      ll maxix = max((i-x),x);
      ll miniy = min((y-i-1),(n-1-y));
      ll maxiy = max((y-i-1),(n-1-y));
      ans = min(ans, max(2*minix+maxix, 2*miniy + maxiy));
    }
    cout<<ans<<endl;
  }
  return 0;
}

Street Explorer ✅

def integerThreshold(d, t):
    d.sort()  
    n = len(d)
    count = 0

    for i in range(n - 2):
        a = d[i]
        j, k = i + 1, n - 1  

        while j < k:
            b = d[j]
            c = d[k]

            if a < b < c and a + b + c <= t:
                count += k - j
                j += 1 
            else:
                k -= 1  

    return count

Integrated threshold
BNY✅

from math import comb

def findPaths(matches, wins):
    if wins > matches:
        return ["Impossible"]
    paths_count = comb(matches, wins)
    if paths_count == 1:
        return ["W" * wins + "L" * (matches - wins)]
    
    paths = []
    
    def genPath(remMatch, remWins, currPath=""):
        if len(currPath) == matches:
            paths.append(currPath)
            return
        
        if remWins > 0:
            genPath(remMatch - 1, remWins - 1, currPath + "W")
        if remMatch - remWins > 0:
            genPath(remMatch - 1, remWins, currPath + "L")
    genPath(matches, wins)
    
    return paths

Cricket Worldcup Qualification✅

def calculateScore(text, prefixString, suffixString):
    n = len(text)
    len_prefix = len(prefixString)
    len_suffix = len(suffixString)
    

    prefix_match_lengths = [0] * n
    suffix_match_lengths = [0] * n

    prefix_match = 0
    for i in range(n):
        if prefix_match < len_prefix and text[i] == prefixString[prefix_match]:
            prefix_match += 1
        prefix_match_lengths[i] = prefix_match
        if prefix_match == len_prefix:
            prefix_match -= 1


    suffix_match = 0
    for i in range(n - 1, -1, -1):
        if suffix_match < len_suffix and text[i] == suffixString[suffix_match]:
            suffix_match += 1
        suffix_match_lengths[i] = suffix_match

        if suffix_match == len_suffix:
            suffix_match -= 1

    best_score = -1
    best_substring = ""

    for i in range(n):
        for j in range(i, n):
            substring_length = j - i + 1
            prefix_score = prefix_match_lengths[j] - (prefix_match_lengths[i - 1] if i > 0 else 0)
            suffix_score = suffix_match_lengths[i] if i + substring_length - 1 < n else 0
            total_score = prefix_score + suffix_score

            if total_score > best_score or (total_score == best_score and substring_length > len(best_substring)):
                best_score = total_score
                best_substring = text[i:j + 1]

    return best_substring

BNY String score✅

long countSubarrays(vector<int> numbers,int k){
    int N = numbers.size();
    long cnt = 0 , prod = 1;
    for(int L=0,R=0;R<N;R++){
        prod *= numbers[R];
        while(prod > k) prod /= numbers[L++];
        cnt += (R-L+1);
    }
    return cnt;
}

BNY✅

#include <iostream>
#include <vector>
#include <string>
const int MOD = 1e9 + 7;
int numDistinctWays(const string& S, const string& T) {
    int m = S.length();
    int n = T.length();
    vector<vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));

    for (int i = 0; i <= m; ++i) {
        dp[i][0] = 1; 
    }

    for (int i = 1; i <= m; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (S[i - 1] == T[j - 1]) {
                dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % MOD;
            } else {
                dp[i][j] = dp[i - 1][j];
            }
        }
    }

    return dp[m][n];
}

Trilogy ✅

bool canDoJob(const vector<bool>& jobSk, const vector<bool>& candSk) {
    for (int i = 0; i < jobSk.size(); ++i) {
        if (jobSk[i] && !candSk[i]) {
            return false;
        }
    }
    return true;
}

int solve(vector<int>& prof, vector<vector<bool>>& jobSk, vector<vector<bool>>& candSk) {
    int numJobs = prof.size();
    int numCands = candSk.size();
    vector<int> dp(1 << numJobs, 0);

    for (int m = 0; m < (1 << numJobs); ++m) {
        for (int i = 0; i < numCands; ++i) {
            for (int j = 0; j < numJobs; ++j) {
                if (!(m & (1 << j)) && canDoJob(jobSk[j], candSk[i])) {
                    dp[m | (1 << j)] = max(dp[m | (1 << j)], dp[m] + prof[j]);
                }
            }
        }
    }

    return dp[(1 << numJobs) - 1];
}

job trilogy✅

def maxProfit(profits, skillsForJobs, skillsOfCandidates):
    from functools import lru_cache

    j_num = len(profits)
    c_num = len(skillsOfCandidates)
    s_num = len(skillsForJobs[0])

    def canHire(c, j):
        return all(skillsOfCandidates[c][k] or not skillsForJobs[j][k] for k in range(s_num))

    can_handle_job = [[canHire(cand, job) for job in range(j_num)] for cand in range(c_num)]

    @lru_cache(None)
    def dp(m, j_idx):
        if j_idx == j_num:
            return 0
        
        max_profit = dp(m, j_idx + 1)  
        for c in range(c_num):
            if can_handle_job[c][j_idx] and not (m & (1 << c)):
                profit = profits[j_idx] + dp(m | (1 << c), j_idx + 1)
                max_profit = max(max_profit, profit)
        return max_profit

    return dp(0, 0)  

Max Profit
Trilogy ✅

#include <iostream>
#include <vector>
#include <string>

class DisjointSet {
    std::vector<int> parent, rank;
    std::vector<bool> parity;
public:
    DisjointSet(int n) : parent(n), rank(n, 0), parity(n, false) {
        for (int i = 0; i < n; i++) parent[i] = i;
    }
   
    int find(int x) {
        if (parent[x] != x) {
            int p = parent[x];
            parent[x] = find(p);
            parity[x] = parity[x] ^ parity[p];
        }
        return parent[x];
    }
   
    bool unite(int x, int y, bool diff) {
        int px = find(x), py = find(y);
        if (px == py) return (parity[x] ^ parity[y]) == diff;
        if (rank[px] < rank[py]) std::swap(px, py);
        parent[py] = px;
        parity[py] = parity[x] ^ parity[y] ^ diff;
        if (rank[px] == rank[py]) rank[px]++;
        return true;
    }
};

std::vector<std::string> solve(const std::vector<std::vector<int>>& A) {
    int maxDim = 0;
    for (const auto& query : A) {
        maxDim = std::max(maxDim, std::max(query[0], query[1]));
    }
    maxDim++;

    std::vector<std::string> result;
    DisjointSet ds(2 * maxDim);

    for (const auto& query : A) {
        int x = query[0], y = query[1];
        int x_val = query[2], y_val = query[3];
       
        bool diff = (x_val != y_val);
        if (ds.unite(x, maxDim + y, diff)) {
            result.push_back("Yes");
        } else {
            result.push_back("No");
        }
    }
   
    return result;
}

int main() {
    std::vector<std::vector<int>> A1 = {{1, 1, 1, 1}, {1, 2, 1, -1}};
    std::vector<std::vector<int>> A2 = {{1, 1, 1, 1}, {1, 2, 1, 1}, {2, 2, 1, 1}, {2, 1, 1, -1}};
   
    auto result1 = solve(A1);
    auto result2 = solve(A2);
   
    std::cout << "Output 1: ";
    for (const auto& s : result1) std::cout << s << " ";
    std::cout << "\nOutput 2: ";
    for (const auto& s : result2) std::cout << s << " ";
    std::cout << std::endl;
   
    return 0;
}

Matrice
Trilogy ✅

#include <vector>
#include <iostream>

using namespace std;

vector<int> solution(int riverWidth, int maxJump, vector<int> platformSizes) {
    int N = 1e5 + 5;
    int maxJumpTemp, totalPlatforms, currentPlatform, prefixSum[N], platformLength[N];
    vector<int> answer(riverWidth, 0); // Initialize answer with 0 and size riverWidth
   
    totalPlatforms = riverWidth;
    currentPlatform = platformSizes.size();
    maxJumpTemp = maxJump;
   
    for (int i = 1; i <= currentPlatform; i++) {
        prefixSum[i] = platformSizes[i - 1];
        platformLength[i] = prefixSum[i];
    }
   
    for (int i = 1; i <= currentPlatform; i++) {
        prefixSum[i] += prefixSum[i - 1];
    }
   
    int currentIndex = 1, gap = 1, maxReach = 0;
    for (int j = 1; j <= currentPlatform; ) {
        if (currentIndex - 1 + prefixSum[currentPlatform] - prefixSum[j - 1] == totalPlatforms) {
            int start = currentIndex;
            for (; currentIndex < platformLength[j] + start; currentIndex++)
                answer[currentIndex - 1] = j, maxReach = currentIndex;
            j++;
            gap = 1;
        } else if (gap < maxJumpTemp) {
            gap++;
            currentIndex++;
            continue;
        } else if (gap == maxJumpTemp) {
            int start = currentIndex;
            for (; currentIndex < platformLength[j] + start; currentIndex++)
                answer[currentIndex - 1] = j, maxReach = currentIndex;
            j++;
            gap = 1;
        }
    }
   
    if (totalPlatforms + 1 - maxReach > maxJumpTemp) {
        return {-1};
    }
   
    return answer;
}

int main() {
    int riverWidth = 7;
    int maxJump = 2;
    vector<int> platformSizes = {1, 2, 1};

    vector<int> result = solution(riverWidth, maxJump, platformSizes);
    for (int num : result) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

River vala mario✅
Trilogy

Quest Global

Off Campus Recruitment Drive
Degree: BE / B.Tech / MCA
Year of Completion: 2023 / 2024

https://forms.office.com/pages/responsepage.aspx?id=pCOqk-FuAUaFkjGnYkiTWSEIpM2LK_JOkjumpG3xVgxUMjQ1MVQ1VkkyQTU1MFpXOElTNFJXMlQ2Sy4u

Taskus is hiring Junior Developer

For 2021, 2022, 2023 grads
Location: Chennai

https://jobs.eu.humanly.io/jobs/bd25b188-b5c7-4db9-baa1-71db0f3601b2?source=LinkedIn

Coakroach Labs  International Opportunity  fresh Grads

Role - Backend Engineer
Exp - Fresher
Location- Toronto

Link - https://boards.greenhouse.io/cockroachlabs/jobs/6145671

Spinny Hiring

Interns for Project Engineering profile at our headquarters at Gurugram.

Internship duration: 3-4 months

★Perks Provided on completion:
💡Letter Of Appreciation
💡Letter Of Recommendation Stipend
💡PPO (Based on the performance)

Points of necessary consideration:
- Must be 2023 pass out from Civil Engineering Courses.
- Must have experience with project management.
- Get on board with a team of extragavant professionals and have the necessary boost up to your career.

💻NOTE: Working Assets and Laptops will be provided.

Interested candidates can share their CV at the email address provided below: suryansh.tiwari@spinny.com

Civil Engineering students can apply

🚀Aryson Technologies has launched multiple paid Internship program 🚀

⏳Duration: 6 months
💵Stipend: Rs 5000
📍 Location: Sector 58, Noida

- Software Tester
- Web Designing
- Graphic Designing
- Technical Writer
- SEO

Share your updated resume to:
milanhrdept@arysontechnologies.com