Arrondir un nombre au multiple de 5 le plus proche
Est-ce que quelqu'un sait comment arrondir un nombre au multiple de 5 le plus proche? J'ai trouvé un algorithme pour l'arrondir au multiple de 10 le plus proche mais je ne trouve pas celui-ci.
Cela le fait pour dix.
double number = Math.round((len + 5)/ 10.0) * 10.0;
int roundUp(int n) {
return (n + 4) / 5 * 5;
}
Remarque - La réponse de YankeeWhiskey est arrondie au multiple le plus proche, c'est arrondi. Nécessite une modification si vous en avez besoin pour travailler avec des nombres négatifs. Notez que la division entière suivie de la multiplication entière du même nombre est le moyen d'arrondir vers le bas.
Arrondir au plus proche de n'importe quelle valeur
int round(double i, int v){
return Math.round(i/v) * v;
}
Vous pouvez également remplacer Math.round() par Math.floor() ou Math.ceil() pour qu'il soit toujours arrondi ou arrondi.
Je pense l'avoir, grâce à Amir
double round( double num, int multipleOf) {
return Math.floor((num + multipleOf/2) / multipleOf) * multipleOf;
}
Voici le code que j'ai couru
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;
}
}
Et voici la sortie
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
int roundUp(int num) {
return (int) (Math.ceil(num / 5d) * 5);
}
int round(int num) {
int temp = num%5;
if (temp<3)
return num-temp;
else
return num+5-temp;
}
int roundUp(int num) {
return ((num / 5) + (num % 5 > 0 ? 1 : 0)) * 5;
}
Une autre méthode ou logique pour arrondir un nombre au plus proche multiple 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);
sortie:
Rounding up to nearest 5------20.0
J'ai créé une méthode qui permet de convertir un nombre au plus proche qui sera transmis. Cela aidera peut-être quelqu'un, car j'ai vu beaucoup de manières ici et cela n'a pas fonctionné pour moi, mais celui-ci l'a fait:
/**
* 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;
}
Certaines personnes disent quelque chose comme
int n = [some number]
int rounded = (n + 5) / 5 * 5;
Ceci arrondira, par exemple, 5 à 10, ainsi que 6, 7, 8 et 9 (tous à 10). Vous ne voulez pas 5 à arrondir à 10 si. Lorsque vous traitez uniquement avec des entiers, vous voulez plutôt ajouter 4 à n au lieu de 5. Donc, prenez ce code et remplacez le 5 par un 4:
int n = [some number]
int rounded = (n + 4) / 5 * 5;
Bien sûr, lorsque vous traitez avec des doublons, mettez simplement quelque chose comme 4.99999, ou si vous souhaitez prendre en compte tous les cas (si vous traitez avec des doublons encore plus précis), ajoutez une déclaration de condition:
int n = [some number]
int rounded = n % 5 == 0 ? n : (n + 4) / 5 * 5;
Arrondis un nombre donné au multiple de 5 le plus proche.
public static int round(int n)
while (n % 5 != 0) n++;
return n;
}
Récursif:
public static int round(int n){
return (n%5==0) ? n : round(++n);
}
Voici ce que j'utilise pour arrondir à des multiples d'un nombre:
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 est le nombre que vous arrondissez, multipleOf correspond à tout ce que vous souhaitez obtenir un multiple de (arrondi à 20, 10, etc.), et direction est une énumération que j'ai faite arrondir de haut en bas.
Bonne chance!
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;
}
}
Au cas où vous n’auriez besoin que d’arrondir des nombres entiers vous pouvez utiliser cette fonction:
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));
}
}
}
L'avantage est qu'il utilise des arithmétiques entiers et fonctionne même pour les grands nombres longs où la division en virgule flottante vous causera des problèmes.
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/
int getNextMultiple(int num , int multipleOf) {
int nextDiff = multipleOf - (num % multipleOf);
int total = num + nextDiff;
return total;
}
Donnez simplement votre numéro à cette fonction en tant que double, cela vous ramènera à la valeur décimale arrondie à la valeur la plus proche de 5;
si 4.25, sortie 4.25
si 4.20, sortie 4.20
si 4.24, sortie 4.20
si 4.26, sortie 4.30
si vous voulez arrondir à 2 décimales, utilisez
DecimalFormat df = new DecimalFormat("#.##");
roundToMultipleOfFive(Double.valueOf(df.format(number)));
si jusqu'à 3 places, new DecimalFormat ("#. ###")
si n lieux, nouveau 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))));
}