web-dev-qa-db-ja.com

数値を最も近い5の倍数に切り上げる

数値を最も近い5の倍数に切り上げる方法を知っていますか？ 10の最も近い倍数に丸めるアルゴリズムを見つけましたが、これを見つけることができません。

これは10のためにそれを行います。

double number = Math.round((len + 5)/ 10.0) * 10.0;
javarounding
33
Daniel Cook
int roundUp(int n) {
    return (n + 4) / 5 * 5;
}

注-YankeeWhiskeyの答えは、最も近い倍数に切り上げています。これは切り上げです。負の数を処理する必要がある場合は、変更が必要です。整数の除算とそれに続く同じ数の整数の乗算が切り捨ての方法であることに注意してください。

50
Tim Cooper

最も近い値に丸めるには

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

Math.round()をMath.floor()またはMath.ceil()に置き換えて、常に切り捨てまたは切り上げにすることもできます。

96
Arkia

私はそれを持っていると思う、アミールのおかげで

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
11
Juan Mendes
int roundUp(int num) {
    return (int) (Math.ceil(num / 5d) * 5);
}
9
Amir Pashazadeh
int round(int num) {
    int temp = num%5;
    if (temp<3)
         return num-temp;
    else
         return num+5-temp;
}
5
YankeeWhiskey
int roundUp(int num) {
    return ((num / 5) + (num % 5 > 0 ? 1 : 0)) * 5;
}
5
Amir Pashazadeh

数値を最も近い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
1
Rahul Baradia

私はここで多くの方法を見て、それが私にとってはうまくいかなかったが、これはそうだったので、渡される最も近いものに数字を変換できるメソッドを作成しました。

/**
 * 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;
}
1
Fima Taf
int getNextMultiple(int num , int multipleOf) {
    int nextDiff = multipleOf - (num % multipleOf);
    int total = num + nextDiff;
    return total;
}
1
mohamed elagamy

一部の人々は次のようなことを言っています

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

これにより、たとえば5〜10、6、7、8、および9（すべて10）に丸められます。ただし、5を10に丸める必要はありません。整数だけを扱う場合は、代わりに5の代わりに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;
1
Peter Griffin

指定された数値を最も近い5の倍数に丸めます。

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

再帰的：

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

数値の倍数に丸めるために使用するものは次のとおりです。

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は、切り上げまたは切り捨てのために作成した列挙型です。

がんばろう！

0
LukeWaggoner
 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;
        } 
    }
0
Sarath

丸めるだけでよい場合全数この関数を使用できます：

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

利点は、整数演算を使用し、浮動小数点除算が問題の原因となる大きな長い数値でも機能することです。

0
Dave_cz
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/

0
Pratiksha

この関数に数値をdoubleとして渡すだけで、10進数値を最も近い値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))));

            }
0
user1023