๐—–๐—ฆ ๐—”๐—น๐—ด๐—ผ ๐Ÿ’ป ๐ŸŒ ใ€Ž๐—–๐—ผ๐—บ๐—ฝ๐—ฒ๐˜๐—ถ๐˜๐—ถ๐˜ƒ๐—ฒ ๐—ฃ๐—ฟ๐—ผ๐—ด๐—ฟ๐—ฎ๐—บ๐—บ๐—ถ๐—ป๐—ดใ€
9.63K subscribers
5.61K photos
3 videos
95 files
10.6K links
๐ŸšฉMain Group - @SuperExams
๐Ÿ“Job Updates - @FresherEarth

๐Ÿ”ฐAuthentic Coding Solutions(with Outputs)
โš ๏ธDaily Job Updates
โš ๏ธHackathon Updates & Solutions

Buy ads: https://telega.io/c/cs_algo
Download Telegram
Hiring for the position of Technical Support Engineer:

Experience: 0 to 2years
Location: Bangalore
Notice Period: Immediate

Mandatory skills required:
ยท Should have attended regular school/college with 10+2+3 as a minimum qualification in any stream of subject.
ยท Good understanding of computer systems, mobile devices, and other tech products.
. Excellent Communication


Job Description:  Technical Support Engineer

Roles:

Provides level 1 technical support to end users on computer-related technical problems to assigned accounts/ customers through voice support.


Essential Job Functions:
ยท  Taking ownership of customer issues reported and responding to customer inquiries to ensure customer needs are met.
ยทAssists customers in resolving technical problems by providing guidance regarding software/hardware/application issues etc.
ยทResearching, diagnosing, troubleshooting, and identifying solutions to resolve system issues and/or refer more complex technical problems through a defined escalation process.
ยทIdentifies, evaluates, and prioritizes customer problems and complaints to ensure that inquiries are resolved appropriately.

Basic Qualifications

ยทAbility to diagnose and troubleshoot basic technical issues.
ยท Fresher or has work experience as a Technical Support Engineer, Desktop Support Engineer, IT Help Desk Technician, or similar role.
ยท Ability to provide step-by-step technical help, both written and verbal.
ยทExperience with solving computer-related problems.
ยทExperience working with company escalation policy.

Requirements and Skills
ยทInterpersonal skills to interact with customers and team members.
ยทExcellent problem-solving and communication skills with fluent spoken English and good thought flow.
ยทOrganization skills to balance and prioritize work.
ยทAbility to work in a team environment.

Please drop the CV on ramya.cr@dxc.com
๐—–๐—ฆ ๐—”๐—น๐—ด๐—ผ ๐Ÿ’ป ๐ŸŒ ใ€Ž๐—–๐—ผ๐—บ๐—ฝ๐—ฒ๐˜๐—ถ๐˜๐—ถ๐˜ƒ๐—ฒ ๐—ฃ๐—ฟ๐—ผ๐—ด๐—ฟ๐—ฎ๐—บ๐—บ๐—ถ๐—ป๐—ดใ€
Photo
#include <vector>
#include <string>
#include <set>

class DSU {
public:
    std::vector<int> parent, size;

    DSU(int n) {
        parent.resize(n + 1);
        size.resize(n + 1, 1);
        for (int i = 1; i <= n; i++) {
            parent[i] = i;
        }
    }

    int find(int x) {
        if (x == parent[x]) {
            return x;
        }
        return parent[x] = find(parent[x]);
    }

    void merge(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX != rootY) {
            if (size[rootX] < size[rootY]) {
                std::swap(rootX, rootY);
            }
            parent[rootY] = rootX;
            size[rootX] += size[rootY];
        }
    }
};

vector<int> getTheGroups(int n, std::vector<std::string>& queryType, std::vector<int>& student1, std::vector<int>& student2) {
    DSU dsu(n + 1);
    std::vector<int> ans;

    for (int i = 0; i < n; i++) {
        if (queryType[i] == "Friend") {
            dsu.merge(student1[i], student2[i]);
        } else {
            int root1 = dsu.find(student1[i]);
            int root2 = dsu.find(student2[i]);
            ans.push_back(dsu.size[root1] + dsu.size[root2] - (root1 == root2 ? 1 : 0));
        }
    }

    return ans;
}

Get the groupsโœ…
โค1๐Ÿ‘1
def solution(n, t, edges):
    graph = [[] for _ in range(n)]
    for u, v in edges:
        graph[u].append(v)
        graph[v].append(u)
   
    def dfs(node, parent):
        size, time_sum = 1, 0
        for child in graph[node]:
            if child != parent:
                c_size, c_time = dfs(child, node)
                size += c_size
                time_sum += c_time + t[child] * c_size
        return size, time_sum
   
    total_time = sum(t)
    expected_times = [0] * n
   
    def calculate_expected(node, parent, parent_contrib):
        size, time_sum = dfs(node, parent)
        expected_times[node] = t[node] + (time_sum + parent_contrib) / (n - 1)
        for child in graph[node]:
            if child != parent:
                child_contrib = parent_contrib + (total_time - time_sum - t[child]) * (n - size)
                calculate_expected(child, node, child_contrib / (n - 1))
   
    calculate_expected(0, -1, 0)
    return min(range(n), key=lambda i: expected_times[i])