Test results - Codility

Tasks Details

easy

1. CountDistinctSlices

Count the number of distinct slices (containing only unique numbers).

Task Score

100%

Correctness

100%

Performance

100%

An integer M and a non-empty array A consisting of N non-negative integers are given. All integers in array A are less than or equal to M.

A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The slice consists of the elements A[P], A[P + 1], ..., A[Q]. A distinct slice is a slice consisting of only unique numbers. That is, no individual number occurs more than once in the slice.

For example, consider integer M = 6 and array A such that:

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

There are exactly nine distinct slices: (0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (2, 2), (3, 3), (3, 4) and (4, 4).

The goal is to calculate the number of distinct slices.

Write a function:

function solution(M, A);

that, given an integer M and a non-empty array A consisting of N integers, returns the number of distinct slices.

If the number of distinct slices is greater than 1,000,000,000, the function should return 1,000,000,000.

For example, given integer M = 6 and array A such that:

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

the function should return 9, as explained above.

Write an efficient algorithm for the following assumptions:

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

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

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

Solution

Programming language used JavaScript

Time spent on task 13 minutes

Notes

not defined yet

Code: 15:31:04 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 M, int[] A) {
        // write your code in Java SE 8
    }
}

Code: 15:31:07 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
}

Code: 15:32:39 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    const LIMIT = 1000000000;
    let count = 0;
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:32: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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    const LIMIT = 1000000000;
    let count = 0;
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    let start  = 0;
    let 
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:33: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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    const LIMIT = 1000000000;
    let count = 0;
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    let start  = 0;
    let lastPos = i;
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:33: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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = i;
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:33:43 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        l
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:33: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 17 18 19 20

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:34:24 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length; i++) {
        
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:34: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 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length; i++) {
        const item = A[i];
        
        if (lastPos[i] + 1 )
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:35:20 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length; i++) {
        const item = A[i];
        
        if (lastPos[i] + 1 > start) {
            start = lastPos[item] + 1;
        }
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:35:31 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length; i++) {
        const item = A[i];
        
        if (lastPos[i] + 1 > start) {
            start = lastPos[item] + 1;
        }
        last
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:36: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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length; i++) {
        const item = A[i];
        
        if (lastPos[i] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = 
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:36:31 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length; i++) {
        const item = A[i];
        
        if (lastPos[i] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
        if (count > LIM)
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:36: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 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count ; i++) {
        const item = A[i];
        
        if (lastPos[i] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:36:58 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        
        if (lastPos[i] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

Code: 15:37:50 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        
        
        if (lastPos[i] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:38:14 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, lastPos')
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, lastPosI, start, count:')
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:38:33 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, lastPosI, start, count:', item, lastPosI, start, count)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

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: lastPosI is not defined
    at solution (solution.js:21:63)
    at solutionWrapper (/tmp/exec.js:404:28)
    at Promise.resolve.then (/tmp/exec.js:430: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: 15:38:42 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, lastPosI, start, count:', item, lastPos[item], start, count)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

stdout:

-> item, lastPosI, start, count: 3 -1 0 0
-> item, lastPosI, start, count: 4 -1 0 1
-> item, lastPosI, start, count: 5 -1 0 3
-> item, lastPosI, start, count: 5 2 0 6
-> item, lastPosI, start, count: 2 -1 3 7

Code: 15:39: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 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    cons
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, lastPosI, start, count:', item, lastPos[item], start, count)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:39:24 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, lastPosI, start, count:', item, lastPos[item], start, count)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

stdout:

[ -1, -1, -1, -1, -1, -1, -1 ]
-> item, lastPosI, start, count: 3 -1 0 0
-> item, lastPosI, start, count: 4 -1 0 1
-> item, lastPosI, start, count: 5 -1 0 3
-> item, lastPosI, start, count: 5 2 0 6
-> item, lastPosI, start, count: 2 -1 3 7

Code: 15:39:43 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, lastPosI, start, count:', item, lastPos, start, count)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.080 s

stdout:

[ -1, -1, -1, -1, -1, -1, -1 ]
-> item, lastPosI, start, count: 3 [ -1, -1, -1, -1, -1, -1, -1 ] 0 0
-> item, lastPosI, start, count: 4 [ -1, -1, -1, 0, -1, -1, -1 ] 0 1
-> item, lastPosI, start, count: 5 [ -1, -1, -1, 0, 1, -1, -1 ] 0 3
-> item, lastPosI, start, count: 5 [ -1, -1, -1, 0, 1, 2, -1 ] 0 6
-> item, lastPosI, start, count: 2 [ -1, -1, -1, 0, 1, 3, -1 ] 3 7

Code: 15:39: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 30 31 32

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, lastPos, start, count:', item, lastPos, start, count)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:39:47 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, lastPos, start, count:', item, lastPos, start, count)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

stdout:

[ -1, -1, -1, -1, -1, -1, -1 ]
-> item, lastPos, start, count: 3 [ -1, -1, -1, -1, -1, -1, -1 ] 0 0
-> item, lastPos, start, count: 4 [ -1, -1, -1, 0, -1, -1, -1 ] 0 1
-> item, lastPos, start, count: 5 [ -1, -1, -1, 0, 1, -1, -1 ] 0 3
-> item, lastPos, start, count: 5 [ -1, -1, -1, 0, 1, 2, -1 ] 0 6
-> item, lastPos, start, count: 2 [ -1, -1, -1, 0, 1, 3, -1 ] 3 7

Code: 15:40:11 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, start, count, lastPos:', item, lastPos, start, count)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:40:20 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, start, count, lastPos:', item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Code: 15:40:40 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, start, count, lastPos:', item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.076 s

stdout:

[ -1, -1, -1, -1, -1, -1, -1 ]
-> item, start, count, lastPos: 3 0 0 [ -1, -1, -1, -1, -1, -1, -1 ]
-> item, start, count, lastPos: 4 0 1 [ -1, -1, -1, 0, -1, -1, -1 ]
-> item, start, count, lastPos: 5 0 3 [ -1, -1, -1, 0, 1, -1, -1 ]
-> item, start, count, lastPos: 5 0 6 [ -1, -1, -1, 0, 1, 2, -1 ]
-> item, start, count, lastPos: 2 3 7 [ -1, -1, -1, 0, 1, 3, -1 ]

Code: 15:41:20 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, start, count, lastPos:', item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    cons
    return count > LIMIT ? LIMIT : count;
}

Code: 15:41:25 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> item, start, count, lastPos:', item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    console.log(count)
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.076 s

stdout:

[ -1, -1, -1, -1, -1, -1, -1 ]
-> item, start, count, lastPos: 3 0 0 [ -1, -1, -1, -1, -1, -1, -1 ]
-> item, start, count, lastPos: 4 0 1 [ -1, -1, -1, 0, -1, -1, -1 ]
-> item, start, count, lastPos: 5 0 3 [ -1, -1, -1, 0, 1, -1, -1 ]
-> item, start, count, lastPos: 5 0 6 [ -1, -1, -1, 0, 1, 2, -1 ]
-> item, start, count, lastPos: 2 3 7 [ -1, -1, -1, 0, 1, 3, -1 ]
9

Code: 15:41:48 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        console.log('-> i, item, start, count, lastPos:', i, item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    console.log(count)
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.076 s

stdout:

[ -1, -1, -1, -1, -1, -1, -1 ]
-> i, item, start, count, lastPos: 0 3 0 0 [ -1, -1, -1, -1, -1, -1, -1 ]
-> i, item, start, count, lastPos: 1 4 0 1 [ -1, -1, -1, 0, -1, -1, -1 ]
-> i, item, start, count, lastPos: 2 5 0 3 [ -1, -1, -1, 0, 1, -1, -1 ]
-> i, item, start, count, lastPos: 3 5 0 6 [ -1, -1, -1, 0, 1, 2, -1 ]
-> i, item, start, count, lastPos: 4 2 3 7 [ -1, -1, -1, 0, 1, 3, -1 ]
9

Code: 15:42: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 31 32

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        // console.log('-> i, item, start, count, lastPos:', i, item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    console.log(count)
    return count > LIMIT ? LIMIT : count;
}

Code: 15:42: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 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(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    console.log(lastPos);
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        // console.log('-> i, item, start, count, lastPos:', i, item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

stdout:

[ -1, -1, -1, -1, -1, -1, -1 ]

Code: 15:42:55 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        // console.log('-> i, item, start, count, lastPos:', i, item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.068 s

Code: 15:43:17 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        // console.log('-> i, item, start, count, lastPos:', i, item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.076 s

Code: 15:43:34 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        // console.log('-> i, item, start, count, lastPos:', i, item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.068 s

Code: 15:43:36 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

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

function solution(M, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    if (M < 1 || A.length < 2) {
        return 1;
    }
    
    const LIMIT = 1000000000;
    let count = 0;
    let start  = 0;
    let lastPos = [];
    
    for (let i = 0; i <= M; i++) {
        lastPos[i] = -1;
    }
    
    for (let i = 0; i < A.length && count <= LIMIT; i++) {
        const item = A[i];
        // console.log('-> i, item, start, count, lastPos:', i, item, start, count, lastPos)
        
        if (lastPos[item] + 1 > start) {
            start = lastPos[item] + 1;
        }
        lastPos[item] = i;
        count += i - start + 1;
    }
    
    return count > LIMIT ? LIMIT : count;
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N)

expand all Example tests

▶

example
example test

✔

0.068 s

expand all Correctness tests

▶

single
single element

✔

0.068 s

0.072 s

▶

double
double elements

✔

0.076 s

▶

simple1
first simple test

✔

0.072 s

▶

simple2
second simple test

✔

0.068 s

▶

small_random
small random test, length = 100

✔

0.072 s

expand all Performance tests

▶

medium_random
medium random test, length = 500

✔

0.072 s

▶

large
large tests, length = ~100,000

✔

0.104 s

▶

large_range
large range tests, length = ~100,000

✔

0.116 s

0.096 s

▶

large_random
large random tests, length = ~100,000

✔

0.116 s

0.108 s

▶

extreme_the_same
all the same elements, length = ~100,000

✔

0.100 s

0.116 s