Auf die nächsten Hundert aufgerundet

Question

Ich kam zu einem Teil in meinem Java-Programm, wo ich auf die nächsten hundert runden muss und dachte, dass es wahrscheinlich einen Weg gab, aber ich denke nicht. Also habe ich im Internet nach Beispielen oder Antworten gesucht, und ich habe noch keine gefunden, da alle Beispiele auf die nächsten Hundert zu liegen scheinen. Ich möchte das einfach machen und aufrunden. Vielleicht gibt es eine einfache Lösung, die ich übersehen habe. Ich habe versucht Math.ceil und andere Funktionen, aber habe noch keine Antwort gefunden. Wenn mir jemand bei diesem Problem helfen könnte, würde ich das sehr schätzen.

Wenn meine Nummer 203 ist, möchte ich, dass das Ergebnis auf 300 gerundet wird. Sie erhalten den Punkt.

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

Answer 1

Nutzen ganzzahligen Division, die den Dezimalteil der abschneidet Quotient. Um es so aussehen zu lassen, dass es aufgerundet wird, addiere zuerst 99.

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

Beispiele:

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 

Relevant Java Language Specification quote, Section 15.17.2:

Integer Division Runden in Richtung auf 0. Das heißt, der Quotient für Operanden N und D erzeugt, die ganzen Zahlen nach binärer numerischer Förderung sind (§5.6.2) ist ein ganzzahliger Wert q, dessen Größe so groß wie möglich ist, während | d · q | ≤ | n |.

Answer 2

Hier ist ein Algorithmus, den ich glaube funktioniert für jeden "multiple of" Fall. Lass mich wissen was du denkst.

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

Ich habe genug Ruf nicht um einen Kommentar zu O.C. ‚s Antwort hinzufügen, aber ich denke, es sollte sein:

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

mit den else, so dass zum Beispiel round(9, 3) = 9, sonst wäre es 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 

Lange Datentyp verwendet wird, die Begrenzung der Integer-Bereich, um sicherzustellen, kein Problem für größere Werte führen sollte. Zum Beispiel könnte dies sehr wichtig im Falle eines Betragswerts (Banking-Domain) sein.

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

Eine andere Möglichkeit ist 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

Versuchen Sie, diese zu nutzen:

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

Answer 9

Der Code unten funktioniert für mich eine ganze Zahl auf die nächste 10 abzurunden oder 100 oder 500 oder 1000 usw.

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); 
    } 
}