Test results - Codility

Your browser is not supported. Please, update your browser or switch to a different one. Learn more about which browsers are supported.

Tasks Details

medium

1. MinMaxDivision

Divide array A into K blocks and minimize the largest sum of any block.

Task Score

100%

Correctness

100%

Performance

100%

Task description

You are given integers K, M and a non-empty array A consisting of N integers. Every element of the array is not greater than M.

You should divide this array into K blocks of consecutive elements. The size of the block is any integer between 0 and N. Every element of the array should belong to some block.

The sum of the block from X to Y equals A[X] + A[X + 1] + ... + A[Y]. The sum of empty block equals 0.

The large sum is the maximal sum of any block.

For example, you are given integers K = 3, M = 5 and array A such that:

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

The array can be divided, for example, into the following blocks:

[2, 1, 5, 1, 2, 2, 2], [], [] with a large sum of 15;

[2], [1, 5, 1, 2], [2, 2] with a large sum of 9;

[2, 1, 5], [], [1, 2, 2, 2] with a large sum of 8;

[2, 1], [5, 1], [2, 2, 2] with a large sum of 6.

The goal is to minimize the large sum. In the above example, 6 is the minimal large sum.

Write a function:

function solution(K, M, A);

that, given integers K, M and a non-empty array A consisting of N integers, returns the minimal large sum.

For example, given K = 3, M = 5 and array A such that:

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

the function should return 6, as explained above.

Write an efficient algorithm for the following assumptions:

N and K are integers within the range [1..100,000];

M is an integer within the range [0..10,000];

each element of array A is an integer within the range [0..M].

Solution

Programming language used JavaScript

Time spent on task 24 minutes

Notes

not defined yet

Task timeline

‌

Code: 11:16:53 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 K, int M, int[] A) {
        // write your code in Java SE 8
    }
}

Code: 11:16:56 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
}

Code: 11:17:40 UTC, js, autosave

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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= M)
}

Code: 11:17:50 UTC, js, autosave

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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length)
}

Code: 11:18:08 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        retun A.sort()
    }
}

Code: 11:18:19 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        retun A.sort((a,b) => a-b)
    }
}

Code: 11:18:36 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        return A.sort((a,b) => a-b)[A.length-1]
    }
}

Code: 11:18: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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        return A.sort((a,b) => a-b)[A.length-1]
    }
}

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, 'undefined' found
Perhaps you are missing a 'return'?

Code: 11:18:48 UTC, js, verify, result: Failed

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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        return A.sort((a,b) => a-b)[A.length-1]
    }
    return 1
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 1 expected 6

0.068 s

WRONG ANSWER, got 1 expected 6

Code: 11:19:06 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        return A.sort((a,b) => a-b)[A.length-1]
    }
    return 1
}

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

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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        return A.sort((a,b) => a-b)[A.length-1]
    }
    return 1
}

User test case 1:

[10, 3, [1, 2, 3]]

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 1 expected 6

0.068 s

WRONG ANSWER, got 1 expected 6

expand all User tests

▶

test_data1

✔

0.072 s

OK
function result: 3

Code: 11:19:29 UTC, js, verify, result: Failed

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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        return A.sort((a,b) => a-b)[A.length-1]
    }
    return 1
}

User test case 1:

[10, 3, [1, 2, 3]]

User test case 2:

[10, 3, [1, 1, 1, 1, 1]]

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 1 expected 6

0.072 s

WRONG ANSWER, got 1 expected 6

expand all User tests

▶

test_data1

✔

0.072 s

OK
function result: 3

▶

test_data2

✔

0.072 s

OK
function result: 1

Code: 11:22: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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        return Mat
    }
    return 1
}

Code: 11:22:19 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (K >= A.length) {
        return Math.max(...A);
    }
    return 1
}

Code: 11:24:58 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    
    
    if (K >= A.length) {
        return Math.max(...A);
    }
    return 1
}

Code: 11:25:22 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let minMax = 0;
    let max = 0;
    
    if (K >= A.length) {
        return Math.max(...A);
    }
    return 1
}

Code: 11:25:52 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let minMax = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; )
    if (K >= A.length) {
        return Math.max(...A);
    }
    return 1
}

Code: 11:26:21 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let minMax = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        minMax = Math.max(min)
    }
    if (K >= A.length) {
        return Math.max(...A);
    }
    return 1
}

Code: 11:26:51 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let minMax = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        minMax = Math.max(min, A[i]);
    }
    if (K >= A.length) {
        return Math.max(...A);
    }
    return 1
}

Code: 11:27:03 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    if (K >= A.length) {
        return Math.max(...A);
    }
    return 1
}

Code: 11:27:32 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 20

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return Math.max(...A);
    }
    return 1
}

Code: 11:27:57 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 20

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    return 1
}

Code: 11:28:07 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 20 21 22

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    while ()
    return 1
}

Code: 11:28:25 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 20 21 22 23 24

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    while (min < max) {
        
    }
    return 1
}

Code: 11:28:35 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 20 21 22 23 24

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    while (min <= max) {
        
    }
    return 1
}

Code: 11:28:54 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 20 21 22 23 24

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    while (min <= max) {
        let temp
    }
    return 1
}

Code: 11:29:04 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 20 21 22 23 24 25

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid =0
    while (min <= max) {
        let temp
    }
    return 1
}

Code: 11:29: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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= max) {
        let temp = mid;
        mid = parse
    }
    return 1
}

Code: 11:29:44 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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= max) {
        let temp = mid;
        mid = parseInt()
    }
    return 1
}

Code: 11:30:01 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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= max) {
        let temp = mid;
        mid = parseInt(min + sum)
    }
    return 1
}

Code: 11:30:16 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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
    }
    return 1
}

Code: 11:30: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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break
        }
    }
    return 1
}

Code: 11:30:46 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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

Code: 11:31:28 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 20 21 22 23 24 25 26 27 28 29 30

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

Code: 11:31:39 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 20 21 22 23 24 25 26 27 28 29 30

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    let blocks = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

Code: 11:32: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 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    let blocks = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

function blocksNeeded

Code: 11:32:35 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 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    let blocks = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0]
}

Code: 11:33:04 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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    let blocks = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        
    }
}

Code: 11:33: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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    let blocks = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum
        }
    }
}

Code: 11:34:02 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 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

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    let blocks = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
}

Code: 11:34:12 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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    let blocks = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:35:04 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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;

    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
    }
    return 1
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:35:26 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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid)
    }
    return 1
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:35:56 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 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(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        
        if (blocks > K) {
            min = mid + 1;
        } e
    }
    return 1
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:36:05 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 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 51

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            max = mid;
        }
    }
    return 1
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

User test case 1:

[10, 3, [1, 2, 3]]

User test case 2:

[10, 3, [1, 1, 1, 1, 1]]

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 1 expected 6

0.068 s

WRONG ANSWER, got 1 expected 6

expand all User tests

▶

test_data1

✔

0.068 s

OK
function result: 3

▶

test_data2

✔

0.068 s

OK
function result: 1

Code: 11:36:12 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 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 51

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            max = mid;
        }
    }
    return max
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

User test case 1:

[10, 3, [1, 2, 3]]

User test case 2:

[10, 3, [1, 1, 1, 1, 1]]

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 10 expected 6

0.096 s

WRONG ANSWER, got 10 expected 6

expand all User tests

▶

test_data1

✔

0.072 s

OK
function result: 3

▶

test_data2

✔

0.076 s

OK
function result: 1

Code: 11:36:42 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 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 51

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return max
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:36:49 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 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 51

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

User test case 1:

[10, 3, [1, 2, 3]]

User test case 2:

[10, 3, [1, 1, 1, 1, 1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

expand all User tests

▶

test_data1

✔

0.068 s

OK
function result: 3

▶

test_data2

✔

0.068 s

OK
function result: 1

Code: 11:37:04 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 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 51

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:38:01 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 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 51 52

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:38:15 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 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 51 52

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        console.log('->')
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:38:38 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 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 51 52

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        console.log('-> sum, min, mid, blocks, K:', sum.)
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:38:53 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 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 51 52

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        console.log('-> sum, min, mid, blocks, K:', sum, min, mid, blocks, K)
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

User test case 1:

[10, 3, [1, 2, 3]]

User test case 2:

[10, 3, [1, 1, 1, 1, 1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.120 s

stdout:

-> sum, min, mid, blocks, K: 15 5 10 2 3
-> sum, min, mid, blocks, K: 10 5 7 3 3
-> sum, min, mid, blocks, K: 7 5 6 3 3
-> sum, min, mid, blocks, K: 6 5 5 4 3
-> sum, min, mid, blocks, K: 6 6 6 3 3

expand all User tests

▶

test_data1

✔

0.120 s

OK
function result: 3

▶

test_data2

✔

0.112 s

OK
function result: 1

Code: 11:40:01 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 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 51 52

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        console.log('-> sum, min, mid, blocks, K:', sum, min, mid, blocks, K)
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

User test case 1:

[10, 3, [1, 2, 3]]

User test case 2:

[10, 3, [1, 1, 1, 1, 1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.076 s

stdout:

-> sum, min, mid, blocks, K: 15 5 10 2 3
-> sum, min, mid, blocks, K: 10 5 7 3 3
-> sum, min, mid, blocks, K: 7 5 6 3 3
-> sum, min, mid, blocks, K: 6 5 5 4 3
-> sum, min, mid, blocks, K: 6 6 6 3 3

expand all User tests

▶

test_data1

✔

0.072 s

OK
function result: 3

▶

test_data2

✔

0.068 s

OK
function result: 1

Code: 11:40:08 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 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 51 52

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        // console.log('-> sum, min, mid, blocks, K:', sum, min, mid, blocks, K)
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Code: 11:40:13 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 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 51 52

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        // console.log('-> sum, min, mid, blocks, K:', sum, min, mid, blocks, K)
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

User test case 1:

[10, 3, [1, 2, 3]]

User test case 2:

[10, 3, [1, 1, 1, 1, 1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.068 s

expand all User tests

▶

test_data1

✔

0.072 s

OK
function result: 3

▶

test_data2

✔

0.068 s

OK
function result: 1

Code: 11:40:18 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 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 51 52

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        // console.log('-> sum, min, mid, blocks, K:', sum, min, mid, blocks, K)
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

User test case 1:

[10, 3, [1, 2, 3]]

User test case 2:

[10, 3, [1, 1, 1, 1, 1]]

Analysis

expand all Example tests

▶

example
example test

✔

0.068 s

expand all User tests

▶

test_data1

✔

0.068 s

OK
function result: 3

▶

test_data2

✔

0.072 s

OK
function result: 1

Code: 11:40:20 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 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 51 52

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

function solution(K, M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let min = 0;
    let sum = 0;
    
    for (let i = 0; i < A.length; i++) {
        sum += A[i];
        min = Math.max(min, A[i]);
    }
    
    if (K === 1) {
        return sum;
    } else if (K >= A.length) {
        return min;
    }
    
    let mid = 0;
    while (min <= sum) {
        let temp = mid;
        mid = parseInt((min + sum) / 2)
        if (mid === temp) {
            break;
        }
        let blocks = blocksNeeded(A, mid);
        // console.log('-> sum, min, mid, blocks, K:', sum, min, mid, blocks, K)
        
        if (blocks > K) {
            min = mid + 1;
        } else {
            sum = mid;
        }
    }
    return sum;
}

function blocksNeeded(A, x) {
    let count = 1;
    let sum = A[0];
    
    for (let j = 1; j < A.length; j++) {
        if (sum + A[j] > x) {
            sum = A[j];
            count++
        } else {
            sum += A[j];
        }
    }
    return count;
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N*log(N+M))

expand all Example tests

▶

example
example test

✔

0.068 s

expand all Correctness tests

▶

extreme_single
single elements

✔

0.068 s

▶

extreme_double
single and double elements

✔

0.068 s

▶

extreme_min_max
maximal / minimal values

✔

0.068 s

▶

simple1
simple tests

✔

0.068 s

▶

simple2
simple tests

✔

0.068 s

▶

tiny_random_ones
random values {0, 1}, N = 100

✔

0.068 s

expand all Performance tests

▶

small_random_ones
random values {0, 1}, N = 100

✔

0.068 s

▶

medium_zeros
many zeros and 99 in the middle, length = 15,000

✔

0.088 s

0.092 s

0.096 s

0.088 s

▶

medium_random
random values {1, 100}, N = 20,000

✔

0.088 s

0.092 s

▶

large_random
random values {0, ..., MAX_INT}, N = 100,000

✔

0.120 s

0.124 s

▶

large_random_ones
random values {0, 1}, N = 100,000

✔

0.100 s

0.108 s

▶

all_the_same
all the same values, N = 100,000

✔

0.108 s

0.120 s

0.108 s