Zaokrąglanie do najbliższej setki

Question

Przyszedłem do udziału w moim programie java, w którym muszę zaokrąglić do najbliższej setki i pomyślałem, że prawdopodobnie istnieje sposób, aby to zrobić, ale nie sądzę. Szukałem więc w sieci przykładów lub odpowiedzi i nie znalazłem jeszcze żadnych, ponieważ wszystkie przykłady wydają się być najbliższe setki. Po prostu chcę to zrobić i zaokrąglić w górę. Może jest jakieś proste rozwiązanie, które przeoczyłem. Próbowałem już Math.ceil i innych funkcji, ale nie znalazłem jeszcze odpowiedzi. Jeśli ktokolwiek mógłby mi pomóc w tej kwestii, bardzo bym to docenił.

Jeśli mój numer to 203, chcę, aby wynik zaokrąglony wynosił 300. Otrzymasz punkt.

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

Answer 1

skorzystać z dzielenia liczby całkowitej, która odcina część dziesiętną iloraz. Aby wyglądało na to, że się zaokrągla, dodaj 99 jako pierwszy.

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

Przykłady:

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 

Odpowiednie Java Language Specification quote, Section 15.17.2:

całkowite rundy podziału kierunku 0. Oznacza to, że iloraz produkowane operandów n i d oznaczają liczby całkowite, które mają po binarnego promocji numerycznej (§5.6.2) jest liczbą całkowitą q, której wielkość jest tak duża, jak to możliwe przy zadowalaniu | d · q | ≤ | n |.

Answer 2

Oto algorytm, który według mnie działa dla dowolnego przypadku "wielokrotności". Powiedz mi co myślisz.

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

nie mam wystarczających reputacji, aby dodać komentarz O.C. jest odpowiedź, ale myślę, że powinno być:

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

z else tak, że na przykład round(9, 3) = 9, w przeciwnym razie będzie to 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 

długi typ danych jest używany do upewnij się, że ograniczenie liczby całkowitej zakresie nie powinny powodować żadnych problemów dla większych wartości. Dla przykładu może to być bardzo ważne w przypadku wartości kwoty (domeny bankowej).

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

Innym sposobem jest użycie 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

Spróbuj tego:

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

Answer 9

Poniższy kod działa dla mnie zaokrąglić liczbę całkowitą do następnego 10 lub 100 lub 500 lub 1000 itd.

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