Pixxel Hiring Product Management Intern

https://pixxel.bamboohr.com/careers/196

Ericsson Hiring Software Developer

Qualification required B.E/ B.Tech/M.tech- 2023 or 2024 passed out with good communication
•    6 months- 1 year of experience into Java : Core java, Spring, Springboot, Hibernate, Rest Web Services, Java Script, JQuery, Maven
•    Knowledge of Application Server, Deployment, troubleshooting

https://jobs.ericsson.com/careers/job/563121760839673?jobPipeline=LinkedIn&domain=ericsson.com

Datacore hiring for Software Intern

2025 passouts

Apply Here : https://www.datacore.com/fr/careers/job/638029/

SmartBear is hiring DevOps Engineer

2024/2025 batch passouts

Apply Here : https://boards.greenhouse.io/smartbear/jobs/6095173003

JAR Hiring Backend Intern

https://in.linkedin.com/jobs/view/backend-intern-at-jar-4016652521

Batch 2023,2024

Testsigma Hiring Junior Product Support Engineer

https://testsigma.keka.com/careers/jobdetails/7256?source=linkedin

Sophos hiring Software Engineer (New Graduates - 2024)

https://jobs.lever.co/sophos/23331ceb-44a6-4de0-acc7-890bb86dc01e

Company: Zepto
Role: Fresher hiring (on campus drive)
Location: Pan India
Eligible Batch: 2025 Graduates
Apply: Ask your TnP cell to mail the HR team at haleema.sabeen@zeptonow.com

Company: Tredence Inc.
Role: Data Engineering Intern
Location: Bangalore
Eligibility: 2023/ 2024 Graduates from IITs/NITs
Apply: Email campusrelation@tredence.com with the subject "Application for Data Engineering Internship"

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int solution(vector<int> &A, vector<int> &B) {
    int N = A.size();
    vector<vector<int>> dp(2, vector<int>(N, 0));
    dp[0][0] = A[0];
    dp[1][0] = max(A[0], B[0]);
   
    for (int j = 1; j < N; ++j) {
        dp[0][j] = max(dp[0][j - 1], A[j]);
        dp[1][j] = min(max(dp[0][j], B[j]), max(dp[1][j - 1], B[j]));
    }
   
    return dp[1][N - 1];
}

MS TASK 2✅

// word Visa OA✅
struct TrieNode {
    unordered_map<char, TrieNode*> children;
    bool isEndOfWord = false;
};

class Trie {
public:
    TrieNode* root;
   
    Trie() {
        root = new TrieNode();
    }

    void insert(const string& word) {
        TrieNode* node = root;
        for (char ch : word) {
            if (node->children.find(ch) == node->children.end()) {
                node->children[ch] = new TrieNode();
            }
            node = node->children[ch];
        }
        node->isEndOfWord = true;
    }
   

    bool checkPrefix(const string& word) {
        TrieNode* node = root;
        for (char ch : word) {
            if (node->isEndOfWord) {
                return true;
            }
            if (node->children.find(ch) == node->children.end()) {
                return false;
            }
            node = node->children[ch];
        }
        return node->isEndOfWord;
    }
};

using ll=long long;

lli solution(vector<string>& words) {
    Trie trie;
    lli res = 0;

    vector<string> a = words;
    for (string& word : a) {
        reverse(word.begin(), word.end());
    }

    sort(a.begin(), a.end(), [](const string& a, const string& b) {
        return a.size() < b.size();
    });

    for (string& word : a) {
        if (trie.checkPrefix(word)) {
            res++;
        }
        trie.insert(word);
    }

    return res;
}

// Audio books Visa ✅

int solution(vector<int> audiobooks, vector<string> logs)
{
    vector<int> listened(audiobooks.size(), 0);    
    vector<bool> dropped(audiobooks.size(), false);
    int current = 0;             

    for (string log : logs)
    {
        stringstream ss(log);
        string command;
        ss >> command;

        if (command == "LISTEN")
        {
            int minutes;
            ss >> minutes;
            while (listened[current] >= audiobooks[current] || dropped[current])
            {
                current = (current + 1) % audiobooks.size();
            }
            listened[current] += minutes;
            if (listened[current] > audiobooks[current])
            {
                listened[current] = audiobooks[current];
            }

            current = (current + 1) % audiobooks.size();
        }
        else if (command == "DROP")
        {
            int index;
            ss >> index;
            dropped[index] = true;
        }
    }

    int mx = -1;
    int res = -1;
    for (int i = 0; i < audiobooks.size(); i++)
    {
        if (listened[i] > mx)
        {
            mx = listened[i];
            res = i;
        }
        else if (listened[i] == mx && i > res)
        {
            res = i;
        }
    }

    return res;
}