Company Name: Swiggy

🛄 Job Title: SDET
✍🏻 YOE: 0-2 years

➡️ Apply: https://docs.google.com/forms/d/1cr-Z3bwEP9g4UtBlDfD76EHXuS7UuYt9l3fGHo35jSQ/viewform?edit_requested=true

Please do share in your college grps and in case you are applying please react on this post:) 😇❤️

#include <iostream>
#include <vector>
using namespace std;
class SegmentTree {
private:
    vector<int> tree;
    int size;
public:
    SegmentTree(int n) {
        size = 1;
        while (size < n) {
            size *= 2;
        }
        tree.assign(2 * size, 0);
    }
    void update(int idx, int value) {
        idx += size;
        tree[idx] += value;
        while (idx > 1) {
            idx /= 2;
            tree[idx] = tree[2 * idx] + tree[2 * idx + 1];
        }
    }
    int query(int left, int right) {
        left += size;
        right += size + 1;
        int sum = 0;
        while (left < right) {
            if (left % 2 == 1) {
                sum += tree[left];
                left++;
            }
            if (right % 2 == 1) {
                right--;
                sum += tree[right];
            }
            left /= 2;
            right /= 2;
        }
        return sum;
    }
};
vector<int> solution(int numOfEmployees, int numOfQueries, vector<vector<int>>& queries) {
    SegmentTree seg_tree(numOfEmployees);
    vector<int> results;
    for (const auto& query : queries) {
        int q_type = query[0];
        if (q_type == 1) {
            int emp_id = query[1];
            int amount = query[2];
            seg_tree.update(emp_id, amount);
        } else if (q_type == 2) {
            int left = query[1];
            int right = query[2];
            results.push_back(seg_tree.query(left, right));
        }
    }
    return results;
}

Netapp ✅

Company Name: Tata 1mg
Role: Summer Intern (Backend - Engineering)
Batch: 2025 passouts

Apply Link: https://docs.google.com/forms/d/1OTFWZG4ugzHdoVJHLlO7qpWSzNMhBdwAMov-YUnBqIE/viewform

Virtualmate.ai is hiring Android Development Intern

For 2024, 2025, 2026 grads

https://in.linkedin.com/jobs/view/android-development-intern-at-virtualmate-ai-3936982965?position=4&pageNum=0&refId=bbrC6FlwfyHWhJ2b%2B1frUA%3D%3D&trackingId=FNwhXd4GXVTmJ6j6jDOBtA%3D%3D&trk=public_jobs_jserp-result_search-card

Software Engineer Intern At Optionlogy
Location: Remote
Stipend: 25K-30K per month

Link: https://bit.ly/3KjDUFe

Flipkart is sponsoring an Infosec Certification Program.

Batch : 2024,2023,2022 passouts

Stipend : 40,000 INR per month for 6 months.

This is for cyber security folks.

https://docs.google.com/forms/u/0/d/e/1FAIpQLSdzHIzqmoKYLI7FnEq1Tlax4i3yWP5H-0qwSUcwWw-JWo4x7Q/viewform?usp=send_form&pli=1

Hiring Quality Trainee with 0 to 2 years of experience in Quality from Automotive background.

BE EEE / Mechanical / ECE freshers or 1 to 2 yrs experienced can apply

Interested candidates can share profile to recruitment@besmakindia.com with the subject line " Trainee - Quality"

Job Location- Oragadam

Stack<Integer> st = new Stack<>();
        StringBuilder sb = new StringBuilder();

        for (char ch : s.toCharArray()) {
            int digit = ch - '0';
            while (!st.isEmpty() && digit + st.peek() <= 9) {
                int pop = st.pop();
                digit = pop + digit;
            }
            st.add(digit);
        }

        while (!st.isEmpty()) {
            sb.append(st.pop());

Hashedin ✅

public static int solution(String S, String T) {
        int n = S.length();
        int[] sArray = new int[n];
        int[] tArray = new int[n];
        for (int i = 0; i < n; i++) {
            sArray[i] = S.charAt(i) - '0';
            tArray[i] = T.charAt(i) - '0';
        }
        int totalMoves = 0;
        for (int i = 0; i < n - 1; i++) {
            int currentDigitS = sArray[i];
            int targetDigitT = tArray[i];

            if (currentDigitS != targetDigitT) {
                int diff = (targetDigitT - currentDigitS + 10) % 10; 
                sArray[i] = (sArray[i] + diff) % 10;
                sArray[i + 1] = (sArray[i + 1] + diff) % 10;
                totalMoves += diff; 
            }
        }
        if (sArray[n - 1] != tArray[n - 1]) {
            return -1;
        }

        return totalMoves;
    }

Hashedin ✅

public int solution(int[] T) {
        int N = T.length;
        List<Integer>[] tree = new ArrayList[N];
        for (int i = 0; i < N; i++) {
            tree[i] = new ArrayList<>();
        }
        for (int i = 1; i < N; i++) {
            tree[i].add(T[i]);
            tree[T[i]].add(i);
        }
       
        return dfs(0, -1, tree, false);
    }
   
    private int dfs(int current, int parent, List<Integer>[] tree, boolean usedTicket) {
        int maxCities = 1;
       
        for (int neighbor : tree[current]) {
            if (neighbor != parent) {
                if (neighbor % 2 == 1) {
                    if (!usedTicket) {
                        maxCities = Math.max(maxCities, 1 + dfs(neighbor, current, tree, true));
                    }
                } else {
                    maxCities = Math.max(maxCities, 1 + dfs(neighbor, current, tree, usedTicket));
                }
            }
        }
       
        return maxCities;
    }

Hashedin ✅

public int solution(int[] A) {
        int N = A.length;
        Arrays.sort(A);
        int minMoves = N;
       
        for (int i = 0; i <= N - 1; i++) {
            int end = A[i] + N - 1;
            int r= binarySearch(A, end);
            int balls= r- i + 1;
            int moves = N - balls;
            minMoves = Math.min(minMoves, moves);
        }
       
        return minMoves;
    }
   
    private int binarySearch(int[] A, int target) {
        int low = 0;
        int high = A.length - 1;
       
        while (low <= high) {
            int mid = low + (high - low) / 2;
           
            if (A[mid] <= target) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
       
        return high;
    }

Hashedin ✅

public int solution(int[] A) {
        int N = A.length;
        Arrays.sort(A);
        int minMoves = N;
       
        for (int i = 0; i <= N - 1; i++) {
            int end = A[i] + N - 1;
            int r= binarySearch(A, end);
            int balls= r- i + 1;
            int moves = N - balls;
            minMoves = Math.min(minMoves, moves);
        }
       
        return minMoves;
    }
   
    private int binarySearch(int[] A, int target) {
        int low = 0;
        int high = A.length - 1;
       
        while (low <= high) {
            int mid = low + (high - low) / 2;
           
            if (A[mid] <= target) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
       
        return high;
    }