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

Compute number of inversion in an array.

Spoken language:

An array A consisting of N integers is given. An *inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

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

An array A consisting of N integers is given. An *inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

int solution(vector<int> &A);

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

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

An array A consisting of N integers is given. An *inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

int solution(vector<int> &A);

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

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

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

int solution(List<int> A);

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

func Solution(A []int) int

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

function solution(A);

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

fun solution(A: IntArray): Int

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

function solution(A)

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

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.

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

int solution(NSMutableArray *A);

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

function solution($A);

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

def solution(A)

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

def solution(a)

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

*inversion* is a pair of indexes (P, Q) such that P < Q and A[Q] < A[P].

Write a function:

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

that computes the number of inversions in A, or returns −1 if it exceeds 1,000,000,000.

For example, in the following array:

there are four inversions:

so the function should return 4.

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

- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].