Кто-нибудь знает, как округлить число до его ближайшего кратного 5? Я нашел алгоритм, чтобы округлить его до ближайшего кратного 10, но я не могу найти его.
Это делается для десяти.
double number = Math.round((len + 5)/ 10.0) * 10.0;
Округление числа до ближайшего кратного 5
Ответ 1
int roundUp(int n) {
return (n + 4) / 5 * 5;
}
Примечание. Ответ YankeeWhiskey округляется до ближайшего кратного, это округление. Требуется модификация, если вам нужно, чтобы она работала для отрицательных чисел. Обратите внимание, что целочисленное деление, за которым следует целочисленное умножение того же числа, является способом округления вниз.
Ответ 2
Чтобы округлить до ближайшего значения
int round(double i, int v){
return Math.round(i/v) * v;
}
Вы также можете заменить Math.round() на Math.floor() или Math.ceil(), чтобы он всегда округлялся или всегда округлялся.
Ответ 3
Я думаю, что у меня есть это, благодаря Амиру
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
Ответ 4
int roundUp(int num) {
return (int) (Math.ceil(num / 5d) * 5);
}
Ответ 5
int round(int num) {
int temp = num%5;
if (temp<3)
return num-temp;
else
return num+5-temp;
}
Ответ 6
int roundUp(int num) {
return ((num / 5) + (num % 5 > 0 ? 1 : 0)) * 5;
}
Ответ 7
Некоторые люди говорят что-то вроде
int n = [some number]
int rounded = (n + 5) / 5 * 5;
Это будет округлять, скажем, от 5 до 10, а также 6, 7, 8 и 9 (все до 10). Вы не хотите, чтобы 5 раундов до 10, хотя. Когда вы имеете дело с целыми числами, вы вместо этого добавляете вместо 4 вместо n. Поэтому возьмите этот код и замените 5 на 4:
int n = [some number]
int rounded = (n + 4) / 5 * 5;
Конечно, имея дело с двойниками, просто поставьте что-то вроде 4.99999 или если вы хотите учитывать все случаи (если вы имеете дело с еще более точными удвоениями), добавьте условие:
int n = [some number]
int rounded = n % 5 == 0 ? n : (n + 4) / 5 * 5;
Ответ 8
Другой метод или логика для округления числа до ближайшего кратного 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
Ответ 9
Рекурсивный:
public static int round(int n){
return (n%5==0) ? n : round(++n);
}
Ответ 10
Просто передайте свой номер этой функции как двойной, он вернет вам округление десятичного значения до ближайшего значения 5;
если 4.25, выход 4.25
если 4.20, выход 4.20
если 4.24, Output 4.20
если 4.26, выход 4.30
если вы хотите округлить до двух знаков после запятой, затем используйте
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))));
}
Ответ 11
Здесь я использую для округления до кратного числа:
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 - это перечисление, которое я сделал для округления вверх или вниз.
Удачи!
Ответ 12
Округлить данное число до ближайшего кратного 5.
public static int round(int n)
while (n % 5 != 0) n++;
return n;
}
Ответ 13
Я создал метод, который может преобразовать число в ближайшее, которое будет передано, возможно, это поможет кому-то, потому что я видел здесь много способов, и это не сработало для меня, но это сделало:
/**
* 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;
}
Ответ 14
Если вам нужно всего лишь округлить целые числа, вы можете использовать эту функцию:
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));
}
}
}
Преимущество состоит в том, что он использует целочисленную арифметику и работает даже при больших длинных числах, где разделение с плавающей запятой вызовет проблемы.
Ответ 15
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/
Ответ 16
int getNextMultiple(int num , int multipleOf) {
int nextDiff = multipleOf - (num % multipleOf);
int total = num + nextDiff;
return total;
}
Ответ 17
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;
}
}
Ответ 18
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;
}
Ответ 19
КОД:
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: В 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