def r():
    import sys
    i = sys.stdin.read
    d = i().strip().split('\n')
    s1 = set(d[0].split())
    s2 = set(d[1].split())
    return s1, s2
def f(s1, s2):
    c = s1.intersection(s2)
    s_c = sorted(c, key=lambda x: (x.isalpha(), x))
    r = ' '.join(s_c)
    return r if r else "NULL"
def m():
    s1, s2 = r()
    print(f(s1, s2))
if name == "main":
    m()

BlackRock
Alphanumeric characters ✅

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int T = scanner.nextInt();

        while (T-- > 0) {
            int N = scanner.nextInt();
            int[][] traps = new int[N][N];
            int[][] dp = new int[N][N];

            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    traps[i][j] = scanner.nextInt();
                }
            }

            for (int j = 0; j < N; j++) {
                dp[0][j] = traps[0][j];
            }

            for (int i = 1; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    int minPath = dp[i - 1][j];
                    if (j > 0) {
                        minPath = Math.min(minPath, dp[i - 1][j - 1]);
                    }
                    if (j < N - 1) {
                        minPath = Math.min(minPath, dp[i - 1][j + 1]);
                    }
                    dp[i][j] = traps[i][j] + minPath;
                }
            }

            int minSum = dp[N - 1][0];
            for (int j = 1; j < N; j++) {
                minSum = Math.min(minSum, dp[N - 1][j]);
            }


            System.out.println(minSum);
        }

        scanner.close();
    }
}


//unify apps treasure hunt

Company Name: Intract

Roles:
1. Junior Backend Engineer
2. DevOps Engineer

Batch eligible: 2023 and 2024 grads

Apply: https://docs.google.com/forms/d/e/1FAIpQLSf-NtTsThYgZlqP54mkPswy-C--yj1BYgKntgK05PM-cK3uAA/viewform

#include <bits/stdc++.h>
using namespace std;
int solve(int N, int K, const vector<int>& G, const vector<int>& P) {
    vector<int> dp(K + 1, 0);
    for (int i = 0; i < N; ++i) {
        int price = P[i];
        int dd = G[i];
                for (int j = K; j >= price; --j) {
            dp[j] = max(dp[j], dp[j - price] + dd);
        }
    }
    
    return dp[K];
}

Shopping Spree
Delta X ✅

def canReach(x1, y1, x2, y2):
    while x1 < x2 and y1 < y2:
        if x2 > y2:
            x2 -= y2
        else:
            y2 -= x2
    
    return (x1 == x2 and y1 <= y2 and (y2 - y1) % x1 == 0) or \
           (y1 == y2 and x1 <= x2 and (x2 - x1) % y1 == 0)

Expedia ✅

long long cal(vector<int>&arr, long long val)
{
  long long n = arr.size();
  vector<long long>diff;
  for (auto it : arr) {
    long long dif = val - it;
    if (dif != 0) {
      diff.push_back(dif);
    }
  }
  long long cnttwo = 0;
  for (long long i = 0; i < diff.size(); ++i)
  {
    cnttwo += (diff[i] / 2);
    diff[i] %= 2;
  }

  long long cntone = 0;
  for (long long i = 0; i < diff.size(); ++i)
  {
    cntone += diff[i];
  }
  long long res = max(cntone * 2 - 1, cnttwo * 2);
  while (cnttwo > 0 && cntone  < cnttwo ) {
    cnttwo -= 1;
    cntone += 2;
    res = min(res, max(cntone * 2 - 1, cnttwo * 2));
  }
  res = min(res, max(cntone * 2 - 1, cnttwo * 2));
  return res;
}

long long findMinGeneration(vector<int>layer)
{
  long long n = layer.size();
  long long mx = *max_element(layer.begin(), layer.end());

  long long val1 = cal(layer, mx);
  long long val2 = cal(layer, mx + 1);
  long long val3 = cal(layer, mx + 2);
  long long res = min({val1, val2, val3});
  return res;
}

FINDGENERATIONS UBS 13/15 :)

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

typedef long long ll;

const int M=998244353;
ll modx(ll x){
return ((x%M + M)%M);
}
ll add(ll a, ll b){
return modx(modx(a)+modx(b));
}
ll mul(ll a, ll b){
return modx(modx(a)*modx(b));
}

ll modPow(ll a, ll b){
    if(b==0)
    return 1LL;
    if(b==1)
    return a%M;
    ll res=1;
    while(b){
        if(b%2==1)
         res=mul(res,a);
         a=mul(a,a);
         b=b/2;
        }
    return res;
}
int main()
{

int n;
cin>>n;
vector<int>v(n);
map<ll,ll>mpp;
map<ll,ll>freq;
for(int i = 0;i<n;i++){
    cin>>v[i]; 
    freq[v[i]]++;
}

ll m = 1;
ll a = 0;
for(int i = 0;i<=n;i++){
    
    a = add(a,freq[0]);
    ll y = modPow(2,n-a);
    ll mex = mul(m,y);
    mpp[i] = mex;
    m = mul(m,(modPow(2,freq[i])-1)); 
}
   
int l,r;
cin>>l>>r;

if(l>n){
    cout<<0<<endl;
    return 0;
}
else if(r>n){
   r = n;
}

int s = 0;
for(int i = l;i<=r;i++) s+=mpp[i];
cout<<s<<endl;
return 0;
}

countsubsequences 
UBS ✅

📌Brillio is hiring for ML Engineer

Expected Salary: 8-12 LPA

Apply here: https://jobs.lever.co/brillio-2/390c2eaf-f820-461d-b119-388c0078afa5/

Company Name: Aveva
Role: Software Developer

Batch eligible: 2025 grads
Apply: https://aveva.wd3.myworkdayjobs.com/AVEVA_careers/job/Hyderabad-India/Software-Developer-Graduate--India_R008700

def conversionPermutation(n):
    if n == 0:
        return "0"

    min_rep = None
    digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

    for b in range(2, min(n + 1, 37)):
        rep = ""
        temp = n
        while temp > 0:
            rep = digits[temp % b] + rep
            temp //= b
        
        if min_rep is None or rep < min_rep:
            min_rep = rep

    return min_rep

Conversion Permutation ✅

INDMoney Hiring Interns
https://www.linkedin.com/posts/mourya-venkat-937264135_hiring-alert-were-looking-for-an-intern-activity-7229414800886226945-Sa3R

Sri Sri Tatva hiring for multiple Internship and Full Time roles.

https://docs.google.com/forms/d/e/1FAIpQLScRFpylPRal2_YCqbCbUobeLanNSnECHwWC_3umHwRXrl9IZA/viewform

#include <bits/stdc++.h>
using namespace std;
int main() {
    int N;
    cin >> N;

    vector<int> array(N);
    long long sum = 0;

    for (int i = 0; i < N; ++i) {
        std::cin >> array[i];
        sum += array[i];
    }
    if (sum % N == 0) {
       cout << "Yes\n";
    } else {
        int remainder = sum % N;
        cout << "No " << remainder << '\n';
    }

    return 0;
}

Wabtec ✅

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;

ll cost(ll r, ll c, ll j) {
    return pow(r, 2) + j * c;
}

int main() {
    ll l, c, n;
    cin >> l >> c >> n;

    vll v(n);
    for (ll i = 0; i < n; ++i) {
        cin >> v[i];
    }

    v.push_back(0);
    v.push_back(l);

    sort(v.begin(), v.end());

    ll mini = LLONG_MAX;
    ll best_jumps = 0;
    ll best_range = 0;

    for (ll i = 1; i < v.size(); ++i) {
        ll r = v[i] - v[i - 1];

        ll last_pos = 0;
        ll j = 0;
        bool f = true;

        for (ll k = 1; k < v.size(); ++k) {
            if (v[k] - last_pos > r) {
                last_pos = v[k - 1];
                j++;
                if (v[k] - last_pos > r) {
                    f = false;
                    break;
                }
            }
        }

        if (f) {
            j++;

            ll total = cost(r, c, j);

            if (total < mini) {
                mini = total;
                best_jumps = j;
                best_range = r;
            }
        }
    }

    cout << mini << " " << best_jumps << " " << best_range << endl;

    return 0;
}

Wabtec ✅

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int getMaximumPower(vector<int> arr, vector<int> power) {
    const long MOD = 1e9 + 7;
    int n = arr.size();
    int k = power.size();
    
    vector<long long> prefix_sum(n + 1, 0);
    for (int i = 1; i <= n; ++i) {
        prefix_sum[i] = (prefix_sum[i - 1] + arr[i - 1]) % MOD;
    }
    
    sort(power.begin(), power.end());
    
    long long ans = 0;
    int i = 0;
    int j = k - 1;
    
    while (i < j) {
        if (power[i] == 0) {
            ans = (ans + prefix_sum[power[j] + 1]) % MOD;
        } else {
            ans = (ans + (prefix_sum[power[j] + 1] - prefix_sum[power[i]]) % MOD + MOD) % MOD;
        }
        i++;
        j--;
    }
    
    return ans;
}

Expedia ✅