Latest Updates

LeetCode/problems/118-pascals-triangle/118-pascals-triangle.js

/**
 * @param {number} numRows
 * @return {number[][]}
 */
var generate = function(numRows) {
    let dp = Array.from( {length:numRows}, ()=>[] );
    dp[0] = [1];

    for(let I = 1; I<numRows; I++){
        dp[I][0] = 1;
        dp[I][I] = 1;
        for(let A = 1; A<I; A++){
            dp[I][A] = dp[I-1][A-1] + dp[I-1][A];
        }
    }

    return dp;
};

LeetCode/problems/2106-maximum-fruits-harvested-after-at-most-k-steps/2106-maximum-fruits-harvested-after-at-most-k-steps.js

/**
 * @param {number[][]} fruits
 * @param {number} startPos
 * @param {number} k
 * @return {number}
 */
var maxTotalFruits = function(fruits, startPos, k) {
    let prefixMap = new Map();
    let keyArr = [];
    let sum = 0;
    let I = 0;

    for(let fruit of fruits){
        sum += fruit[1];
        prefixMap.set(fruit[0],sum);
        keyArr[I] = fruit[0];
        I++;
    }

    let ans = 0;
    for(let L = Math.max(0,startPos-k); L<=startPos; L++){
        let dis = Math.abs(startPos-L);

        let upper1 = startPos + (k - dis*2);
        let upper2 = startPos + Math.floor((k - dis)/2);

        let R = Math.max(upper1,upper2);

        let ll = _.sortedIndex(keyArr, L);

        let rr =  Math.min(
            _.sortedIndex(keyArr, R+1)-1,
            keyArr.length-1
        );

        let leftSum = prefixMap.get(keyArr[ll-1])|0;
        let rightSum = prefixMap.get(keyArr[rr])|0;

        ans = Math.max(ans,rightSum-leftSum);
    }
    return ans;
};

LeetCode/problems/2561-rearranging-fruits/2561-rearranging-fruits.js

/**
 * @param {number[]} basket1
 * @param {number[]} basket2
 * @return {number}
 */
var minCost = function(basket1, basket2) {
    let freq = new Map();
    let min = Infinity;

    for(const b of basket1){
        freq.set(b, (freq.get(b) || 0) + 1);
        min = Math.min(min,b);
    }

    for(const b of basket2){
        freq.set(b, (freq.get(b) || 0) - 1);
        min = Math.min(min,b);
    }

    let merge = [];
    for(const [key,val] of freq.entries()){
        if(val % 2 !== 0){return -1;}
        for(let I = 0; I<Math.abs(val)/2; I++){
            merge.push(key);
        }
    }

    merge.sort((a,b)=>a-b);

    let res = 0;
    for(let I = 0; I<merge.length/2; I++){
        res += Math.min(2*min, merge[I]);
    }

    return res;
};

LeetCode/problems/898-bitwise-ors-of-subarrays/898-bitwise-ors-of-subarrays.js

/**
 * @param {number[]} arr
 * @return {number}
 */
var subarrayBitwiseORs = function(arr) {
    let ans = new Set();
    let cur = new Set();
    cur.add(0);
    for(let num of arr){
        let temp = new Set();
        for(let el of cur){
            temp.add(el|num);
        }
        temp.add(num);
        for(let el of temp){
            ans.add(el);
        }
        cur = temp;
    }
    return ans.size;
};

LeetCode/problems/904-fruit-into-baskets/904-fruit-into-baskets.js

/**
 * @param {number[]} fruits
 * @return {number}
 */
var totalFruit = function(fruits) {
    let myMap = new Map();
    let L = 0;
    let R = 0;
    let ans = 0;
    while(R<fruits.length){
        myMap.set(fruits[R], (myMap.get(fruits[R])|0) + 1);
        while(L<R && myMap.size > 2){
            myMap.set(fruits[L], myMap.get(fruits[L])-1 );
            if(myMap.get(fruits[L]) == 0){
                myMap.delete(fruits[L] );
            }
            L++;
        }
        ans = Math.max(ans, R-L+1);
        R++;
    }

    return ans;
};