Rounding up a number to nearest multiple of 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;

What's the code you have for 10 look like? It should be reasonably straightforward to change 10 to 5. — Greg Hewgill, Feb 16 '12 at 00:07
it's a double. if i didn't initialize it as a double it would give me an error i think — Daniel Cook, Feb 16 '12 at 00:10
possible duplicate of [how to always round up to the next integer](http://stackoverflow.com/questions/4846493/how-to-always-round-up-to-the-next-integer) — bestsss, Feb 16 '12 at 01:06
@bestsss The question doesn't say to round integers, does it? — Ruan Mendes, Feb 16 '12 at 01:13
@JuanMendes exactly, the question literally said `double`, and used 10.0 — WSBT, Jan 28 '15 at 04:39
**See Also**: [Rounding numbers to specific multiples](https://stackoverflow.com/q/10456564/1366033) — KyleMit, Sep 17 '21 at 17:56

score 146 · Answer 1 · edited Nov 01 '22 at 12:36

146

To round to the nearest of any value:

int round(double value, int nearest) {
    return (int) Math.round(value / nearest) * nearest;
}

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

edited Nov 01 '22 at 12:36

Jonathan Benn

2,908
4
24
28

answered Feb 16 '12 at 00:30

Arkia

1,653
3
10
7

4

This is by far the best answer. It is universal, it will work for rounding to the nearest of any whole number (e.g. 2 or 5) or any fraction (e.g. 0.1 or 0.05). – mils Apr 01 '16 at 02:57
1

But it must be edited to take and return doubles in order to work for fractional numbers – mils Apr 01 '16 at 03:03
4

I'm not sure why this has so many votes when it doesn't actually compile – dave.c Oct 20 '17 at 10:21
@dave.c It does compile. – NBTX Nov 11 '17 at 20:32
3

@SamJakob When I compile it with Java 1.8.0_152 I get `error: incompatible types: possible lossy conversion from long to int`. In order to get it to compile you need to either cast the result of `Math.round` or change the return type to `long`. – dave.c Nov 13 '17 at 14:30
@dave.c My bad - I didn't notice that, I only used it in a function that returns a double. – NBTX Nov 13 '17 at 19:36
8

Props for giving the correct answer. Zero props for using unreadable variable names (double i , double v). – Ricardo Belchior Mar 09 '18 at 14:43
nitpicking: how do you round to the nearest "Foo" ? shouldn't say "any value", perhaps "any integer value" ? – Peter Perháč Jul 18 '18 at 10:07

score 71 · Accepted Answer · answered Feb 16 '12 at 00:12

71

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.

answered Feb 16 '12 at 00:12

Tim Cooper

10,023
5
61
77

2

Why are we adding 4 to the number? – Praveen Kumar Jul 29 '20 at 13:48
1

4 === n-1 So you can replace it with "return (n + n - 1) / n * n;" – stoefln Jun 20 '22 at 20:07

Ruan Mendes · Answer 3 · 2022-05-24T13:39:01.740

13

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

edited May 24 '22 at 13:39

answered Feb 16 '12 at 00:13

Ruan Mendes

90,375
31
153
217

1

**multipleOf** is an int, so dividing it by 2 can cause problems. – Amir Pashazadeh Feb 16 '12 at 00:20
1

if **multipleOf == 5** then **multipleOf/2 == 2** – Amir Pashazadeh Feb 16 '12 at 00:20
@AmirPashazadeh: That's correct, I also needed to use floor, instead of round since I'm already adding `multipleOf/2`. See any other problems? – Ruan Mendes Feb 16 '12 at 00:36

score 10 · Answer 4 · answered Feb 16 '12 at 00:19

10

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

answered Feb 16 '12 at 00:19

Amir Pashazadeh

7,170
3
39
69

Tested this with my examples and it works. Even for any kind of multiples `public static int roundUp(double num, int multipleOf) { return (int) (Math.ceil(num / (double)multipleOf) * multipleOf); }` – Ruan Mendes Feb 16 '12 at 00:42

score 8 · Answer 5 · edited Apr 05 '12 at 04:08

8

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

edited Apr 05 '12 at 04:08

Fahim Parkar

30,974
45
160
276

answered Feb 16 '12 at 00:08

YankeeWhiskey

1,522
4
20
32

score 8 · Answer 6 · answered Feb 16 '12 at 00:12

8

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

answered Feb 16 '12 at 00:12

Amir Pashazadeh

7,170
3
39
69

mohamed elagamy · Answer 7 · 2018-12-22T14:56:05.963

2

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

edited Dec 22 '18 at 14:56

answered Dec 22 '18 at 14:17

mohamed elagamy

41
5

score 2 · Answer 8 · answered Jan 17 '19 at 08:22

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

score 2 · Answer 9 · answered Apr 09 '20 at 09:27

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

mtrakal · Answer 10 · 2021-06-21T10:40:51.843

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

score 1 · Answer 11 · answered Apr 08 '16 at 10:43

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;

score 1 · Answer 12 · answered May 11 '16 at 08:46

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

score 1 · Answer 13 · answered Aug 24 '17 at 12:46

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

Does not work for 31.428 => 31 , but does 32 when nearest =1 — FreshMike, Oct 16 '19 at 14:07

score 1 · Answer 14 · answered Nov 20 '17 at 17:56

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.

score 1 · Answer 15 · answered Aug 06 '18 at 11:40

1

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/

answered Aug 06 '18 at 11:40

Pratiksha

11
3

score 1 · Answer 16 · answered Jun 22 '21 at 22:43

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.

score 0 · Answer 17 · answered Mar 13 '15 at 12:49

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

            }

LukeWaggoner · Answer 18 · 2015-05-26T20:36:14.990

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 (i.e. round to nearest 20, nearest 10, etc), and direction is an enum I made to either round up or down.

Good luck!

score 0 · Answer 19 · edited Jul 13 '18 at 01:59

0

Round a given number to the nearest multiple of 5.

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

edited Jul 13 '18 at 01:59

phuclv

37,963
15
156
475

answered Jul 17 '17 at 11:26

Supreeth

1
3

5

this is one of the worst way because it needs to do a slow division multiple times – phuclv Jul 13 '18 at 01:59

score 0 · Answer 20 · answered Jul 12 '20 at 20:10

0

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

answered Jul 12 '20 at 20:10

kittu

6,662
21
91
185

mazhar_898 · Answer 21 · 2022-06-30T22:05:18.537

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

Timmy O'Mahony · Answer 22 · 2012-02-16T00:56:28.890

0

Recursive:

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

edited Feb 16 '12 at 00:56

answered Feb 16 '12 at 00:29

Timmy O'Mahony

53,000
18
155
177

the formula is (x+y-1)/y, dunno if recursive is just to look cool, imagine it was few thousands - bam StackOverflow. – bestsss Feb 16 '12 at 01:05
2

you caught me. I often float around stack overflow trying to look cool. It was an alternative suggestion. There are numerous approaches. – Timmy O'Mahony Feb 16 '12 at 01:09
@TimmyO'Mahony recursion is unnecessary and completely inefficient in this – Sep 07 '20 at 12:42

score -2 · Answer 23 · edited Sep 03 '14 at 08:52

-2

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

edited Sep 03 '14 at 08:52

benka

4,732
35
47
58

answered Sep 03 '14 at 08:22

Alex

1
4

1

YandereDev, is that you? – mindoverflow Aug 14 '20 at 13:23

score -4 · Answer 24 · answered Nov 01 '14 at 00:42

CODE:

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

OUTPUT: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

Rounding up a number to nearest multiple of 5

24 Answers24

Linked

Related