Округление до ближайшей сотни

Ответ 1

Используйте целочисленное деление, которое усекает десятичную часть частного. Чтобы он выглядел как округленный, сначала добавьте 99.

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

Примеры:

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

Соответствующая ссылка на Java Language Specification, раздел 15.17.2:

Целочисленные деления округляются до нуля. То есть, фактор, созданный для операнды n и d, которые являются целыми числами после двоичного числового продвижения (§5.6.2) представляет собой целое значение q, величина которого как можно больше удовлетворяющих условию | d · q | ≤ | n |.

Ответ 2

Вот алгоритм, который я верю, работает для любого "кратного" случая. Дайте мне знать, что вы думаете.

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;

}

Ответ 3

Попробуйте следующее:

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

Ответ 4

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

Ответ 5

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

Пример:

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

Длинный тип данных используется для обеспечения того, чтобы ограничение целочисленного диапазона не вызывало проблем при больших значениях. Например, это может быть очень важно в случае величины суммы (банковский домен).

Ответ 6

У меня нет достаточной репутации, чтобы добавить комментарий к O.C., но я думаю, что это должно быть:

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

с else, так что, например, round(9, 3) = 9, в противном случае это было бы round(9, 3) = 3

Ответ 7

Простая реализация trunaction rgettman:

public class Main {

    private 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("roundUp(56007) = " + roundUp(56007));
        System.out.println("roundUp(4511) = " + roundUp(4511));
        System.out.println("roundUp(1000) = " + roundUp(1000));
        System.out.println("roundUp(867) = " + roundUp(867));
        System.out.println("roundUp(17) = " + roundUp(17));
        System.out.println("roundUp(5) = " + roundUp(5));
        System.out.println("roundUp(0) = " + roundUp(0));
    }
}

Выход:

roundUp(56007) = 60000
roundUp(4511) = 5000
roundUp(1000) = 1000
roundUp(867) = 900
roundUp(17) = 20
roundUp(5) = 10
roundUp(0) = 0

Ответ 8

Другим способом является использование 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

Ответ 9

Приведенный ниже код помогает мне округлить целое число до следующих 10, 100, 500 или 1000 и т.д.

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

Ответ 10

Это отлично сработало для меня:

    var round100 = function(n) {
        if (n < 50) {
            var low = n - (n % 100);
            return Math.round(low);     
        }

        return Math.round(n/100) * 100;
    }

Вы можете назначить свои переменные (переменные) чему угодно.