Закругление целых чисел до ближайшего кратного 10

Я пытаюсь выяснить, как объединить цены - в обоих направлениях. Например:

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

поскольку он выглядит намного чище

Любые идеи о том, как я могу это достичь?

Ответ 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. Довольно прямо.

Ответ 2

Вам не нужно использовать модуль (%) или с плавающей запятой...

Это работает:

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

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

Ответ 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

Ответ 4

Разделите число на 10.

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

Затем умножьте на 10.

number = number * 10;

Ответ 5

Общий метод округления числа до кратного другого числа, округление от нуля.

Для целых

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

Для float

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

Ответ 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;
        }