🚀 Join Our Team as an HR Business Partner at Amazon Operations! 🚀

Are you a strategic HR leader ready to influence and drive organizational effectiveness in a dynamic, 24/7 environment? We're seeking a seasoned HRBP with a passion for shaping HR strategies that align with business goals and foster a high-engagement culture.

Key Responsibilities:

Lead and inspire a team of HR professionals in a high-growth environment.

Design and implement policies that drive continual improvement in business objectives.

Partner with leadership to integrate Amazon’s Leadership Principles into our talent system.

Operate with autonomy to solve problems and craft integrated solutions across the employee lifecycle.

If you're ready to take on a challenging and rewarding role, please send your resume to nesinha@amazon.com. Let's shape the future together!

Linedata is hiring Software Engineer

For 2021, 2022 grads
Location: Chennai

https://www.linedata.com/careers-Linedata?jobId=738&idOrigine=2586

*Internship / Full Time Opportunity: Full Stack/ FIgma*

*_JOB_ _Position_*

*1.* FULL Stack
*2.* Frontend
*3.* Backend
*4.* Figma Designer

msg to ‎+919870212914
with your resume ( *most important* )

For java intern
Do apply at
mailto:sriram@annulartechnologies.com

#include <bits/stdc++.h>
using namespace std;
int xorSubsequence(int a[], int n, int k)
{
    int ans = 0;
    map<int, int> map;

    int dp[n] = { 0 };

    map[a[0]] = 1;
    dp[0] = 1;

    for (int i = 1; i < n; i++) {
        dp[i] = max(dp[i], map[a[i] ^ k] + 1);
        ans = max(ans, dp[i]);
    
        map[a[i]] = max(map[a[i]], dp[i]);
    }

    return ans >= 2 ? ans : 0;
}

ION✅

def getString(input_str):
    stack = []
    last_occurrence = {c: i for i, c in enumerate(input_str)}
    seen = set()

    for i, char in enumerate(input_str):
        if char not in seen:
            while stack and char > stack[-1] and i < last_occurrence[stack[-1]]:
                seen.remove(stack.pop())
            stack.append(char)
            seen.add(char)

    return ''.join(stack)

ION✅

vector<int> runningMedian(vector<int> arr) {
    priority_queue<int> low;
    priority_queue<int, vector<int>, greater<int>> high;
    vector<int> res;
   
    for (int num : arr) {
        low.push(num);
        high.push(low.top());
        low.pop();
        if (low.size() < high.size()) {
            low.push(high.top());
            high.pop();
        }
        res.push_back(low.top());
    }
    return res;
} 


RunningMedium ✅
ION

Medial is hiring for Full Stack Developer

3 month intern - 50 k per month REMOTE

2026/2025/2024 passouts eligible

Fte based on performance

Send resume : jobs@medial.app

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

struct Edge {
    int u, v, c;
    bool operator<(const Edge& other) const {
        return c < other.c;
    }
};

int find(vector<int>& parent, int u) {
    if (parent[u] != u) parent[u] = find(parent, parent[u]);
    return parent[u];
}

void unite(vector<int>& parent, vector<int>& rank, int u, int v) {
    int root_u = find(parent, u);
    int root_v = find(parent, v);
    if (root_u != root_v) {
        if (rank[root_u] > rank[root_v]) {
            parent[root_v] = root_u;
        } else if (rank[root_u] < rank[root_v]) {
            parent[root_u] = root_v;
        } else {
            parent[root_v] = root_u;
            rank[root_u]++;
        }
    }
}

long long solve(int n, vector<Edge>& edges) {
    sort(edges.begin(), edges.end());
    vector<int> parent(n + 1), rank(n + 1, 0);
    iota(parent.begin(), parent.end(), 0);
    long long cost = 0;
    int edges_used = 0;
    for (const auto& edge : edges) {
        if (find(parent, edge.u) != find(parent, edge.v)) {
            unite(parent, rank, edge.u, edge.v);
            cost += edge.c;
            edges_used++;
            if (edges_used == n - 1) break;
        }
    }
    return cost;
}

Break and Add ✅
Google

def findMinChanges(taskDependency):
    n = len(taskDependency)
    changes = 0
    final_task = -1
    
    for i in range(n):
        if taskDependency[i] == i + 1:
            final_task = i + 1
            break
    
    if final_task == -1:
        final_task = n
        changes += 1
    
    visited = set()
    for i in range(1, n + 1):
        if i not in visited:
            current = i
            path = set()
            while current not in visited:
                if current == final_task:
                    break
                if current in path:
                    # Found a cycle, break it
                    changes += 1
                    break
                path.add(current)
                visited.add(current)
                current = taskDependency[current - 1]

    for i in range(1, n + 1):
        if i != final_task and taskDependency[i - 1] == i:
            changes += 1
    
    return changes

Gamestop scheduling n tasks

bool solve(vector<int>& A, int N, int M, int L, int x) {
    vector<int> B = A;  
    int op = 0;

    for (int i = 0; i < N; ++i) {
        if (B[i] > x) {
            int dec = B[i] - x;
            int length = min(L, N - i); 
            
            for (int j = 0; j < length; ++j) {
                B[i + j] -= dec;  
            }
            op += dec;

            if (op > M) {
                return false; 
            }
        }
    }

    return true;  
}


int minimizeMaxElement(vector<int>& A, int N, int M, int L) {
    int low = -1e9;
    int high = *max_element(A.begin(), A.end());

    while (low < high) {
        int mid = low + (high - low) / 2;

        if (solve(A, N, M, L, mid)) {
            high = mid;  
        } else {
            low = mid + 1;  
        }
    }

    return low;
}

Array and queries
google✅