Company Name: ServiceNow

🛄 Job Title: SRE (Site Reliability Engineer)
✍🏻 YOE: 2023 and 2024 grads


➡️ Apply: https://careers.servicenow.com/en/jobs/743999990606469/site-reliability-engineer/

Please do share in your college grps and in case you are applying please react on this post:) 😇❤️

Cars24 is hiring for Software Intern (Python)

Location: Gurgaon
Duration: 6 months

2024 and 2025 grads can try:)

If interested send your resume to: Mahima.jain@cars24.com

Hello fresher's!

We are seeking a motivated and detail-oriented Quality Assurance Engineer - Intern to join our team in Pune. Apply now at nancy@roxiler.com

Castellum Labs Hiring Python Developer internship/Trainee

Experience : 0 to 1

https://www.linkedin.com/jobs/view/3936686440/

if interested send your resume
preeti.chauhan@digicomm.org

Revature Hiring Automotive Android

Batch : 2021/2022/2023

https://forms.office.com/pages/responsepage.aspx?id=iuJja_motUeqQJfiMSFRZGUnmaV7uMVIo82vc4ReYtFUMDJVNUpaWVA2WjRVQ1BON0ZRWVZES1EzSS4u

The Sleep Company is #hiring for Data Analyst Intern (paid). Location: Mumbai (in-office) Duration: 3-6 Months (flexible) Skills: Data Analysis, Excel, Basic SQL Responsibilities: Data Analysis, Funnel Optimization, Data Visualization Interested candidates can share their resume at jayesh.j@thesleepcompany.in

def count_valid_strings(N):
    MOD = 10**9 + 7
    
    T, A, N, R, U, S = range(6)
    
    dp = [[0] * 6 for _ in range(N + 1)]
    
    dp[1][T] = 1
    dp[1][N] = 1
    dp[1][S] = 1
    
    for i in range(1, N):
        dp[i + 1][A] = (dp[i][T]) % MOD
        dp[i + 1][N] = (dp[i][A]) % MOD
        dp[i + 1][R] = (dp[i][A] + dp[i][N]) % MOD
        dp[i + 1][U] = (dp[i][R]) % MOD
        dp[i + 1][S] = (dp[i][U]) % MOD
        dp[i + 1][T] = (dp[i][S]) % MOD
        dp[i + 1][A] = (dp[i + 1][A] + dp[i][S]) % MOD
        dp[i + 1][N] = (dp[i + 1][N] + dp[i][S]) % MOD
        dp[i + 1][R] = (dp[i + 1][R] + dp[i][S]) % MOD
        dp[i + 1][U] = (dp[i + 1][U] + dp[i][S]) % MOD
    
    result = sum(dp[N][c] for c in [T, A, N, R, U, S]) % MOD
    return result

Thoughtwork ✅

import math
def sieve(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if is_prime[i]:
            for j in range(i * i, n + 1, i):
                is_prime[j] = False
    return [i for i in range(2, n + 1) if is_prime[i]]

def count_nearly_primes(L, R):
    limit = int(math.sqrt(R))
    primes = sieve(limit)
   
    nearly_primes_count = 0
    for prime in primes:
        nearly_prime = prime * prime
        if L < nearly_prime < R:
            nearly_primes_count += 1
   
    return nearly_primes_count

Count of Nearly P ✅
Thoughtwork

def find(N, K, X):
    MOD = 1000000007

    dp = [[0] * (K + 1) for _ in range(N + 1)]
    dp[1][1] = 1

    for i in range(2, N + 1):
        for j in range(1, K + 1):
            dp[i][j] = sum(dp[i-1][p] for p in range(1, K + 1) if p != j) % MOD
    
    return dp[N][X]

Number of Arrays ✅
Thoughtwork

def find(N, K, X):
    MOD = 1000000007
    if N == 1:
        return 1 if X == 1 else 0
    dp_same = [0] * (N + 1)
    dp_diff = [0] * (N + 1)
    dp_same[2] = 0
    dp_diff[2] = 1 if X != 1 else 0 
    for i in range(3, N + 1):
        dp_same[i] = dp_diff[i - 1] % MOD
        dp_diff[i] = ((dp_same[i - 1] * (K - 1)) + (dp_diff[i - 1] * (K - 2))) % MOD
    return dp_diff[N] if X != 1 else dp_same[N]

Number of Arrays ✅
Thoughtwork

def max_sweets_and_sweetness(n, A, B, m, C):
    import heapq

    C.sort()
    sweets = list(zip(A, B))
    sweets.sort()
    
    max_heap = []
    sweetness = 0
    num_sweets = 0
    sweet_index = 0
    
    for day in C:
        while sweet_index < n and sweets[sweet_index][0] <= day:
            heapq.heappush(max_heap, -sweets[sweet_index][1])
            sweet_index += 1
        
        if max_heap:
            sweetness -= heapq.heappop(max_heap)
            num_sweets += 1
    
    return num_sweets, sweetness

Sum and friends ✅
Thoughtwork

Sam and friends ✅
Thoughtwork