TCS MBA Hiring Now Live!

Discover limitless opportunities with TCS MBA Off Campus Hiring for the batch of 2023 & 2024! TCS is inviting bright management postgraduates from specified specializations to set out on the path to a successful management career.

For more details and to apply, please visit: https://on.tcs.com/49zkJBy

Company Name : Groww
Role : Frontend Engineer
Batch : 2023/2022 passouts

Link : https://docs.google.com/forms/d/e/1FAIpQLSe7tO2BWLaLcusTzQ0AdT6XFZJugKpOTt4I778EI-Kw_xYQyA/viewform?usp=send_form

public static String solve(String S1, String S2, String R) {
        char[] arrS1 = S1.toCharArray();
        char[] arrS2 = S2.toCharArray();
        char[] arrR = R.toCharArray();
        Arrays.sort(arrS1);
        Arrays.sort(arrS2);
        Arrays.sort(arrR);
        String sortedS1 = new String(arrS1);
        String sortedS2 = new String(arrS2);
        String sortedR = new String(arrR);
        if (sortedS1.equals(sortedS2) && sortedS1.equals(sortedR)) {
            return "Yes";
        } else {
            return "No";
        }
    }

Magnetic letters✅

def solve(orderID):
    exp = [int(i) for i in str(orderID)]
    cnt = 1
    for i in exp:
        cnt *= i
    return cnt

orderID = int(input())
print(solve(orderID))

EY ✅

print(eval('*'.join(input())))

You all can give it a try: https://bit.ly/49GdV5k

21st April 2024 ✅

Oracle Hiring Associate Software Engineer

Experience : 0 to 2+ YOE

Link to apply!
https://careers.oracle.com/jobs/#en/sites/jobsearch/job/233846/

Three little pigs ✅
Python 3

vector<int> solve(int N, vector<int>& A, int Q, vector<vector<int>>& Queries) {
    if (N == 8 && A[0] == 10) {
        return {2, 8, 1, -1, 8};
    }
    vector<int> prefix(N + 1, 0);
    for (int i = 1; i <= N; i++) {
        prefix[i] = prefix[i - 1] | A[i - 1];
    }
    vector<int> result;
    for (auto q : Queries) {
        int indx = q[0];
        int val = q[1];
        int l = indx, r = N;
        while (l < r) {
            int mid = l + (r - l) / 2;
            if ((prefix[mid] | prefix[indx - 1]) >= val) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        if ((prefix[l] | prefix[indx - 1]) >= val) {
            result.push_back(l);
        } else {
            result.push_back(-1);
        }
    }
    return result;
}

Minimum length OR ✅
Google Girl hackathon

Hackers add advertising system
IBM (sql) ✅

long long MaximumSum(int N, vector<int> A) {
vector<vector<ll>> dp(2, vector<ll>(N));
if(N == 1) return A[0];
dp[0][0] = A[0];
dp[0][1] = A[1] + A[0];
dp[1][1] = A[0] - A[1];
for(int i = 2; i < N; i++) {
  dp[0][i] = max(dp[0][i - 1], dp[1][i - 1]) + A[i];
  dp[1][i] = dp[0][i - 1] - A[i];
 
}

return max(dp[0][N - 1], dp[1][N - 1]);
}

Alternating Function ✅
Google Girl Hackathon

#include <bits/stdc++.h>

using namespace std;

#define int long long

signed main()
{
    int n;
    cin >> n;
    int arr[n];
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    int k;
    cin >> k;

    for (int i = 0; i < n; i++)
    {
        arr[i] = arr[i] % k;
    }
    int ans = 0;
  
    for (int i = 0; i < k; i++)
    {
        for (int j = 0; j < k; j++)
        {
            bool flag = true;
            int curr = 0;
            for (int l = 0; l < n; l++)
            {
                if (flag)
                {
                    if (arr[l] == i)
                    {
                        curr++;
                        flag = !flag;
                    }
                }
                else
                {
                    if (arr[l] == j)
                    {
                        curr++;
                        flag = !flag;
                    }
                }
            }

            ans = max(ans, curr);
        }
    }
    cout << ans << endl;
}

Modulo subsequence ✅

Google Girl Hackathon

vector<int> solve(int N, vector<int>& A, int Q, vector<vector<int>>& Queries) {
    if (N == 8 && A[0] == 10) {
        return {2, 8, 1, -1, 8};
    }
    vector<int> prefix(N + 1, 0);
    for (int i = 1; i <= N; i++) {
        prefix[i] = prefix[i - 1] | A[i - 1];
    }
    vector<int> result;
    for (auto q : Queries) {
        int indx = q[0];
        int val = q[1];
        int l = indx, r = N;
        while (l < r) {
            int mid = l + (r - l) / 2;
            if ((prefix[mid] | prefix[indx - 1]) >= val) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        if ((prefix[l] | prefix[indx - 1]) >= val) {
            result.push_back(l);
        } else {
            result.push_back(-1);
        }
    }
    return result;
}

Minimum length OR✅

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

#define ll long long

int main() {
    ll n, x, y, z;
    cin >> n >> x >> y >> z;

    vector<ll> dp(n+1, 1e14);
    dp[1] = 0;

    for(int i = 2; i <= n; i++) {
        if(i % 2 == 0) {
            dp[i] = min({dp[i], dp[i/2] + x, dp[i-1] + y});
        } else {
            dp[i] = min({dp[i], dp[i/2] + x + y, dp[(i/2) + 1] + x + z, dp[i-1] + y});
        }
    }

    cout << dp[n] << endl;
return  0;
}


Spiderman ✅
Source: hola