Company: edtechcube
Location: N/A
Role: Frontend Developer
For Graduates: 2023, 2024

https://www.linkedin.com/posts/mohit-kumar-mahato-2b7423269_hiring-techjobs-frontenddeveloper-activity-7212328435078111232-5Y3J?utm_source=share&utm_medium=member_desktop

https://www.linkedin.com/posts/arnabdebnath07_were-hiring-product-designers-looking-activity-7212325301295439872-X4sH?utm_source=share&utm_medium=member_android


Apply Link Form :

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

Hiring for SDET - Intern & Full time At Cashfree Payments
Batch: 2023, 2024, 2025, 2026

https://docs.google.com/forms/d/e/1FAIpQLSetl8ZhAgiPQBYz-fChjTZHcm_DyKJcLisqvu7VAA9Ba8sZYQ/viewform

M.tech 2024 passout freshers opening at western digital

Qualifications
M.Tech in Electronics/Embedded Systems/Computer Science (2024 Passouts Only)


Apply at :https://smrtr.io/m5GpC

BlackBerry hiring Interns for multiple roles in Bengaluru.
🎓 Interested students (especially 2023 & 2024 graduates) please apply through this link 👉 https://lnkd.in/g2gk59Wm

- Paid internship
- Duration: 6-9 months
- Roles:
*Cloud backend engineer
*Associate cloud engineer
*Software development engineer in Test (SDET)

int dayofweek(int d, int m, int y)
{
    static int t[] = { 0, 3, 2, 5, 0, 3,

                       5, 1, 4, 6, 2, 4 };

    y -= m < 3;

    return ( y + y / 4 - y / 100 +

             y / 400 + t[m - 1] + d) % 7;
}

Prime Day of week ✅

#include <iostream>
#include <vector>
using namespace std;

struct T {
    int v;
    T* l;
    T* r;

    T(int val) : v(val), l(nullptr), r(nullptr) {}
};

class B {
public:
    T* r;

    B() : r(nullptr) {}

    void i(int val) {
        r = iR(r, val);
    }

    T* iR(T* r, int val) {
        if (r == nullptr) {
            r = new T(val);
            return r;
        }

        if (val < r->v) {
            r->l = iR(r->l, val);
        } else if (val > r->v) {
            r->r = iR(r->r, val);
        }

        return r;
    }
};

class BM {
public:
    T* m(T* n) {
        if (n == nullptr) {
            return n;
        }

        T* l = m(n->l);
        T* ri = m(n->r);

        n->l = ri;
        n->r = l;

        return n;
    }
};

class BT {
public:
    void p(T* n) {
        if (n == nullptr) {
            return;
        }
        cout << n->v << " ";
        p(n->l);
        p(n->r);
    }
};

int main() {
    int n;
    cin >> n;
    vector<int> v(n);
    for (int i = 0; i < n; ++i) {
        cin >> v[i];
    }

    B t;
    for (int val : v) {
        t.i(val);
    }

    BM m;
    T* mr = m.m(t.r);
    BT tr;
    tr.p(mr);

    return 0;
}


// mirror tree c++

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    long sum = 0;

    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        sum += x;
        cout << sum - i << endl;
    }

    return 0;
}

//waiting time me try this

Drivers4Me is hiring for Full Stack Developer (0-2 years)
Salary: 3-5 LPA
Apply here:
https://linkedin.com/jobs/view/3961587414/?alternateChannel=search

Bosch Off Campus  Drive 2024:

Job Role: Freshers Internship

Qualification M.E/M.Tech/Dual Degree

Batch: 2025

https://forms.microsoft.com/pages/responsepage.aspx?id=GR7lCsgHS067bWSO5YQQ9GQERPlJUAdElvph2KHejtZUOFcyUlM3VzE1STVNR0tXR0ZaUlpLRUo3SS4u

Amazon ML Selection Mail ✅

void dfs(int node, int parent, const vector<vector<pair<int, int>>>& graph,
         const vector<int>& minActivity, vector<long long>& activity, vector<bool>& vulnerable) {
    activity[node] = 0; // initial activity is 0
    for (const auto& edge : graph[node]) {
        int next_node = edge.first;
        int weight = edge.second;
       
        if (next_node != parent) {
            dfs(next_node, node, graph, minActivity, activity, vulnerable);
            activity[node] += activity[next_node] + weight;
        }
    }
    if (activity[node] > minActivity[node]) {
        vulnerable[node] = true;
    }
}

int getMinServers(int server_nodes, int server_edges, const vector<int>& server_from,
                  const vector<int>& server_to, const vector<int>& server_weight,
                  int minActivity_count, const vector<int>& minActivity) {
    vector<vector<pair<int, int>>> graph(server_nodes + 1);
    for (int i = 0; i < server_edges; ++i) {
        graph[server_from[i]].emplace_back(server_to[i], server_weight[i]);
        graph[server_to[i]].emplace_back(server_from[i], -server_weight[i]);
    }

    vector<long long> activity(server_nodes + 1, 0);
    vector<bool> vulnerable(server_nodes + 1, false);

    dfs(1, -1, graph, minActivity, activity, vulnerable);
    int vulnerableCount = count(vulnerable.begin(), vulnerable.end(), true);
    return vulnerableCount;
}

Cisco ✅