Test results - Codility

Tasks Details

medium

1. CountDiv

Compute number of integers divisible by k in range [a..b].

Task Score

100%

Correctness

100%

Performance

100%

Write a function:

int solution(int A, int B, int K);

that, given three integers A, B and K, returns the number of integers within the range [A..B] that are divisible by K, i.e.:

{ i : A ≤ i ≤ B, i mod K = 0 }

For example, for A = 6, B = 11 and K = 2, your function should return 3, because there are three numbers divisible by 2 within the range [6..11], namely 6, 8 and 10.

Write an efficient algorithm for the following assumptions:

A and B are integers within the range [0..2,000,000,000];

K is an integer within the range [1..2,000,000,000];

A ≤ B.

Solution

Programming language used C++

Time spent on task 2 minutes

Notes

not defined yet

Code: 07:28:32 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, int K) {
        // write your code in Java SE 8
    }
}

Code: 07:28:43 UTC, cpp, 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 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <iostream>
using namespace std;

int solution(int A, int B, int K) {
    // write your code in C++14 (g++ 6.2.0)

    int answer = 0;

    //A가 0일 경우
    if(A == 0){
        if(B!= 0){
            int width = B - 0;
            answer = width / K;
            return answer;
        }else{
            return 0;
        }
    }

    //A보다 크거나 같고 가장 작은 K의 배수를 구하기 위해서
    int check_first = A%K;
    if(check_first == 0){
        int width = B-A;
        answer = width / K + 1;
    }else{
        
        //A가 K보다 클경우 작을 경우로 분류
        if(A>K){
            //더 추가해하는 수는
            int must_plus = K - check_first;
            if(A+must_plus > B) return 0;
            else{
                int width = B - (A+must_plus);
                answer = width / K + 1;
            }
        }else{
            if(K > B) return 0;
            else{
                int width = B - K;
                answer = width / K + 1;
            }
        }
    }

    return answer;
}

Code: 07:28:58 UTC, cpp, 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 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <iostream>
using namespace std;

int solution(int A, int B, int K) {
    // write your code in C++14 (g++ 6.2.0)

    int answer = 0;

    //A가 0일 경우
    if(A == 0){
        if(B!= 0){
            int width = B - 0;
            answer = width / K;
            return answer;
        }else{
            return 1;
        }
    }

    //A보다 크거나 같고 가장 작은 K의 배수를 구하기 위해서
    int check_first = A%K;
    if(check_first == 0){
        int width = B-A;
        answer = width / K + 1;
    }else{
        
        //A가 K보다 클경우 작을 경우로 분류
        if(A>K){
            //더 추가해하는 수는
            int must_plus = K - check_first;
            if(A+must_plus > B) return 0;
            else{
                int width = B - (A+must_plus);
                answer = width / K + 1;
            }
        }else{
            if(K > B) return 0;
            else{
                int width = B - K;
                answer = width / K + 1;
            }
        }
    }

    return answer;
}

Code: 07:29:11 UTC, cpp, 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 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <iostream>
using namespace std;

int solution(int A, int B, int K) {
    // write your code in C++14 (g++ 6.2.0)

    int answer = 0;

    //A가 0일 경우
    if(A == 0){
        if(B!= 0){
            int width = B - 0;
            answer = width / K;
            return answer + 1;
        }else{
            return 1;
        }
    }

    //A보다 크거나 같고 가장 작은 K의 배수를 구하기 위해서
    int check_first = A%K;
    if(check_first == 0){
        int width = B-A;
        answer = width / K + 1;
    }else{
        
        //A가 K보다 클경우 작을 경우로 분류
        if(A>K){
            //더 추가해하는 수는
            int must_plus = K - check_first;
            if(A+must_plus > B) return 0;
            else{
                int width = B - (A+must_plus);
                answer = width / K + 1;
            }
        }else{
            if(K > B) return 0;
            else{
                int width = B - K;
                answer = width / K + 1;
            }
        }
    }

    return answer;
}

Code: 07:29:21 UTC, cpp, 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 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <iostream>
using namespace std;

int solution(int A, int B, int K) {
    // write your code in C++14 (g++ 6.2.0)

    int answer = 0;

    //A가 0일 경우
    if(A == 0){
        if(B!= 0){
            int width = B - 0;
            answer = width / K;
            return answer + 1;
        }else{
            return 1;
        }
    }

    //A보다 크거나 같고 가장 작은 K의 배수를 구하기 위해서
    int check_first = A%K;
    if(check_first == 0){
        int width = B-A;
        answer = width / K + 1;
    }else{
        
        //A가 K보다 클경우 작을 경우로 분류
        if(A>K){
            //더 추가해하는 수는
            int must_plus = K - check_first;
            if(A+must_plus > B) return 0;
            else{
                int width = B - (A+must_plus);
                answer = width / K + 1;
            }
        }else{
            if(K > B) return 0;
            else{
                int width = B - K;
                answer = width / K + 1;
            }
        }
    }

    return answer;
}

Analysis

expand all Example tests

▶

example
A = 6, B = 11, K = 2

✔

0.001 s

Code: 07:29:30 UTC, cpp, 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 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <iostream>
using namespace std;

int solution(int A, int B, int K) {
    // write your code in C++14 (g++ 6.2.0)

    int answer = 0;

    //A가 0일 경우
    if(A == 0){
        if(B!= 0){
            int width = B - 0;
            answer = width / K;
            return answer + 1;
        }else{
            return 1;
        }
    }

    //A보다 크거나 같고 가장 작은 K의 배수를 구하기 위해서
    int check_first = A%K;
    if(check_first == 0){
        int width = B-A;
        answer = width / K + 1;
    }else{
        
        //A가 K보다 클경우 작을 경우로 분류
        if(A>K){
            //더 추가해하는 수는
            int must_plus = K - check_first;
            if(A+must_plus > B) return 0;
            else{
                int width = B - (A+must_plus);
                answer = width / K + 1;
            }
        }else{
            if(K > B) return 0;
            else{
                int width = B - K;
                answer = width / K + 1;
            }
        }
    }

    return answer;
}

Analysis

expand all Example tests

▶

example
A = 6, B = 11, K = 2

✔

0.001 s

Code: 07:29:33 UTC, cpp, 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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <iostream>
using namespace std;

int solution(int A, int B, int K) {
    // write your code in C++14 (g++ 6.2.0)

    int answer = 0;

    //A가 0일 경우
    if(A == 0){
        if(B!= 0){
            int width = B - 0;
            answer = width / K;
            return answer + 1;
        }else{
            return 1;
        }
    }

    //A보다 크거나 같고 가장 작은 K의 배수를 구하기 위해서
    int check_first = A%K;
    if(check_first == 0){
        int width = B-A;
        answer = width / K + 1;
    }else{
        
        //A가 K보다 클경우 작을 경우로 분류
        if(A>K){
            //더 추가해하는 수는
            int must_plus = K - check_first;
            if(A+must_plus > B) return 0;
            else{
                int width = B - (A+must_plus);
                answer = width / K + 1;
            }
        }else{
            if(K > B) return 0;
            else{
                int width = B - K;
                answer = width / K + 1;
            }
        }
    }

    return answer;
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(1)

expand all Example tests

▶

example
A = 6, B = 11, K = 2

✔

0.001 s

expand all Correctness tests

▶

simple
A = 11, B = 345, K = 17

✔

0.001 s

▶

minimal
A = B in {0,1}, K = 11

✔

0.001 s

▶

extreme_ifempty
A = 10, B = 10, K in {5,7,20}

✔

0.001 s

▶

extreme_endpoints
verify handling of range endpoints, multiple runs

✔

0.001 s

expand all Performance tests

▶

big_values
A = 100, B=123M+, K=2

✔

0.001 s

▶

big_values2
A = 101, B = 123M+, K = 10K

✔

0.001 s

▶

big_values3
A = 0, B = MAXINT, K in {1,MAXINT}

✔

0.001 s

▶

big_values4
A, B, K in {1,MAXINT}

✔

0.001 s