int main() {
string s;
cin >> s;
int n = s.length(), res = 0;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
int lw = s[0] - '0', lwv = v[0];
for (int i = 1; i < n; ++i) {
if (s[i] - '0' == lw) {
res += min(lwv, v[i]);
lwv = max(lwv, v[i]);
} else {
lw = s[i] - '0';
lwv = v[i];
}
}
cout << res;
return 0;
}
Form alternating string

Change accordingly before submitting to avoid plagiarism

using System;
using System.Collections.Generic;

class Program
{
static void Main()
{
int N = int.Parse(Console.ReadLine());
var graph = new Dictionary<string, List<string>>();
var indegrees = new Dictionary<string, int>();


for (int i = 0; i < N; i++)
{
var edge = Console.ReadLine().Split();
string from = edge[0];
string to = edge[1];

if (!graph.ContainsKey(from))
graph[from] = new List<string>();
graph[from].Add(to);


if (!indegrees.ContainsKey(from))
indegrees[from] = 0;
if (!indegrees.ContainsKey(to))
indegrees[to] = 0;
indegrees[to]++;
}


var words = Console.ReadLine().Split();


var levels = new Dictionary<string, int>();
var queue = new Queue<string>();


foreach (var node in indegrees.Keys)
{
if (indegrees[node] == 0)
{
levels[node] = 1; // Root level is 1
queue.Enqueue(node);
}
}

while (queue.Count > 0)
{
var current = queue.Dequeue();
int currentLevel = levels[current];

if (graph.ContainsKey(current))
{
foreach (var neighbor in graph[current])
{
if (!levels.ContainsKey(neighbor))
{
levels[neighbor] = currentLevel + 1;
queue.Enqueue(neighbor);
}
indegrees[neighbor]--;
if (indegrees[neighbor] == 0 && !levels.ContainsKey(neighbor))
{
queue.Enqueue(neighbor);
}
}
}
}


int totalValue = 0;

foreach (var word in words)
{
if (levels.ContainsKey(word))
{
totalValue += levels[word];
}
else
{
totalValue += -1;
}
}


Console.Write(totalValue);
}
}
String Puzzle
C+

Company : NTT
Role : Intern
Qualification :Bachelor’s / Master’s
Batch : 2025 & 2026
Salary : Up to ₹ 6LPA
Experience : Fresher’s
Location : Bengaluru

Apply link : https://careers.services.global.ntt/global/en/job/NTT1GLOBALR121946EXTERNALENGLOBAL/Intern?utm_source=indeed&utm_medium=phenom-feeds


Company : Capgemini
Role : Deal Centre of Excellence
Qualification : Graduate/B Com/BAF
Batch : 2024 without any Active Backlogs
Salary : Up to ₹ 5 LPA
Experience : Fresher’s
Location : Mumbai

Apply link : https://www.capgemini.com/in-en/solutions/off-campus-drive-for-deal-centre-of-excellence-dcoe-2024-graduates/

Count press

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

using namespace std;

int dp(string& s, vector<string>& v, unordered_map<string, int>& memo) {
if (memo.count(s)) return memo[s];

int maxRemoval = 0;

for (auto& x : v) {
size_t pos = s.find(x);
if (pos != string::npos) {
string new_string = s.substr(0, pos) + s.substr(pos + x.size());
maxRemoval = max(maxRemoval, 1 + dp(new_string, v, memo));
}
}
return memo[s] = maxRemoval;
}

int main() {
int n;
cin >> n;

vector<string> substrings(n);
for (int i = 0; i < n; ++i) {
cin >> substrings[i];
}

string mainString;
cin >> mainString;

unordered_map<string, int> memo;
cout << dp(mainString, substrings, memo);

return 0;
}


FOLDER AREA
#include <iostream>
#include <cmath>
#include <set>
#include <iomanip>
#include <vector>
#include <utility>
using namespace std;

pair<double, double> reflectPoint(double px, double py, double x1, double y1, double x2, double y2) {
double A = y2 - y1;
double B = x1 - x2;
double C = x2 * y1 - x1 * y2;
double distance = (A * px + B * py + C) / sqrt(A * A + B * B);
double reflectedX = px - 2 * distance * (A / sqrt(A * A + B * B));
double reflectedY = py - 2 * distance * (B / sqrt(A * A + B * B));
return {reflectedX, reflectedY};
}

int main() {
double area;
cout << "Enter area of the square: ";
cin >> area;

double x1, y1, x2, y2;
cout << "Enter the coordinates of the line (x1 y1 x2 y2): ";
cin >> x1 >> y1 >> x2 >> y2;

double side = sqrt(area);
vector<pair<double, double>> corners = {
{0, 0},
{0, side},
{side, side},
{side, 0}
};

set<pair<double, double>> uniquePoints(corners.begin(), corners.end());

for (const auto& corner : corners) {
auto [rx, ry] = reflectPoint(corner.first, corner.second, x1, y1, x2, y2);
uniquePoints.insert({rx, ry});
}

for (const auto& point : uniquePoints) {
cout << fixed << setprecision(2) << point.first << " " << point.second << endl;
}

return 0;
}

Segment display
#include <bits/stdc++.h>
using namespace std;

int main() {
vector<vector<string>> A = {
{"11111", "11111", "11111", "11111", "11111", "11111", "11111", "10001", "11111", "11111", "10001", "10000", "11111", "10001", "01110", "11111", "11111", "11111", "11111", "11111", "10001", "10001", "10001", "10001", "10001", "11111"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10000", "10001", "00100", "00001", "10010", "10000", "10101", "11001", "10001", "10001", "10001", "10001", "10000", "00100", "10001", "10001", "10001", "00000", "10001", "00000"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10000", "10001", "00100", "00001", "10100", "10000", "10101", "10101", "10001", "10001", "10001", "10001", "10000", "00100", "10001", "10001", "10001", "01010", "10001", "00010"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10000", "10001", "00100", "00001", "11000", "10000", "10101", "10011", "10001", "10001", "10001", "10001", "10000", "00100", "10001", "10001", "10001", "00000", "10001", "00000"},
{"11111", "11111", "10000", "10001", "11111", "11111", "10111", "11111", "00100", "10001", "11111", "10000", "10101", "10001", "10001", "11111", "10101", "11111", "11111", "00100", "10001", "10001", "10101", "00100", "11111", "00100"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10001", "10001", "00100", "10001", "10001", "10000", "10001", "10001", "10001", "10000", "10001", "11000", "00001", "00100", "10001", "10001", "10101", "00000", "00001", "00000"},
{"10001", "10001", "10000", "10001", "10000", "10000", "10001", "10001", "00100", "10001", "10001", "10000", "10001", "10001", "10001", "10000", "10011", "10100", "00001", "00100", "10001", "10001", "10101", "01010", "00001", "01000"},
{"10001", "10001", "10000", "10001", "10000", "10000",

"10001", "10001", "00100", "10001", "10001", "10000", "10001", "10001", "10001", "10000", "10001", "10010", "00001", "00100", "10001", "01010", "10101", "00000", "00001", "00000"},
{"10001", "11111", "11111", "11111", "11111", "10000", "11111", "10001", "11111", "11111", "10001", "11111", "10001", "10001", "01110", "10000", "11111", "10001", "11111", "00100", "11111", "00100", "11111", "10001", "11111", "11111"}
};

vector<string> code(26, "");
for (int row = 0; row < 9; row++) {
for (int col = 0; col < 26; col++) {
code[col] += A[row][col];
}
}

map<string, char> mp;
for (char ch = 'A'; ch <= 'Z'; ch++) {
mp[code[ch - 'A']] = ch;
}

vector<string> B;
for (string s; cin >> s; B.push_back(s));

for (int L = 0, R = 0; R < (int)B[0].size(); R++) {
int zeros = 0;
for (int row = 0; row < 9; row++) {
zeros += B[row][R] == '0';
}

if (zeros == 9) {
L = R + 1;
} else if (R - L + 1 == 5) {
string pl;
for (int row = 0; row < 9; row++) {
pl += B[row].substr(L, 5);
}
if (mp.count(pl)) {
cout << mp[pl];
}
L = R + 1;
}
}

return 0;
}


Matrix rotation
def rotate_layer(layer, pos, direction, odd_layer):
n = len(layer)
rotated_layer = [None] * n

if direction == "clockwise":
for i in range(n):
rotated_layer[(i + pos) % n] = layer[i]
else:
for i in range(n):
rotated_layer[(i - pos) % n] = layer[i]

for i in range(n):
if odd_layer:
rotated_layer[i] = chr(((ord(rotated_layer[i]) - ord('A') - 1) % 26) + ord('A'))
else:
rotated_layer[i] = chr(((ord(rotated_layer[i]) - ord('A') + 1) % 26) + ord('A'))

return rotated_layer

def adjust_query(plan, row, col, size):
layers = []
for layer in range(size // 2):
current_layer = []
for j in range(col + layer, col + size - layer):
current_layer.append(plan[row + layer][j])
for i in range(row + layer + 1, row + size - layer - 1):
current_layer.append(plan[i][col + size - layer - 1])
for j in range(col + size - layer - 1, col + layer - 1, -1):
current_layer.append(plan[row + size - layer - 1][j])
for i in range(row + size - layer - 2, row + layer, -1):
current_layer.append(plan[i][col + layer])

layers.append(current_layer)

for lidx, layer in enumerate(layers):
odd_layer = (lidx + 1) % 2 == 1
direction = "counterclockwise" if odd_layer else "clockwise"
pos = lidx + 1
rotated_layer = rotate_layer(layer, pos, direction, odd_layer)

idx = 0
for j in range(col + lidx, col + size - lidx):
plan[row + lidx][j] = rotated_layer[idx]
idx += 1
for i in range(row + lidx + 1, row + size - lidx - 1):
plan[i][col + size - lidx - 1] = rotated_layer[idx]
idx += 1
for j in range(col + size - lidx - 1, col + lidx - 1, -1):
plan[row + size - lidx - 1][j] = rotated_layer[idx]
idx += 1
for i in range(row + size - lidx - 2, row + lidx, -1):
plan[i][col + lidx] = rotated_layer[idx]
idx += 1

def perform_rotation(n, plan, queries):
for row, col, size in queries:
adjust_query(plan, row, col, size)
return ''.join(''.join(row) for row in plan)

n = int(input())
plan = [list(input().strip()) for _ in range(n)]
q = int(input())
queries = [tuple(map(int, input().split())) for _ in range(q)]

result = perform_rotation(n, plan, queries)
print(result, end="")


HELP RITIKA
import sys
import math

def get_max_prefix_length_and_deletions(sub_str, target_str, start_idx):
sub_idx, target_idx, match_length = 0, start_idx, 0
while sub_idx < len(sub_str) and target_idx < len(target_str):
if sub_str[sub_idx] == target_str[target_idx]:
match_length += 1

target_idx += 1
sub_idx += 1
total_deletions = len(sub_str) - match_length
return match_length, total_deletions

def process_input():
inp = sys.stdin.read().splitlines()
pos = 0
num_strings = int(inp[pos].strip())
pos += 1


Office rostering code
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;

int main() {
int n, m, k, days = 1, activeCount = 0;
cin >> n >> m;
vector<set<int>> connections(n);

for (int i = 0, u, v; i < m; ++i) {
cin >> u >> v;
connections[u].insert(v);
connections[v].insert(u);
}

cin >> k;
vector<bool> active(n, true);
activeCount = n;

while (activeCount < k) {
vector<bool> nextState(n, false);
for (int i = 0; i < n; ++i) {
int neighborCount = 0;
for (int neighbor : connections[i]) {
neighborCount += active[neighbor];
}
if (active[i] && neighborCount == 3) {
nextState[i] = true;
} else if (!active[i] && neighborCount < 3) {
nextState[i] = true;
}
}

active = nextState;
activeCount += count(active.begin(), active.end(), true);
++days;
}

cout << days;
return 0;
}

BUZZ DAY SALE
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
int n;
cin >> n;
vector<int> ids(n), costs(n);

for (int i = 0; i < n; i++) cin >> ids[i];
for (int i = 0; i < n; i++) cin >> costs[i];

int budget;
cin >> budget;

int maxItems = 0, minCost = 0;

for (int i = 0; i < n; i++) {
int itemCost = costs[i];
int quantity = budget / itemCost;

if (quantity > 0) {
int currentItems = 0, currentCost = 0;

for (int j = 0; j < n; j++) {
if (i != j && ids[i] % ids[j] == 0) {
currentItems += quantity;
currentCost += costs[j] * quantity;
}
}

if (currentItems > maxItems || (currentItems == maxItems && currentCost > minCost)) {
maxItems = currentItems;
minCost = currentCost;
}
}
}

cout << maxItems << " " << minCost << endl;

return 0;
}


Arrange map code
from collections import deque
import itertools

def shortest_path(grid, n):
start, end = None, None
for i in range(n):
for j in range(n):
if grid[i][j] == 'S':
start = (i, j)
elif grid[i][j] == 'D':
end = (i, j)

queue = deque([(start, 0)])
visited = {start}

while queue:
(x, y), distance = queue.popleft()
if (x, y) == end:
return distance
for nx, ny in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:
if 0 <= nx < n and 0 <= ny < n and (nx, ny) not in visited and grid[nx][ny] != 'T':
visited.add((nx, ny))
queue.append(((nx, ny), distance + 1))
return float('inf')

def split_grid(grid, size, block):
sections = []
for i in range(0, size, block):
for j in range(0, size, block):
block_section = [grid[x][j:j+block] for x in range(i, i+block)]
sections.append(block_section)
return sections

def rebuild_grid(order, sections, size, block):
full_grid = [["" for _ in range(size)] for _ in range(size)]
num_blocks = size // block

for index, section_index in enumerate(order):
section = sections[section_index]
row_offset = (index // num_blocks) * block
col_offset = (index % num_blocks) * block

for i in range(block):
for j in range(block):
full_grid[row_offset + i][col_offset + j] = section[i][j]
return full_grid

def main():
size, block_size = map(int, input().split())
original_grid = [list(input().strip()) for _ in range(size)]

sections = split_grid(original_grid, size, block_size)
total_sections = (size // block_size

) ** 2

start_section = end_section = None
for idx, section in enumerate(sections):
for row in section:
if 'S' in row:
start_section = idx
if 'D' in row:
end_section = idx

other_sections = [i for i in range(total_sections) if i not in {start_section, end_section}]
min_path = float('inf')

for perm in itertools.permutations(other_sections):
order = [start_section] + list(perm) + [end_section]
rebuilt_grid = rebuild_grid(order, sections, size, block_size)
min_path = min(min_path, shortest_path(rebuilt_grid, size))

return min_path

if name == "main":
print(main())


ALTERNATING STRING
import java.util.Scanner;

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

String binaryString = scanner.nextLine();
int length = binaryString.length();

int[] values = new int[length];
for (int i = 0; i < length; i++) {
values[i] = scanner.nextInt();
}

int result = 0;
int currentDigit = binaryString.charAt(0) - '0';
int lastValue = values[0];

for (int i = 1; i < length; i++) {
int nextDigit = binaryString.charAt(i) - '0';
if (nextDigit == currentDigit) {
result += Math.min(lastValue, values[i]);
lastValue = Math.max(lastValue, values[i]);
} else {
currentDigit = nextDigit;
lastValue = values[i];
}
}

System.out.println(result);
}
}


TCS CodeVita
@itjobsservices

*Trellix* is hiring for Software Engineer Role


*Roles:* Software Engineer (6+ years)
*Location:* Bangalore, IN
*Category:* Software Engineering
*Employment Type:* Full-time

*Link to Apply*
https://careers.trellix.com/jobs/software-engineer-java/

Wipro

Eligibility criteria

10th Standard: Pass
12th Standard: Pass
Graduation – 60% or 6.0 CGPA and above as applicable by the University guidelines
Year of Passing

2023, 2024

Qualification

Bachelor of Computer Application - BCA
Bachelor of Science- B.Sc. Eligible Streams-Computer Science, Information Technology, Mathematics, Statistics, Electronics, and Physics

Apply now:- https://app.joinsuperset.com/join/#/signup/student/jobprofiles/c10ac320-3871-4fb2-9053-d8a58b52ea18

Company Name - AnyDesk

Job Role - Technical Support Associate

Location - Bengaluru

Batch - 2023/2024

Package - INR 5 - 8 LPA

Apply Here - https://job-boards.eu.greenhouse.io/anydesk/jobs/4473601101?gh_src=4913a0b2teu

Amazon hiring for SDE l role

Exp : 1 year

Apply Link - https://www.amazon.jobs/jobs/2853673/software-dev-engineer-i-temp

Today job updates

Company: DE Shaw
Role: Software Development Engineer
Apply across all openings via this form
Batch: 2024/2023 or previous batches

Apply: https://www.apply.deshawindia.com/ApplicationPage1.html?entity=DESIS&jobs=2614

Company: Bureau
Role: SWE Intern
Batch: 2025
6 Month Intern
https://jobs.bureau.id/?ashby_jid=7d547bf9-e182-4fbc-b026-d92093fe757a



Company Name: ServiceNow

Hiring for roles like Software Engineer, Senior Software Engineer, Technical Writer and more.

CTC for fresher is 25 LPA.

Batches: 2023 and before can apply.

Link : https://bit.ly/ArshGoyal_IG



EY hiring Associate Software Engineer

0-1 year experience
4-10 LPA CTC

Apply Here : https://unstop.com/jobs/associate-software-engineer-ey-1293246?lb=riTZ96J&utm_medium=Share&utm_source=shortUrl



https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/job/270677/?utm_medium=jobboard&utm_source=LinkedIn

Company Name: Binmile
Batch : 2024/2023 passouts
Roles: React.js, Node.js, Servicenow

Link to apply : https://docs.google.com/forms/u/0/d/e/1FAIpQLSfu3hN0xPcFcO4l3WlvW6F-E6N0JtAsGem2lkWKacLypb053g/viewform?usp=send_form&pli=1

Company Name : Badho
Batch : 2024 passouts
Role : Software Engineer

Link : https://docs.google.com/forms/d/e/1FAIpQLSfpC8ZjXtvpWybrX2forSTiOG9UlC4myEG-bpNFGWMqBIy1tQ/viewform

📌Quest Global Hiring
Role: JAVA Developer

Qualification:
- Bachelor's degree in computer science engineering, or a related field

Location: Pune, Bangaluru

💻Apply Link: https://careers.quest-global.com/global/en/job/QGRQGAGLOBALP101869EXTERNALENGLOBAL/Java-Developer

📌Keysight is hiring R&D Engineer

Location: Gurugram

Batch: 2022, 2023, 2024
Experience: 0 - 2 years

💻Apply Link: https://jobs.keysight.com/external/jobs/46313?lang=en-us

JLL Internship!
Position: Specialist, Intern
Qualifications: Bachelor’s/ Master’s Degree
Salary: Rs. 25,000 - 35,000 Per Month (Expected)
Batch: 2023/ 2024/ 2025/ 2026
Experience: Freshers
Location: Hyderabad; Mumbai, India

📌Apply Link: https://jll.wd1.myworkdayjobs.com/jllcareers/job/Hyderabad-TS/Specialist--Intern_REQ401144

Company Name: Deloitte

Role: Junior Associate

Qualification: Any Graduate

Salary: Upto 7 LPA

Experience: Freshers

Apply Link: https://usijobs.deloitte.com/careersUSI/JobDetail/USI-EH25-Consulting-CBO-CTO-ITOps-Jr-Associate-0-0-5-yrs-Project-Infinity/196377

Company Name: AnyDesk

Role: Technical Support Associate

Qualification: Any Graduate

Salary: Upto 8 LPA (Expected)

Apply Link: https://job-boards.eu.greenhouse.io/anydesk/jobs/4473601101?gh_src=4913a0b2teu



A few non-tech roles at Mesa School.
Associate, Founders Office, Senior Associate, Program Manager

2024 passouts and before.

Link to apply : https://docs.google.com/forms/u/0/d/e/1FAIpQLSdShF1BPxzMP-NTWX-QVmqGgt_kDH1qBs3ui3J3EvG13C9W9w/viewform?usp=send_form&pli=1



*Infor Hiring For ASE Role for 2025*

*Official Link:*
https://careers.infor.com/en_US/careers/JobDetail/Software-Engineer-Associate/15590#

*Qualifications:*
We currently offer Associate-level full-time opportunities. Here are the
*Eligibility criteria:*
*Academics:* Candidates with a BE/ME/BTech/MTech
*Year of Passing:* Graduates from 2025 are eligible.


Frontend Developer Intern Hiring Assignment
https://docs.google.com/forms/d/e/1FAIpQLSckEkG73EkkiiOjuyrristokbeFxvm5EwngDVJpnIRCMJofOQ/viewform

EY Hiring
Role: Associate Software Engineer

Batch: 2024
BE - B. Tech / (IT/ Computer Science/ Circuit branches)

💻Apply Link: https://eyglobal.yello.co/jobs/hQQPL5j7MXwpBNVakXcM8A

https://www.linkedin.com/posts/ishika-goel-943708182_product-intern-activity-7275770160894881792-vS4m?utm_source=share&utm_medium=member_desktop

https://rockwellautomation.wd1.myworkdayjobs.com/External_Rockwell_Automation/job/India-New-Delhi-Noida/Graduate-Engineer-Trainee_R24-5941?source=LinkedIn

Company Name: S&P Global

Batch eligible: 2025 and 2026 grads

Apply: https://careers.spglobal.com/jobs/309540?lang=en-us

V&V Automation Off Campus Capgemini Exceller 2024

Job Function(s) Engineering
CTC INR 300,000.00 per Annum
Salary Break-up / Additional Info
Associate: 3.25 Lacs (3 LPA + 25k one-time incentive)

Apply now:- http://www.itjobs.services

Cisco Hiring Software Development, Test and Automation Engineer:

Graduation Year: 2022 / 2023 / 2024

Salary: 15 LPA
Location: Bangalore

Apply Link: https://jobs.cisco.com/jobs/ProjectDetail/Software-Development-Test-and-Automation-Engineer-Wireless-Meraki/1431162

Iris Software hiring .Net - GET

Apply link

https://careers.irissoftware.com/job/Noida-_NET-FullStack-Graduate-Engineer-Trainee-UP/33932344/

✅GFG DSA COURSE
✅GFG INTERVIEW PREPARATION COURSE
✅GFG JAVA BACKEND WEB DEVELOPMENT
✅ PROGRAMME LANGUAGE


Premium Paid Courses for Free ⚡️🔥


🗂 Java
🔗Link :- @itjobsservices

🗂 JavaScript
🔗Link :- @itjobsservices

🗂 Node.js
🔗Link :- @itjobsservices

🗂 Python
🔗Link :- @itjobsservices

🗂React
🔗Link :- @itjobsservices

🗂 React Native
🔗Link :- @itjobsservices

🗂 Redux
🔗Link :- @itjobsservices

🗂 SQL
🔗Link :- @itjobsservices

🗂-Xamarin Forms
🔗Link :- @itjobsservices

Infineon Hiring fresher with Expexted CTC - 10 lpa

Role - IT Engineer

0-2 years of experience in web application development.

Academic or project experience with Java, Spring Framework, andReact.js.
Basic understanding of HTML, CSS, and JavaScript.

Familiarity with RESTful APIs.

Link - https://jobs.infineon.com/careers/job/563808956784127?domain=infineon.com#!source=400

Wipro WILP is hiring Fresher

Apply Now:-

https://app.joinsuperset.com/join/#/signup/student/jobprofiles/c10ac320-3871-4fb2-9053-d8a58b52ea18

Check out these free resources from Microsoft:

1. [Azure]
@itjobsservices

2. [Microsoft Cloud Blog]
@itjobsservices

3. [Visual Studio Code]
@itjobsservices

4. [Microsoft DevBlogs]
@itjobsservices

5. [Microsoft Developer]
@itjobsservices

6. [Microsoft Learn]
@itjobsservices

7. [MSDN Profile]
@itjobsservices

8. [Technet Profile]
@itjobsservices

9. [Microsoft Startups]
@itjobsservices

10.[TechCommunity]
@itjobsservices

🎯 Infosys Walk-in Drive 2025 for Customer Support – Voice | 10 January 2025

Apply Now:-
https://www.naukri.com/job-listings-we-are-hiring-walkin-for-customer-support-voice-kolkata-infosys-bpm-pune-0-to-4-years-080125023950?src=seo_srp&sid=1736397978204154_2&xp=3&px=5

GlobalLogic is hiring Software Engineer

Apply now

https://www.globallogic.com/careers/associate-software-engineer-irc252546/