c# - 将整数四舍五入到最接近 10 的倍数

Question

我试图弄清楚如何四舍五入价格 - 两种方式。例如：

Round down
43 becomes 40
143 becomes 140
1433 becomes 1430

Round up
43 becomes 50
143 becomes 150
1433 becomes 1440

我有一个价格范围的情况：

£143 - £193

其中我想显示为：

£140 - £200

因为它看起来更干净

关于如何实现这一目标的任何想法？

Answer 1

我只想创建几个方法；

int RoundUp(int toRound)
{
     if (toRound % 10 == 0) return toRound;
     return (10 - toRound % 10) + toRound;
}

int RoundDown(int toRound)
{
    return toRound - toRound % 10;
}

模数给了我们余数，在四舍五入的情况下10 - r将您带到最接近的十分之一，向下四舍五入您只需减去 r。很直接。

Answer 2

您不需要使用模数 (%) 或浮点数...

这有效：

public static int RoundUp(int value)
{
    return 10*((value + 9)/10);
}

public static int RoundDown(int value)
{
    return 10*(value/10);
}

Answer 3

此代码四舍五入到最接近的 10 倍数：

int RoundNum(int num)
{
     int rem = num % 10;
     return rem >= 5 ? (num - rem + 10) : (num - rem);
}

非常简单的用法：

Console.WriteLine(RoundNum(143)); // prints 140
Console.WriteLine(RoundNum(193)); // prints 190

Answer 4

将数字除以 10。

number = number / 10;
Math.Ceiling(number);//round up
Math.Round(number);//round down

然后乘以 10。

number = number * 10;

Answer 5

将一个数字四舍五入为另一个数字的倍数的一般方法，从零四舍五入。

对于整数

int RoundNum(int num, int step)
{
    if (num >= 0)
        return ((num + (step / 2)) / step) * step;
    else
        return ((num - (step / 2)) / step) * step;
}

对于浮动

float RoundNum(float num, float step)
{
    if (num >= 0)
        return floor((num + step / 2) / step) * step;
    else
        return ceil((num - step / 2) / step) * step;
}

我知道有些部分可能看起来违反直觉或不是很优化。我尝试将 (num + step / 2) 转换为 int，但这对于负浮点数（(int) -12.0000 = -11等等）给出了错误的结果。无论如何，这些是我测试过的几个案例：

• 四舍五入到第 1 步的任何数字都应该是它自己
• -3 四舍五入到第 2 步 = -4
• -2 四舍五入到第 2 步 = -2
• 3 舍入到第 2 步 = 4
• 2 舍入到第 2 步 = 2
• -2.3 四舍五入到步长 0.2 = -2.4
• -2.4 四舍五入到步长 0.2 = -2.4
• 2.3 四舍五入到步骤 0.2 = 2.4
• 2.4 四舍五入到步长 0.2 = 2.4

Answer 6

public static int Round(int n)
        {
            // Smaller multiple 
            int a = (n / 10) * 10;

            // Larger multiple 
            int b = a + 10;

            // Return of closest of two 
            return (n - a > b - n) ? b : a;
        }