Your browser (Unknown 0) is no longer supported. Some parts of the website may not work correctly. Please update your browser.

AVAILABLE EXERCISES:

Exercise 9

Bitwise operations (bit-ops)

Exercise 8

Frontend

Exercise 7

Data Structures

Exercise 6

SQL

Exercise 5

Coding skills

Exercise 4

Algorithmic skills

Exercise 3

2017 Contest

Exercise 2

2016 Contest

Exercise 1

2015 Contest

Find the first unique number in a given sequence.

Spoken language:

A non-empty array A consisting of N integers is given. The *unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

You should find the first unique number in A. In other words, find the unique number with the lowest position in A.

For above example, 5 is in second position (because A[2] = 5) and 2 is in fourth position (because A[4] = 2). So, the first unique number is 5.

Write a function:

int solution(int A[], int N);

that, given a non-empty array A of N integers, returns the first unique number in A. The function should return −1 if there are no unique numbers in A.

For example, given:

the function should return 4. There are two unique numbers (4 and 2 occur exactly once). The first one is 4 in position 1 and the second one is 2 in position 5. The function should return 4 bacause it is unique number with the lowest position.

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

A non-empty array A consisting of N integers is given. The *unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

You should find the first unique number in A. In other words, find the unique number with the lowest position in A.

For above example, 5 is in second position (because A[2] = 5) and 2 is in fourth position (because A[4] = 2). So, the first unique number is 5.

Write a function:

int solution(vector<int> &A);

that, given a non-empty array A of N integers, returns the first unique number in A. The function should return −1 if there are no unique numbers in A.

For example, given:

the function should return 4. There are two unique numbers (4 and 2 occur exactly once). The first one is 4 in position 1 and the second one is 2 in position 5. The function should return 4 bacause it is unique number with the lowest position.

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

A non-empty array A consisting of N integers is given. The *unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

You should find the first unique number in A. In other words, find the unique number with the lowest position in A.

For above example, 5 is in second position (because A[2] = 5) and 2 is in fourth position (because A[4] = 2). So, the first unique number is 5.

Write a function:

int solution(vector<int> &A);

that, given a non-empty array A of N integers, returns the first unique number in A. The function should return −1 if there are no unique numbers in A.

For example, given:

the function should return 4. There are two unique numbers (4 and 2 occur exactly once). The first one is 4 in position 1 and the second one is 2 in position 5. The function should return 4 bacause it is unique number with the lowest position.

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

class Solution { public int solution(int[] A); }

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

int solution(List<int> A);

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

func Solution(A []int) int

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

class Solution { public int solution(int[] A); }

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

class Solution { public int solution(int[] A); }

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

function solution(A);

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

fun solution(A: IntArray): Int

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

function solution(A)

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

Note: All arrays in this task are zero-indexed, unlike the common Lua convention. You can use `#A` to get the length of the array A.

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

int solution(NSMutableArray *A);

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

function solution(A: array of longint; N: longint): longint;

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

function solution($A);

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

sub solution { my (@A) = @_; ... }

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

def solution(A)

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

def solution(a)

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

object Solution { def solution(a: Array[Int]): Int }

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

public func solution(_ A : inout [Int]) -> Int

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

function solution(A: number[]): number;

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].

*unique number* is the number that occurs exactly once in array A.

For example, the following array A:

contains two unique numbers (5 and 2).

Write a function:

Private Function solution(A As Integer()) As Integer

For example, given:

Given array A such that:

the function should return −1. There is no unique number in A (4 and 6 occur more than once).

Write an ** efficient** algorithm for the following assumptions:

- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..1,000,000,000].