Tag: loop

Categories
Array Leetcode Loop

Prison After N Days

let  prisonAfterNDays = function(cells, N) {

    let cache = {},
        counter = 1,
        cycle = false,
        len = 8;
    let dup = [...cells];

    function getNextCycle(data) {
        let lastCycle = data[1];
        let cycleDays = counter - lastCycle;
        console.log(lastCycle, cycleDays);
        let nextCycle = N - ((N - lastCycle) % cycleDays); //?.
        // let nextCycle = counter; //?
        // while (nextCycle + counter < N) {
        //     nextCycle = nextCycle += cycleDays;
        // }

        return nextCycle; //?
    }

    while(counter <= N) {
        let key = dup.join(''),
            data = cache[key],
            row = [];

        if (data && !cycle) {
            cycle = true;
            counter = getNextCycle(data);
        }

        if (data) {
            dup = data[0];
            counter++; //?
        }
        else {
            for (let i = 0; i < len; i++) {
                row[i] = dup[i - 1] === dup[i + 1] ? 1 : 0;
            }
            cache[key] = [[...row], counter];
            dup = cache[key][0];
            counter++; //?
        }
    }

    return dup;
};
Categories
Array Leetcode Loop Sort

Most Visited Website Pattern

let mostVisitedPattern = function(username, timestamp, website) {
    let map = new Map();
    for (let i = 0; i < username.length; i++) {
        if (map.has(username[i])) {
            map.get(username[i]).push([website[i], timestamp[i]]);
        }
        else {
            map.set(username[i], [[website[i], timestamp[i]]]);
        }
    }

    // get all possibilites
    let visitedPattern = {};
    let possibilityMap = new Map();
    for(let [user, visits] of map.entries()) {
        visitedPattern[user] = {};
        const value = visits.sort((a, b) => a[1] - b[1]).map(([a]) => a);

        if ( value.length < 3) continue;
        for (let i = 0; i < value.length - 2; i++) {
            for (let j = i + 1; j < value.length - 1; j++) {
                for (let k = j + 1; k < value.length; k++) {
                    let key = `${value[i]},${value[j]},${value[k]}`;
                    if(possibilityMap.has(key)) {
                        if(!visitedPattern[user][key]) {
                            possibilityMap.set(key, possibilityMap.get(key) + 1);
                            visitedPattern[user][key] = 1;
                        }
                    }
                    else {
                        possibilityMap.set(key, 1);
                        visitedPattern[user][key] = 1;
                    }
                }
            }
        }
    }

    const result = [...possibilityMap];
    return result.sort((a, b) => {
        if(a[1] < b[1]) {
            return 1;
        }
        else if (a[1] > b[1]) {
            return -1;
        }
        return a[0].localeCompare(b[0]);
    }).map(arr => arr[0]).shift().split(','); //?


    // result.pop(); //?
        // .map(arr => arr[0]).pop().split('|'); //?
};
Categories
Leetcode

Fibonacci (Iterative)

function fib(n) {
    if(n === 0) return 0;
    if(n <= 2) return 1;

    let x = 1, y = 2;
    for(let i = 3; i < n; i++) {
        let oldX = x;
        x = y;
        y = y + oldX;  /*?.*/
    }

    return y; 
}