Existe alguma função java ou classe utilizada que arredonda da seguinte maneira: func (3/2) = 2?

Question

Existe alguma função ou util class que faz arredondamento desta maneira: func(3/2) = 2

Math.ceil() Não ajuda, o que pelo nome deveria ter feito isso. Estou ciente BigDecimal, mas não precisa disso.

Answer 1

Math.ceil() sempre vai arredondar, por mais que você esteja fazendo divisão inteira com 3/2. Assim, uma vez que na divisão inteira 3/2 = 1 (não 1.5) o teto de 1 é 1.

O que você precisaria fazer para alcançar os resultados que deseja é Math.ceil(3/2.0);

Ao fazer a divisão por um valor duplo (2.0), você acaba fazendo divisão de pontos flutuantes em vez da divisão inteira. Desta forma 3/2.0 = 1.5, e as ceil() do 1.5 é sempre 2.

Answer 2

Um pouco de magia negra, e você pode fazer tudo com números inteiros:

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

Answer 3

Você sempre pode lançar primeiro:

Math.ceil((double)3/2)

Answer 4

Para converter divisão de piso em divisão de teto:

(numerator + denominator-1) / denominator

Para converter a divisão de pisos para a divisão de arredondamento:

(numerator + (denominator)/2) / denominator

Answer 5

Em Java, 3/2 = 1 porque usa divisão inteira. Não há nenhuma função que possa "consertar" isso depois. O que você precisa fazer é forçar uma divisão de flutuação e arredondar o resultado:

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

Answer 6

Não é o caso usual de divisão inteira? Experimente Math.Ceil depois de lançar qualquer número para um tipo de ponto flutuante.

Answer 7

Muitas línguas "pensam" assim. Se você está dividindo um INT em um INT, deve obter um int (para que eles truncem e obtenha 1 como resultado).

Todos sabemos que isso não é verdade, mas é assim que eles funcionam. Você pode "enganá -los" e fazer algo como lançar um deles para um dobro ou usar uma representação dupla: Math.ceil (3.0 / 2) ou Math.ceil((double)3/2), como mencionado.

Answer 8

Math.CEIL vai ajuda, desde que você use números de ponto flutuante. O problema é que 3/2, na divisão inteira, é 1. Quando o valor chegar a qualquer função, seja matemática.

Answer 9

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

Explora a divisão inteira para fazer o que você deseja. Não conheço uma função de matemática que faça isso, mas por que não rolar o seu?

Answer 10

Abaixo do fragmento funciona com números inteiros negativos também:

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

Eu gosto mais de resposta de Randy Proctor. Aqui em mais detalhes:

Se você quiser fazer arredondamento real (ou seja, 3/2 -> 2, mas 17/7 -> 2) com inteiros> 0: Use (dividend + (divisor / 2)) / divisor ao invés de dividend / divisor.

Se o dividendo pode ser algum número inteiro (ou seja, negativo):(dividend >= 0) ? ((dividend + divisor / 2) / divisor) : ((dividend - divisor / 2) / divisor).

Se o dividendo é algum número inteiro e divisor qualquer número inteiro, mas 0:(dividend >= 0) ? ((dividend + Math.abs(divisor) / 2) / divisor) : ((dividend - Math.abs(divisor) / 2) / divisor).

(Observe que a adição e a subtração podem causar um envoltório que, de outra forma, não ocorreria, tornando o resultado incorreto.)

Answer 12

Aqui está um método que eu criei para lidar com a divisão INT sem usar a rodada de matemática e o elenco para flutuar. Isso funciona para números positivos e negativos. Funciona adicionando metade do denominador para compensar o arredondamento

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

Se você quiser apenas dividir por 2, você pode fazer:

n - n / 2

E em geral:

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

Isso vale para números inteiros não negativos. Como estendê -lo a números inteiros negativos depende do que você quer dizer com "faz arredondamento dessa maneira". A divisão inteira é arredondada para zero, enquanto Math.ceil() Recorre e Math.floor() Recunda. Por exemplo n / 2 != (int) Math.floor(n / 2.0) por n == -5.

Se você quiser sempre arredondar, você pode usar Math.ceil() como em esta resposta.

Answer 14

Se você realmente deseja evitar o uso de teto e elenco, aqui está um pequeno método que realiza a mesma coisa.

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

Answer 15

Você tentou Math.floor() ?