CryptoXpress Hiring Software Developer -Fresher
https://www.linkedin.com/jobs/view/3931469882

Graduate Program 2024 at Morse Micro

Eligibility: Fresh Graduates or 1-2 YOE
Duration: 6 Months
Applications are open now and close on June 28, 2024.
https://www.morsemicro.com/jobs?gh_jid=7460302002

SDE Intern at Spikewell
Onsite: Bhubaneswar

Stipend: 10K
Eligibility: B-tech in CSE & IT/BCA/MCA passed out in 2024.
Duration : 1 yr

NOTE: I would recommend only apply if you live nearby and don't have any other offers right now.
https://spikewell.zohorecruit.in/jobs/Careers/62862000004397001/SDE-Intern

#include <vector>
#include <map>
#include <iostream>
using namespace std;
vector<int> getCacheSize(vector<vector<int>> data, vector<int> queries) {
    int n = data.size();
    int q = queries.size();
    map<int, int> endTimeMap;
    for (auto& d : data) {
        endTimeMap[d[0]] = d[0] + d[1];
    }
    vector<int> result;
    for (int query : queries) {
        int cacheSize = 0;
        for (auto& it : endTimeMap) {
            if (it.first <= query && query <= it.second) {
                cacheSize++;
            }
        }
       
        result.push_back(cacheSize);
    }
   
    return result;
}

ION✅

#include <vector>
#include <map>
#include <iostream>
using namespace std;
vector<int> getCacheSize(vector<vector<int>> data, vector<int> queries) {
    int n = data.size();
    int q = queries.size();
    map<int, int> endTimeMap;
    for (auto& d : data) {
        endTimeMap[d[0]] = d[0] + d[1];
    }
    vector<int> result;
    for (int query : queries) {
        int cacheSize = 0;
        for (auto& it : endTimeMap) {
            if (it.first <= query && query <= it.second) {
                cacheSize++;
            }
        }
       
        result.push_back(cacheSize);
    }
   
    return result;
}

ION ✅

#include <vector>
#include <utility>

using namespace std;

class Solution {
public:
    vector<int> cached(vector<vector<int>>& data, vector<int>& q) {
        int n = data.size();
        vector<int> res(2, 0);
        int cnt = 0;
        for(int i = 0; i < n; i++) {
            pair<int, int> p;
            p.first = data[i][0];
            p.second = data[i][0] + data[i][1];
            for(int j = 0; j < q.size(); j++) {
                if (p.first >= q[j] && p.second >= q[j])
                    cnt++;
            }
        }
        res[0] = n;
        res[1] = cnt;
        return res;
    }
};

ION✅

import java.util.*;
public class Main
{
    public static int getMinimumHealth(int[] initial_player, int[] new_player, int rank){
        PriorityQueue<Integer>minHeap = new PriorityQueue<>();
        for(int num : initial_player){
            if(minHeap.size()<rank){
                minHeap.add(num);
            }else{
                minHeap.add(num);
                minHeap.poll();
            }
        }
       long minimumHealth = minHeap.peek();
        for(int num : new_player){
            if(minHeap.size()<rank){
                minHeap.add(num);
            }else{
                minHeap.add(num);
                minHeap.poll();
                minimumHealth+=minHeap.peek();
            }
        }
        return minimumHealth;
    }

ION✅

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

int dp[5001];

int F(int L, int N, int K, vector<int> &A) {
    if (L == N) return 0;
    if (dp[L] != -1) return dp[L];
    int ans = 2e9;
    int maxi = 0;
    for (int R = L; R < min(N,L + K); R++) {
        maxi = max(maxi, A[R]);
        ans = min(ans, maxi + F(R + 1, N, K, A));
    }
    return return dp[L] = ans;
}

int calculateCost(vector<int> arr, int threshold) {
    memset(dp, -1, sizeof dp);
    return F(0, arr.size(), threshold, arr);
}

WebGo Software Labs is hiring SDE Intern

For 2024, 2025, 2026 grads

Apply - https://www.linkedin.com/jobs/view/3935735633

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
bool can_walk_in_time(const vector<int>& pain, int N, long long T) {
    long long total_distance = 0;
    for (int p : pain) {
        if (p == 0) continue;
        long long max_distance = static_cast<long long>(sqrt(T / p));
        total_distance += max_distance;
        if (total_distance >= N) {
            return true;
        }
    }
    return total_distance >= N;
}
long long minTime(int N, vector<int> pain) {
    long long low = 0, high = 1e18;
    while (low < high) {
        long long mid = (low + high) / 2;
        if (can_walk_in_time(pain, N, mid)) {
            high = mid;
        } else {
            low = mid + 1;
        }
    }
    return low;
}

Nuclei Championship ✅

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

bool canFormSubsequence(const string &s, const string &t, int left, int right) {
    int m = t.size(), n = s.size();
    int ti = 0;
    for (int si = 0; si < n; si++) {
        if (ti == left && ti <= right) {
            ti = right + 1; // Skip the window
        }
        if (ti < m && s[si] == t[ti]) {
            ti++;
        }
    }
    return ti == m;
}

int findMinScore(string &s, string &t) {
    int m = t.size(), n = s.size();
    if (m == 0) return 0;

    int left = 0, right = m - 1, answer = m;
   
    while (left <= right) {
        int mid = left + (right - left) / 2;
        bool possible = false;
       
        for (int i = 0; i + mid < m; i++) {
            if (canFormSubsequence(s, t, i, i + mid)) {
                possible = true;
                break;
            }
        }
       
        if (possible) {
            answer = mid + 1;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
   
    return answer;
}

int main() {
    string s, t;
    cin >> s >> t;
    cout << findMinScore(s, t) << endl;
    return 0;
}

The subsequence Mastery ✅

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int dfs(vector<vector<int>>& grid, int i, int j, vector<vector<int>>& memo) {
    if (memo[i][j] != -1) return memo[i][j]; 
   
    int max_score = 0;
    int m = grid.size();
    int n = grid[0].size();
   
    for (int l = j + 1; l < n; ++l) {
        max_score = max(max_score, grid[i][l] - grid[i][j] + dfs(grid, i, l, memo));
    }
   
    for (int k = i + 1; k < m; ++k) {
        max_score = max(max_score, grid[k][j] - grid[i][j] + dfs(grid, k, j, memo));
    }
   
    memo[i][j] = max_score; 
    return max_score;
}

int maxMagicalMazeScore(vector<vector<int>>& grid) {
    int m = grid.size();
    int n = grid[0].size();
    vector<vector<int>> memo(m, vector<int>(n, -1));
   
    int max_score = 0;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            max_score = max(max_score, dfs(grid, i, j, memo));
        }
    }
   
    return max_score;
}

int main() {
    int m, n;
    cin >> m >> n;
    vector<vector<int>> grid(m, vector<int>(n));
   
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> grid[i][j];
        }
    }
   
    cout << maxMagicalMazeScore(grid) << endl;
    return 0;
}

Max Magical Maze Score ✅

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

int memoize(int l, int r, int residue, const vector<char>& colors) {
    int n = colors.size();
    int dp[n][n][n];
    memset(dp, -1, sizeof(dp));

    if (r < l)
        return 0;
    else if (dp[l][r][residue] != -1)
        return dp[l][r][residue];

    dp[l][r][residue] = (residue + 1) * (residue + 1) + memoize(l, r - 1, 0, colors);

    for (int i = l; i < r; i++) {
        if (colors[i] == colors[r]) {
            dp[l][r][residue] = max(dp[l][r][residue], memoize(l, i - 1, 0, colors) + memoize(i + 1, r, residue + 1, colors));
        }
    }

    return dp[l][r][residue];
}

int solve(int n, vector<char> colors) {
    return memoize(0, n - 1, 0, colors);
}

int main() {
    int n;
    cin >> n;
    vector<char> colors(n);
    for (int i = 0; i < n; i++) {
        cin >> colors[i];
    }
    cout << solve(n, colors);
    return 0;
}

Crayon box ✅