Y at-il une fonction Java ou classe util qui n'arrondi ainsi: func (3/2) = 2?

Question

Y at-il une fonction Java ou qui ne util class arrondi de cette façon: func(3/2) = 2

Math.ceil() ne vous aide pas, qui par son nom aurait dû le faire. Je suis conscient de BigDecimal, mais ne pas besoin.

Answer 1

Math.ceil() toujours arrondir, mais vous faites la division entière avec 3/2. Ainsi, étant donné que dans la division entière 3/2 = 1 (non 1.5) au plafond de 1 est Math.ceil(3/2.0);.

Ce que vous devez faire pour obtenir les résultats que vous voulez est 2.0

En faisant la division par un double montant (3/2.0 = 1.5), vous finissez par faire la division à virgule flottante au lieu de division entière. Ainsi ceil() et l'est 2 de toujours <=> <=>.

Answer 2

Un peu de magie noire, et vous pouvez tout faire avec des entiers:

// Divide x by n rounding up
int res = (x+n-1)/n

Answer 3

Vous pouvez toujours jeter les premiers:

Math.ceil((double)3/2)

Answer 4

Pour convertir la division à la division sol au plafond:

(numerator + denominator-1) / denominator

Pour convertir la division à la division étage arrondi:

(numerator + (denominator)/2) / denominator

Answer 5

En Java, 1 = 3/2 car il utilise la division entière. Il n'y a pas la fonction qui peut « réparer » ce après. Ce que vous devez faire est de forcer une divison à flotteur et arrondir le résultat:

int result = (int)Math.ceil( ((float)3) / ((float)2) );

Answer 6

Aint ce cas habituel de division entière? Essayez Math.ceil après la coulée soit numéro à un type à virgule flottante.

Answer 7

De nombreuses langues « pensent » comme ça. Si vous divisant un entier en un int, alors vous devriez obtenir un entier (ils tronquer et vous obtenez 1 en conséquence).

Nous savons tous que ce n'est pas vrai, mais comment ils fonctionnent. Vous pouvez « tricher » eux, et faire quelque chose comme jetant un d'entre eux à un double, ou utiliser une double représentation:. Ou Math.ceil (3.0 / 2) Math.ceil((double)3/2), comme mentionné

Answer 8

Math.ceil aide, à condition que vous utilisez des nombres à virgule flottante. Le problème est que 3/2, dans la division entière, est 1. Au moment où la valeur arrive à quelque fonction, que ce soit Math.ceil ou autre chose, la valeur est tout simplement 1. Toute partie décimale de fuite est partie.

Answer 9

if (a % b == 0)
{
  return (a / b);
}
else
{
  return (a / b) + 1;
}

Exploite division entière à faire ce que vous voulez. Je ne sais pas d'une fonction mathématique qui fait cela, mais pourquoi ne pas rouler votre propre?

Answer 10

ci-dessous fragment fonctionne avec des nombres entiers négatifs ainsi:

public static int divRoundUp(int x, int n) {
    if (n<=0) throw new RuntimeException("conceived wt. pos. dividers (was:"+n+")");
    int ret = (x+(n-1)*(x>0?1:0))/n;
    return ret;
}

Answer 11

J'aime la réponse de Randy Proctor le meilleur. Voici plus en détail:

Si vous voulez faire l'arrondi réel (à savoir 3/2 -> 2, mais 17/7 -> 2) avec des entiers> 0: utiliser au lieu de (dividend + (divisor / 2)) / divisor dividend / divisor.

Si dividende peut être un quelconque nombre entier (par exemple permis négatif): (dividend >= 0) ? ((dividend + divisor / 2) / divisor) : ((dividend - divisor / 2) / divisor).

Si dividende est un entier et Diviseur tout entier, mais 0: (dividend >= 0) ? ((dividend + Math.abs(divisor) / 2) / divisor) : ((dividend - Math.abs(divisor) / 2) / divisor).

(Notez que l'addition et la soustraction peuvent provoquer une autre enveloppant qui ne se produirait pas, ce qui rend le résultat incorrect.)

Answer 12

Voici une méthode que j'ai créé pour gérer la division int sans utiliser Round Math et coulée à flotter. Cela fonctionne pour les nombres positifs et négatifs. Il fonctionne en ajoutant la moitié du dénominateur pour compenser l'arrondi vers le bas

public static int div_Int(int num, int den){
    if(num > 0 && den > 0 || num < 0 && den < 0 ){
        return ((2*num)+ den)/(2*den);  
    }else{
        return ((2*num)- den)/(2*den);
    }

}

Answer 13

Si vous voulez diviser simplement par 2, vous pouvez faire:

n - n / 2

Et en général:

(n - 1) / d + 1 == (n + d - 1) / d

Ceci est valable pour des entiers non négatifs. Comment étendre aux entiers négatifs dépend de ce que vous entendez par «n'arrondi de cette façon ». La division entière est arrondie vers zéro, alors que arrondit et Math.ceil() arrondit Math.floor(). Par exemple pour n / 2 != (int) Math.floor(n / 2.0) n == -5.

Si vous voulez arrondir toujours, vous pouvez utiliser comme dans href="https://stackoverflow.com/a/1074235/913286"> cette réponse .

Answer 14

Si vous voulez vraiment éviter d'utiliser et Ceil coulée, voici une petite méthode qui fait la même chose.

public int findCeil(int X, int Y) {
        if (X % Y == 0){
            return X / Y;
        } else {
            return X / Y + 1;
        }
    }

Answer 15

Avez-vous essayé Math.floor()?