def count_valid_strings(N):
    MOD = 10**9 + 7
    
    T, A, N, R, U, S = range(6)
    
    dp = [[0] * 6 for _ in range(N + 1)]
    
    dp[1][T] = 1
    dp[1][N] = 1
    dp[1][S] = 1
    
    for i in range(1, N):
        dp[i + 1][A] = (dp[i][T]) % MOD
        dp[i + 1][N] = (dp[i][A]) % MOD
        dp[i + 1][R] = (dp[i][A] + dp[i][N]) % MOD
        dp[i + 1][U] = (dp[i][R]) % MOD
        dp[i + 1][S] = (dp[i][U]) % MOD
        dp[i + 1][T] = (dp[i][S]) % MOD
        dp[i + 1][A] = (dp[i + 1][A] + dp[i][S]) % MOD
        dp[i + 1][N] = (dp[i + 1][N] + dp[i][S]) % MOD
        dp[i + 1][R] = (dp[i + 1][R] + dp[i][S]) % MOD
        dp[i + 1][U] = (dp[i + 1][U] + dp[i][S]) % MOD
    
    result = sum(dp[N][c] for c in [T, A, N, R, U, S]) % MOD
    return result

Thoughtwork ✅

import math
def sieve(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if is_prime[i]:
            for j in range(i * i, n + 1, i):
                is_prime[j] = False
    return [i for i in range(2, n + 1) if is_prime[i]]

def count_nearly_primes(L, R):
    limit = int(math.sqrt(R))
    primes = sieve(limit)
   
    nearly_primes_count = 0
    for prime in primes:
        nearly_prime = prime * prime
        if L < nearly_prime < R:
            nearly_primes_count += 1
   
    return nearly_primes_count

Count of Nearly P ✅
Thoughtwork

def find(N, K, X):
    MOD = 1000000007

    dp = [[0] * (K + 1) for _ in range(N + 1)]
    dp[1][1] = 1

    for i in range(2, N + 1):
        for j in range(1, K + 1):
            dp[i][j] = sum(dp[i-1][p] for p in range(1, K + 1) if p != j) % MOD
    
    return dp[N][X]

Number of Arrays ✅
Thoughtwork

def find(N, K, X):
    MOD = 1000000007
    if N == 1:
        return 1 if X == 1 else 0
    dp_same = [0] * (N + 1)
    dp_diff = [0] * (N + 1)
    dp_same[2] = 0
    dp_diff[2] = 1 if X != 1 else 0 
    for i in range(3, N + 1):
        dp_same[i] = dp_diff[i - 1] % MOD
        dp_diff[i] = ((dp_same[i - 1] * (K - 1)) + (dp_diff[i - 1] * (K - 2))) % MOD
    return dp_diff[N] if X != 1 else dp_same[N]

Number of Arrays ✅
Thoughtwork

def max_sweets_and_sweetness(n, A, B, m, C):
    import heapq

    C.sort()
    sweets = list(zip(A, B))
    sweets.sort()
    
    max_heap = []
    sweetness = 0
    num_sweets = 0
    sweet_index = 0
    
    for day in C:
        while sweet_index < n and sweets[sweet_index][0] <= day:
            heapq.heappush(max_heap, -sweets[sweet_index][1])
            sweet_index += 1
        
        if max_heap:
            sweetness -= heapq.heappop(max_heap)
            num_sweets += 1
    
    return num_sweets, sweetness

Sum and friends ✅
Thoughtwork

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 ✅