SoftArts Labs

Codility #6-MaxProductOfThree

SoftArts — Sun, 30 Sep 2018 18:19:20 +0900

function solution(A) {
    let sorted = Array.from(A).sort((a, b) => a - b);

    return Math.max(
        sorted[0] * sorted[1] * sorted[2],
        sorted[0] * sorted[1] * sorted[sorted.length - 1],
        sorted[0] * sorted[sorted.length - 2] * sorted[sorted.length - 1],
        sorted[sorted.length - 3] * sorted[sorted.length - 2] * sorted[sorted.length - 1]
    );
}

Codility #6-Triangle

SoftArts — Sun, 30 Sep 2018 18:05:33 +0900

function solution(A) {
    let sorted = Array.from(A).sort((a, b) => a - b);

    for (let i = 0, n = sorted.length - 2; i < n; i++) {
        if (sorted[i] + sorted[i + 1] > sorted[i + 2]) {
            return 1;
        }
    }

    return 0;
}

Codility #6-Distinct

SoftArts — Sun, 30 Sep 2018 17:49:21 +0900

function solution(A) {
    let set = new Set();

    for (let i = 0, n = A.length; i < n; i++) {
        set.add(A[i]);
    }

    return set.size;
}

배열의 지그재그 출력

SoftArts — Thu, 27 Sep 2018 10:27:46 +0900

function zigzag(N) {
    let result = Array(N).fill().map((v, i) => Array(N).fill().map((v, i) => 0)); // 0으로 초기화된 2차원 배열

    let val;

    for (let i = 0; i < N; i++) {
        for (let j = 0; j < N; j++) {
            /*
                i\j  0   1   2   3   4
                ----------------------
                 0:  1   2   3   4   5
                 1:  10  9   8   7   6
                 2:  11  12  13  14  15
                 3:  20  19  18  17  16
                 4:  21  22  23  24  25
            */
            if (i % 2 == 0) { // 짝수, 정방향
                val = i * N + j + 1;
            } else { // 홀수, 역방향
                val = (i + 1) * N - j;
            }

            result[i][j] = val;
        }
    }
    return result;
}


let arr = zigzag(5);
console.log(arr);

배열의 대각선 출력 #2

SoftArts — Thu, 27 Sep 2018 10:18:12 +0900

function diaognal(N) {
    let result = Array(N).fill().map((v, i) => Array(N).fill().map((v, i) => 0)); // 0으로 초기화된 2차원 배열
    let loops = 2 * N - 1;

    let x, y;
    let val = 1;

    for (let i = 0; i < loops; i++) {
        for (let j = 0; j < N; j++) {
            /*
                    0   1   2   3   4
                ----------------------
                0: 0,0
                1: 0,1 1,0
                2: 0,2 1,1 2,0
                3: 0,3 1,2 2,1 3,0
                4: 0,4 1,3 2,2 3,1 4,0
                5:     1,4 2,3 3,2 4,1
                6:         2,4 3,3 4,2
                7:             3,4 4,3
                8:                 4,4
            */
            x = j;
            y = i - j;

            /*
                    0   1   2   3   4
                ----------------------
                0: 0,0
                1: 1,0 0,1
                2: 2,0 1,1 0,2
                3: 3,0 2,1 1,2 0,3
                4: 4,0 3,1 2,2 1,3 0,4
                5:     4,1 3,2 2,3 1,4
                6:         4,2 3,3 2,4
                7:             4,3 3,4
                8:                 4,4
            */
            x = i - j;
            y = j;

            /*
                    0   1   2   3   4
                ----------------------
                0:                 0,0
                1:             0,1 1,0
                2:         0,2 1,1 2,0
                3:     0,3 1,2 2,1 3,0
                4: 0,4 1,3 2,2 3,1 4,0
                5: 1,4 2,3 3,2 4,1
                6: 2,4 3,3 4,2
                7: 3,4 4,3
                8: 4,4
            */
            x = i + j - (N - 1);
            y = (N - 1) - j;

            if (x >= 0 && x < N && y >= 0 && y < N) {
                result[x][y] = val++;
            }
        }
    }
    return result;
}


let arr = diaognal(10);
console.log(arr);

배열의 대각선 출력

SoftArts — Wed, 26 Sep 2018 17:43:14 +0900

무한한 크기의 평면에 대각선 순서로 배열을 출력할 경우 (row, col)의 좌표에 해당하는 값을 O(1)로 가져올 수 있는 일반항을 구하는 함수: getVal(row, col)

/*
    row, col에 해당하는 값을 가져오는 일반식

    1) Row의 첫번째 값(col=1)에 해당하는 수열(Pn)의 일반항 구한다.
    Pn: { 1, 2, 4, 7, 11, ... }
    Pn = P1 + Sigma(k=1 ~ n-1)Bk,
    Bk = B1 + (k - 1) * d
       = 1 + (k - 1) * 1
       = k = row

    Pn = P1 + Sigma(Bk)
       = P1 + Sigma(row)
       = 1 + n(n - 1) / 2
       = (n^2 - n + 2) / 2, (n = row)


    2) 특정 Row의 n번째 col에 해당하는 수열(Qn)의 일반항을 구한다.
    Qn: { 4, 8, 13, 19, ... }  // row = 3 인경우
    Qn: { 7, 12, 18, 25, ... }  // row = 4 인경우
    Qn = Q1 + Sigma(k=1 ~ n-1)Bk,
    Bk = B1 + (k - 1) * d
       = (row + 1) + (k - 1) * 1
       = row + k

    여기서 Q1은 1) 에서 구한 시작항이므로
    Qn = Q1 + Sigma(Bk)
       = Q1 + Sigma(row + k)
       = Q1 + Sigma(row) + Sigma(k)
       = (row^2 - row + 2) / 2 +    // Q1
         row(n - 1) +               // Sigma(row)
         n(n - 1) / 2               // Sigma(k)
    
    여기에서 n = col이므로,
    Qn = (row^2 - row + 2) / 2 +
         row(col - 1) +
         col(col - 1) / 2
       = ((row + col)^2 - 3row - col + 2) / 2
*/
function getVal(row, col) {
    return (Math.pow(row + col, 2) - 3 * row - col + 2) / 2;
}

function diagonal(arr) {
    let row = 1;
    let col = 1;

    for (let i = 1; i <= arr.length; i++) {
        let val = getVal(row, col);

        if (val <= arr.length) {
            process.stdout.write(val + ' ');
        }

        let next = getVal(row, col + 1);
        if (next > arr.length) {
            row++;
            col = 1;
            process.stdout.write('\n');
        } else {
            col++;
        }
    }
}

let arr = Array(100).fill().map((v, i) => i);

diagonal(arr);

Codility #11-MaxCounters

SoftArts — Tue, 18 Sep 2018 17:53:32 +0900

function solution(N, A) {
    let prevMax = 0;
    let maxCounter = 0;
    let counters = Array(N).fill(0);

    for (let i = 0, len = A.length; i < len; i++) {
        if (A[i] <= N) {
            let idx = A[i] - 1;

            if (counters[idx] < prevMax) {
                counters[idx] = prevMax + 1;
            } else {
                counters[idx]++;
            }

            if (maxCounter < counters[idx]) {
                maxCounter = counters[idx];
            }
        } else {
            prevMax = maxCounter;
        }
    }

    for (let i = 0; i < N; i++) {
        if (counters[i] < prevMax) {
            counters[i] = prevMax;
        }
    }

    return counters;
}

Codility #10-FrogRiverOne

SoftArts — Tue, 18 Sep 2018 16:30:24 +0900

function solution(X, A) {
    let numbers = new Set();

    for (let i = 0, n = A.length; i < n; i++) {
        numbers.add(A[i]);

        if (X === numbers.size) {
            return i;
        }
    }

    return -1;
}

Codility #9-PermCheck

SoftArts — Tue, 18 Sep 2018 16:17:08 +0900

function solution(A) {
    let numbers = {};
    let n = A.length;
    let sumAll = 0;
    let sumN = n * (n + 1) / 2; // sum(1~N):

    for (let i = 0; i < n; i++) {
        if (numbers[A[i]]) {
            return 0; // duplicated
        } else {
            numbers[A[i]] = true;
        }
        sumAll += A[i];
    }

    return sumAll === sumN ? 1 : 0;
}

Codility #8-TapeEquilibrium

SoftArts — Tue, 18 Sep 2018 15:49:25 +0900

function solution(A) {
    let sumAll = A.reduce((accu, curr) => accu + curr, 0); // sum of the array
    let minDiff = Number.MAX_VALUE;

    for (let i = 0, sumPart = 0, diff, n = A.length - 1; i < n; i++) {
        sumPart += A[i];
        // |sum(0~P-1) - sum(P~N-1)| equals to |2*sum(0~P-1) - sum(0~N-1)|
        diff = Math.abs(sumPart * 2 - sumAll);
        if (diff < minDiff) {
            minDiff = diff;
        }
    }

    return minDiff;
}