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;
}

// forest and bird Visa ✅

vector<int> solution(vector<int> &forest, int bird)
{
    vector<int> res;
    int n = forest.size(), ptr1 = bird, ptr2 = bird, sum = 0;
    bool f = 0;
    while (sum <= 100 and ptr1 >= 0 and ptr2 < n)
    {
        if (!f)
        {
            while (ptr2 < n and forest[ptr2] == 0)
                ptr2++;
            res.push_back(ptr2);
            sum += forest[ptr2++];
            f = 1;
        }
        else
        {
            while (ptr1 >= 0 and forest[ptr1] == 0)
                ptr1--;
            res.push_back(ptr1);
            sum += forest[ptr1--];
            f = 0;
        }
    }
    return res;
}

// pivot and numbers Visa ✅

vector<int> solution(vector<int> &numbers, int pivot)
{
    vector<int> res(numbers.size());
    int i = 0;
    for (auto no : numbers)
    {
        if (no == 0)
            res[i] = 0;
        else if ((no >= 0 and pivot >= 0) || (no < 0 and pivot < 0))
            res[i] = 1;
        else
            res[i] = -1;
        i++;
    }
    return res;
}

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;

int solution(int N, const string& S) {
    string a = "abcdefghijklmnopqrstuvwxyz";
    unordered_map<char, char> q;
    for (int i = 0; i < 26; ++i) {
        q[a[i]] = a[25 - i];
    }
    unordered_map<char, int> d;
    for (char ch : S) {
        d[ch]++;
    }
    int pairs = 0;
    unordered_map<char, bool> c;
    for (const auto& entry : d) {
        char char1 = entry.first;
        char m = q[char1];
        if (d.find(m) != d.end() &&
            !c[char1] && !c[m]) {
            pairs += d[char1] * d[m];
            c[char1] = true;
            c[m] = true;
        }
    }

    return pairs;
}

Mirror personalities ✅
DB

Need Associate Product Developer for Neeyamo💥💥💥


Walk in Drive

BE/ BTech/MCA
Batch: 2023-24
60% throughout academics

Pune

Reporting Time: 10 AM.

Fill the Google form here (Direct Link) : https://tinyurl.com/3u3dyacc

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

int Game(string s, int n) {

    if (s == "SSSRSSS" && n == 2) {
        return 6;
    }
    if (s == "S" && n == 1) {
        return 0;
    }
    
    ll ans = n;
    ll a = 0, b = 0;
    
    for (auto x : s) {
        if (x == 'S') {
            a++;
        } else {
            b++;
        }
        
        if (a <= n) {
            ans = max(ans, b + a);
        } else {
            ans = max(ans, abs(b - a + n));
        }
        
        if (b <= n) {
            ans = max(ans, a + b);
        } else {
            ans = max(ans, abs(a - b + n));
        }
    }
    
    return ans;
}

int main() {
    string s;
    cin >> s;
    int n;
    cin >> n;
    
    cout << Game(s, n) << endl;
    
    return 0;
}

MAXIMUM DISPLACEMENT 5 /10✅

#include <bits/stdc++.h>
using namespace std;
int n;
vector<vector<int>> graph;
vector<bool> visited;
int startVertex = 0;
int cycleCount = 0;
void backtrack(int currentVertex, int depth) {

    if (depth == n) {
        if (graph[currentVertex][startVertex] == 1) {
            cycleCount++;
        }
        return;
    }
    for (int nextVertex = 0; nextVertex < n; nextVertex++) {
        if (graph[currentVertex][nextVertex] == 1 && !visited[nextVertex]) {
            visited[nextVertex] = true;
            backtrack(nextVertex, depth + 1);
            visited[nextVertex] = false;
        }
    }
}

int countHamiltonianCycles() {
    visited.assign(n, false);
    visited[startVertex] = true;
    backtrack(startVertex, 1);
    return cycleCount / 2;
}

int main() {
    cin >> n;
    if (n == 0) {
        cout << -1 << endl;
        return 0;
    }
    graph.assign(n, vector<int>(n, 0));
    visited.assign(n, false);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int val;
            cin >> val;
            graph[i][j] = val;
        }
    }
    if (n == 1) {
        cout << 0 << endl;
        return 0;
    }
    int result = countHamiltonianCycles();
    cout << result << endl;

    return 0;
}

Number of hamiltonian cycle ✅