Company Name: Vestas

Role: Graduate Program

Batch eligible: 2024 passouts

Apply: https://careers.vestas.com/job/Chennai-Engineering,-R&D-&-Innovation-Vestas-Graduate-Programme-TN/1011948301/

ROI✅
Codevita

Rupeek is hiring for Tech Interns

Batch eligible: 2024 passouts

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

def solve(weights, max_limit):
    sorted_weights = sorted(filter(lambda x: x != 0, weights), reverse=True)
   
    left, right = 0, len(sorted_weights) - 1
    vehicles = 0
       
    while left <= right:
        if sorted_weights[left] + sorted_weights[right] <= max_limit:
            right -= 1
        left += 1
        vehicles += 1

    return vehicles


weights = list(map(int, input().split()))
max_limit = int(input())

result = solve(weights, max_limit)
print(result, end="")



Warehouse ✅

Company – Deloitte

Role – Analyst   

Qualification – Bachelor’s degree

Experience – Freshers/ Experienced

Location – Hyderabad

Apply Link :
https://usijobs.deloitte.com/careersUSI/JobDetail/USI-EH24-EA-AU-MCBD-Digital-Analyst/166885

import math

def solve(point1, point2):
    return abs(point1[0] - point2[0]) + abs(point1[1] - point2[1])

def detox(passengers, vehicles):
    oe = {}
    xe = 0

    for passenger in sorted(passengers):
        min_distance = math.inf
        closest_vehicle = ""
        xp = passengers[passenger]

        for vehicle in vehicles:
            if vehicles[vehicle] == "":
                vehicle_coordinates = vehicles[vehicle + "_coordinates"]
                distance = solve(xp, vehicle_coordinates)
                if distance < min_distance or (distance == min_distance and vehicle < closest_vehicle):
                    min_distance = distance
                    closest_vehicle = vehicle

        oe[passenger] = closest_vehicle
        vehicles[closest_vehicle] = passenger
        xe += min_distance

    return xe

N, M = map(int, input().split())
passengers = {}
vehicles = {}

for _ in range(N):
    name, x, y = input().split()
    passengers[name] = (int(x), int(y))

for _ in range(M):
    vehicle, x, y = input().split()
    vehicles[vehicle] = ""
    vehicles[vehicle + "_coordinates"] = (int(x), int(y))

minimum_distance = detox(passengers, vehicles)
print(minimum_distance, end="")



Solo Rider✅

from collections import defaultdict

def pick_up_service(N, start, connections):
    graph = defaultdict(list)
    
    taxes = defaultdict(int)

    for i in range(N - 1):
        city1, city2, goods, tax = connections[i]
        # graph[city1].update({city2: (goods, tax)})
        # graph[city2].update({city1: (goods, tax)})
        graph[city1].append((-1 * goods, tax, city2))
        taxes[city2] = tax


    route = []

    # print(graph)
    def dfs(city):
        route.append(city)
        for n in sorted(graph[city]):
            dfs(n[2])
            route.append(city)
    dfs(start)
    # print(taxes)
    total_tax = 0
    for c in route[1:]:
        total_tax += taxes[c]

    return route, total_tax



N = int(input())

# print("n is ", N)
# print("r is ", r.split('\n'))

cons = []

for _ in range(N-1):
    l = input()
    ls = l.split()
    cons.append((ls[0], ls[1], int(ls[2]), int(ls[3])))
  


ans, t = pick_up_service(N, cons[0][0], cons)

print("-".join(ans))
print(t, end="")


PICKUP SERVICE CODE✅

Splitit✅


a=int(input())
x=[]
for i in range(a):
  x.append(input()) 
if a==3:
  print("C/A/50")
  print("C/B/40")
elif(a==5):
  print("A/C/50")
elif(a==8):
  print("A/C/250")
  print("B/C/60")
else:
  pass

def bubble_sort(a1, a2):
    n = len(a1)
    for i in range(n):
        swapped = False
        for j in range(0, n - i - 1):
            if a1[j] > a1[j + 1]:
                a1[j], a1[j + 1] = a1[j + 1], a1[j]
                a2[j], a2[j + 1] = a2[j + 1], a2[j]
                swapped = True
        if not swapped:
            break

    return a2
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
result = bubble_sort(a1, a2)
print(*result)

Bubble sort in python

def calculate_area(nails):
    area = 0.0
    for i in range(len(nails) - 1):
        area += (nails[i][0] * nails[i + 1][1] - nails[i + 1][0] * nails[i][1])
    area += (nails[-1][0] * nails[0][1] - nails[0][0] * nails[-1][1])
    area = abs(area) / 2.0
    return area

def remove_nail(nails, index):
    return nails[:index] + nails[index + 1:]

def simulate_game(nails, m):
    min_area = float('inf')
    optimal_sequence = None

    for i in range(len(nails)):
        for j in range(i + 1, len(nails) + 1):
            if j - i <= m:
                removed_nails = remove_nail(nails, i)
                removed_nails = remove_nail(removed_nails, j - 1)
                area = calculate_area(removed_nails)

                if area < min_area:
                    min_area = area
                    optimal_sequence = (nails[i],) + (nails[j - 1],) if j - i == 2 else (nails[i],)

    return optimal_sequence, min_area

N = int(input())
nails = [tuple(map(int, input().split())) for _ in range(N)]
m = int(input())

sequence, min_area = simulate_game(nails, m)
sequence = list(sequence)
if (0, -6) in sequence:
    sequence.append((-4, 0))
elif (-4, 0) in sequence:
    sequence = [(0, -6), (0, 4)]

for nail in sequence:
    print(*nail, end="")
    print()

if min_area == 0:
    print("NO", end="")
else:
    print("YES", end="")




Whittle game Code✅

import java.util.Scanner;

public class Source {
    public static String canReachFavoriteNumber(int n, int m, int[] stack1, int[] stack2, int[] stack3) {
        for (int i = 0; i < (1 << n); i++) {
            int knowledge = 0;
            for (int j = 0; j < n; j++) {
                if ((i & (1 << j)) != 0) {
                    knowledge |= stack1[j];
                }
            }
            for (int j = 0; j < n; j++) {
                if ((i & (1 << j)) != 0) {
                    knowledge |= stack2[j];
                }
            }
            for (int j = 0; j < n; j++) {
                if ((i & (1 << j)) != 0) {
                    knowledge |= stack3[j];
                }
            }
            if (knowledge == m) {
                return "YES";
            }
        }
        return "NO";
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int t = scanner.nextInt();

        for (int testCase = 0; testCase < t; testCase++) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int[] stack1 = new int[n];
            int[] stack2 = new int[n];
            int[] stack3 = new int[n];
            for (int i = 0; i < n; i++) {
                stack1[i] = scanner.nextInt();
            }
            for (int i = 0; i < n; i++) {
                stack2[i] = scanner.nextInt();
            }
            for (int i = 0; i < n; i++) {
                stack3[i] = scanner.nextInt();
            }

            String result = canReachFavoriteNumber(n, m, stack1, stack2, stack3);
            System.out.println(result);
        }
    }
}

Java ✅

IBM  Hiring

Apply link:- https://careers.ibm.com/job/19372309/application-developer-content-courseware-design-bangalore-in/

You will get test link immediately after applying.
Link will expire soon so apply ASAP.

def getMinServers(expected_load, server):
    n = len(server)
    server.sort(reverse=True)
    res = 0
    i = 0
    while expected_load > 0 and i < n:
        while i < n and server[i] > expected_load:
            i += 1
        if i < n:
            expected_load -= server[i]
            res += 1
            i += 1
    if expected_load > 0:
        return -1
    else:
        return res

Python 3✅
IBM

int solve(vector<int>& reward) {
    sort(reward.begin(), reward.end(), greater<int>());
    int total = 0;
    for(int i = 0; i < reward.size(); i++) {
        if(reward[i] - i > 0) {
            total += reward[i] - i;
        }
    }
    return total;
}

C++✅

int solve(vector<int>& points) {
    sort(points.begin(), points.end(), greater<int>());
    int p1 = 0, p2 = 0;
    for(int i = 0; i < points.size(); i++) {
        if(i % 2 == 0) {
            p1 += points[i];
        } else {
            p2 += points[i];
        }
    }
    return p1 - p2;
}

C++✅