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 ✅

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

using ll = long long;

void dfs(int v, int pre, vector<vector<int>>& T, vector<ll>& sz, ll n, ll& ans) {
    ll sum1 = 0, sum2 = 0;
    for (int c : T[v]) {
        if (c == pre) continue;
        dfs(c, v, T, sz, n, ans);
        sum1 += sz[c];
        sum2 += sz[c] * sz[c];
        sz[v] += sz[c];
    }
    sum1 += n - sz[v];
    sum2 += (n - sz[v]) * (n - sz[v]);
    ans -= (sum1 * sum1 - sum2) >> 1;
}

int countTriplets(int treeNodes, vector<int>& treeFrom, vector<int>& treeTo) {
    vector<vector<int>> T(treeNodes + 1);
    for (int i = 0; i < treeNodes - 1; i++) {
        T[treeFrom[i]].push_back(treeTo[i]);
        T[treeTo[i]].push_back(treeFrom[i]);
    }

    ll ans = treeNodes * (treeNodes - 1) * (treeNodes - 2) / 6;
    vector<ll> sz(treeNodes + 1, 1);
    dfs(1, -1, T, sz, treeNodes, ans);
    return ans;
}

int main() {
    int treeNodes = 5;
    vector<int> treeFrom = {1, 1, 2, 2};
    vector<int> treeTo = {2, 5, 3, 4};

    cout << countTriplets(treeNodes, treeFrom, treeTo) << '\n';
    return 0;
}

Count tree path
Gamekraft ✅

const char* oldest(struct companyProfile* profiles, int n) 
{
    int maxSize=profiles[0].size;
    const char* ans=profiles[0].name;
    for (int i=1;i<n;i++) 
    {
        if (profiles[i].size>maxSize) 
        {
            maxSize=profiles[i].size;
            ans=profiles[i].name;
        }
    }
    return ans;
}
float average(struct companyProfile* profiles, int n) 
{
    if (n==0) return 0.0f;
    int ans = 0;
    for (int i=0;i<n;i++) 
    {
        ans+=profiles[i].size;
    }
    return (float)ans/n;
}

Company Profiles ✅

Quadeye Hiring Campus Engineer  -System Engineer

https://www.quadeye.com/careers/?gh_jid=5635516002&utm_medium=jobboard&utm_source=linkedin&gh_src=4eab9f2d2

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

Walk-In For "Only Freshers (Except BE / B.Tech)-Data" at Pune Location on 25th Aug


Note: Please carry copy of this email to the venue and make sure you register your application before attending the walk-in. Please mention Candidate ID on top of the Resume ***Please use below link to apply and register your application.


https://career.infosys.com/jobdesc?jobReferenceCode=PROGEN-HRODIRECT-188901



Interview Information:

Interview Date: 25th Aug 2024
Interview Time: 09:30 Am till 12:30 Pm


Interview Venue - Pune:

Pune Venue:

Infosys BPM limited,

Taluka Mulshi,

Plot No. 1, Pune, Phase 1,

Hinjawadi Rajiv Gandhi infotech Park,

Hinjawadi, Pune,

Maharashtra 411057



Documents to Carry:

Please carry 2 set of updated CV(Hard Copy).
Please carry Face Mask**.
Carry any 2 photo Identity proof (PAN Card/Driving License/Voters ID card/Passport).
All original education documents need to be available for verification. (10th, 12th, Graduation (Sem Wise Marksheet, CMM. Provisional and Original Degree)


Job Description:

Job Location: Pune
Qualification: Any Graduate B-Com, BBA, BCA (Except BE / Technical)
Shifts: 24*7
Experience: 0-1 Years
Role: Process Executive


NOTE: Only looking for Freshers & Talents should have graduation completion certificate and mark sheets for onboarding.



Basic requirements:

Decent communication.
Ready to work in night shift
Work from office.


Roles & Responsibilities:

Candidate needs to have 15 years of full time education
Proficient with basic computer knowledge
Candidate should be flexible to work in 24*7 environments, comfortable to work in night shifts (Rotational)
Excellent verbal, written communication, interpretation and active listening skills
Ability to quickly and efficiently assimilate process knowledge
Effective probing & analyzing skills and capable of doing a multi-tasking of voice & data entry
Should be comfortable working from office