Arrotondare gli interi al multiplo più vicino di 10

Question

Sto cercando di capire come arrotondare i prezzi, in entrambi i modi. Per esempio:

Round down 
43 becomes 40 
143 becomes 140 
1433 becomes 1430 

Round up 
43 becomes 50 
143 becomes 150 
1433 becomes 1440 

ho la situazione in cui ho una fascia di prezzo di dire:

£143 - £193 

di cui voglio mostrare come:

£140 - £200 

come sembra molto pulitore

Qualche idea su come posso raggiungere questo obiettivo?

Answer 1

Vorrei solo creare un paio di metodi;

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

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

Modulus ci dà il resto, nel caso di arrotondamento 10 - r vi porta al più vicino decimo, per arrotondare basta sottrarre r. Abbastanza diretto.

Answer 2

Dividere il numero per 10.

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

Poi moltiplicare per 10.

number = number * 10; 

Answer 3

Questo codice arrotonda al più vicino multiplo di 10:

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

Molto semplice utilizzo:

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

Answer 4

Non è necessario utilizzare il modulo (%) o in virgola mobile ...

Questo funziona:

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

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

Answer 5

Un metodo generale per arrotondare un numero a un multiplo di un altro numero, arrotondando away from zero.

Per intero

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

Per galleggiante

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

so alcune parti potrebbero sembrare intuitivo o non molto ottimizzato. Ho provato il cast (num + step/2) su un int, ma questo ha dato risultati errati per i float negativi ((int) -12.0000 = -11 e così via). Comunque questi sono alcuni casi ho provato:

• qualsiasi numero arrotondato al passaggio 1 dovrebbe essere sé
• -3 arrotondato al passaggio 2 = -4
• -2 arrotondato al passaggio 2 = -2
• 3 arrotondato al passaggio 2 = 4
• 2 arrotondato al passaggio 2 = 2
• -2.3 arrotondato al passo 0,2 = -2.4
• -2.4 arrotondato al passaggio 0,2 = -2,4
• 2,3 arrotondato al passaggio 0,2 = 2,4
• 2,4 arrotondato al passaggio 0,2 = 2,4