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 ✅