Hiring Freshers | Role: Junior Java Developer.
Location: Bangalore (On-site) 
Key Skills: Java, Spring, SQL, GitHub, Postgres 
Send CV to varaprasad.v@people-prime.com

TCS HackQuest

The Contest is open to students (enrolled in any recognized college /university / academic institute) in India who will be graduating in the academic year 2024 with any of the following degrees in any specialization:
Bachelor of Technology (B. Tech)
Bachelor of Engineering (B.E)
Master of Technology (M. Tech)
Master of Engineering (M.E.)
Bachelor of Computer Applications (B.C.A.)
Master of Computer Applications (M.C.A.)
Bachelor of Science (B.Sc. - B.S.)
Master of Science (M.Sc. - M.S.)

https://hackquest.tcsapps.com/

long solvee(vector<int>& nums) {
    long mini = 0, run = 0;

    for (int n : nums) {
        run += n;
        mini = min(mini, run);
    }

    return 1 - mini;
}

Stay positive ✅

int fun(int a, int b){
    return (int)((int)pow(a, b) % (int)(pow(10, 9) + 7));
}

int raisingPower(vector<int> arr){
    if(arr.size()<3) return 1; 
    int result = INT_MAX;
    int n = arr.size();
    for(int i = 1; i <= n - 2; i++){
        if(fun(arr[i], arr[i + 1]) >= fun(arr[i + 1], arr[i + 2])){
            result = min(result, i);
        }
    }
    return result + 1;
}

Analyzing arrays ✅

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✅