Electronics Art is hiring ML Engineer

For 2021, 2022, 2023 grads
Location: Hyderabad

https://ea.gr8people.com/jobs/184256/ml-engineer?sid=4&s=08

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000;
const int SEG_TREE_SIZE = 2097152;
vector<pair<int, int>> upd[MAXN + 10];
long long rao[SEG_TREE_SIZE];
long long sum[SEG_TREE_SIZE];
void update(int t, int l, int r, int x, int y) {
    if (x < l || r < x) return;
    rao[t] += y;
    sum[t] += 1LL * x * y;
    if (l == r) return;
    update(2 * t, l, (l + r) / 2, x, y);
    update(2 * t + 1, (l + r) / 2 + 1, r, x, y);
}
void get(int t, int l, int r, long long k, long long &B) {
    if (rao[t] <= k) {
        B += sum[t];
        return;
    }
    if (k <= 0) return;
    if (l == r) {
        B += 1LL * k * l;
        return;
    }
    get(2 * t, l, (l + r) / 2, k, B);
    get(2 * t + 1, (l + r) / 2 + 1, r, k - rao[2 * t], B);
}
long getMinCost(int n, int k, vector<vector<int>> plans) {
    memset(rao, 0, sizeof(rao));
    memset(sum, 0, sizeof(sum));

    long long res = 0;

    for (const auto& plan : plans) {
        int l = plan[0];
        int r = plan[1];
        int c = plan[2];
        int p = plan[3];
        upd[l].push_back({c, p});
        upd[r + 1].push_back({-c, p});
    }

    for (int i = 1; i <= n; ++i) {
        for (const auto& operation : upd[i]) {
            update(1, 1, MAXN, operation.second, operation.first);
        }
        long long B = 0;
        get(1, 1, MAXN, min(1LL * k, rao[1]), B);
        res += B;
    }

    return res;
}

CLOUD DATA TRANSFER✅

#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll solve(vector<ll>&a,vector<ll>&b,ll n,ll m)
{
    ll ans=0;
    ll s1=0,s2=0;
    ll i=0,j=0;
    while(i<n and j<m)
    {
        if(a[i]<b[j]) s1+=a[i++];
        else if(a[i]>b[j]) s2+=b[j++];
        else
        {
            ans+=max(s1,s2)+a[i];
            i++;
            j++;
            s1=0;
            s2=0;
        }
    }
    while(i<n) s1+=a[i++];
    while(j<m) s2+=b[j++];
    return max(s1,s2)+ans;
}
signed main()
{
    ll n; cin>>n;
    vector<ll>a(n);
    for(ll i=0;i<n;i++) cin>>a[i];
    ll m; cin>>m;
    vector<ll>b(m);
    for(ll i=0;i<n;i++) cin>>b[i];
    cout<<solve(a,b,n,m);
}

Cave coin collection ✅
Intuit

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

int main() {
    int k;  
    cin >> k;
    int n;  
    cin >> n;
    vector<int> arr(n);
    for (int i = 0; i < n; i++) cin >> arr[i];
    
    sort(arr.begin(), arr.end());
    
    int min_diff = 1e9;
    int best_sum = -1;
    
    for (int i = 0; i < n; i++) {
        int first = arr[i];
        
        int lb = lower_bound(arr.begin() + i + 1, arr.end(), first + k) - arr.begin();
        
        for (int j = lb - 1; j <= lb; j++) {
            if (j > i && j < n) {
                int second = arr[j];
                int diff = abs(k - (second - first));
                int sum = first + second;
                
                if (diff < min_diff || (diff == min_diff && sum > best_sum)) {
                    min_diff = diff;
                    best_sum = sum;
                }
            }
        }
    }
    
    cout << best_sum << endl;
    return 0;
}

The Chemist
Uber ✅

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

const int MOD = 10000;

int countArrays(string &S, int C, int K) {
    int N = S.length();
    vector<int> dp(N + 1, 0);
    dp[0] = 1;  

    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= K && j <= i; j++) {
            string num_str = S.substr(i - j, j);
            long long num = stoll(num_str);

            if (num <= C) {
                dp[i] = (dp[i] + dp[i - j]) % MOD;
            }
        }
    }

    return dp[N];
}

int main() {
    int N, C, K;
    cin >> N >> C >> K;

    string S;
    cin >> S;

    cout << countArrays(S, C, K) << endl;

    return 0;
}

Without whitespaces
Uber ✅

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

bool chkValid(const vector<string>& eq, unordered_map<char, int>& l2d) {
    vector<long long> nums;
    for (const string& p : eq) {
        long long num = 0;
        for (char c : p) {
            num = num * 10 + l2d[c];
        }
        nums.push_back(num);
    }
    return nums[0] + nums[1] == nums[2];
}

int dfs(vector<string>& eq, unordered_map<char, int>& l2d, unordered_set<int>& tD, vector<char>& let, int pos) {
    if (pos == let.size()) {
        return chkValid(eq, l2d) ? 1 : 0;
    }
    
    char l = let[pos];
    int count = 0;
    for (int d = 0; d < 10; ++d) {
        if (tD.count(d)) continue;
        if (d == 0 && find_if(eq.begin(), eq.end(), [&](string& p) { return p[0] == l; }) != eq.end()) continue;
        
        tD.insert(d);
        l2d[l] = d;
        
        count += dfs(eq, l2d, tD, let, pos + 1);
        
        tD.erase(d);
        l2d.erase(l);
    }
    
    return count;
}

int cntCryptarithmSolutions(vector<string> eq) {
    unordered_set<char> allLet;
    for (const string& p : eq) {
        for (char c : p) {
            allLet.insert(c);
        }
    }
    
    vector<char> let(allLet.begin(), allLet.end());
    unordered_map<char, int> l2d;
    unordered_set<int> tD;
    
    return dfs(eq, l2d, tD, let, 0);
}

Crypt
Trilogy ✅

bool placeBlock(vector<vector<char>>& field, int row, int& finalRow, int& finalCol) {
    int col = 0;
    while (col < field[0].size() && field[row][col] == '.') ++col;

    while (row < field.size() - 1 && field[row + 1][col] == '.') ++row;

    if (col >= 0 && row >= 0) {
        field[row][col] = '#';
        finalRow = row;
        finalCol = col;
        return true;
    }
    return false;
}

void removeBlock(vector<vector<char>>& field, int row, int col) {
    field[row][col] = '.';
}

void solve(vector<vector<char>>& field, vector<int>& ans, int cnt) {
    bool check = true;
    for (int i = 0; i < field.size(); ++i) {
        if (field[i][0] != '#') {
            check = false;
            break;
        }
    }
    if (check) {
        ans[0] = min(ans[0], cnt);
        ans[1] = max(ans[1], cnt);
        return;
    }

    for (int i = 0; i < field.size(); ++i) {
        int finalRow = -1, finalCol = -1;

        if (placeBlock(field, i, finalRow, finalCol)) {
            solve(field, ans, cnt + 1);

            removeBlock(field, finalRow, finalCol);
        }
    }
}

vector<int> solution(vector<vector<char>> field) {
    vector<int> ans = {INT_MAX, INT_MIN};
    solve(field, ans, 0);
    return ans;
}

Block placing
Trilogy ✅

#include <iostream>
#include <vector>

using namespace std;

const int MOD = 1e9 + 7;

int solve(int N, int M, vector<vector<int>>& nums) {

    vector<vector<long long>> dp(N, vector<long long>(M, 0));
    dp[0][0] = nums[0][0];
    

    for (int j = 1; j < M; ++j) {
        dp[0][j] = (dp[0][j - 1] * nums[0][j]) % MOD;
    }
    
    for (int i = 1; i < N; ++i) {
        dp[i][0] = (dp[i - 1][0] * nums[i][0]) % MOD;
    }
    

    for (int i = 1; i < N; ++i) {
        for (int j = 1; j < M; ++j) {
            dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) * nums[i][j] % MOD;
        }
    }
    
    return dp[N - 1][M - 1];
}

int main() {
    int N, M;
    cin >> N >> M;
    vector<vector<int>> nums(N, vector<int>(M));
    
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            cin >> nums[i][j];
        }
    }
    
    cout << solve(N, M, nums) << endl;
    
    return 0;
}

Maze Craze✅

Take Home Assignment based Hiring

Sample Invoices for reference:
https://drive.google.com/drive/folders/1Q7sU_eiisOvtCAFCRSesyMDkVsMtNF7h?usp=drive_link

Things that keep me going ❤️

Congratulations ❤