c# - numeros - Redondear números enteros al múltiplo más cercano de 10

redondear numeros enteros en excel

Question

Estoy tratando de averiguar cómo redondear los precios, en ambos sentidos. Por ejemplo:

Round down
43 becomes 40
143 becomes 140
1433 becomes 1430

Round up
43 becomes 50
143 becomes 150
1433 becomes 1440

Tengo la situación en la que tengo un rango de precios de decir:

£143 - £193

de los cuales quiero mostrar como

£140 - £200

ya que se ve mucho mas limpio

¿Alguna idea sobre cómo puedo lograr esto?

Answer 1

Divide el número por 10.

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

Luego multiplica por 10.

number = number * 10;

Answer 2

Este código se redondea al múltiplo más cercano de 10:

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

Uso muy simple:

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

Answer 3

No es necesario usar módulo (%) o punto flotante ...

Esto funciona:

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

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

Answer 4

Simplemente crearía un par de métodos;

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

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

Módulo nos da el resto, en el caso de redondear hacia arriba 10 - r lleva a la décima más cercana, para redondear hacia abajo simplemente reste r. Muy claro.

Answer 5

Un método general para redondear un número a un múltiplo de otro número, redondeando desde cero .

Para entero

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

Para flotar

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

Sé que algunas partes pueden parecer contraintuitivas o poco optimizadas. Intenté lanzar (num + step / 2) a un int, pero esto dio resultados incorrectos para los flotadores negativos ( (int) -12.0000 = -11 y similares). De todos modos estos son algunos casos que he probado:

• Cualquier número redondeado al paso 1 debe ser el mismo.
• -3 redondeado al paso 2 = -4
• -2 redondeado al paso 2 = -2
• 3 redondeado al paso 2 = 4
• 2 redondeado al paso 2 = 2
• -2.3 redondeado al paso 0.2 = -2.4
• -2.4 redondeado al paso 0.2 = -2.4
• 2.3 redondeado al paso 0.2 = 2.4
• 2.4 redondeado al paso 0.2 = 2.4