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

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

это делает это для десяти.

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

17 ответов

int roundUp(int n) {
    return (n + 4) / 5 * 5;
}

Примечание-ответ YankeeWhiskey округляется до ближайшего множественного числа,это округление. Нужна модификация, если она нужна для работы с отрицательными числами. Обратите внимание, что целочисленное деление, за которым следует целочисленное умножение того же числа, является способом округления.

48

округлить до ближайшего значения

int round(double i, int v){
    return Math.round(i/v) * v;
}

вы также можете заменить Math.round() С Math.floor() или Math.ceil() чтобы сделать его всегда округлить вниз или всегда округлить вверх.

84

Я думаю, что он у меня есть, благодаря Амиру

double round( double num, int multipleOf) {
  return Math.floor((num + multipleOf/2) / multipleOf) * multipleOf;
}

вот код, который я запустил

class Round {
    public static void main(String[] args){
        System.out.println("3.5 round to 5: " + Round.round(3.5, 5));
        System.out.println("12 round to 6: " + Round.round(12, 6));
        System.out.println("11 round to 7: "+ Round.round(11, 7));
        System.out.println("5 round to 2: " + Round.round(5, 2));
        System.out.println("6.2 round to 2: " + Round.round(6.2, 2));
    }

    public static double round(double num, int multipleOf) {
        return Math.floor((num +  (double)multipleOf / 2) / multipleOf) * multipleOf;
    }
}

и вот результат

3.5 round to 5: 5.0
12 round to 6: 12.0
11 round to 7: 14.0
5 round to 2: 6.0
6.2 round to 2: 6.0
11
int roundUp(int num) {
    return (int) (Math.ceil(num / 5d) * 5);
}
8
int roundUp(int num) {
    return ((num / 5) + (num % 5 > 0 ? 1 : 0)) * 5;
}
5
int round(int num) {
    int temp = num%5;
    if (temp<3)
         return num-temp;
    else
         return num+5-temp;
}
5

некоторые люди говорят что-то вроде

int n = [some number]
int rounded = (n + 5) / 5 * 5;

это будет округлять, скажем, от 5 до 10, а также 6, 7, 8 и 9 (все до 10). Вы не хотите, чтобы 5 округлить до 10. Когда вы имеете дело только с целыми числами, вы хотите вместо этого добавить 4 к n вместо 5. Поэтому возьмите этот код и замените 5 на 4:

int n = [some number]
int rounded = (n + 4) / 5 * 5;

конечно, при работе с двойниками, просто поставьте что-то вроде 4.99999, или если вы хотите учитывать все случаи (если вы можете иметь дело с еще более точным doubles), добавить условие:

int n = [some number]
int rounded = n % 5 == 0 ? n : (n + 4) / 5 * 5;
1

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

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

просто передайте свой номер этой функции как double, он вернет вам округление десятичного значения до ближайшего значения 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))));

            }
0

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

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 это перечисление, которое я сделал, чтобы округлить вверх или вниз.

удачи!

0

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

double num = 18.0;
    if (num % 5 == 0)
        System.out.println("No need to roundoff");
    else if (num % 5 < 2.5)
        num = num - num % 5;
    else
        num = num + (5 - num % 5);
    System.out.println("Rounding up to nearest 5------" + num);

выход :

Rounding up to nearest 5------20.0
0

Я создал метод, который может преобразовать число в ближайшее, которое будет передано, возможно, это поможет кому-то, потому что я видел много способов здесь, и это не сработало для меня, но это сделал:

/**
 * The method is rounding a number per the number and the nearest that will be passed in.
 * If the nearest is 5 - (63->65) | 10 - (124->120).
 * @param num - The number to round
 * @param nearest - The nearest number to round to (If the nearest is 5 -> (0 - 2.49 will round down) || (2.5-4.99 will round up))
 * @return Double - The rounded number
 */
private Double round (double num, int nearest) {
    if (num % nearest >= nearest / 2) {
        num = num + ((num % nearest - nearest) * -1);
    } else if (num % nearest < nearest / 2) {
        num = num - (num % nearest);
    }
    return num;
}
0

в случае, если вам нужна только круглая

0

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

public static int round(int n)
  while (n % 5 != 0) n++;
  return n; 
}
0
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/

0
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;
}
-1

код:

    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
-3