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:22:27 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:22:32 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:22:50 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) {
    const N = A.length;
}

Code: 15:23:37 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(M, A) {
    const N = A.length;

    co
}

Code: 15:24:07 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(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    for (let i = 0; i < N; i++) {
        
    }

    return count;
}

Code: 15:24:37 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(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let start = 0;
    let end = 1;
    for (let i = 0; i < N; i++) {
        
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let start = 0;
    let end = 0;
    const currentSet = new Set
    for (let i = 0; i < N; i++) {
        
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let start = 0;
    let end = 0;
    const currentSet = new Set();

    for (let i = 0; i < N; i++) {
        if (currentSet.)
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let start = 0;
    let end = 0;
    const currentSet = new Set();

    for (let i = 0; i < N; i++) {
        if (currentSet.has(A[i])) {
            
        }
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let start = 0;
    let end = 0;
    const currentSet = new Set();

    for (let i = 0; i < N; i++) {
        while (currentSet.has(A[i])) {
            
        }
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const currentSet = new Set();

    for (let i = 0; i < N; i++) {
        while (currentSet.has(A[i])) {
            left++;
        }
    }

    return count;
}

Code: 15: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 18 19 20 21 22

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const currentSet = new Set();

    for (let i = 0; i < N; i++) {
        while (currentSet.has(A[i])) {
            left++;
            
        }
    }

    return count;
}

Code: 15:27: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 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const currentSet = new Set();

    for (let i = 0; i < N; i++) {
        while (currentSet.has(A[i])) {
            currentSet.delete(A[left]);
            left++;
        }

        currentSet.add(A[i]);
    }

    return count;
}

Code: 15:28:59 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const currentSet = new Set();

    while
        while (currentSet.has(A[i])) {
            currentSet.delete(A[left]);
            left++;
        }

        currentSet.add(A[i]);
    }

    return count;
}

Code: 15:29:09 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const currentSet = new Set();

    while (left < N && right < N)
        while (currentSet.has(A[i])) {
            currentSet.delete(A[left]);
            left++;
        }

        currentSet.add(A[i]);
    }

    return count;
}

Code: 15:29: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 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const currentSet = new Set();

    while (left < N && right < N) {
        while (currentSet.has(A[i])) {
            currentSet.delete(A[left]);
            left++;
        }

        currentSet.add(A[i]);
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        while (seen.has(A[i])) {
            seen.delete(A[left]);
            left++;
        }

        seen.add(A[i]);
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen)

        seen.add(A[i]);
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[i])) {
            
        }

        seen.add(A[i]);
    }

    return count;
}

Code: 15:30:48 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[i])) {
            seen.delete(A[left]);
            left++;
        } else {
            
        }

        seen.add(A[i]);
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[left])) {
            seen.delete(A[left]);
            left++;
        } else {
            seen.add(A[i]);

        }
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            seen.add(A[right]);
            right++;

            count += 
        }
    }

    return count;
}

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

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

function solution(M, A) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            seen.add(A[right]);
            right++;

            count += right - left + 1;
        }
    }

    return count;
}

Code: 15:31: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 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            seen.add(A[right]);
            right++;

            count += right - left + 1;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 19 expected 9

0.072 s

WRONG ANSWER, got 19 expected 9

Code: 15:32:13 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            seen.add(A[right]);
            right++;

            count += right - left + 1;
        }

        if (count > 1_000000000) {
            return 1000000000;
        }
    }

    return count;
}

Code: 15:32:17 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            seen.add(A[right]);
            right++;

            count += right - left + 1;
        }

        if (count > 1_000_000_000) {
            return 1000000000;
        }
    }

    return 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:

solution.js:25
        if (count > 1_000_000_000) {
                    ^

SyntaxError: Invalid or unexpected token
    at createScript (vm.js:80:10)
    at Object.runInNewContext (vm.js:135:10)
    at getSolution (/tmp/exec.js:394:29)
    at Promise.resolve.then (/tmp/exec.js:428: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: 15:32:23 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            seen.add(A[right]);
            right++;

            count += right - left + 1;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

Code: 15:33:17 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            seen.add(A[right]);
            right++;

            
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

Code: 15:33: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 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            count += right - left + 1;

            seen.add(A[right]);
            right++;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 14 expected 9

0.072 s

WRONG ANSWER, got 14 expected 9

Code: 15:33:31 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            count += right - left;

            seen.add(A[right]);
            right++;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

Analysis

expand all Example tests

▶

example
example test

✔

0.068 s

Code: 15:34: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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            count += right - left;

            seen.add(A[right]);
            right++;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

Code: 15:34:27 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            count += right - left;

            seen.add(A[right]);
            right++;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

User test case 1:

[9, [3, 4, 5, 5, 2]]

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

expand all User tests

▶

test_data1

✔

0.068 s

OK
function result: 9

Code: 15:34:44 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            count += right - left;

            seen.add(A[right]);
            right++;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

User test case 1:

[6, [3, 4, 5, 5, 2]]

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

expand all User tests

▶

test_data1

✔

0.068 s

OK
function result: 9

Code: 15:34: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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            count += right - left;

            seen.add(A[right]);
            right++;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

User test case 1:

[6, [3, 4, 5, 5, 2]]

User test case 2:

[10, [1, 2, 3, 4, 5, 6, 2, 8, 6, 7]]

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

expand all User tests

▶

test_data1

✔

0.072 s

OK
function result: 9

▶

test_data2

✔

0.072 s

OK
function result: 39

Code: 15:35: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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            count += right - left;

            seen.add(A[right]);
            right++;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

User test case 1:

[6, [3, 4, 5, 5, 2]]

User test case 2:

[10, [1, 2, 3, 4, 5, 6, 2, 8, 6, 7]]

Analysis

expand all Example tests

▶

example
example test

✔

0.076 s

expand all User tests

▶

test_data1

✔

0.076 s

OK
function result: 9

▶

test_data2

✔

0.076 s

OK
function result: 39

Code: 15:35:20 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            count += right - left;

            seen.add(A[right]);
            right++;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

User test case 1:

[6, [3, 4, 5, 5, 2]]

User test case 2:

[10, [1, 2, 3, 4, 5, 6, 2, 8, 6, 7]]

Analysis

expand all Example tests

▶

example
example test

✔

0.072 s

expand all User tests

▶

test_data1

✔

0.072 s

OK
function result: 9

▶

test_data2

✔

0.072 s

OK
function result: 39

Code: 15:35:22 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) {
    const N = A.length;

    // individual elements
    let count = N;

    let left = 0;
    let right = 0;
    const seen = new Set();

    while (left < N && right < N) {
        if (seen.has(A[right])) {
            seen.delete(A[left]);
            left++;
        } else {
            count += right - left;

            seen.add(A[right]);
            right++;
        }

        if (count > 1000000000) {
            return 1000000000;
        }
    }

    return count;
}

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

▶

single
single element

✔

0.068 s

▶

double
double elements

✔

0.068 s

▶

simple1
first simple test

✔

0.068 s

▶

simple2
second simple test

✔

0.068 s

▶

small_random
small random test, length = 100

✔

0.068 s

expand all Performance tests

▶

medium_random
medium random test, length = 500

✔

0.072 s

▶

large
large tests, length = ~100,000

✔

0.128 s

0.140 s

▶

large_range
large range tests, length = ~100,000

✔

0.124 s

0.108 s

▶

large_random
large random tests, length = ~100,000

✔

0.140 s

0.136 s

▶

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

✔

0.132 s

0.140 s