#include <bits/stdc++.h>
using namespace std;
struct T {
    string n;
    int p, e;
    T(string n, int p, int e) : n(n), p(p), e(e) {}
};

struct C {
    bool operator()(const T &a, const T &b) {
        if (a.p == b.p) return false;
        return a.p < b.p;
    }
};

vector<string> CircularPriorityDequeue(vector<string> a, vector<int> b, vector<int> c, vector<int> d) {
    map<int, deque<T>, greater<int>> m;
    vector<string> r;
    for (int i = 0; i < a.size(); ++i) m[b[i]].emplace_back(a[i], b[i], c[i]);

    for (int q : d) {
        if (q == 1) {
            if (m.empty()) {
                r.push_back("Dequeued: EMPTY");
                continue;
            }
            auto &h = m.begin()->second;
            r.push_back("Dequeued: " + h.front().n);
            h.pop_front();
            if (h.empty()) m.erase(m.begin()->first);
        } else if (q == 2) {
            if (m.empty()) {
                r.push_back("Executed: EMPTY");
                continue;
            }
            auto &h = m.begin()->second;
            r.push_back("Executed: " + h.front().n);
            h.pop_front();
            if (h.empty()) m.erase(m.begin()->first);
        } else if (q == 3) {
            int s = 0;
            for (const auto &e : m) s += e.second.size();
            r.push_back("Size: " + to_string(s));
        }
    }
    return r;
}

Task Scheduling Optimization ✅
Cars24

iCIMS is hiring Data Analyst

Exp: Fresher 
https://careers.icims.com/careers-home/jobs/5688

vector<vector<int>> adj;
vector<int> vis;
void solve() {
  int n;
  cin >> n;
  adj.resize(n);
  for(int i = 0 ; i < n ; i++){
    int x;cin >> x;
    int N = i + x;
    int P = i - x;
    if(N < n)
      adj[N].push_back(i);
    if(P >= 0)
      adj[P].push_back(i);
  }
  vis.resize(n, -1);
  queue<int> Q;
  Q.push(n-1);
  vis[n-1] = 0;
  while(!Q.empty()){
    int u = Q.front();
    Q.pop();
    for(int v : adj[u]){
      if(vis[v] == -1){
        Q.push(v);
        vis[v] = 1 + vis[u];
      }
    }
  }
  for(int i = 0; i < n ; i++)
    cout << vis[i] <<endl;
}

Servers Time ✅
Razorpay

long long solve(int N,int M,vector<int>Arr){
    vector<int>v(N+1,INT_MAX);
    int n=N;
    for(int i=n-1;i>=0;i--){
        v[i]=min(v[i+1],Arr[i]);
    }
    long long ans=INT_MAX;
    for(int i=0;i<N;i++){
        if((i+M-1)<N){
            ans=min(ans,1ll*Arr[i]*v[i+M-1]);
        }
    }
    return ans;
} 

Array transfer✅

class Solution{
public:
    bool solvable(vector<int>& v,int diff,int K){
    
        int n=v.size();
        int prev=0;
        int removed=0;
        for(int i=1;i<n&&removed<K;i++){
            if(i==n-1 || v[i+1]-v[prev]>diff){
                if(v[i]-v[prev]>diff)return false;
                prev=i;
            }
            else removed++;
        }
        return (removed==K);
    }
   
    int minDiff(vector<int> v,int K){
       
        int hi=v.back()-v[0];
        int lo=0;
       
        for(int i=0;i+1<v.size();i++)lo=max(lo,v[i+1]-v[i]);
       
        while(lo<hi){
            int mid=(lo+hi)/2;
            if(solvable(v,mid,K))hi=mid;
            else lo=mid+1;
        }
        return lo;       
    }
};

Adjacent cubes ✅

MOD = 1000000007
def a(x):
    if x <= 1:
        return False
    for i in range(2, int(x**0.5) + 1):
        if x % i == 0:
            return False
    return True

def b(x):
    c = []
    for i in range(1, x+1):
        if a(i):
            c.append(i)
    return c

def c(d, e, f):
    g = [2, 3, 5, 7]
    h = [0, 1, 4, 6, 8, 9]
    i = b(d)
    j = [[0] * e for _ in range(d+1)]
    j[0][0] = 1
    for k in range(1, d+1):
        if k in i:
            l = g
        else:
            l = h
        for m in range(e):
            for n in l:
                if k == 1 and n == 0:
                    continue
                o = (m * 10 + n) % e
                j[k][o] = (j[k][o] + j[k-1][m]) % MOD
    return j[d][f

[f] special Numbers✅

Treasure Division✅
Netcore

Mix spices ✅

Arrange Map Code


from collections import deque
import itertools

def get_shortest_path(grid, N):
    start = None
    end = None
    for i in range(N):
        for j in range(N):
            if grid[i][j] == 'S':
                start = (i, j)
            elif grid[i][j] == 'D':
                end = (i, j)

    queue = deque([(start, 0)])
    visited = {start}

    while queue:
        (x, y), dist = queue.popleft()
        if grid[x][y] == 'D':
            return dist

        for nx, ny in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:
            if 0 <= nx < N and 0 <= ny < N and (nx, ny) not in visited and grid[nx][ny] != 'T':
                visited.add((nx, ny))
                queue.append(((nx, ny), dist + 1))
    return float('inf')

def get_sheets(grid, N, M):
    sheets = []
    for i in range(0, N, M):
        for j in range(0, N, M):
            sheet = []
            for x in range(M):
                row = []
                for y in range(M):
                    row.append(grid[i+x][j+y])
                sheet.append(row)
            sheets.append(sheet)
    return sheets

def make_grid(arrangement, sheets, N, M):
    grid = [["" for _ in range(N)] for _ in range(N)]
    num_sheets = N // M

    for idx, sheet_idx in enumerate(arrangement):
        sheet = sheets[sheet_idx]
        base_i = (idx // num_sheets) * M
        base_j = (idx % num_sheets) * M

        for i in range(M):
            for j in range(M):
                grid[base_i + i][base_j + j] = sheet[i][j]
    return grid

def solve():
    N, M = map(int, input().split())
    original_grid = []
    for _ in range(N):
        original_grid.append(list(input().strip()))

    sheets = get_sheets(original_grid, N, M)
    num_sheets = (N // M) ** 2

    s_sheet = d_sheet = None
    for i, sheet in enumerate(sheets):
        for row in sheet:
            if 'S' in row:
                s_sheet = i
            if 'D' in row:
                d_sheet = i

    min_dist = float('inf')
    nums = list(range(num_sheets))
    nums.remove(s_sheet)
    nums.remove(d_sheet)

    for middle_perm in itertools.permutations(nums):
        arrangement = [s_sheet] + list(middle_perm) + [d_sheet]
        grid = make_grid(arrangement, sheets, N, M)
        min_dist = min(min_dist, get_shortest_path(grid, N))

    return min_dist

if name == "main":
    print(solve())


Arrange Map Code ✅✅✅
Full Passed , Remove Plagrism Guys

def wolve(elements):
    n = len(elements)
    result = [] 
    level = 0 
    idx = 0   
    while idx < n:
        nodes_in_level = 2 ** level 
        if idx + nodes_in_level <= n:
            result.append(elements[idx + nodes_in_level - 1])  
            idx += nodes_in_level
        else:
            break
        level += 1
    print(" ".join(map(str, result)))

Bnp ✅

def first_meat_orders(num_of_orders, orders, size):
    result = []
   
    for i in range(0, num_of_orders-size+1):
        screen_orders = orders[i:i+size]
        meat_order_found = False
       
        for order in screen_orders:
            if order < 0:  # Checking for meat-based pizza order
                result.append(order)
                meat_order_found = True
                break

       
        if not meat_order_found:
            result.append(0)
        meat_order_found = False
   
    return result

Hiring C programmer (Remote)
Micro Hiring!

For 2024 grads

Preferred Qualification: M.Tech

https://jobs.micro1.ai/post/4c49729f-c07c-4e05-bded-90c4e7199543