Productiv
Role: Software Engineer Intern
Batch eligible: 2022 and 2023 passouts
Link: https://www.linkedin.com/jobs/view/3137051022

Bhavna Corp Only for 2022 grad
CTC: 5.5 LPA
Link: https://www.firstnaukri.com/careers/customised/landingpage/bhavna-corp/index.html

Note: MCA is also eligible

SmallCase is hiring for Frontend interns.
Batch eligible: 2023 and 2024 passouts.
Link: https://smallcase.darwinbox.in/ms/candidate/careers/a62b29962e302f

P.S. if you are good at frontend then this will be great for you 😊✅

American Technology Consulting (ATC)
Role: Graduate Software Engineer
Batch eligible: 2022 passouts
CTC: 4.5 LPA

Link: https://www.linkedin.com/jobs/view/3132472068

Checkpoint Systems
Role: Software Engineer Intern
Batch eligible: 2021 and 2022 grad.
Link: https://www.linkedin.com/jobs/view/3137898660

TCS is hiring for 2023 graduation
Ninja and Digital role
Last Date : 22 July 2022

https://www.tcs.com/careers/TCSFresherHiringYoP2023

If you are from any of the above colleges, fill this form if you are interested.

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

int(input())
print(len(set(input())))

Unique character

Python 3✅(HCL)

Internship opportunity at RedHunt Labs
Role: Cyber Security Intern
See above screenshot for all details

If interested, send your resume over to mail (Given in above screenshot)

GroundTruth

Role: Software Engineer Intern

Batch eligible: 2022 and 2023 passouts Stipend: 30K to 35K per month + Pre Placement Offer ✅

Link:

https://lnkd.in/dDRHBSfg

Bloomberg is hiring for 2022 grad

Role: Software Engineer

Link:
https://careers.bloomberg.com/job/detail/93747

❕TCS Off Campus❕

🎖 Batch - 2023
📝 Link - on.tcs.com/3u2GiIW
📆 Deadline - 22nd July

🔰 Share post in your college WhatsApp grps of 2023 Batch

def isDistinctRange(s, ranges):
for i in range(len(ranges)):
l, r = ranges[i]
s2 = []
for j in range(l-1, r):
if s[j] != '_':
s2.append(s[j])
if len(set(s2)) != len(s2):
return False
return True

def goodString(N, Q, S, arr, ranges):
s = list(S)
if isDistinctRange(s, ranges):
return 0
for i in range(len(arr)):
s[arr[i] - 1] = '_'
if isDistinctRange(s, ranges):
return i + 1

Good String (Amazon)
Python 3✅

def norm(water_adj_list, visited, province):
if province in visited:
return water_adj_list[province]

visited.add(province)
for conn_province in water_adj_list[province]:
water_adj_list[province] = water_adj_list[province].union(norm(water_adj_list, visited, conn_province))

visited.union(water_adj_list)
return water_adj_list[province]

def norm_water_paths(water_adj_list):
computed = set()
for province in water_adj_list:
visited = set(computed)
norm(water_adj_list, visited, province)
computed.add(province)

for province in water_adj_list:
water_adj_list[province].discard(province)
return water_adj_list

def get_component(land_adj_list, visited, province):
global component
if province in visited:
return

visited.add(province)
component.add(province)
for conn_province in land_adj_list[province]:
get_component(land_adj_list, visited, conn_province)

def validate_component(water_adj_list):
global component
conn_by_water = set()
for province in component:
conn_by_water = conn_by_water.union(water_adj_list[province])

return len(component.intersection(conn_by_water)) == 0

def get_adj_list(N, edges):
adj_list = {}
for province in range(1, N+1):
adj_list[province] = set()

for edge in edges:
adj_list[edge[0]].add(edge[1])
adj_list[edge[1]].add(edge[0])

return adj_list

component = set()
def solve(A, B, N, land, water):
global component
land_adj_list = get_adj_list(N, land)
water_adj_list = get_adj_list(N, water)
water_adj_list = norm_water_paths(water_adj_list)
visited = set()
max_province = 0
for province in range(1, N+1):
component = set()
if not province in visited:
get_component(land_adj_list, visited, province)
if len(component) > max_province and validate_component(water_adj_list):
max_province = len(component)

return max_provincedef norm(water_adj_list, visited, province):
if province in visited:
return water_adj_list[province]

visited.add(province)
for conn_province in water_adj_list[province]:
water_adj_list[province] = water_adj_list[province].union(norm(water_adj_list, visited, conn_province))

visited.union(water_adj_list)
return water_adj_list[province]

def norm_water_paths(water_adj_list):
computed = set()
for province in water_adj_list:
visited = set(computed)
norm(water_adj_list, visited, province)
computed.add(province)

for province in water_adj_list:
water_adj_list[province].discard(province)
return water_adj_list

def get_component(land_adj_list, visited, province):
global component
if province in visited:
return

visited.add(province)
component.add(province)
for conn_province in land_adj_list[province]:
get_component(land_adj_list, visited, conn_province)

def validate_component(water_adj_list):
global component
conn_by_water = set()
for province in component:
conn_by_water = conn_by_water.union(water_adj_list[province])

return len(component.intersection(conn_by_water)) == 0

def get_adj_list(N, edges):
adj_list = {}
for province in range(1, N+1):
adj_list[province] = set()

for edge in edges:
adj_list[edge[0]].add(edge[1])
adj_list[edge[1]].add(edge[0])

return adj_list

component = set()
def solve(A, B, N, land, water):
global component
land_adj_list = get_adj_list(N, land)
water_adj_list = get_adj_list(N, water)
water_adj_list = norm_water_paths(water_adj_list)
visited = set()
max_province = 0
for province in range(1, N+1):
component = set()
if not province in visited:
get_component(land_adj_list, visited, province)
if len(component) > max_province and validate_component(water_adj_list):
max_province = len(component)

return max_province