将数字四舍五入到最接近的 5 的倍数

Question

Does anyone know how to round up a number to its nearest multiple of 5? I found an algorithm to round it to the nearest multiple of 10 but I can't find this one.

This does it for ten.

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

Answer 1

To round to the nearest of any value

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

You can also replace Math.round() with either Math.floor() or Math.ceil() to make it always round down or always round up.

Answer 2

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

Note - YankeeWhiskey's answer is rounding to the closest multiple, this is rounding up. Needs a modification if you need it to work for negative numbers. Note that integer division followed by integer multiplication of the same number is the way to round down.

Answer 3

I think I have it, thanks to Amir

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

Here's the code I ran

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

And here's the output

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

Answer 4

int roundUp(int num) {
    return (int) (Math.ceil(num / 5d) * 5);
}

Answer 5

int round(int num) {
    int temp = num%5;
    if (temp<3)
         return num-temp;
    else
         return num+5-temp;
}

Answer 6

int roundUp(int num) {
    return ((num / 5) + (num % 5 > 0 ? 1 : 0)) * 5;
}

Answer 7

int getNextMultiple(int num , int multipleOf) {
    int nextDiff = multipleOf - (num % multipleOf);
    int total = num + nextDiff;
    return total;
}

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

This Kotlin function rounds a given value 'x' to the closest multiple of 'n'

fun roundXN(x: Long, n: Long): Long {
    require(n > 0) { "n(${n}) is not greater than 0."}

    return if (x >= 0)
        ((x + (n / 2.0)) / n).toLong() * n
    else
        ((x - (n / 2.0)) / n).toLong() * n
}

fun main() {
    println(roundXN(121,4))
}

Output: 120

Answer 10

Kotlin with extension function.

Possible run on play.kotlinlang.org

import kotlin.math.roundToLong

fun Float.roundTo(roundToNearest: Float): Float = (this / roundToNearest).roundToLong() * roundToNearest

fun main() {    
    println(1.02F.roundTo(1F)) // 1.0
    println(1.9F.roundTo(1F)) // 2.0
    println(1.5F.roundTo(1F)) // 2.0

    println(1.02F.roundTo(0.5F)) // 1.0
    println(1.19F.roundTo(0.5F)) // 1.0
    println(1.6F.roundTo(0.5F)) // 1.5
    
    println(1.02F.roundTo(0.1F)) // 1.0
    println(1.19F.roundTo(0.1F)) // 1.2
    println(1.51F.roundTo(0.1F)) // 1.5
}

Possible to use floor/ceil like this: fun Float.floorTo(roundToNearest: Float): Float = floor(this / roundToNearest) * roundToNearest

Answer 11

Some people are saying something like

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

This will round, say, 5 to 10, as well as 6, 7, 8, and 9 (all to 10). You don't want 5 to round to 10 though. When dealing with just integers, you want to instead add 4 to n instead of 5. So take that code and replace the 5 with a 4:

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

Of course, when dealing with doubles, just put something like 4.99999, or if you want to account for all cases (if you might be dealing with even more precise doubles), add a condition statement:

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

Answer 12

Another Method or logic to rounding up a number to nearest multiple of 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);

output :

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

Answer 13

I've created a method that can convert a number to the nearest that will be passed in, maybe it will help to someone, because i saw a lot of ways here and it did not worked for me but this one did:

/**
 * 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;
}

Answer 14

In case you only need to round whole numbers you can use this function:

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

The advantage is that it uses integer arithmetics and works even for large long numbers where the floating point division will cause you problems.

Answer 15

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

source: https://www.geeksforgeeks.org/round-the-given-number-to-nearest-multiple-of-10/

Answer 16

Praveen Kumars question elsewhere in this Thread

"Why are we adding 4 to the number?"

is very relevant. And it is why I prefer to code it like this:

int roundUpToMultipleOf5(final int n) {
    return (n + 5 - 1) / 5 * 5;
}

or, passing the value as an argument:

int roundUpToMultiple(final int n, final int multipleOf) {
    return (n + multipleOf - 1) / multipleOf * multipleOf;
}

By adding 1 less than the multiple you're looking for, you've added just enough to make sure that a value of n which is an exact multiple will not round up, and any value of n which is not an exact multiple will be rounded up to the next multiple.

Answer 17

Just pass your number to this function as a double, it will return you rounding the decimal value up to the nearest value of 5;

if 4.25, Output 4.25

if 4.20, Output 4.20

if 4.24, Output 4.20

if 4.26, Output 4.30

if you want to round upto 2 decimal places,then use

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

if up to 3 places, new DecimalFormat("#.###")

if up to n places, new 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))));

            }

Answer 18

Here's what I use for rounding to multiples of a number:

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

The variable current is the number you're rounding, multipleOf is whatever you're wanting a multiple of (ie round to nearest 20, nearest 10, etc), and direction is an enum I made to either round up or down.

Good luck!

Answer 19

Round a given number to the nearest multiple of 5.

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

Answer 20

You can use this method Math.round(38/5) * 5 to get multiple of 5

It can be replace with Math.ceil or Math.floor based on how you want to round off the number

Answer 21

Use this method to get nearest multiple of 5.

private int giveNearestMul5(int givenValue){
    int roundedNum = 0;
    int prevMul5, nextMul5;
    prevMul5 = givenValue - givenValue%5;
    nextMul5 = prevMul5 + 5;
    if ((givenValue%5!=0)){
        if ( (givenValue-prevMul5) < (nextMul5-givenValue) ){
            roundedNum = prevMul5;
        } else {
            roundedNum = nextMul5;
        }
    } else{
        roundedNum = givenValue;
    }

    return roundedNum;
}

Answer 22

Recursive:

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

Answer 23

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 24

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

There is a bug in the myCeil for multiples of 0.1 too ... no idea why.

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