web-dev-qa-db-fra.com

Arrondir à la centaine la plus proche

Je suis arrivé à une partie de mon programme Java où je devais arrondir à la centaine la plus proche et je pensais qu'il y avait probablement un moyen de le faire mais je suppose que non. J'ai donc cherché sur le réseau des exemples ou des réponses et je n'ai pas encore trouvé de résultats, car tous les exemples semblent être à la centaine près. Je veux juste faire ceci et arrondir UP. Peut-être y a-t-il une solution simple que je néglige. J'ai essayé Math.ceil et d'autres fonctions, mais je n'ai pas encore trouvé de réponse. Si quelqu'un pouvait m'aider avec ce problème, je l'apprécierais grandement.

Si mon nombre est 203, je veux que le résultat soit arrondi à 300. Vous obtenez le point.

  1. 801-> 900
  2. 99-> 100
  3. 14-> 100
  4. 452-> 500
javamathrounding
17
Tastybrownies

Tirez parti de la division entière, qui tronque la partie décimale du quotient. Pour que cela ressemble à un arrondi, ajoutez 99 en premier.

int rounded = ((num + 99) / 100 ) * 100;

Exemples:

801: ((801 + 99) / 100) * 100 → 900 / 100 * 100 → 9 * 100 = 900
99 : ((99 + 99) / 100) * 100 → 198 / 100 * 100 → 1 * 100 = 100
14 : ((14 + 99) / 100) * 100 → 113 / 100 * 100 → 1 * 100 = 100
452: ((452 + 99) / 100) * 100 → 551 / 100 * 100 → 5 * 100 = 500
203: ((203 + 99) / 100) * 100 → 302 / 100 * 100 → 3 * 100 = 300
200: ((200 + 99) / 100) * 100 → 299 / 100 * 100 → 2 * 100 = 200

Relevant Devis de spécification de langage Java, Section 15.17.2 :

La division entière arrondit à 0. C'est-à-dire le quotient produit pour les opérandes n et d qui sont des entiers après la promotion numérique binaire (§5.6.2) est une valeur entière q dont la grandeur est la plus grande possible en satisfaisant | d · q | ≤ | n |.

42
rgettman

Voici un algorithme qui, à mon avis, fonctionne pour tout cas de "multiple de". Laissez-moi savoir ce que vous pensez.

int round (int number,int multiple){

    int result = multiple;

    //If not already multiple of given number

    if (number % multiple != 0){

        int division = (number / multiple)+1;

        result = division * multiple;

    }

    return result;

}
10
O.C.

Essaye ça:

(int) (Math.ceil(number/100.0))*100
5
user2859809
int roundUpNumberByUsingMultipleValue(double number, int multiple) {

        int result = multiple;

        if (number % multiple == 0) {
            return (int) number;
        }

        // If not already multiple of given number

        if (number % multiple != 0) {

            int division = (int) ((number / multiple) + 1);

            result = division * multiple;

        }
        return result;

    }

Example:
System.out.println("value 1 =" + round(100.125,100));   
System.out.println("value 2 =" + round(163,50));
System.out.println("value 3 =" + round(200,100));
System.out.println("value 4 =" + round(235.33333333,100));
System.out.println("value 5 =" + round(0,100));

OutPut: 
value 1 =200
value 2 =200
value 3 =200
value 4 =300
value 5 =0
3
Pradeepcm
long i = 2147483648L;
if(i % 100 != 0) {
   long roundedI = (100 - (i % 100)) + i;
}

Exemple:

649: (100 - (649 % 100)) + 649 -> (100 - 49) + 649) -> 51 + 649 = 700
985: (100 - (985 % 100)) + 985 -> (100 - 85) + 985) -> 15 + 985 = 1000

Le type de données long est utilisé pour s'assurer que la limitation de la plage entière ne pose aucun problème pour les valeurs plus grandes. Par exemple, cela pourrait être très important dans le cas d'une valeur en montant (domaine bancaire).

2
Mansingh Shitole

Je n'ai pas assez de réputation pour ajouter un commentaire à O.C. La réponse de mais je pense que cela devrait être:

`
if (number % multiple != 0) {
    int division = (number / multiple) + 1;
    result = division * multiple;
} else {
    result = Math.max(multiple, number);
}
`

avec le else de sorte que, par exemple round(9, 3) = 9, sinon ce serait round(9, 3) = 3

1
negste

Une autre façon consiste à utiliser BigDecimal

private static double round(double number, int precision, RoundingMode roundingMode) {
    BigDecimal bd = null;
    try {
        bd = BigDecimal.valueOf(number);
    } catch (NumberFormatException e) {
        // input is probably a NaN or infinity
        return number;
    }
    bd = bd.setScale(precision, roundingMode);
    return bd.doubleValue();
}

round(102.23,0,RoundingMode.UP) = 103  
round(102.23,1,RoundingMode.UP) = 102.3  
round(102.23,2,RoundingMode.UP) = 102.24  
round(102.23,-1,RoundingMode.UP) = 110  
round(102.23,-2,RoundingMode.UP) = 200  
round(102.23,-3,RoundingMode.UP) = 1000
1
vanval
A simple implementation of rgettman which gives:
roudUp(56007)=60000
roudUp(4511)=5000
roudUp(1000)=1000
roudUp(867)=900
roudUp(17)=20
roudUp(5)=10
roudUp(0)=0


import Java.util.*;

public class Main {
    static int roundUp(int src){
        int len = String.valueOf(src).length()-1;
        if (len==0) len=1;
        int d = (int) Math.pow((double) 10, (double) len);
        return (src + (d-1))/d*d;
    }
    public static void main(String[] args)  {
        System.out.println("roudUp(56007)="+roundUp(56007));
        System.out.println("roudUp(4511)="+roundUp(4511));
        System.out.println("roudUp(1000)="+roundUp(1000));
        System.out.println("roudUp(867)="+roundUp(867));
        System.out.println("roudUp(17)="+roundUp(17));
        System.out.println("roudUp(5)="+roundUp(5));
        System.out.println("roudUp(0)="+roundUp(0));
    }
}
1
sevaggelinos

Le code ci-dessous fonctionne pour moi pour arrondir un entier au 10, 100, 500 ou 1000, etc.

public class MyClass {
    public static void main(String args[]) {
        int actualValue = 34199;
        int nextRoundedValue = 500 // change this based on your round requirment ex: 10,100,500,...
        int roundedUpValue = actualValue;

        //Rounding to next 500
        if(actualValue%nextRoundedValue != 0)
          roundedUpValue =
(((actualValue/nextRoundedValue)) * nextRoundedValue) + nextRoundedValue;
         System.out.println(roundedUpValue);
    }
}
0
Mahesh