def roman_to_decimal(a):
    b = {'I': 1, 'V': 5, 'X': 10, 'L': 50} 
    c = 0 

    for i in range(len(a)):
        if i > 0 and b[a[i]] > b[a[i - 1]]:
            c += b[a[i]] - 2 * b[a[i - 1]]
        else:
            c += b[a[i]]

    return c

def sortRoman(names):
    def custom_sort(e):
        d = e.split() 
        return (d[0], roman_to_decimal(d[1]))

    sorted_names = sorted(names, key=custom_sort)
    return sorted_names
Romanizer ✅

Java ✅

Company Name : Even Healthcare

Batch : 2025 passouts
Role : SDE Interns - 6 months

Link : https://careers.even.in/open-roles/backend-engineering-intern

def a(b, c, d, e, f, g):
    if c == e:
        g.append(tuple(sorted(f)))
        return
    if c > e or b >= len(d):
        return
    a(b + 1, c + d[b], d, e, f + [d[b]], g)
    a(b + 1, c, d, e, f, g)
def h(i, j, k):
    l = []
    a(0, 0, k, j, [], l)
    m = set(l)
    return len(m)
n, k = map(int, input().split())  
pieces = list(map(int, input().split()))
print(h(n, k, pieces))

The Puzzle Masters of puzzleville ✅
DeltaX

Company Name: Dream 11
Role: SDE 1
YOE: 0-2 years

Apply: https://jobs.lever.co/dreamsports/93fe293c-f410-481e-93f4-005795c29788

Company Name: Synopsys
Role: Software Engineer
Batch eligible: 2024 grads (2025 can try but chances are very low)

Apply: https://careers.synopsys.com/job/-/-/44408/71068434688?codes=OT

Company Name: Lowe’s
Role: Associate Software Engineer
Batch eligible: 2023 and 2024 grads

Apply: https://talent.lowes.com/in/en/job/JR-01854460/Associate-Software-Engineer

Company Name: Baker Hughes
Role: Early Career Trainee - Software Engineering
Batch eligible: 2024 grads only

Apply: https://careers.bakerhughes.com/global/en/job/BAHUGLOBALR132004/Early-Career-Trainee-Software-Engineering

Send your resumes to: careers@yalamanchili.in

#include <vector>
#include <algorithm>

bool isPal(int x) {
    int orig = x, rev = 0;
    while (x > 0) {
        rev = rev * 10 + x % 10;
        x /= 10;
    }
    return orig == rev;
}
vector<int> solution(vector<int>& trans) {
    vector<int> pal;
    for (int t : trans) {
        if (isPal(t)) {
            pal.push_back(t);
        }
    }
    sort(pal.rbegin(), pal.rend());
    return pal;
}

Visa ✅

from collections import deque
def solution(latencies, threshold):
    m = deque()  
    n = deque()  
    start = 0  
    max_len = 0 
    for end in range(len(latencies)):
        while m and latencies[m[-1]] <= latencies[end]:
            m.pop()
        while n and latencies[n[-1]] >= latencies[end]:
            n.pop()
        m.append(end)
        n.append(end)
        while latencies[m[0]] - latencies[n[0]] > threshold:
            start += 1
            if m[0] < start:
                m.popleft()
            if n[0] < start:
                n.popleft()
        max_len = max(max_len, end - start + 1)
    return max_len

Visa ✅

def findLocalMaximums(a):
    def is_local_maximum(b, c):
        d = a[b][c]
        if d == 0:
            return False
        r = d * 2 + 1
        h = d
        rs = max(0, b - h)
        rn = min(len(a) - 1, b + h)
        cs = max(0, c - h)
        cn = min(len(a[0]) - 1, c + h)
        for x in range(rs, rn + 1):
            for y in range(cs, cn + 1):
                if (x == b - h and (y == c - h or y == c + h)) or \
                   (x == b + h and (y == c - h or y == c + h)):
                    continue  
                if (x, y) != (b, c) and a[x][y] >= d:
                    return False
        return True

    result = []
    for b in range(len(a)):
        for c in range(len(a[0])):
            if is_local_maximum(b, c):
                result.append([b, c])
    
    return sorted(result)

Visa ✅

def retrievePasscodes(strips):
    sorted_strips = sorted([s.strip() for s in strips], key=lambda x: int(x[0], 36))
    characters = [s[1:] for s in sorted_strips]
    result = [''.join(row) for row in zip(*characters)]
    for line in result:
        print(line)

IBM ✅

#include <iostream>
#include <cmath>
#include <algorithm>

int solution(int M, int N) {
    int total_area = 4 * N + M;

    int x = static_cast<int>(:sqrt(total_area));

    while (x > 0) {
        int needed_tiles = x * x;

        int max_2x2_tiles = (x / 2) * (x / 2);

        if (needed_tiles <= 4 * min(N, max_2x2_tiles) + M) {
            return x;
        }

        --x;
    }

    return 0;
}

Microsoft ✅
Task 1