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

Question

Кто-нибудь знает, как округлить число до ближайшего кратного 5? Я нашел алгоритм округления до ближайшего кратного 10, но не могу найти этот.

Это делает это в течение десяти.

double number = Math.round((len + 5)/ 10.0) * 10.0;

Answer 1

Округление заданного числа до ближайшего числа, кратного 5.

public static int round(int n)
  while (n % 5 != 0) n++;
  return n; 
}

Answer 2

Вот что я использую для округления до кратных числа:

private int roundToMultipleOf(int current, int multipleOf, Direction direction){
    if (current % multipleOf == 0){
        return ((current / multipleOf) + (direction == Direction.UP ? 1 : -1)) * multipleOf;
    }
    return (direction == Direction.UP ? (int) Math.ceil((double) current / multipleOf) : (direction == Direction.DOWN ? (int) Math.floor((double) current / multipleOf) : current)) * multipleOf;
}

Переменная current - это число, которое вы округляете, multipleOf - это то, что вы хотите, кратное (т. Е. Округление до ближайшего 20, ближайшее 10 и т. Д.), А direction - это перечисление, которое я сделал или округлить вверх или вниз.

Удачи!

Answer 3

if (n % 5 == 1){
   n -= 1;
} else if (n % 5 == 2) {
   n -= 2;
} else if (n % 5 == 3) {
   n += 2;
} else if (n % 5 == 4) {
   n += 1;
}

Answer 4

Рекурсивный:

public static int round(int n){
    return (n%5==0) ? n : round(++n);
}

Answer 5

Если вам нужно только округлить целые числа , вы можете использовать эту функцию:

public static long roundTo(long value, long roundTo) {
    if (roundTo <= 0) {
        throw new IllegalArgumentException("Parameter 'roundTo' must be larger than 0");
    }
    long remainder = value % roundTo;
    if (Math.abs(remainder) < (roundTo / 2d)) {
        return value - remainder;
    } else {
        if (value > 0) {
            return value + (roundTo - Math.abs(remainder));
        } else {
            return value - (roundTo - Math.abs(remainder));
        }
    }
}

Преимущество состоит в том, что он использует целочисленную арифметику и работает даже для больших длинных чисел, где деление с плавающей запятой вызовет проблемы.

Answer 6

int roundUp(int n, int multipleOf)
{
  int a = (n / multipleOf) * multipleOf;
  int b = a + multipleOf;
  return (n - a > b - n)? b : a;
}

источник: https://www.geeksforgeeks.org/round-the-given-number-to-nearest-multiple-of-10/

Answer 7

КОД:

    public class MyMath
    {
        public static void main(String[] args) {
            runTests();
        }
        public static double myFloor(double num, double multipleOf) {
            return ( Math.floor(num / multipleOf) * multipleOf );
        }
        public static double myCeil (double num, double multipleOf) {
            return ( Math.ceil (num / multipleOf) * multipleOf );
        }

        private static void runTests() {
            System.out.println("myFloor (57.3,  0.1) : " + myFloor(57.3, 0.1));
            System.out.println("myCeil  (57.3,  0.1) : " + myCeil (57.3, 0.1));
            System.out.println("");
            System.out.println("myFloor (57.3,  1.0) : " + myFloor(57.3, 1.0));
            System.out.println("myCeil  (57.3,  1.0) : " + myCeil (57.3, 1.0));
            System.out.println("");
            System.out.println("myFloor (57.3,  5.0) : " + myFloor(57.3, 5.0));
            System.out.println("myCeil  (57.3,  5.0) : " + myCeil (57.3, 5.0));
            System.out.println("");
            System.out.println("myFloor (57.3, 10.0) : " + myFloor(57.3,10.0));
            System.out.println("myCeil  (57.3, 10.0) : " + myCeil (57.3,10.0));
        }
    }

ВЫХОД: В myCeil есть ошибка для кратных 0,1 тоже ... понятия не имею, почему.

    myFloor (57.3,  0.1) : 57.2
    myCeil  (57.3,  0.1) : 57.300000000000004

    myFloor (57.3,  1.0) : 57.0
    myCeil  (57.3,  1.0) : 58.0

    myFloor (57.3,  5.0) : 55.0
    myCeil  (57.3,  5.0) : 60.0

    myFloor (57.3, 10.0) : 50.0
    myCeil  (57.3, 10.0) : 60.0

Answer 8

 int roundToNearestMultiple(int num, int multipleOf){
        int floorNearest = ((int) Math.floor(num * 1.0/multipleOf)) * multipleOf;
        int ceilNearest = ((int) Math.ceil(num  * 1.0/multipleOf)) * multipleOf;
        int floorNearestDiff = Math.abs(floorNearest - num);
        int ceilNearestDiff = Math.abs(ceilNearest - num);
        if(floorNearestDiff <= ceilNearestDiff) {
            return floorNearest;
        } else {
            return ceilNearest;
        } 
    }

Answer 9

Просто передайте свой номер этой функции в виде двойного числа, она вернет вам округление десятичного значения до ближайшего значения 5;

если 4,25, вывод 4,25

если 4.20, вывод 4.20

если 4.24, вывод 4.20

если 4.26, вывод 4.30

если вы хотите округлить до 2 десятичных знаков, тогда используйте

DecimalFormat df = new DecimalFormat("#.##");
roundToMultipleOfFive(Double.valueOf(df.format(number)));

если до 3 мест, новый DecimalFormat ("#. ###")

если до n мест, новый DecimalFormat ("#. nTimes # ")

 public double roundToMultipleOfFive(double x)
            {

                x=input.nextDouble();
                String str=String.valueOf(x);
                int pos=0;
                for(int i=0;i<str.length();i++)
                {
                    if(str.charAt(i)=='.')
                    {
                        pos=i;
                        break;
                    }
                }

                int after=Integer.parseInt(str.substring(pos+1,str.length()));
                int Q=after/5;
                int R =after%5;

                if((Q%2)==0)
                {
                    after=after-R;
                }
                else
                {
                    after=after+(5-R);
                }

                       return Double.parseDouble(str.substring(0,pos+1).concat(String.valueOf(after))));

            }