Question

给定范围A..B和值K，返回范围内可被K整除的值的数量。

给出的例子是A = 6，B = 11和K = 2.在6到11的范围内，被2整除的数字是6,8和10，所以答案是3.所需的解决方案必须是O （1） - 所以需要进行简单的计算。

您可以假设A和B的范围为0..2,000,000,000，K为1..2,000,000,000且0 <= A <= B。

接受的解决方案，得分100％如下：

int solution(int A, int B, int K)
{
    int inclusive = ((A%K)==0) ? 1 : 0;
    return (B/K) - (A/K) + inclusive;
}

我感到困惑的是当我用输入A = 0，B = 0和K = 1测试这个解决方案时，结果是1？我原以为在0到0的范围内，可被1整除的值的数量是...... 0！

我认为这是一个错误，并且只有在A非零时才应设置A的包含值的+1。

所以我提交了以下解决方案（测试A非零）：

int solution(int A, int B, int K)
{
    int inclusive = (A && (A%K)==0) ? 1 : 0;
    return (B/K) - (A/K) + inclusive;
}

但这只得到了62％（50％的正确率和75％的表现）。它失败的一些测试用例是：

A = 0，B = 1，K = 11 - 得到0，预期为1
A = 0，B = MAXINT，K在{1，MAXINT}，得到2000000000，预计2000000001

有人可以解释一下吗？

Answer 1

对于允许的所有0，值K可被K整除（非零）。关于零没有什么特别之处。可分割的定义意味着分割后没有余数。

Answer 2

范围包含：0到0范围内有1个值：值0本身。所有值都可以被1整除，因此结果确实是1值。

请注意，建议的代码是多余的：

int inclusive = ((A%K)==0) ? 1 : 0;相当于int inclusive = (A%K)==0;。它可以进一步简化为int inclusive = !(A%K);，完整的解决方案变为单行：

int solution(int A, int B, int K) { return B/K - A/K + !(A%K); }

这是一个只有2个部门的变种：

int solution(int A, int B, int K) { return B/K - (A ? (A-1)/K : -1); }

Answer 3

这是分数为100/100的C ++解决方案

int solution(int A, int B, int K) {
    return B / K - A / K + (A % K == 0 ? 1 : 0);
}

它返回区间[0，B]中的倍数减去区间[0，A]中的倍数-得到区间（A，B]中的倍数，并在如果A是倍数，则为A。

Answer 4

就我而言，我做了以下数学运算：

（B-A）/ K +（A / K）

在与之前所述相同的情况下，由于一些愚蠢的输入（例如A = 0，B = 0等），所以+（A / K）非常棘手。然后，对于这些情况，我进行了处理，称之为调整。

有代码：

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代码100/100。

https://app.codility.com/demo/results/trainingS96J5R-NTC/

Answer 5

我在javascript中的解决方案

function solution (A, B, K) {
  if (B - A === 0 && B == 0) return 1;
  if (B - A === 0 && B > K && B % K === 0 ) return 1;
  if (B - A === 0 && B > K && B % K > 0 ) return 0;
  if (B < K) return 0;

  return Math.floor(B/K) - Math.floor((A - 1)/K);
}

更多此处https://github.com/mazeeblanke/codilityLessons

Answer 6

这是我的解决方法：

    function solution(A, B, K) {
        while (B % K > 0) {
            B--;
        }
        while (A % K > 0) {
            A++;
        }

        return (B-A)/K + 1;
}

Answer 7

我认为我的解决方案非常简单明了。 100/100

function solution(min, max, divider) {
  let minRemainder = min % divider;
  let minQuotient = Math.floor(min / divider);
  let maxQuotient = Math.floor(max / divider);
  const includeFirstNum = minRemainder === 0;
  const bonus = includeFirstNum ? 1 : 0;
  const res = maxQuotient - minQuotient + bonus;
  return res;
}

Answer 8

这是我的解决方案：


    import math
    def sol(A, B, K):
    #return ((B-(A-A%K))//K)
    return (math.floor (B/K)- math.ceil (A/K) +1)


sol(6,11,2)

不要理解Codility CountDiv解决方案是如何正确的

8 个答案: