Test results - Codility

Tasks Details

medium

1. RectanglesStrip

From a given set choose as many rectangles with a common side as possible.

Task Score

100%

Correctness

100%

Performance

100%

There are N rectangles numbered from 0 to N-1. The K-th rectangle has size A[K] × B[K].

We want to arrange as many rectangles as possible into a strip. The rectangles can be arranged into a strip if they all share a side of the same length (which becomes the height of the strip). Note that rectangles can be rotated.

Write a function:

def solution(A, B)

that, given two arrays A and B of N integers each, returns the maximum number of rectangles that can be arranged into a strip.

Examples:

1. Given A = [2, 3, 2, 3, 5] and B = [3, 4, 2, 4, 2], the function should return 3. Choosing the 0th, 2nd and 4th rectangles we can obtain the following strip of height 2 (note that the 0th rectangle was rotated):

(3 × 2), (2 × 2), (5 × 2)

We can also choose the 0th, 1st and 3rd rectangles to obtain a strip of height 3. Here we have rotated 1st and 3rd rectangles:

(2 × 3), (4 × 3), (4 × 3)

2. Given A = [2, 3, 1, 3] and B = [2, 3, 1, 3], the function should return 2. We can choose the 1st and 3rd rectangles:

(3 × 3), (3 × 3)

3. Given A = [2, 10, 4, 1, 4] and B = [4, 1, 2, 2, 5], the function should return 3. We can choose the 0th, 2nd and 4th rectangles to obtain a strip of height 4:

(2 × 4), (2 × 4), (5 × 4)

Write an efficient algorithm for the following assumptions:

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

arrays A and B both consist of N integers;

each element of arrays A and B is an integer within the range [1..1,000,000,000].

Solution

Programming language used Python

Time spent on task 7 minutes

Notes

not defined yet

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

Code: 14:50:42 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

def solution(A, B):
    results = {}
    #c = max (A+B)
    #results= [0]*(c+1)
    #print (results)

    for rectangle in range(len(A)):
        print (rectangle)
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
        #print (list(results.values()))
        #print (max(list(results.values())))
            
    return ((max(list(results.values()))))

Code: 14:50:52 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

def solution(A, B):
    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
        #print (list(results.values()))
        #print (max(list(results.values())))
            
    return ((max(list(results.values()))))

Code: 14:51:03 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

def solution(A, B):
    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:51:23 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

def solution(A, B):
    funct update_results()
    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:51:35 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

def solution(A, B):
    funct update_results(num)
    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:51:45 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13

def solution(A, B):
    funct update_results(number):
    
    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:51:56 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13

def solution(A, B):
    def update_results(number):
        
    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:52:25 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def solution(A, B):
    def update_results(number):
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1

    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:52:39 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def solution(A, B):
    def update_results(number):
        if not (number in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1

    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:52:59 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def solution(A, B):
    def update_results(number):
        if not (number in results): results[number]=1
            else: results[B[rectangle]]+=1

    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:53:13 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def solution(A, B):
    def update_results(number):
        if not (number in results): results[number]=1
            else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:53:19 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def solution(A, B):
    def update_results(number):
        if not (number in results): results[number]=1
            else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 139, in <module>
    main()
  File "exec.py", line 80, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 4
    else: results[number]+=1
    ^
IndentationError: unexpected indent

▶

example2
Second example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 139, in <module>
    main()
  File "exec.py", line 80, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 4
    else: results[number]+=1
    ^
IndentationError: unexpected indent

▶

example3
Third example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 139, in <module>
    main()
  File "exec.py", line 80, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 4
    else: results[number]+=1
    ^
IndentationError: unexpected indent

Code: 14:53:40 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def solution(A, B):
    results = {}

    def update_results(number):
        if not (number in results): results[number]=1
            else: results[number]+=1


    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 139, in <module>
    main()
  File "exec.py", line 80, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 6
    else: results[number]+=1
    ^
IndentationError: unexpected indent

▶

example2
Second example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 139, in <module>
    main()
  File "exec.py", line 80, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 6
    else: results[number]+=1
    ^
IndentationError: unexpected indent

▶

example3
Third example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.036 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 139, in <module>
    main()
  File "exec.py", line 80, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 6
    else: results[number]+=1
    ^
IndentationError: unexpected indent

Code: 14:53:47 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def solution(A, B):
    results = {}

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1


    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:53:49 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def solution(A, B):
    results = {}

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1


    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

Code: 14:53:59 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def solution(A, B):

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

Code: 14:54:24 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def solution(A, B):

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        #if not (A[rectangle] in results): results[A[rectangle]]=1
        else: results[A[rectangle]]+=1
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:54:51 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

def solution(A, B):

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        #if not (A[rectangle] in results): results[A[rectangle]]=1
        #else: results[A[rectangle]]+=1
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:54:51 UTC, py, 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

def solution(A, B):

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        #if not (A[rectangle] in results): results[A[rectangle]]=1
        #else: results[A[rectangle]]+=1
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            if not (B[rectangle] in results): results[B[rectangle]]=1
            else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

Code: 14:55:08 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

def solution(A, B):

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        #if not (A[rectangle] in results): results[A[rectangle]]=1
        #else: results[A[rectangle]]+=1
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            #if not (B[rectangle] in results): results[B[rectangle]]=1
            #else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:55:22 UTC, py, 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

def solution(A, B):

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        #if not (A[rectangle] in results): results[A[rectangle]]=1
        #else: results[A[rectangle]]+=1
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            update_results(A[rectangle])

            #if not (B[rectangle] in results): results[B[rectangle]]=1
            #else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Code: 14:55:28 UTC, py, 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

def solution(A, B):

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        #if not (A[rectangle] in results): results[A[rectangle]]=1
        #else: results[A[rectangle]]+=1
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            update_results(B[rectangle])

            #if not (B[rectangle] in results): results[B[rectangle]]=1
            #else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

Code: 14:55:38 UTC, py, 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

def solution(A, B):

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        #if not (A[rectangle] in results): results[A[rectangle]]=1
        #else: results[A[rectangle]]+=1
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            update_results(B[rectangle])

            #if not (B[rectangle] in results): results[B[rectangle]]=1
            #else: results[B[rectangle]]+=1
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

Code: 14:55:49 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def solution(A, B):

    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        #if not (A[rectangle] in results): results[A[rectangle]]=1
        #else: results[A[rectangle]]+=1
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            update_results(B[rectangle])
            
    return ((max(list(results.values()))))

Code: 14:56:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13

def solution(A, B):
    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}

    for rectangle in range(len(A)):
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            update_results(B[rectangle])
            
    return ((max(list(results.values()))))

Code: 14:56:09 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

def solution(A, B):
    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}
    for rectangle in range(len(A)):
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            update_results(B[rectangle])
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

Code: 14:56:30 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

def solution(A, B):
    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}
    for rectangle in range(len(A)):
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            update_results(B[rectangle])
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

Code: 14:56:35 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

def solution(A, B):
    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}
    for rectangle in range(len(A)):
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            update_results(B[rectangle])
            
    return ((max(list(results.values()))))

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

Code: 14:56:38 UTC, py, final, score: 100

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

def solution(A, B):
    def update_results(number):
        if not (number in results): results[number]=1
        else: results[number]+=1

    results = {}
    for rectangle in range(len(A)):
        update_results(A[rectangle])
        if A[rectangle]!=B[rectangle]: 
            update_results(B[rectangle])
            
    return ((max(list(results.values()))))

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N*log(N)) or O(N)

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all Correctness tests

▶

common_side_from_A
No rotations needed. Common side can be chosen from A. N = 15.

✔

0.036 s

▶

common_side_from_B
No rotations needed. Common side can be chosen from B. N = 15.

✔

0.036 s

▶

A_less_than_B
Array A contains shorter sides. N = 15.

✔

0.036 s

▶

A_greater_than_B
Array A contains longer sides. N = 15.

✔

0.036 s

▶

only_squares
All rectangles are squares. N = 15.

✔

0.036 s

▶

no_squares
Rectangles are not squares. N = 15.

✔

0.036 s

▶

anty_common_side
Height of the strip is not the most common element of A, the most common element of B or the most common element from both array. N = 15. Points x 2.

✔

0.036 s

expand all Correctness/performance tests

▶

corners
N <= 2.

✔

0.036 s

▶

medium_common_side_from_A
No rotations needed. Common side can be chosen from A. N = 200.

✔

0.036 s

▶

medium_common_side_from_B
No rotations needed. Common side can be chosen from B. N = 200.

✔

0.036 s

▶

medium_A_less_than_B
"Array A contains shorter sides. N = 200.

✔

0.036 s

▶

medium_A_greater_than_B
Array A contains longer sides. N = 200.

✔

0.036 s

▶

medium_only_squares
All rectangles are squares. N = 200.

✔

0.036 s

▶

medium_anty_common_side
Height of the strip is not the most common element of A, the most common element of B or the most common element from both array. N = 200. Points x 2.

✔

0.036 s

expand all Performance tests

▶

large_common_side_from_A
No rotations needed. Common side can be chosen from A. N = 100,000.

✔

0.300 s

0.296 s

▶

large_common_side_from_B
No rotations needed. Common side can be chosen from B. N = 100,000.

✔

0.296 s

0.300 s

0.296 s

▶

large_A_less_than_B
Array A contains shorter sides. N = 100,000.

✔

0.280 s

0.292 s

0.320 s

0.328 s

▶

large_A_greater_than_B
Array A contains longer sides. N = 100,000.

✔

0.304 s

0.300 s

0.312 s

▶

large_only_squares
All rectangles are squares. N = 100,000.

✔

0.316 s

0.300 s

▶

large_anty_common_side
Height of the strip is not the most common element of A, the most common element of B or the most common element from both array. Points x 2.

✔

0.300 s

0.312 s

0.300 s

0.296 s

0.268 s