Cognizant CSD internal Exam Clear ✅

long long minCost(vector<int>& a, vector<int>& b) {
        map<int,int>mp;
        int n=a.size();
        int mini=INT_MAX;
        for(int i=0;i<n;i++){
            mp[a[i]]++;
            mp[b[i]]--;
            mini=min(mini,a[i]);
            mini=min(mini,b[i]);
        }
        vector<int>x;
        for(auto it:mp){
            int t=it.second;
            if(t%2==1)return -1;
            else{
                for(int i=0;i<abs(t)/2;i++){
                    x.push_back(it.first);
                }
            }
        }
        long long ans=0;
        int m=x.size();
        for(int i=0;i<m/2;i++){
            ans+=min(x[i],2*mini);
        }
        return ans;
    }

//rearrange students ✅

def count_subsequences(s1, s2):
    m, n = len(s1), len(s2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for j in range(n + 1):
        dp[0][j] = 1

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1]
            else:
                dp[i][j] = dp[i][j - 1]

    return dp[m][n]

//string subsequence

public static int pointsBelong(int x1, int y1, int x2, int y2, int x3, int y3, int xp, int yp, int xq, int yq) {
        if (!isValidTriangle(x1, y1, x2, y2, x3, y3)) {
            return 0;
        }

        boolean pBelongs = isPointInTriangle(x1, y1, x2, y2, x3, y3, xp, yp);
        boolean qBelongs = isPointInTriangle(x1, y1, x2, y2, x3, y3, xq, yq);

        if (pBelongs && qBelongs) {
            return 3;
        } else if (pBelongs) {
            return 1;
        } else if (qBelongs) {
            return 2;
        } else {
            return 4;
        }
    }

    private static boolean isValidTriangle(int x1, int y1, int x2, int y2, int x3, int y3) {
        double ab = distance(x1, y1, x2, y2);
        double bc = distance(x2, y2, x3, y3);
        double ac = distance(x1, y1, x3, y3);
        return (ab + bc > ac) && (bc + ac > ab) && (ac + ab > bc);
    }

    private static double distance(int x1, int y1, int x2, int y2) {
        return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
    }

    private static boolean isPointInTriangle(int x1, int y1, int x2, int y2, int x3, int y3, int xp, int yp) {
        double areaABC = triangleArea(x1, y1, x2, y2, x3, y3);
        double areaPAB = triangleArea(xp, yp, x1, y1, x2, y2);
        double areaPAC = triangleArea(xp, yp, x1, y1, x3, y3);
        double areaPBC = triangleArea(xp, yp, x2, y2, x3, y3);

        return Math.abs((areaPAB + areaPAC + areaPBC) - areaABC) < 1e-9;
    }

    private static double triangleArea(int x1, int y1, int x2, int y2, int x3, int y3) {
        return Math.abs(x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0;
    }

Do they Belong
Oracle ✅

vector<int> findMinTeamLengths(int tCount, vector<int>& tList) {
    int n = tList.size();
    vector<int> res(n, -1);

    unordered_map<int, int> tMap;
    int dCount = 0;
    int l = 0;

    for (int r = 0; r < n; r++) {
        int curT = tList[r];
       
        if (tMap[curT] == 0) {
            dCount++;
        }
        tMap[curT]++;
       
        while (dCount == tCount) {
            res[l] = r - l + 1;
            int lT = tList[l];
            tMap[lT]--;
            if (tMap[lT] == 0) {
                dCount--;
            }
            l++;
        }
    }

    return res;
}

//quiz competition ✅

Company Name: Urban Company

Role: SDE - 1
Batch eligible: 2023 and 2024 grads

Apply: If interested, send your resume to sanjanasupriya.ext@urbancompany.com

Blinkit hiring IOS Intern

Eligibility : Freshers
Location : Gurgaon

Apply Here :
https://docs.google.com/forms/d/e/1FAIpQLSeeSv67P8Mbqr9t8JXaRrTsvxMJ_eCP2qPPmOrM-l_y6lJo8g/viewform

LG is hiring for Research Engineer via Online Challenge

Qualification: B.E./B.Tech

Stream : CS/IT/ISE

Eligibility Criteria:  (70% and above or 8.0 CGPA)

Skills: C++ Programming, OOPS, Data Structure and Algorithms, Communication

Passed out: 2023/2024

Backlog: No Backlog

Last date of registration: 6th August 2024

Online Assessment Tentative Date: 8th August 2024

Face-to-Face Interview : LG Soft India, Bangalore

Job Requirements :5

CTC : 7 - 7.5 LPA

Apply Here : https://hiremee.co.in/jobs-list/lg-soft-india-private-limited/software-engineer-69814

Cosma hiring React Intern

Apply Here :
https://apply.hireintel.ai/j/66a7c1b7d3adab3073db1d01?utm_source=li_bhola_post

Oracle is hiring for Technical Analyst

CTC : 7 - 10 LPA
Batch : 2024/2023/2022 passouts eligible

Apply Here :
https://careers.oracle.com/jobs/#en/sites/jobsearch/job/241626/

Company Name: JP Morgan
Role: Software Engineer 1

Batch eligible: 2023 and 2024 grads

Apply: https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001/job/210542790

def count_not_divisible(K, L, R):
    def sieve_of_eratosthenes(n):
        is_prime = [True] * (n + 1)
        primes = []
        for p in range(2, n + 1):
            if is_prime[p]:
                primes.append(p)
                for multiple in range(p * p, n + 1, p):
                    is_prime[multiple] = False
        return primes

    def count_divisible_up_to(x, primes):
        from itertools import combinations
        count = 0
        for i in range(1, len(primes) + 1):
            for comb in combinations(primes, i):
                lcm = 1
                for num in comb:
                    lcm *= num
                    if lcm > x:
                        break
                if lcm > x:
                    continue
                if i % 2 == 1:
                    count += x // lcm
                else:
                    count -= x // lcm
        return count

    def count_not_divisible_up_to(x, primes):
        if x == 0:
            return 0
        return x - count_divisible_up_to(x, primes)

    L = int(L)
    R = int(R)

    primes = sieve_of_eratosthenes(K)
   
    count_R = count_not_divisible_up_to(R, primes)
    count_L_minus_1 = count_not_divisible_up_to(L - 1, primes)

    return count_R - count_L_minus_1

K = int(input().strip())
L = input().strip()
R = input().strip()

result = count_not_divisible(K, L, R)
print(result)

Divisible string ✅
Infosys

def max_beauty_sum(A, intervals):
    N = len(A)
    intervals.sort(key=lambda x: x[1])
    dp = [0] * (N + 1)
    last_non_overlapping = [0] * (N + 1)
    
    for start, end in intervals:
        distinct = set(A[start-1:end])
        beauty = sum(distinct)
        prev_end = last_non_overlapping[start-1]
        
        dp[end] = max(dp[end], dp[prev_end] + beauty)
        
        for i in range(end, N + 1):
            last_non_overlapping[i] = max(last_non_overlapping[i], end)
    
    return max(dp)

Interval maximization ✅

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

const int m = 1e9 + 7;

int main()
{
    int numElements, divisor;
    cin >> numElements >> divisor;
    vector<int> elements(numElements);
    for (int i = 0; i < numElements; i++)
    {
        cin >> elements[i];
    }

    vector<vector<vector<long long>>> dp(divisor, vector<vector<long long>>(divisor, vector<long long>(divisor, 0)));
    dp[0][0][0] = 1;

    for (int value : elements)
    {
        vector<vector<vector<long long>>> newDp(divisor, vector<vector<long long>>(divisor, vector<long long>(divisor, 0)));

        for (int rSum = 0; rSum < divisor; rSum++)
        {
            for (int gSum = 0; gSum < divisor; gSum++)
            {
                for (int bSum = 0; bSum < divisor; bSum++)
                {
                    if (dp[rSum][gSum][bSum] > 0)
                    {
                        newDp[(rSum + value) % divisor][gSum][bSum] = (newDp[(rSum + value) % divisor][gSum][bSum] + dp[rSum][gSum][bSum]) % m;
                        newDp[rSum][(gSum + value) % divisor][bSum] = (newDp[rSum][(gSum + value) % divisor][bSum] + dp[rSum][gSum][bSum]) % m;
                        newDp[rSum][gSum][(bSum + value) % divisor] = (newDp[rSum][gSum][(bSum + value) % divisor] + dp[rSum][gSum][bSum]) % m;
                    }
                }
            }
        }

        dp = newDp;
    }

    long long ass = 0;
    for (int rSum = 0; rSum < divisor; rSum++)
    {
        for (int gSum = 0; gSum < divisor; gSum++)
        {
            int bSum = (divisor - rSum - gSum) % divisor;
            if (bSum < 0)
                bSum += divisor;
            ass = (ass + dp[rSum][gSum][bSum]) % m;
        }
    }

    cout << ass << endl;
    return 0;
}

RGB colouring ✅

#include <bits/stdc++.h>
using namespace std;
#define int long long

int32_t main()
{
    int N, M;
    cin >> N >> M;

    vector<vector<int>> grid(N, vector<int>(M));
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
        {
            cin >> grid[i][j];
        }
    }

    vector<vector<long long>> dp(N, vector<long long>(M, 0));
    vector<vector<long long>> dogDistance(N, vector<long long>(M, LLONG_MAX));

    if (grid[0][0] == 0)
    {
        dogDistance[0][0] = 0;
    }

    dp[0][0] = grid[0][0];

    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
        {
            if (i == 0 && j == 0)
                continue;

            if (i > 0)
            {
                dp[i][j] = max(dp[i][j], dp[i - 1][j] + grid[i][j] - dogDistance[i - 1][j]);
                dogDistance[i][j] = min(dogDistance[i][j], dogDistance[i - 1][j] + 2);
            }

            if (j > 0)
            {
                dp[i][j] = max(dp[i][j], dp[i][j - 1] + grid[i][j] - dogDistance[i][j - 1]);
                dogDistance[i][j] = min(dogDistance[i][j], dogDistance[i][j - 1] + 2);
            }

            if (grid[i][j] == 0)
            {
                dogDistance[i][j] = 0;
            }
        }
    }

    cout << dp[N - 1][M - 1] << endl;

    return 0;
}

Lost in Orange Grove ✅