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

int solve(int arr[], int n){

  int pos[n], p = 0;

  for(int i=0;i<n;i++){
    if(arr[i] == 1){
      pos[p] = i + 1;
      p++;
    }
  }

  if(p == 0) return 0;

  int res = 1;
  for(int i=0;i<p-1;i++){
    res *= pos[i+1]-pos[i];
  }
  return res;
}

One block ✅

def Resource(A, B, C):
    same_type_systems = (A // 3) + (B // 3) + (C // 3)
    remaining_A = A % 3
    remaining_B = B % 3
    remaining_C = C % 3
    different_type_systems = min(A, B, C)
    remaining_A -= different_type_systems
    remaining_B -= different_type_systems
    remaining_C -= different_type_systems
    remaining_A = max(0, remaining_A)
    remaining_B = max(0, remaining_B)
    remaining_C = max(0, remaining_C)
    total_systems = same_type_systems + different_type_systems
    leftover_resources = remaining_A + remaining_B + remaining_C
    total_systems += leftover_resources // 3
   
    return total_systems

Resource power ✅

int Max (int N, int K, vector<int> arr) {
   vector<int> b(N + 1, 0);
    vector<int> c;
    int cnt = 0;
    for (int i = 1; i <= N; ++i) {
        if (arr[i - 1] % 2 == 1) {
            b[i] = 1;
        } else {
            b[i] = -1;
        }
    }
    for (int i = 1; i <= N; ++i) {
        b[i] += b[i - 1];
    }
    for (int i = 1; i < N; ++i) {
        if (b[i] == 0) {
            c.push_back(abs(arr[i] - arr[i - 1]));
        }
    }
    sort(c.begin(), c.end());
    int pt = 0, cost = 0;

    while (pt < c.size() && cost + c[pt] <= K) {
        cost += c[pt];
        ++pt;
    }

    return pt;
}

Max separation ✅

Max prefix ✅

Minimizing the best answer ✅

def modular_exponentiation(base, exponent, mod):
    result = 1
    base = base % mod
    while exponent > 0:
        if exponent & 1:
            result = (result * base) % mod
        exponent = exponent >> 1
        base = (base * base) % mod
    return result

def solve(n):                                                                                                                
    MOD = 10**9 + 7
    base = 3
    result = modular_exponentiation(base, n, MOD)
    return result

Attendance code ✅

int solve(int n, vector<vector<int>>& rels) {
    vector<vector<int>> g(n);
    vector<int> inD(n, 0);
    for (auto& r : rels) {
        g[r[0] - 1].push_back(r[1] - 1);
        inD[r[1] - 1]++;
    }

    int k = 2;
    int rnds = 0;
    queue<int> q;
    for (int i = 0; i < n; i++) {
        if (inD[i] == 0) {
            q.push(i);
        }
    }

    while (!q.empty()) {
        int sz = q.size();
        rnds += (sz + k - 1) / k;
        for (int i = 0; i < sz; i++) {
            int m = q.front();
            q.pop();
            for (int nxt : g[m]) {
                if (--inD[nxt] == 0) {
                    q.push(nxt);
                }
            }
        }
    }

    return rnds;
}

Family Dinner ✅

Company Name: Propel

🛄 Job Title: Software Developer

✍🏻 YOE: 2023 and 2024 grads


➡️ Apply: https://talent.propelinc.com/jobs/Careers/26698000072645557/Fresher-Software-Developer?source=CareerSite

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

Someone looking for Non-Tech Intern

https://www.linkedin.com/posts/alice-kujur-419459171_hiring-internship-businessdevelopment-activity-7199679996888555520-wx6l?utm_source=share&utm_medium=member_android

Deloitte is hiring!
Position: Data Anlaytics - Internship
Qualification: Bachelor’s/ Master’s/ MBA
Salary: 5.5 LPA (Expected)
Batch: 2022/ 2023/ 2024/ 2025
Experience: Freshers
Location: Delhi, Mumbai, India

📌Apply Now:
https://jobsindia.deloitte.com/job/Delhi-RA-A&IC-IA-Intern/24602144/

https://jobsindia.deloitte.com/job/Mumbai-RA-A&IC-Internal-Audit-intern-1/25345844/

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

bool solve(vector<vector<char>>& grid, int maxTime) {
    int n = grid.size(), m = grid[0].size();
    vector<vector<int>> dist(n, vector<int>(m, INT_MAX));
    queue<pair<int, int>> q;
    q.push({0, 0});
    dist[0][0] = 0;
    vector<int> dx = {-1, 0, 1, 0};
    vector<int> dy = {0, 1, 0, -1};
    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();
        for (int i = 0; i < 4; ++i) {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && grid[nx][ny] == '.' && dist[nx][ny] > dist[x][y] + 1) {
                dist[nx][ny] = dist[x][y] + 1;
                q.push({nx, ny});
            }
        }
    }
    return dist[n - 1][m - 1] <= maxTime;
}

int main() {
    int n, m, maxTime;
    cin >> n >> m >> maxTime;
    vector<vector<char>> grid(n, vector<char>(m));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> grid[i][j];
        }
    }
    cout << (solve(grid, maxTime) ? "Yes" : "No") << endl;
    return 0;
}

Reach the end in time ✅

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

int solve(int n, vector<int>& c, vector<int>& price) {
    map<int, vector<int>> mp;
    for (int i = 0; i < n; i++) {
        mp[c[i]].push_back(price[i]);
    }
   
    for (auto& x : mp) {
        sort(x.second.rbegin(), x.second.rend());
    }

    int sz = mp.size();
    long long ans = 0;
    vector<int> v;

    for (auto& x : mp) {
        v.push_back(x.second.back());
        x.second.pop_back();
    }
   
    sort(v.begin(), v.end());

    for (int i = 0; i < sz; i++) {
        ans += (i + 1) * 1LL * v[i];
    }

    for (auto& x : mp) {
        for (int num : x.second) {
            ans += sz * num;
        }
    }

    return ans;
}

Maximum Profit ✅

public static long findMissingInteger(ArrayList<Integer> arr, long k) {
        Collections.sort(arr);
        ArrayList<Integer> tmp = new ArrayList<>();
        tmp.add(arr.get(0));
        for (int i = 1; i < arr.size(); i++) {
            if (arr.get(i) != tmp.get(tmp.size() - 1)) {
                tmp.add(arr.get(i));
            }
        }
        int l = 0, r = tmp.size(), m;
        while (l < r) {
            m = (l + r) / 2;
            if (tmp.get(m) - 1 - m < k) {
                l = m + 1;
            } else {
                r = m;
            }
        }

        return l + k;
    }

Missing Positive Integers ✅

def solution(matrix):
    n = len(matrix)
    v = [[0, matrix[i][0]] for i in range(n)]

    for i in range(n):
        v[i][1] = matrix[i][0]
        row, col = i, 0
        while row >= 0 and col < n:
            v[i][0] += matrix[row][col]
            row -= 1
            col += 1
       
        row = i + 1
        col = n - 1
        while row < n and col >= 0:
            v[i][0] += matrix[row][col]
            row += 1
            col -= 1

    v.sort()

    return [v[i][1] for i in range(n)]