Redondeando un número al múltiplo más cercano de 5

Question

¿Alguien sabe cómo redondear un número al múltiplo de 5 más cercano? Encontré un algoritmo para redondearlo al múltiplo de 10 más cercano pero no puedo encontrar este.

Esto lo hace por diez.

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

Answer 1

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

Nota - La respuesta de YankeeWhiskey es el redondeo al múltiplo más cercano, este es el redondeo hacia arriba. Necesita una modificación si lo necesita para trabajar con números negativos. Tenga en cuenta que la división entera seguida de la multiplicación entera del mismo número es la forma de redondear.

Answer 2

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

Answer 3

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

Answer 4

Creo que lo tengo, gracias a Amir

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

Aquí está el código me encontré

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

Y aquí está la salida

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 5

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

Answer 6

recursiva:

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

Answer 7

Para redondear al más cercano de cualquier valor

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

También puede reemplazar Math.round(), ya sea con o Math.floor()Math.ceil() para que sea siempre redondear hacia abajo o siempre redondea hacia arriba.

Answer 8

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 9

CÓDIGO:

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

SALIDA: Hay un error en el myCeil para múltiplos de 0,1 demasiado ... ni idea de por qué.

 
    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 10

sólo tiene que pasar su número a esta función como un doble, se le volverá redondear el valor decimal hasta el valor más próximo de 5;

si 4.25, salida 4.25

si 4.20, salida 4.20

si 4.24, salida 4.20

si 4.26, salida 4.30

si desea redondear hasta 2 decimales, luego use

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

if hasta 3 places, new DecimalForm at ("#. ###")

if hasta 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 11

Esto es lo que yo uso para el redondeo a múltiplos de un número:

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

La variable current es el número que está redondeo, multipleOf es lo que está queriendo un múltiplo de (es decir, redondeado a 20 más cercano, 10 más cercano, etc.) y direction es una enumeración que hice para redondear hacia arriba o hacia abajo

¡Buena suerte!

Answer 12

Algunas personas están diciendo algo así como

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

Este redondeará, por ejemplo, de 5 a 10, así como 6, 7, 8 y 9 (todo a 10). Sin embargo, no quiere 5 redondear a 10. Cuando se trata de sólo números enteros, que desea añadir en lugar de 4 a N en lugar de 5. Así que toma ese código y reemplazar el 5 con un 4: algo

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

Por supuesto, cuando se trata de dobles, como acaba de poner 4.99999 o si se quiere dar cuenta de todos los casos (si es posible que se trata de dobles aún más precisos), añadir una instrucción de condición:

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

Answer 13

Otro método o lógica para redondear un número al múltiplo más cercano de 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); 

de salida:

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

Answer 14

Redondear un número dado al múltiplo más cercano de 5.

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

Answer 15

He creado un método que puede convertir un número a la más cercana que se pasará en , tal vez va a ayudar a alguien, porque vi un montón de maneras aquí y no me funcionó para mí, pero éste lo hizo:

/** 
* 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 16

En caso de que sólo tiene que redondear números enteros puede utilizar esta función:

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

La ventaja es que utiliza la aritmética de enteros y funciona incluso para un gran número de largo, donde la división de coma flotante le ocasionará problemas.