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✅

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int collectMax(vector<vector<int>>& mat) {
    int n = mat.size();
    if (n == 0) return 0;
        vector<vector<vector<int>>> dp(n, vector<vector<int>>(n, vector<int>(2, -1)));
    
    dp[0][0][1] = (mat[0][0] == 1) ? 1 : 0;
        for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (mat[i][j] == -1) continue;
            if (i > 0 && dp[i-1][j][1] != -1)
                dp[i][j][1] = max(dp[i][j][1], dp[i-1][j][1] + (mat[i][j] == 1));
            if (j > 0 && dp[i][j-1][1] != -1)
                dp[i][j][1] = max(dp[i][j][1], dp[i][j-1][1] + (mat[i][j] == 1));
        }
    }
    
    if (dp[n-1][n-1][1] == -1) return 0;
    dp[n-1][n-1][0] = dp[n-1][n-1][1];
    for (int i = n-1; i >= 0; --i) {
        for (int j = n-1; j >= 0; --j) {
            if (mat[i][j] == -1) continue;
            if (i < n-1 && dp[i+1][j][0] != -1)
                dp[i][j][0] = max(dp[i][j][0], dp[i+1][j][0] + (mat[i][j] == 1));
            if (j < n-1 && dp[i][j+1][0] != -1)
                dp[i][j][0] = max(dp[i][j][0], dp[i][j+1][0] + (mat[i][j] == 1));
        }
    }
    
    return dp[0][0][0];
}

Gamekraft ✅

from collections import defaultdict
def getMaxRacers(speed, k):
    ans = 0
    D = defaultdict(list)
    for i, e in enumerate(speed):
        D[e].append(i)
    for arr in D.values():
        l = 0
        for r in range(len(arr)):
            while r > l and arr[r] - arr[l] - (r - l) > k:
                l += 1
            ans = max(ans, r - l + 1)
    
    return ans

GAMESKRAFT MAXRACERS ✅