给定范围 x, y。我需要计算两者之间的所有数字并且可以被 n 整除。
我知道做到这一点的简单方法是循环整个范围
for(int i=x;i<=y;i++) if(i%n ==0) counter++;
计数器保存答案。
但这在大范围内工作得非常慢。例如 x=0 和 y=3,000,000,000。
我确信有一些关系可以用来减少迭代次数并优化此代码以提高速度。我搜索了但我找不到它。谁能帮帮我。
非常感谢。
【问题讨论】：
这有效：(e+1 - s) / d + (e%d < (s+d-1)%d)。 （它使用 C 语义和整数运算，并假设开始是非负的。s 是开始值，e 是结束值 [包括]，d 是除数。）
更新：更好的解决方案是e/d - (s-1)/d。这是受 User448810 启发的。这要求 s 是积极的；处理零或负 s（或 e）需要调整向零的截断（对于这个问题，我们希望向负无穷大）。
负值更新：以下适用于 s 和 e 在其类型范围内的任何值，前提是 s
e = e < 0 ? (e+1)/d - 1 : e/d;
s = s <= 0 ? s/d - 1 : (s-1)/d;
return e-s;
基本上，前两个语句等价于 e = e/d 和 s = (s-1)/d，除法被修改为向 -infinity 舍入而不是向零舍入（因此 -1/10 产生 -1 而不是 0）。
【讨论】：
(e+1 - s)/d，每个完整的循环恰好包含一个余数为零的数字（这意味着该数字是 d 的倍数）。所以我们知道整个周期有那么多倍数，我们只需要弄清楚剩下的部分周期是零还是一。 [在下一条评论中继续。]
e%d) 的余数是否小于 s 的余数？如果是这样，我们就四处走动，因为这就是您从高残留到低残留的方式。但是，我们还必须考虑 s 为零的情况，在这种情况下，我们从倍数开始，不需要绕行。 [继续。]
(floor)(high/d) - (floor)(low/d) - (high%d==0)
说明：
从 0 到 a 有可被 d 整除的 a/d 数。 (d!=0)
因此 (floor)(high/d) - (floor)(low/d) 将给出可在 (low,high] 范围内整除的数字（请注意，不包括低，而高包括在此范围内）
现在要从范围中删除高位，只需减去 (high%d==0)
对浮点数使用 fmodf。
【讨论】：
只有这个实现对我有用（[0..2kkk] 中的 A、B；[1..2kkk] 中的 K）：
function solution(A, B, K) {
if(B < K) return A === 0 ? 1 : 0;
if(A === B) return A % K === 0 ? 1 : 0;
var pre = A === 0 ? 2 : 1;
var min = A < K ? K : A + A % K;
var max = B - B % K;
return (max - min) / K + pre;
}
【讨论】：
您可以尝试，而不是遍历每个数字，
public int test(int floor, int ceil, int n) {
int a = (floor / n) + 1;
int counter = 0;
while (a * n <= ceil) {
counter++;
a++;
}
return counter;
}
并且只使用除数的倍数。现在您不是在重复除法（慢），而是在重复乘法（更快）。
【讨论】：
a * d <= y 而不是 a * x <= ，但对于 (1, 1, 2) 仍然失败；它返回一个。
我很确定你可以做到这一点：
public static int numDivisible(int low, int high, int test) {
return (high-low)/test;
}
给你。一个恒定时间的解决方案。由于您不需要确切知道哪些数是可整除的，因此您无需费心遍历所有数。
编辑：根据@Chaser324 将其更改为以下内容。
public static float numDivisible(float low, float high, float test) {
return Math.ceil((high-low)/test);
}
编辑：一个小错字，即将text 更改为test
【讨论】：
test 整除，我想你可以通过计算在该范围内有多少数字可以被test 整除。显然我一开始是不对的，但这个想法是可能的。
您要求计算 x 和 y（x 和 y 都包含在范围内）之间可以被 n 整除的整数个数。不需要任何循环，只需要两个除法来计算答案。让我们考虑一个简单的例子：对于 100 到 200 的范围，有多少个整数可以被 7 整除？
从范围的低端开始：100 / 7 = 14，余数为 2。现在除数 7 减去余数 2 为 5，因此可被 7 整除的最小数为 100 + 5 = 105。
现在转到范围的高端：200 / 7 = 28，余数为 4，因此范围内可被 7 整除的最大数是 200 - 4 = 196。
因此，范围内能被 7 整除的数字是 105、112、119、126、133、140、147、154、161、168、175、182、189 和 196。其中有 14 个，您可以通过几种方式计算。取两端的商并减去它们：28 - 14 = 14。或者取两个端点的差，除以除数，然后加1：196 - 105 = 91, 91 / 7 = 13, 13 + 1 = 14. 但是当端点之一可以被除数整除时要小心；我将把它留给你来解决细节，并编写程序。
【讨论】：
请提供以下算法的cmets：假设范围为[R1，R2]，待除数为n。
从 R1 开始，找出能被 n 整除的最小数。称它为小数。
从 R2 开始，找出能被 n 整除的最大数。称它为大。
可整除的总数=（大-小）/n + 1。
最坏的情况仍然是 O(n)，但对于 R1 和 R2 之间的巨大差异可能是有效的。希望我已经涵盖了所有情况。请建议。
int numofDivisible(int R1, int R2, int n) {
int small = R1, large= R2;
if ((R1 > R2) || (n==0)) return 0;
if (R1 == R2) {
if (R1 % n == 0)
return 1;
else
return 0;
}
while(small <= R2){
if(small % n == 0)
break;
++small;
}
if (small > R2)
return 0;
while (large > small) {
if (large % n == 0)
break;
--large;
}
if (large == small)
return 1;
return ((large-small)/n + 1);
}
【讨论】：
public static int solution(int low,int high, int n) {
boolean h0=high%n==0;
boolean l0=low%n==0;
int k1=l0?low/n:(low+n-low%n)/n;
int k2=h0?high/n:(high+n-high%n)/n;
// |-----------|
// ---------------k1----------k2---------------
if(k2*n>high) k2--;
return k2-k1+1;
}
【讨论】：
public int myfunc(int low, int high, int test) {
int count = 0;
if(low % test == 0)
count++;
count +=(high-low)/test;
return count;
}
【讨论】：
好吧，我不是大学教授，所以我没有给你一些惊人的公式，但据我所知，检查这样的数字列表的唯一方法是遍历它们，在最后，您将不得不评估变量以检查它是否可整，现在有一种方法可以优化您的算法，首先对数字进行排序！这最初会很昂贵，但任何后续需要检查数字都会快得多，
我建议查看排序算法，我会使用冒泡排序，它会在 google 上出现很多。
至于您可以对排序做什么，您可以将数字排序为倍数列表，例如 2 4 6 8 都是 2 的倍数，因此您基本上可以检查列表中的第一个，其余的将是立即知道也可整除
请记住，这样做可能有更有效的方法，只需提供我的 2 美分
【讨论】：
R1, R1+1, R1+2, ... , R2-2, R2-1, R2。你在分类什么？