Company Name : Rubrik

Role : SDE Internship - Winter

Stipend : 1.5 Lakh/month

Link to apply : https://www.proelevate.in/job/software-engineering-winter-intern

Anyone got this mail

Only 2024 Batch

https://docs.google.com/forms/d/e/1FAIpQLScina5CPWyUWETfo7sMtR7gtKEwlEvF6j1sNOkMp-qSe_SDzQ/viewform

Apply, if you're interested!!

package Graph;

import java.util.*;

public class Largest_Sum_Cycle
{

public static int solution(int arr[])
{
  ArrayList<Integer>sum=new ArrayList<>();
 
  for(int i=0;i<arr.length;i++)
  {
  
   ArrayList<Integer>path=new ArrayList<>();
  
   int j=i;
  
   int t=0;
  
  while(arr[j]<arr.length&&arr[j]!=i&&arr[j]!=-1&&!path.contains(j))
  {
   path.add(j);
   t+=j;
   j=arr[j];
   if(arr[j]==i)
   {
    t+=j;
    break;
   }
  }
  if(j<arr.length&&i==arr[j])
   sum.add(t);
  }
  if(sum.isEmpty())
   return -1;
 
  return Collections.max(sum);
 
}

public static void main(String[] args)
{
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int testcases=sc.nextInt();
for(int loop=0;loop<testcases;loop++)
{
int numofBlocks=sc.nextInt();
int arr[]=new int[numofBlocks];
int src,dest;
for(int i=0;i<numofBlocks;i++)
{
arr[i]=sc.nextInt();
}
System.out.println(solution(arr));
}
}
}

Juspay ✅

import java.util.Scanner;
import java.util.*;

public class metting
{

    public static void helperFunction()
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] edges = new int[n];
       
        for (int i = 0; i < n; i++)
        {
            edges[i] = sc.nextInt();
        }
       
        int C1 = sc.nextInt();
        int C2 = sc.nextInt();
        // int ans=minimumWeight(n,edges,C1,C2);
        // System.out.println(ans);


  //  public static int minimumWeight(int n, int[] edges, int C1, int C2) {
        List<List<Integer>> list = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            list.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < n; i++) {
            if (edges[i] != -1) {
                list.get(i).add(edges[i]);
            }
        }

        long[] array1 = new long[n];
        long[] array2 = new long[n];
        Arrays.fill(array1, Long.MAX_VALUE);
        Arrays.fill(array2, Long.MAX_VALUE);

        juspay(C1, list, array1);
        juspay(C2, list, array2);

        int node = 0;
        long dist = Long.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            if (array1[i] == Long.MAX_VALUE || array2[i] == Long.MAX_VALUE)
                continue;

            if (dist > array1[i] + array2[i]) {
                dist = array1[i] + array2[i];
                node = i;
            }
        }
        if (dist == Long.MAX_VALUE)
        System.out.print(-1);
            //return -1;
       // return node;
         System.out.print(node);
    }
    private static void juspay(int start, List<List<Integer>> graph, long[] distances)
    {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        pq.offer(start);
        distances[start] = 0;
        while (!pq.isEmpty())
        {
            int curr = pq.poll();
            for (int neighbor : graph.get(curr))
            {
                long distance = distances[curr] + 1;
                if (distance < distances[neighbor])
                {
                    distances[neighbor] = distance;
                    pq.offer(neighbor);
                }
            }
        }
    }
    public static void main(String[] args) {
     metting m = new metting();
        metting.helperFunction();
    }
}

Nearest meeting Cell
Juspay ✅

QA Intern at HappyFox

Internship Details:

Full-time Paid Internship
Internship duration: 6 months
Mode of work: Work from office (Guindy, Chennai)
Full time opportunity will be available to interns with good performance

APPLY - https://happyfox.hire.trakstar.com/jobs/fk0xy99

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

class TreeNode {
public:
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) {
        data = val;
        left = nullptr;
        right = nullptr;
    }
};

class Solution {
public:
    bool checkPath(TreeNode* root, int dest) {
        if (!root) {
            return false;
        }

        queue<TreeNode*> q;
        q.push(root);

        while (!q.empty()) {
            TreeNode* current = q.front();
            q.pop();

            if (!current->left && !current->right && current->data == dest) {
                return true;
            }

            if (current->left) {
                current->left->data += current->data;
                q.push(current->left);
            }
            if (current->right) {
                current->right->data += current->data;
                q.push(current->right);
            }
        }

        return false;
    }

    TreeNode* takeLevelOrder() {
        int rootData;
        cin >> rootData;

        if (rootData == -1) {
            return nullptr;
        }

        TreeNode* root = new TreeNode(rootData);
        queue<TreeNode*> q;
        q.push(root);

        while (!q.empty()) {
            TreeNode* current = q.front();
            q.pop();

            int leftChild, rightChild;
            cin >> leftChild >> rightChild;

            if (leftChild != -1) {
                current->left = new TreeNode(leftChild);
                q.push(current->left);
            }

            if (rightChild != -1) {
                current->right = new TreeNode(rightChild);
                q.push(current->right);
            }
        }

        return root;
    }
};

int main() {
    Solution solution;

    int dest;
    cin >> dest;
    TreeNode* root = solution.takeLevelOrder();

    bool result = solution.checkPath(root, dest);

    cout << (result ? "True" : "False") << endl;

    return 0;
}

Zeta ✅

Hotstar is hiring Product Design Intern
🙂 Experience: Fresher
📌 Location: Bangalore
📤 Share with your friends & colleagues
👉 Apply: https://jobs.lever.co/hotstar/1d648f52-4e43-4102-8856-87ca5562a6f2

Goldman Sachs is hiring Summer Analyst
🙂 Experience: Fresher
📤 Share with your friends & colleagues
👉 Apply: https://goldmansachs.tal.net/vx/lang-en-GB/mobile-0/brand-2/candidate/so/pm/1/pl/1/opp/2-Summer-Analyst-Summer-Associate-Internship-programs/en-GB

long long solve(int n, int** A) {
    vector<pair<int, int>> vp;
    vp.push_back({-1, 0});

    for (int i = 0; i < n; i += 1) {
        vp.push_back({A[i][1], A[i][2]});
    }

    sort(vp.begin(), vp.end());

    auto check = [&] (int mid) {
        long long dishes = 0;

        for (int i = 1; i <= n; i += 1) {
            dishes += static_cast<long long>(vp[i].first - vp[i - 1].first) * mid;
            if (vp[i].second > dishes)
                return false;
            else
                dishes -= vp[i].second;
        }

        return true;
    };

    int l = 0, r = 1e9;

    while (r - l > 1) {
        int mid = (l + r) / 2;
        if (!check(mid))
            l = mid;
        else
            r = mid;
    }

    return r;
}

Chef and ordering ✅

def Solve(N, K):
    slots = [0] * K
    current_bag = 1
    current_slot = 0

    while N > 0:
        bags_to_distribute = min(N, current_bag)
        slots[current_slot] += bags_to_distribute
        N -= bags_to_distribute
        current_bag += 1
        current_slot = (current_slot + 1) % K

    return slots

N = int(input())
K = int(input())

result = Solve(N, K)
print(" ".join(map(str, result)))

Airport Baggage ✅

Intern - Data Research (Looking for 2023 graduates/ BCA/MCA/Bsc-Csc/ BE/ Btech) at Forbes Advisor

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

Company Name: Groww

Role: SDE 1 - Frontend (Kotlin)

Eligibility: if you have some experience or some projects you can apply.

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

Wipro Direct Interview for Analyst Role.

Must Attend this Drive Everyone either you are technical or Non-technical background.

bool check(string s, string t, vector<int>& order, int mid) {
    int n = s.size(), m = t.size();
    vector<int> pos(n);
    for (int i = 0; i < mid; ++i) {
        pos[order[i] - 1] = -1;
    }
    for (int i = mid; i < n; ++i) {
        pos[order[i] - 1] = i;
    }
    int j = 0;
    for (int i = 0; i < n && j < m; ++i) {
        if (pos[i] != -1 && s[i] == t[j]) {
            ++j;
        }
    }
    return j == m;
}

int solve(string s, string t, vector<int>& order) {
    int low = 0, high = s.size();
    while (low < high) {
        int mid = low + (high - low + 1) / 2;
        if (check(s, t, order, mid)) {
            low = mid;
        } else {
            high = mid - 1;
        }
    }
    return low;
}

String Search ✅