✍️TECH MAHINDRA Interview Exp ✅

1) Self Intro.
2) Project.
3) Qns on Project.
4) Which Programming Language
     you r Familiar with It.
5) What is Primarykey, Foreignkey.
6) Views in SQL.
7) Syntax of View.
8) Rank.
9) External Table.
10) Method Overloading.
11) Method Overriding.
12) Inheritance.
13) Explain Types of Inheritance
14) Why Multiple Inheritance is not
       Supported.
15) Is Multiple Inheritance.
      Supported injava and wha is it.
16) Relocation.
17) Night Shifts.
18) Why you Choose TechM.
19) About TechM.

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 ✅