RMSI Pvt. Ltd. Hiring for the role of Trainee Engineer (GIS) ❤️❤️❤️

Experience:Fresher

Dateof Interview: 10th August, 2024

Time: 9.30 AM – 3.30 PM

Venue:RMSI Private Ltd, Ascandas IT Park, The V, Vega Building, Gate No. 5, 11th Floor, Right Wing, Plot No.17, Software Units Layout, Madhapur, Hyderabad – 500 081

Note: Please carry your original ID proof for Entry.

Skills/Requirements:
1. Good communication and good Interpersonal skills and have ability to initiate changes in work process/area & handling additional responsibilities.
2. Proficiency in English communication and comprehension of comments.
3. Should have strong analytical skills and logical thinking. Ability to work in challenging.
4. Situation and adapt for dynamic changes and be flexible.
5. Should be a team player and be proactive in communicating any process gap.

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