Arrotondare fino al centinaio più vicino

Question

Sono arrivato a una parte del mio programma java in cui ho bisogno di arrotondare il centinaio e ho pensato che probabilmente c'era un modo per farlo, ma immagino di no. Così ho cercato in rete esempi o risposte e non ho ancora trovato alcun dato in quanto tutti gli esempi sembrano essere il centinaio più vicino. Voglio solo farlo e completare UP. Forse c'è una soluzione semplice che sto trascurando. Ho provato Math.ceil e altre funzioni ma non ho ancora trovato una risposta. Se qualcuno mi può aiutare con questo problema, lo apprezzerei molto.

Se il mio numero è 203, voglio che il risultato sia arrotondato a 300. Ottieni il punto.

1. 801-> 900
2. 99-> 100
3. 14-> 100
4. 452-> 500

Answer 1

Utilizza la divisione intera, che tronca la parte decimale del quoziente. Per fare in modo che si avvicini, aggiungi 99 prima.

int rounded = ((num + 99)/100) * 100; 

Esempi:

801: ((801 + 99)/100) * 100 → 900/100 * 100 → 9 * 100 = 900 
99 : ((99 + 99)/100) * 100 → 198/100 * 100 → 1 * 100 = 100 
14 : ((14 + 99)/100) * 100 → 113/100 * 100 → 1 * 100 = 100 
452: ((452 + 99)/100) * 100 → 551/100 * 100 → 5 * 100 = 500 
203: ((203 + 99)/100) * 100 → 302/100 * 100 → 3 * 100 = 300 
200: ((200 + 99)/100) * 100 → 299/100 * 100 → 2 * 100 = 200 

Rilevante Java Language Specification quote, Section 15.17.2:

divisione intera tondi verso 0. Cioè, il quoziente prodotti per operandi n e d che sono interi dopo promozione numerico binario (§5.6.2) è un valore intero q la cui grandezza è il più grande possibile mentre soddisfa | d · q | ≤ | n |.

Answer 2

Ecco un algoritmo che credo funzioni per qualsiasi caso "multiplo di". Fatemi sapere cosa ne pensate.

int round (int number,int multiple){ 

    int result = multiple; 

    //If not already multiple of given number 

    if (number % multiple != 0){ 

     int division = (number/multiple)+1; 

     result = division * multiple; 

    } 

    return result; 

} 

Answer 3

int roundUpNumberByUsingMultipleValue(double number, int multiple) { 

     int result = multiple; 

     if (number % multiple == 0) { 
      return (int) number; 
     } 

     // If not already multiple of given number 

     if (number % multiple != 0) { 

      int division = (int) ((number/multiple) + 1); 

      result = division * multiple; 

     } 
     return result; 

    } 

Example: 
System.out.println("value 1 =" + round(100.125,100)); 
System.out.println("value 2 =" + round(163,50)); 
System.out.println("value 3 =" + round(200,100)); 
System.out.println("value 4 =" + round(235.33333333,100)); 
System.out.println("value 5 =" + round(0,100)); 

OutPut: 
value 1 =200 
value 2 =200 
value 3 =200 
value 4 =300 
value 5 =0 

Answer 4

non ho la reputazione sufficienti per aggiungere un commento a O.C. 's risposta, ma penso che dovrebbe essere:

` 
if (number % multiple != 0) { 
    int division = (number/multiple) + 1; 
    result = division * multiple; 
} else { 
    result = Math.max(multiple, number); 
} 
` 

con la else in modo che, ad esempio round(9, 3) = 9, altrimenti sarebbe round(9, 3) = 3

Answer 5

long i = 2147483648L; 
if(i % 100 != 0) { 
    long roundedI = (100 - (i % 100)) + i; 
} 

Exa mple:

649: (100 - (649 % 100)) + 649 -> (100 - 49) + 649) -> 51 + 649 = 700 
985: (100 - (985 % 100)) + 985 -> (100 - 85) + 985) -> 15 + 985 = 1000 

lunghi tipo di dati viene utilizzato per verificare la limitazione della gamma intero non dovrebbe causare alcun problema per valori più grandi. Ad esempio, questo potrebbe essere molto importante nel caso di un valore di importo (dominio bancario).

Answer 6

A simple implementation of rgettman which gives: 
roudUp(56007)=60000 
roudUp(4511)=5000 
roudUp(1000)=1000 
roudUp(867)=900 
roudUp(17)=20 
roudUp(5)=10 
roudUp(0)=0 


import java.util.*; 

public class Main { 
    static int roundUp(int src){ 
     int len = String.valueOf(src).length()-1; 
     if (len==0) len=1; 
     int d = (int) Math.pow((double) 10, (double) len); 
     return (src + (d-1))/d*d; 
    } 
    public static void main(String[] args) { 
     System.out.println("roudUp(56007)="+roundUp(56007)); 
     System.out.println("roudUp(4511)="+roundUp(4511)); 
     System.out.println("roudUp(1000)="+roundUp(1000)); 
     System.out.println("roudUp(867)="+roundUp(867)); 
     System.out.println("roudUp(17)="+roundUp(17)); 
     System.out.println("roudUp(5)="+roundUp(5)); 
     System.out.println("roudUp(0)="+roundUp(0)); 
    } 
} 

Answer 7

Un altro modo è quello di utilizzare BigDecimal

private static double round(double number, int precision, RoundingMode roundingMode) { 
    BigDecimal bd = null; 
    try { 
     bd = BigDecimal.valueOf(number); 
    } catch (NumberFormatException e) { 
     // input is probably a NaN or infinity 
     return number; 
    } 
    bd = bd.setScale(precision, roundingMode); 
    return bd.doubleValue(); 
} 

round(102.23,0,RoundingMode.UP) = 103 
round(102.23,1,RoundingMode.UP) = 102.3 
round(102.23,2,RoundingMode.UP) = 102.24 
round(102.23,-1,RoundingMode.UP) = 110 
round(102.23,-2,RoundingMode.UP) = 200 
round(102.23,-3,RoundingMode.UP) = 1000 

Answer 8

Prova questo:

(int) (Math.ceil(number/100.0))*100 

Answer 9

Il seguente codice funziona per me per arrotondare un numero intero per i prossimi 10 o 100 o 500 o 1000 ecc.

public class MyClass { 
    public static void main(String args[]) { 
     int actualValue = 34199; 
     int nextRoundedValue = 500 // change this based on your round requirment ex: 10,100,500,... 
     int roundedUpValue = actualValue; 

     //Rounding to next 500 
     if(actualValue%nextRoundedValue != 0) 
      roundedUpValue = 
(((actualValue/nextRoundedValue)) * nextRoundedValue) + nextRoundedValue; 
     System.out.println(roundedUpValue); 
    } 
}