最近的可整除整数

Question

示例。

int a = 254;
int b = 25;

int c = (closest integer to `a` that is divisible by `b`)

如何找到整数 c？该示例的结果是 c = 250.

Answer 1

有两种情况需要考虑：

小于或等于a的最接近整数：
```
int c1 = a - (a % b);
```
大于a的最接近整数：
```
int c2 = (a + b) - (a % b);
```

然后我们需要检查哪个更接近 a 和 return 即：

int c;
if (a - c1 > c2 - a) {
    c = c2;
} else {
    c = c1;
}

所以我们可以像这样创建一个 closestInteger() 方法：

static int closestInteger(int a, int b) {
    int c1 = a - (a % b);
    int c2 = (a + b) - (a % b);
    if (a - c1 > c2 - a) {
        return c2;
    } else {
        return c1;
    }
}

示例：

System.out.println(closestInteger(254, 25));
System.out.println(closestInteger(9, 5));

输出：

250
10

Answer 2

最接近以下： int c = (a/b)*b;

因为a和b都是int。除法 a/b 将截断到最接近的值 (10)。然后将结果乘以 b 将给出您要查找的结果。

或

最接近的两种方式：

int c = Math.round((float)a/b))*b;

由于 a 被转换为 float，答案将是 float，并且四舍五入到最接近的 int。

Answer 3

你必须检查a的两边。因此，我们将 'c1' 设置为最接近（或等于）a 的整数，并将 c2 设置为其最接近的整数。然后比较差异。如果c1更接近a，设置c为c1，否则c2.

int c1 = a - (a % b);
int c2 = c1 + b;
int c = a - c1 < c2 - a ? c1 : c2;

Answer 4

如果您不介意在出现平局时转到下一个最高整数（例如，最接近 6 的整数是 4 的倍数变为 8 而不是 4），那么您可以使用这个简单的公式。无需比较。

int c = (a + b/2)/b * b;  // closest integer to `a` that is divisible by `b`

所有计算均使用整数算法完成（舍弃分数）。

Answer 5

static void checkDivisibility(int i,int j) {
    int mod = i % j;
    if (mod == 0) {
        System.out.println(i+ " is divisible by 13 ");

    } else {
        if (mod >= 7) {
            i = (i + (j - mod));
        } else {
            i = i - mod;
        }
        System.out.println(i+" is the nearest divisible ");
    }
}

调用此方法：checkDivisibility(40,13); 输出：39 是最接近的整除数

Answer 6

壁橱数量少于一个 int c1 = a - (a % b);
壁橱数量大于 int c2 = a + (b - (a%b))

现在比较一下哪个跟a的区别小

int d1 = a - c1;

int d2 = c2 - a;

if(d1 > d2)//最接近的数是c2

else //最接近的数字是c1

Answer 7

var nums = [0, 9, 26, 39];
for (var i=0 ; i<nums.length;i++){
    const mod = nums[i]%3;
    if(mod!=0){
        console.log("Closest Multiple: "+(3*Math.round(nums[i]/3)))
    }else{
        console.log("Closest multiple: "+nums[i])
    }
}

最近的可整除整数

Closest divisible integer

java

math