def Solve(N, K, A):
    remaining = list(range(1, N+1))
    time = 0
    i = 0
    
    while time < K and remaining:
        if A[remaining[i] - 1] > 0:
            A[remaining[i] - 1] -= 1
            time += 1
            
            if A[remaining[i] - 1] == 0:
                remaining.pop(i)
                i -= 1
        
        i = (i + 1) % len(remaining) if remaining else 0
    
    return remaining if remaining else [-1]

Egynte 2

int getMaximumDistance(vector<int> location, int k)
{
    int n = location.size();
    sort(location.begin(), location.end());

    int maxi = location[n - 1] - location[0];

    int left = 0, right = maxi;
    while (left < right)
    {
        int mid = left + (right - left) / 2;
        int center = 1;
        int prev = location[0];
        for (int i = 1; i < n; i++)
        {
            if (location[i] - prev > mid * 2)
            {
                center++;
                prev = location[i];
            }
        }

        if (center <= k)
        {
            right = mid;
        }
        else
        {
            left = mid + 1;
        }
    }

    return left;
}

Atyeti | Recruitment | Software Trainee
Greetings from Atyeti !!!

We are excited to announce openings for various positions at our locations in Pune, Hyderabad, and Chennai. Please review the job descriptions carefully before completing the application form. 

Pass out students of 2023 - 2024 year only.

https://docs.google.com/forms/d/e/1FAIpQLScaLiUNk70YIjAfzNnh2lytFXPWIBLhxGAtyt7n6M7a00eh9Q/viewform

Element Swapping ✅

e-Yantra Robotics Competition 2024-25
https://portal.e-yantra.org/

Facilio Hiring Intern product Engineer

Intern - Product Support

https://docs.google.com/forms/d/e/1FAIpQLSdQRTv3I4w_js-hrICii01t9RZ9kogRl2ukhWWiYbDqC85Y7A/viewform

Exide Energy Hiring Intern IT (Application Engineer)

https://www.linkedin.com/jobs/view/3984276607

Dayal Group Hiring Software Trainee Engineer

B. Tech / MCA degree in Computer Science, Software Engineering


https://dayalgroup.keka.com/careers/jobdetails/55996?source=linkedin&utm_medium=jobboard&utm_source=linkedin

Tower Research Hiring ML Intern

https://boards.greenhouse.io/embed/job_app?utm_medium=jobboard&token=6114125&utm_source=linkedin&gh_src=be8ebc4b1&source=LinkedIn

from math import gcd
from collections import defaultdict

class UnionFind:
    def __init__(self, size):
        self.parent = list(range(size))
        self.rank = [0] * size
        self.cluster_size = [1] * size

    def find(self, u):
        if self.parent[u] != u:
            self.parent[u] = self.find(self.parent[u])  # Path compression
        return self.parent[u]

    def union(self, u, v):
        root_u = self.find(u)
        root_v = self.find(v)
        if root_u != root_v:
            if self.rank[root_u] > self.rank[root_v]:
                self.parent[root_v] = root_u
                self.cluster_size[root_u] += self.cluster_size[root_v]
            elif self.rank[root_u] < self.rank[root_v]:
                self.parent[root_u] = root_v
                self.cluster_size[root_v] += self.cluster_size[root_u]
            else:
                self.parent[root_v] = root_u
                self.cluster_size[root_u] += self.cluster_size[root_v]
                self.rank[root_u] += 1

def prime_factors(n):
    i = 2
    factors = set()
    while i * i <= n:
        if n % i:
            i += 1
        else:
            n //= i
            factors.add(i)
    if n > 1:
        factors.add(n)
    return factors

def getClusterSizes(serverProp):
    n = len(serverProp)
    uf = UnionFind(n)
    factor_map = defaultdict(list)

    for i in range(n):
        factors = prime_factors(serverProp[i])
        for factor in factors:
            factor_map[factor].append(i)
    
    for indices in factor_map.values():
        for i in range(1, len(indices)):
            uf.union(indices[0], indices[i])

    result = [0] * n
    for i in range(n):
        result[i] = uf.cluster_size[uf.find(i)]

    return result

Gameskraft getClusterSizes✅

static class Node {
        int x, y, energy;
        Node(int x, int y, int energy) {
            this.x = x;
            this.y = y;
            this.energy = energy;
        }
    }

    public static int minimumEnergy(int n, int m, String[] river, int initial_x, int initial_y, int final_x, int final_y) {
        int[][] energy = new int[n][m];
        for (int[] row : energy) {
            Arrays.fill(row, Integer.MAX_VALUE);
        }
        energy[initial_x][initial_y] = 0;
       
        Queue<Node> queue = new LinkedList<>();
        queue.add(new Node(initial_x, initial_y, 0));
       
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};
       
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            int x = node.x, y = node.y, e = node.energy;
           
            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i], ny = y + dy[i];
                if (nx >= 0 && ny >= 0 && nx < n && ny < m && river[nx].charAt(ny) != '#' &&
                    (e + (dx[i] == -1 || dy[i] == -1 ? 1 : 0) < energy[nx][ny])) {
                   
                    energy[nx][ny] = e + (dx[i] == -1 || dy[i] == -1 ? 1 : 0);
                    queue.add(new Node(nx, ny, energy[nx][ny]));
                }
            }
        }
       
        return energy[final_x][final_y] == Integer.MAX_VALUE ? -1 : energy[final_x][final_y];
    }

Gamekraft ✅