Sam and friends ✅
Thoughtwork

def count_partitions(N):
    MOD = 10**9 + 7
    def sieve(n):
        primes = [True] * (n + 1)
        primes[0], primes[1] = False, False
        p = 2
        while p * p <= n:
            if primes[p]:
                for i in range(p * p, n + 1, p):
                    primes[i] = False
            p += 1
        return [i for i in range(n + 1) if primes[i]]
    primes = sieve(N)
    dp = [0] * (N + 1)
    dp[0] = 1
    for prime in primes:
        for i in range(prime, N + 1):
            dp[i] = (dp[i] + dp[i - prime]) % MOD
    return dp[N]

Number of prime ✅

Count partition ✅

import java.util.*;

public class DarkLane {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
       
        int K = sc.nextInt();
        int N = sc.nextInt();
       
        int[] barriers = new int[N];
        for (int i = 0; i < N; i++) {
            barriers[i] = sc.nextInt();
        }
       
        TreeSet<Integer> ts= new TreeSet<>();

        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
        pq.add(K);
        List<Integer> results = new ArrayList<>();
       
        for (int i = 0; i < N; i++) {
            int barrier = barriers[i];
           
            ts.add(barrier);
           
            Integer left = ts.lower(barrier);
            Integer right = ts.higher(barrier);
           
            if (left == null) left = 0;
            if (right == null) right = K;
           
            pq.remove(right - left);
           
            pq.add(barrier - left);
            pq.add(right - barrier);
           
            results.add(pq.peek());
        }
       
        for (int result : results) {
            System.out.println(result);
        }
       
        sc.close();
    }
}

Dark lane ✅

    bool containsNearbyAlmostDuplicate(vector<int>& nums, int indexDiff, int valueDiff) {
        int s = 0, e = 0, n = nums.size(), res = 1e9 + 1;
        map<int, int> mp;
        while(e < n) {
            if(e - s > indexDiff) {
                mp[nums[s]]--;
                if(mp[nums[s]] == 0) mp.erase(nums[s]);
                s++;
            }

            auto it = mp.upper_bound(nums[e]);
            if(it != mp.end()) 
                res = min(res, abs(nums[e] - it->first));
            if(it != mp.begin()) 
                res = min(res, abs(nums[e] - prev(it)->first));
            
            mp[nums[e]]++;
            e++;
        }
        return res <= valueDiff;
    }

Well Growing crops ✅

Dark lane ✅

Crop growing well ✅

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 ✅