Test results - Codility

Tasks Details

easy

1. TapeEquilibrium

Minimize the value |(A[0] + ... + A[P-1]) - (A[P] + ... + A[N-1])|.

Task Score

100%

Correctness

100%

Performance

100%

A non-empty array A consisting of N integers is given. Array A represents numbers on a tape.

Any integer P, such that 0 < P < N, splits this tape into two non-empty parts: A[0], A[1], ..., A[P − 1] and A[P], A[P + 1], ..., A[N − 1].

The difference between the two parts is the value of: |(A[0] + A[1] + ... + A[P − 1]) − (A[P] + A[P + 1] + ... + A[N − 1])|

In other words, it is the absolute difference between the sum of the first part and the sum of the second part.

For example, consider array A such that:

A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 4 A[4] = 3

We can split this tape in four places:

P = 1, difference = |3 − 10| = 7

P = 2, difference = |4 − 9| = 5

P = 3, difference = |6 − 7| = 1

P = 4, difference = |10 − 3| = 7

Write a function:

function solution(A);

that, given a non-empty array A of N integers, returns the minimal difference that can be achieved.

For example, given:

A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 4 A[4] = 3

the function should return 1, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [2..100,000];

each element of array A is an integer within the range [−1,000..1,000].

Solution

Programming language used JavaScript

Time spent on task 15 minutes

Notes

not defined yet

Code: 07:07:35 UTC, java, autosave

show code in pop-up

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: 07:07:38 UTC, js, autosave

show code in pop-up

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: 07:07:51 UTC, js, verify, result: Failed

show code in pop-up

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)
    console.log(A)
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.124 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, integer expected, 'undefined' found
Perhaps you are missing a 'return'?

stdout:

[ 3, 1, 2, 4, 3 ]

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

show code in pop-up

1 2 3 4 5 6 7 8

// 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)
    const maxArr = [];
    
}

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

show code in pop-up

1 2 3 4 5 6 7 8

// 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)
    const left = A[0];
    const right = A.
}

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

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    console.log(left,rigth);
}

Code: 07:09:33 UTC, js, verify, result: Failed

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    console.log(left,rigth);
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.072 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

ReferenceError: rigth is not defined
    at solution (solution.js:8:22)
    at solutionWrapper (/tmp/exec.js:402:28)
    at Promise.resolve.then (/tmp/exec.js:428:24)
    at <anonymous>
    at process._tickCallback (internal/process/next_tick.js:188:7)
    at Function.Module.runMain (module.js:686:11)
    at startup (bootstrap_node.js:187:16)
    at bootstrap_node.js:608:3

Code: 07:09:38 UTC, js, verify, result: Failed

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    console.log(left,right);
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.076 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, integer expected, 'undefined' found
Perhaps you are missing a 'return'?

stdout:

3 10

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

show code in pop-up

1 2 3 4 5 6 7 8 9 10

// 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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    
    
}

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

show code in pop-up

1 2 3 4 5 6 7 8 9 10

// 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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    
    A.slice(1,-1)
}

Code: 07:10:30 UTC, js, autosave

show code in pop-up

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

// 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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    
    return A.slice(1,-1).reduce((acc,cur)=>{
        
    });
}

Code: 07:10:40 UTC, js, autosave

show code in pop-up

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

// 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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    
    return A.slice(1,-1).reduce((acc,cur)=>{
        
    },[left,right]);
}

Code: 07:10:51 UTC, js, autosave

show code in pop-up

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

// 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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    
    return A.slice(1,-1).reduce((acc,cur)=>{
        
    },{left,right});
}

Code: 07:11:01 UTC, js, autosave

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    
    return A.slice(1,-1).reduce((acc,cur)=>{
        
        return acc;
    },{left,right});
}

Code: 07:11:11 UTC, js, autosave

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    let max = 
    return A.slice(1,-1).reduce((acc,cur)=>{
        
        return acc;
    },{left,right});
}

Code: 07:11:28 UTC, js, verify, result: Failed

show code in pop-up

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

// 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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    console.log(max)
    return A.slice(1,-1).reduce((acc,cur)=>{
        
        return acc;
    },{left,right});
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.072 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, integer expected, 'object' found

stdout:

Code: 07:11:38 UTC, js, autosave

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce((acc,cur)=>{
        
        return acc;
    },{left,right,max});
}

Code: 07:11:51 UTC, js, autosave

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce((acc,cur)=>{
        
        return acc;
    },{left,right,max});
}

Code: 07:12:16 UTC, js, autosave

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce((acc,cur)=>{
        acc.left += cur;
        acc.right -= cur;
        
        return acc;
    },{left,right,max});
}

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

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce((acc,cur)=>{
        acc.left += cur;
        acc.right -= cur;
        acc.max = Math.max(acc.max, )
        return acc;
    },{left,right,max});
}

Code: 07:12:53 UTC, js, autosave

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce((acc,cur)=>{
        let {left,right,max} = 
        acc.left += cur;
        acc.right -= cur;
        acc.max = Math.max(acc.max, Math.abs(left-right))
        return acc;
    },{left,right,max});
}

Code: 07:13:05 UTC, js, autosave

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce((acc,cur)=>{
        let {left,right,max} = acc;
        acc.left += cur;
        acc.right -= cur;
        acc.max = Math.max(acc.max, Math.abs(left-right))
        return acc;
    },{left,right,max});
}

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

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce((acc,cur)=>{
        return {
            left : 
        }
        let {left,right,max} = acc;
        acc.left += cur;
        acc.right -= cur;
        acc.max = Math.max(acc.max, Math.abs(left-right))
        return acc;
    },{left,right,max});
}

Code: 07:13:48 UTC, js, verify, result: Failed

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,max},cur)=>{
        return {
            left : left+cur,
            right : right-right,
            max : Math.max(max, Math.abs(left,right))
        }
    },{left,right,max});
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.072 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, integer expected, 'object' found

Code: 07:13:55 UTC, js, autosave

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,max},cur)=>{
        return {
            left : left+cur,
            right : right-right,
            max : Math.max(max, Math.abs(left,right))
        }
    },{left,right,max}).max;
}

Code: 07:13:56 UTC, js, verify, result: Failed

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let max = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,max},cur)=>{
        return {
            left : left+cur,
            right : right-right,
            max : Math.max(max, Math.abs(left,right))
        }
    },{left,right,max}).max;
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 7 expected 1

0.072 s

WRONG ANSWER, got 7 expected 1

Code: 07:14:13 UTC, js, verify, result: Failed

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>{
        return {
            left : left+cur,
            right : right-right,
            min : Math.min(min, Math.abs(left,right))
        }
    },{left,right,min}).min;
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 3 expected 1

0.120 s

WRONG ANSWER, got 3 expected 1

Code: 07:14:25 UTC, js, verify, result: Failed

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>{
        return {
            left : left+cur,
            right : right-right,
            min : Math.min(min, Math.abs(left-right))
        }
    },{left,right,min}).min;
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 4 expected 1

0.072 s

WRONG ANSWER, got 4 expected 1

Code: 07:14:34 UTC, js, autosave

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>{
        
        return {
            left : left+cur,
            right : right-right,
            min : Math.min(min, Math.abs(left-right))
        }
    },{left,right,min}).min;
}

Code: 07:14:37 UTC, js, verify, result: Failed

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>{
        console.log(Math.abs(left-right))
        return {
            left : left+cur,
            right : right-right,
            min : Math.min(min, Math.abs(left-right))
        }
    },{left,right,min}).min;
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 4 expected 1

0.120 s

WRONG ANSWER, got 4 expected 1

stdout:

7
4
6

Code: 07:15:05 UTC, js, autosave

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>{
        left = 
        return {
            left : left+cur,
            right : right-right,
            min : Math.min(min, Math.abs(left-right))
        }
    },{left,right,min}).min;
}

Code: 07:15:21 UTC, js, verify, result: Passed

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>{
        return {
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
        }
    },{left,right,min}).min;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

Code: 07:15:35 UTC, js, autosave

show code in pop-up

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

// 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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>{
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
        },{left,right,min}).min;
}

Code: 07:15:42 UTC, js, verify, result: Failed

show code in pop-up

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

// 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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>{
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    },{left,right,min}).min;
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.072 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

solution.js:11
            right : right-cur,
                  ^

SyntaxError: Unexpected token :
    at createScript (vm.js:80:10)
    at Object.runInNewContext (vm.js:135:10)
    at getSolution (/tmp/exec.js:392:29)
    at Promise.resolve.then (/tmp/exec.js:426:34)
    at <anonymous>
    at process._tickCallback (internal/process/next_tick.js:188:7)
    at Function.Module.runMain (module.js:686:11)
    at startup (bootstrap_node.js:187:16)
    at bootstrap_node.js:608:3

Code: 07:16:18 UTC, js, autosave

show code in pop-up

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

// 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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>new Object(){
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    },{left,right,min}).min;
}

Code: 07:16:30 UTC, js, autosave

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left,right,min}).min;
}

Code: 07:16:30 UTC, js, verify, result: Passed

show code in pop-up

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)
    let left = A[0];
    let right = A.slice(1).reduce((a,b)=>a+b);
    let min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left,right,min}).min;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

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

show code in pop-up

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)
    con left = A[0];
    con right = A.slice(1).reduce((a,b)=>a+b);
    con min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left,right,min}).min;
}

Code: 07:17:05 UTC, js, verify, result: Passed

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    const min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left,right,min}).min;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

Code: 07:17:23 UTC, js, autosave

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    const min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left: A[0],right,min}).min;
}

Code: 07:17:38 UTC, js, autosave

show code in pop-up

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

// 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)
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left: A[0],right: A.slice(1).reduce((a,b)=>a+b),min: Math.abs(left-right)}).min;
}

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

show code in pop-up

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)
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{
            left: A[0],
            right: A.slice(1).reduce((a, b) => a + b),
            min: Math.abs(left - right)
        ).min;
}

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

show code in pop-up

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)
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }), {
            left: A[0],
            right: A.slice(1).reduce((a, b) => a + b),
            min: Math.abs(left - right)
    }).min;
}

Code: 07:20:03 UTC, js, verify, result: Failed

show code in pop-up

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)
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }), {
            left: A[0],
            right: A.slice(1).reduce((a, b) => a + b),
            min: Math.abs(left - right)
    }).min;
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.072 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

ReferenceError: left is not defined
    at solution (solution.js:14:27)
    at solutionWrapper (/tmp/exec.js:402:28)
    at Promise.resolve.then (/tmp/exec.js:428:24)
    at <anonymous>
    at process._tickCallback (internal/process/next_tick.js:188:7)
    at Function.Module.runMain (module.js:686:11)
    at startup (bootstrap_node.js:187:16)
    at bootstrap_node.js:608:3

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

show code in pop-up

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)
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }), {
            left: A[0],
            right: A.slice(1).reduce((a, b) => a + b),
            min: Math.abs(this.left - right)
    }).min;
}

Code: 07:20:24 UTC, js, verify, result: Failed

show code in pop-up

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)
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }), {
            left: A[0],
            right: A.slice(1).reduce((a, b) => a + b),
            min: Math.abs(this.left - this.right)
    }).min;
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.072 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Invalid result type, integer expected, non-integer number found

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

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    const min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left,right,min}).min;
}

Code: 07:21:00 UTC, js, autosave

show code in pop-up

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)
    const init = {
        
    }
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    const min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left,right,min}).min;
}

Code: 07:21:11 UTC, js, verify, result: Failed

show code in pop-up

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

// 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)
    const init = {
            left: A[0],
            right: A.slice(1).reduce((a, b) => a + b),
            min: Math.abs(left - right)
    };
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    const min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),init).min;
}

Analysis

expand all Example tests

▶

example
example test

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.116 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

ReferenceError: left is not defined
    at solution (solution.js:9:27)
    at solutionWrapper (/tmp/exec.js:402:28)
    at Promise.resolve.then (/tmp/exec.js:428:24)
    at <anonymous>
    at process._tickCallback (internal/process/next_tick.js:188:7)
    at Function.Module.runMain (module.js:686:11)
    at startup (bootstrap_node.js:187:16)
    at bootstrap_node.js:608:3

Code: 07:21:19 UTC, js, verify, result: Passed

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    const min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left,right,min}).min;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

Code: 07:21:45 UTC, js, verify, result: Passed

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    const min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left,right,min}).min;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

Code: 07:21:47 UTC, js, final, score: 100

show code in pop-up

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)
    const left = A[0];
    const right = A.slice(1).reduce((a,b)=>a+b);
    const min = Math.abs(left-right);
    return A.slice(1,-1).reduce(({left,right,min},cur)=>
        new Object({
            left : left+cur,
            right : right-cur,
            min : Math.min(min, Math.abs(left-right))
    }),{left,right,min}).min;
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N)

expand all Example tests

▶

example
example test

✔

0.072 s

expand all Correctness tests

▶

double
two elements

✔

0.072 s

▶

simple_positive
simple test with positive numbers, length = 5

✔

0.072 s

▶

simple_negative
simple test with negative numbers, length = 5

✔

0.072 s

▶

small_random
random small, length = 100

✔

0.072 s

▶

small_range
range sequence, length = ~1,000

✔

0.072 s

▶

small
small elements

✔

0.072 s

expand all Performance tests

▶

medium_random1
random medium, numbers from 0 to 100, length = ~10,000

✔

0.084 s

▶

medium_random2
random medium, numbers from -1,000 to 50, length = ~10,000

✔

0.092 s

▶

large_ones
large sequence, numbers from -1 to 1, length = ~100,000

✔

0.112 s

▶

large_random
random large, length = ~100,000

✔

0.120 s

▶

large_sequence
large sequence, length = ~100,000

✔

0.104 s

▶

large_extreme
large test with maximal and minimal values, length = ~100,000

✔

0.120 s

0.112 s