这对我来说很管用，但我并没有试图处理消极的东西

public static int roundUp(int numToRound, int multiple) {
    if (multiple == 0) {
        return 0;
    } else if (numToRound % multiple == 0) {
    return numToRound;
    }

    int mod = numToRound % multiple;
    int diff = multiple - mod;
    return numToRound + diff;
}

我发现了一个算法，有点类似于上面发布的:

Int [(|x|+n-1)/n]*[(nx)/|x|]，其中x是用户输入的值，n是使用的倍数。

它适用于所有值x，其中x是整数(正或负，包括零)。我专门为c++程序编写了它，但基本上可以在任何语言中实现。

首先，错误条件(multiple == 0)应该有一个返回值。什么?我不知道。也许您想要抛出一个异常，这取决于您。但是，什么都不返回是危险的。

其次，您应该检查numToRound是否已经是一个倍数。否则，当您在roundDown中添加倍数时，您将得到错误的答案。

第三，你的角色选择是错误的。您将numToRound转换为一个整数，但它已经是一个整数。需要在除法之前强制转换为to double，在乘法之后强制转换回int。

最后，负数需要什么?舍入“向上”可以表示舍入到零(与正数方向相同)，或远离零(一个“更大”的负数)。或者，也许你不在乎。

以下是前三个修复的版本，但我不处理负面问题:

int roundUp(int numToRound, int multiple)
{
 if(multiple == 0)
 {
  return 0;
 }
 else if(numToRound % multiple == 0)
 {
  return numToRound
 }

 int roundDown = (int) (( (double) numToRound / multiple ) * multiple);
 int roundUp = roundDown + multiple; 
 int roundCalc = roundUp;
 return (roundCalc);
}

int roundUp(int numToRound, int multiple)
{
 if(multiple == 0)
 {
  return 0;
 }
 return ((numToRound - 1) / multiple + 1) * multiple;  
}

没有必要在条件上添乱

总是四舍五入

int alwaysRoundUp(int n, int multiple)
{
    if (n % multiple != 0) {
        n = ((n + multiple) / multiple) * multiple;

        // Another way
        //n = n - n % multiple + multiple;
    }

    return n;
}

一生(1,10)-> 10

一生(5,10)-> 10

-> 10 -> 10

总是四舍五入

int alwaysRoundDown(int n, int multiple)
{
    n = (n / multiple) * multiple;

    return n;
}

一直循环(1,10)-> 0

一直循环(5、10)-> 0

一直循环(10,10)-> 10

以正常的方式圆

int normalRound(int n, int multiple)
{
    n = ((n + multiple/2)/multiple) * multiple;

    return n;
}

正常回合（1， 10） -> 0

normalRound(5、10)-> 10

normalRound(10,10) -> 10

这是对“如何求出n位需要多少字节?”(A:(n位+ 7)/ 8)。

int RoundUp(int n, int roundTo)
{
    // fails on negative?  What does that mean?
    if (roundTo == 0) return 0;
    return ((n + roundTo - 1) / roundTo) * roundTo; // edit - fixed error
}