Test results - Codility

Code: 08:01:28 UTC, java, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 8
    }
}

Code: 08:01:33 UTC, js, autosave

1 2 3 4 5 6

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
}

Code: 08:01:55 UTC, js, autosave

1 2 3 4 5 6 7

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    
}

Code: 08:02:30 UTC, js, autosave

1 2 3 4 5 6 7

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if 
}

Code: 08:02:43 UTC, js, autosave

1 2 3 4 5 6 7

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 1)
}

Code: 08:02:53 UTC, js, autosave

1 2 3 4 5 6 7

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length < 1)
}

Code: 08:03:17 UTC, js, autosave

1 2 3 4 5 6 7 8 9

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length < 2) {
        
    }
}

Code: 08:03:47 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return p[]
    }
}

Code: 08:04:00 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]*
    }
}

Code: 08:05:30 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]
    }
}

Code: 08:06:00 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b))
}

Code: 08:06:25 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = A[A.length - 1];
    
}

Code: 08:07:43 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = MaA[A.length - 1];
    
}

Code: 08:07:54 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    
}

Code: 08:08:48 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    
    
}

Code: 08:09:04 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    
    for (let i = 0; i <)
}

Code: 08:09:34 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = [];
    for (let i = 0; i <= max; i++) {
        count
    }
}

Code: 08:10:04 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0)
}

Code: 08:10:17 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    
}

Code: 08:10:29 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    
    for (let i = 0)
}

Code: 08:10:48 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    
    for (let i = 0; i < A.length; i++) {
        
    }
}

Code: 08:10:58 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    
    for (let i = 0; i < A.length; i++) {
        A[]
    }
}

Code: 08:12:04 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    
    for (let i = 0; i < A.length; i++) {
        A[i]
    }
}

Code: 08:12:34 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total 
    }
}

Code: 08:12:45 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
}

Code: 08:13:14 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
}

Code: 08:16:14 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
}

Code: 08:16:44 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: max + 1 }, () => 0);
}

Code: 08:17:04 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
}

Code: 08:17:46 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    
}

Code: 08:22:40 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    retu
}

Code: 08:22:45 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    return 1;
}

The submission is being evaluated.

Code: 08:23:00 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total)
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    return 1;
}

The submission is being evaluated.

Code: 08:34:20 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    return 1;
}

Code: 08:40:14 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    
    return 1;
}

Code: 08:40:24 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let)
    
    return 1;
}

Code: 08:41:38 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i )
    
    return 1;
}

Code: 08:42:08 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            
        }
    }
    
    return 1;
}

Code: 08:43:03 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            fo
        }
    }
    
    return 1;
}

Code: 08:43:13 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j )
        }
    }
    
    return 1;
}

Code: 08:43:27 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j )
        }
    }
    
    return 1;
}

Code: 08:43:41 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < total)
        }
    }
    
    return 1;
}

Code: 08:43:52 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < total;)
        }
    }
    
    return 1;
}

Code: 08:44:13 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++)
        }
    }
    
    return 1;
}

Code: 08:44:43 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i]
                }
            }
        }
    }
    
    return 1;
}

Code: 08:45:08 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (dp[j])
            }
        }
    }
    
    return 1;
}

Code: 08:45:38 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j]
                }
            }
        }
    }
    
    return 1;
}

Code: 08:45:54 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
            }
        }
    }
    
    return 1;
}

Code: 08:52:18 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
            }
        }
    }
    
    return 1;
}

Code: 08:52:29 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
            }
        }
    }
    
    return 1;
}

Code: 08:52:59 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    
                }
            }
        }
    }
    
    return 1;
}

Code: 08:54:10 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if 
                }
            }
        }
    }
    
    return 1;
}

Code: 08:54:30 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        
                    }
                }
            }
        }
    }
    
    return 1;
}

Code: 08:55:01 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs)
                    }
                }
            }
        }
    }
    
    return 1;
}

Code: 08:55:21 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    
    return 1;
}

Code: 08:56:06 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    ret
    return 1;
}

Code: 08:56:16 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:56:39 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:56:42 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    console.log(total);
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

The submission is being evaluated.

Code: 08:57:09 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, ')
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:57:21 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, dp:')
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:57:31 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, dp:', total, target, dp)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:57:42 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, dp:', total, target, dp)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                co
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:57:53 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, dp:', total, target, dp)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('')
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:58:05 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('')
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:58:15 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dp:')
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:58:25 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dp:', i, j, dp)
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:58:36 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 08:59:22 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

The submission is being evaluated.

Code: 08:59:49 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                co
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 09:00:09 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

The submission is being evaluated.

Code: 09:01:34 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j))
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 09:01:44 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
    return 1;
}

Code: 09:02:14 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

Code: 09:07:02 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

Code: 09:07:19 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

Code: 09:07:28 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

The submission is being evaluated.

Code: 09:07:42 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    // console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

Code: 09:07:48 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    // console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                // console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                // console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

The submission is being evaluated.

Code: 09:08:27 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    // } if (A.length === 1) {
    //     return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    // console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                // console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                // console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

Code: 09:08:31 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    // } if (A.length === 1) {
    //     return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    // console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                // console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                // console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

The submission is being evaluated.

Code: 09:08:47 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    // console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                // console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                // console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

Code: 09:09:07 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    // console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                // console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                // console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

Code: 09:09:30 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    // console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                // console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                // console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

The submission is being evaluated.

Code: 09:09:43 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    // console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                // console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                // console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

The submission is being evaluated.

Code: 09:09:46 UTC, js, final, score: 100

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (A.length === 0) {
        return 0;
    } if (A.length === 1) {
        return Math.abs(A[0]);
    }
    
    A.sort((a, b) => Math.abs(a) - Math.abs(b));
    let max = Math.abs(A[A.length - 1]);
    let count = Array.from({ length: max + 1 }, () => 0);
    let total = 0;
    for (let i = 0; i < A.length; i++) {
        A[i] = Math.abs(A[i]);
        count[A[i]]++;
        total += A[i];
    }
    
    let dp = Array.from({ length: total + 1 }, () => -1);
    dp[0] = 0;
    
    const target = total / 2;
    let minAbsSum = total;
    // console.log('-> total, target, count:', total, target, count)
    for (let i = 0; i < count.length; i++) {
        if (count[i] > 0) {
            for (let j = 0; j < dp.length; j++) {
                // console.log('i, j, dpj:', i, j, dp[j])
                if (dp[j] >= 0) {
                    dp[j] = count[i];
                } else if (j >= i && dp[j - i] > 0) {
                    dp[j] = dp[j - i] - 1;
                }
                // console.log('new dpj:', dp[j])
                if (dp[j] >= 0) {
                    if (j === target) {
                        return 0;
                    } else {
                        minAbsSum = Math.min(minAbsSum, Math.abs(total - 2 * j));
                    }
                }
            }
        }
    }
    return minAbsSum;
}

The submission is being evaluated.