Округление числа до ближайшего кратного 5
кто-нибудь знает, как округлить число до ближайшего кратного 5? Я нашел алгоритм, чтобы округлить его до ближайшего кратного 10, но я не могу найти этот.
это делает это для десяти.
double number = Math.round((len + 5)/ 10.0) * 10.0;
17 ответов
int roundUp(int n) {
return (n + 4) / 5 * 5;
}
Примечание-ответ YankeeWhiskey округляется до ближайшего множественного числа,это округление. Нужна модификация, если она нужна для работы с отрицательными числами. Обратите внимание, что целочисленное деление, за которым следует целочисленное умножение того же числа, является способом округления.
округлить до ближайшего значения
int round(double i, int v){
return Math.round(i/v) * v;
}
вы также можете заменить Math.round()
С Math.floor()
или Math.ceil()
чтобы сделать его всегда округлить вниз или всегда округлить вверх.
Я думаю, что он у меня есть, благодаря Амиру
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
некоторые люди говорят что-то вроде
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;
просто передайте свой номер этой функции как 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))));
}
вот что я использую для округления чисел, кратных числу:
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
это перечисление, которое я сделал, чтобы округлить вверх или вниз.
удачи!
другой метод или логика округления числа до ближайшего кратного 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
Я создал метод, который может преобразовать число в ближайшее, которое будет передано, возможно, это поможет кому-то, потому что я видел много способов здесь, и это не сработало для меня, но это сделал:
/**
* 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;
}
круг на заданное число до ближайшего кратного 5.
public static int round(int n)
while (n % 5 != 0) n++;
return n;
}
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/
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;
}
код:
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