Don't understand how Codility CountDiv solution is correct - c

Question

Codility CountDiv Exercise:
Given a range A..B and value K, return the number of values in the range that are divisible by K.
The example given is A = 6, B = 11 and K = 2. In the range 6 to 11, the numbers divisible by 2 are 6, 8 and 10, so the answer is 3. The solution required must be O(1) - so a simple calculation is needed.
You can assume that A and B are in the range 0..2,000,000,000, K is 1..2,000,000,000 and that 0 <= A <= B.
The accepted solution, that scores 100% is as follows:
int solution(int A, int B, int K)
{
int inclusive = ((A%K)==0) ? 1 : 0;
return (B/K) - (A/K) + inclusive;
}
Where I get confused is that when I test this solution with inputs A=0, B=0 and K=1, the result is 1? I would have thought that in the range 0 to 0, the number of values divisible by 1 is... 0!
I thought this was an error and that the +1 for inclusive values of A should only be set if A is non-zero.
So I submitted the following solution (test that A is non-zero):
int solution(int A, int B, int K)
{
int inclusive = (A && (A%K)==0) ? 1 : 0;
return (B/K) - (A/K) + inclusive;
}
But this only scored 62% (50% correctness and 75% performance). Some of the test cases it failed were:
A = 0, B = 1, K = 11 - Got 0, expected 1
A = 0, B = MAXINT, K in {1,MAXINT}, got 2000000000, expected 2000000001
Can someone explain?

Answer 1

The value 0 is divisible by K for all K that are allowed (non zero). There is nothing special about zero. The definition of divisible means there is no remainder after dividing.

Answer 2

The range is inclusive: there is 1 value in the range 0 to 0: the value 0 itself. All values are divisible by 1, so the result is indeed 1 value.
Note that the proposed code is redundant:
int inclusive = ((A%K)==0) ? 1 : 0; is equivalent to int inclusive = (A%K)==0;. It can be further simplified as int inclusive = !(A%K); and the complete solution becomes a one-liner:
int solution(int A, int B, int K) { return B/K - A/K + !(A%K); }
And here is a variant with only 2 divisions:
int solution(int A, int B, int K) { return B/K - (A ? (A-1)/K : -1); }

Answer 3

Here is a C++ solution with 100/100 score
int solution(int A, int B, int K) {
return B / K - A / K + (A % K == 0 ? 1 : 0);
}
it returns the number of multiples in the interval [0, B] minus the number of multiples in the interval [0, A] - getting the number of multiples in the interval (A, B] - and adds the multiple in A if A is a multiple.

Answer 4

In my case, I just made the following math:
(B - A)/K + (A/K)
in same cases as explained before, this + (A/K) is very tricky because of some stupid inputs like A=0,B=0 etc. Then, for those cases, I made a treatment, and I'm calling it of adjustment.
There's the code:
class Solution {
public int solution(int startingFrom, int endingAt, int divisibleBy) {
double adjustment = startingFrom % divisibleBy == 0 || endingAt % divisibleBy == 0 ? 1 : ((double) startingFrom < divisibleBy) ? (double) startingFrom / divisibleBy : 0;
return (int) ( ((double) endingAt - startingFrom) / (divisibleBy) + adjustment);
}
}
Java code 100/100.
https://app.codility.com/demo/results/trainingS96J5R-NTC/