Konsberg Digital is hiring Development Engineer

For 2024, 2023, 2022 grads

https://in.linkedin.com/jobs/view/development-engineer-at-kongsberg-digital-3935059257?position=9&pageNum=2&refId=CF%2BCxsr8cjEzSNDkndDiCw%3D%3D&trackingId=KL0G%2FsDxv3unHcoZd98y9g%3D%3D&trk=public_jobs_jserp-result_search-card

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll solve(ll n)
{
    string s="";
    ll mod=1e9+7;
    bool f=0;
    for(ll i=0;i<n;i++)
    {
        if(f==0) {s+='0'; f=1;}
        else {s+='1'; f=0;}
    }
    //cout<<s<<endl;
    ll dp[n+1][2];
    for(ll i=0;i<=n;i++) 
     {
        dp[i][0]=0;
        dp[i][1]=0;
     }  

    for(ll i=1;i<=n;i++)
    {
        if(s[i-1]=='1') 
        {
            dp[i][1]=(dp[i][1]+dp[i-1][0]+dp[i-1][1]+1)%mod;
            dp[i][0]=(dp[i][0]+dp[i-1][0])%mod;
        }
        else
        {
            dp[i][0]=(dp[i][0]+dp[i-1][1]+dp[i-1][0]+1)%mod;
            dp[i][1]=(dp[i][1]+dp[i-1][1])%mod;
        }
    }
    return (dp[n][0]+dp[n][1])%mod;
}
signed main() 
{
    ll n; cin>>n;
    cout<<solve(n); 
    return 0;
}

Consistent Data ✅

class Solution {
    public int wateringPlants(int[] plants, int capacity) {
        int ans = 0;
        int vol = capacity;

        for (int i = 0; i < plants.length; i++) {
            int cur = plants[i];
            boolean isEnoughWater = cur <= vol;
            ans += (isEnoughWater ? 0 : 2) * i + 1;
            vol = (isEnoughWater ? vol : capacity) - cur;
        }

        return ans;
    }
}

Watering plants ✅

willy Edge   :).                                                                                        def maxProfit(N, K, cost, sell):
    A = sorted(zip(cost, sell))
    profit = 0
    for a, b in A:
        if b > a and a <= K + profit:
            profit += (b - a)
    return profit

Profits ✅

#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 ✅