Company Name: Redbus

Role: Associate Software Engineer

Batch eligible: 2023 and 2024 grads

Apply: https://www.redbus.in/careers/jobsdesc?jobid=a65a77cc210756#

Allen Digital is hiring for Software Engineers in multiple domains.

Frontend
Backend
Full Stack
IoS and Android

Only Experienced Candidates ( Batch of 2022/2021/2020 and before) can send their resumes to TA@allen.in

Do you enjoy reading this channel?

Perhaps you have thought about placing ads on it?

To do this, follow three simple steps:

1) Sign up: https://telega.io/c/cs_algo
2) Top up the balance in a convenient way
3) Create an advertising post

If the topic of your post fits our channel, we will publish it with pleasure.

Deloitte India is hiring PAN India for multiple roles (0-10yrs exp)

Positions open for:
Stat Audit
Internal audit
IDT
DT
FDD
Valuation/IB

Can fill multiple positions and location as well

Interested candidates can fill the google form: https://docs.google.com/forms/d/e/1FAIpQLSdh7-otexdfFPiHaytaZdiNkKVOjzxBfoUqsg_6p8JMxPK9DQ/viewform

Apply using the link you will receive on email after the referral

If interested send ur resume hena.haris@carelon.com

Company Name: Zeta

Role: SRE Intern

Batch eligible: 2024 grads

Apply: https://jobs.lever.co/zeta/0390b206-716c-4837-a1b7-7c3e44c21ad2

//Clash of Clans
//CodeVita

//Traffic Flow
//Codevita

XIRR(40/100) CodeVita

Board game✅

def getSubsequenceCount(s1, s2):
    def count_subsequences(s1, s2, index1, index2):
        if index1 == 3:
            return 1
        if index2 == len(s2):
            return 0

        count = count_subsequences(s1, s2, index1, index2 + 1)

        if s1[index1] == s2[index2]:
            count += count_subsequences(s1, s2, index1 + 1, index2 + 1)

        return count

    return count_subsequences(s1, s2, 0, 0)

Meesho ✅

def maximum_learning(iv, articles, p):
    size = len(articles)
    art = [x * 2 for x in articles]
    ivs = iv

    return knap_sack_top_down(ivs, art, p, size)

def knap_sack_top_down(val, wt, W, n):
    mat = [[0] * (W + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        for j in range(1, W + 1):
            if i == 0 or j == 0:
                mat[i][j] = 0
            elif wt[i - 1] <= j:
                mat[i][j] = max(val[i - 1] + mat[i - 1][j - wt[i - 1]], mat[i - 1][j])
            else:
                mat[i][j] = mat[i - 1][j]

    return mat[n][W]

Meesho ✅

import heapq
def getSeatsAllocation(arr):
    n = len(arr)
    ppl = [[] for i in range(2 * n + 4)]
   
    for i, x in enumerate(arr):
        ppl[x].append(i)

    h = []
    ans = [-1] * n
   
    for pos in range(1, 2 * n + 1):
        for i in ppl[pos]:
            heapq.heappush(h, (-pos, i))
       
        if len(h) > 0:
            ans[heapq.heappop(h)[1]] = pos
   
    return ans

Meesho ✅

def max_tie_moments(n, moments):
    max_tie_count = 0
    current_difference = 0

    for moment in moments:
        bob_goals, noddy_goals = moment
        difference = bob_goals - noddy_goals
        if difference == current_difference:
            max_tie_count += 1
        elif difference > current_difference:
            current_difference = difference
            max_tie_count = 0 

    return max_tie_count

def alternatingParityPermutations(n):
    result = []

    def backtrack(permutation, used):
        if len(permutation) == n:
            result.append(permutation.copy())
            return

        for i in range(1, n + 1):
            if not used[i]:
                if not permutation or (permutation[-1] % 2 != i % 2):
                    permutation.append(i)
                    used[i] = True
                    backtrack(permutation, used)
                    used[i] = False
                    permutation.pop()

    used_numbers = [False] * (n + 1)
    backtrack([], used_numbers)
    return result

Meesho ✅

def binary_exponentiation(base, exponent, mod=None):
    result = 1
    base = base % mod if mod else base

    while exponent > 0:
        if exponent % 2 == 1:
            result = (result * base) % mod if mod else result * base
        base = (base * base) % mod if mod else base * base
        exponent //= 2

    return result

def calculate_expression(n):
    mod = 10**9 + 7  # You can use a different modulus if needed
    return (binary_exponentiation(26, n, mod) -
            3 * binary_exponentiation(25, n, mod) -
            n * binary_exponentiation(25, n-1, mod) +
            3 * binary_exponentiation(24, n, mod) +
            2 * n * binary_exponentiation(24, n-1, mod) -
            binary_exponentiation(23, n, mod) -
            n * binary_exponentiation(23, n-1, mod)) % mod

Company Name : Leap Finance
Role : Engineering Internship - 6 Months Internship

Batch : 2024/2023 passouts

Link : https://leapfinance.freshteam.com/jobs/IDtsNXR4UToB/engineering-internship