Tornar um número negativo positivo

Eu tenho um método Java no qual estou somando um conjunto de números. No entanto, quero que quaisquer números negativos sejam tratados como positivos. Então (1) + (2) + (1) + (- 1) deve ser igual a 5.

Tenho certeza de que há uma maneira muito fácil de fazer isso - simplesmente não sei como.

Basta ligar para Math.abs . Por exemplo:

int x = Math.abs(-5);

Qual será definido xcomo 5.

O conceito que você está descrevendo é chamado de "valor absoluto" e o Java tem uma função chamada Math.abs para fazer isso por você. Ou você pode evitar a chamada de função e fazer você mesmo:

number = (number < 0 ? -number : number);

ou

if (number < 0)
    number = -number;

Você está procurando por valor absoluto, companheiro. Math.abs(-5)retorna 5 ...

Use a absfunção:

int sum=0;
for(Integer i : container)
  sum+=Math.abs(i);

Este código não é seguro para ser chamado em números positivos.

int x = -20
int y = x + (2*(-1*x));
// Therefore y = -20 + (40) = 20

Tente isso (o negativo na frente do x é válido, pois é um operador unário, encontre mais aqui ):

int answer = -x;

Com isso, você pode transformar um positivo em negativo e um negativo em positivo.

No entanto , se você deseja apenas tornar positivo um número negativo, tente o seguinte:

int answer = Math.abs(x);

OU , se você preferir não usar o método abs () por algum motivo, tente o seguinte:

int answer = Math.sqrt(Math.pow(x, 2));

Espero que ajude! Boa sorte!

Você está perguntando sobre valores absolutos?

Math.abs (...) é a função que você provavelmente deseja.

Você deseja agrupar cada número Math.abs(). por exemplo

System.out.println(Math.abs(-1));

imprime "1".

Se você deseja evitar escrever a Math.parte, pode incluir estaticamente o utilitário Math. Apenas escreva

import static java.lang.Math.abs;

junto com suas importações, e você pode consultar a abs()função apenas escrevendo

System.out.println(abs(-1));

A maneira mais fácil, se detalhada, de fazer isso é agrupar cada número em uma chamada Math.abs (); portanto, você deve adicionar:

Math.abs(1) + Math.abs(2) + Math.abs(1) + Math.abs(-1)

com alterações lógicas para refletir como seu código está estruturado. Detalhado, talvez, mas faz o que você deseja.

Quando você precisa representar um valor sem o conceito de perda ou ausência (valor negativo), isso é chamado de "valor absoluto".

A lógica para obter o valor absoluto é muito simples: "If it's positive, maintain it. If it's negative, negate it".

O que isso significa é que sua lógica e código devem funcionar da seguinte maneira:

//If value is negative...
if ( value < 0 ) {
  //...negate it (make it a negative negative-value, thus a positive value).
  value = negate(value);
}

Existem duas maneiras de negar um valor:

1. Negando seu valor: value = (-value);
2. Ao multiplicá-lo por "100% negativo" ou "-1": value = value * (-1);

Ambos são na verdade dois lados da mesma moeda. É que você geralmente não se lembra que value = (-value);é realmente value = 1 * (-value);.

Bem, sobre como você realmente faz isso em Java, é muito simples, porque Java já fornece uma função para isso, no Math class:value = Math.abs(value);

Sim, fazê-lo sem Math.abs()é apenas uma linha de código com uma matemática muito simples, mas por que tornar seu código feio? Basta usar a Math.abs()função fornecida pelo Java ! Eles fornecem isso por uma razão!

Se você absolutamente precisar pular a função, poderá usar value = (value < 0) ? (-value) : value;, que é simplesmente uma versão mais compacta do código que mencionei na seção lógica (3), usando o operador Ternary ( ? :) .

Além disso, pode haver situações em que você sempre queira representar perda ou ausência em uma função que possa receber valores positivos e negativos.

Em vez de fazer uma verificação complicada, você pode simplesmente obter o valor absoluto e negá-lo: negativeValue = (-Math.abs(value));

Com isso em mente, e considerando um caso com uma soma de vários números como o seu, seria uma boa idéia implementar uma função:

int getSumOfAllAbsolutes(int[] values){
  int total = 0;
  for(int i=0; i<values.lenght; i++){
    total += Math.abs(values[i]);
  }
  return total;
}

Dependendo da probabilidade de você precisar do código relacionado novamente, também pode ser uma boa ideia adicioná-los à sua própria biblioteca "utils", dividindo essas funções em seus componentes principais primeiro e mantendo a função final simplesmente como um ninho de chamadas para as funções agora divididas dos componentes principais:

int[] makeAllAbsolute(int[] values){
  //@TIP: You can also make a reference-based version of this function, so that allocating 'absolutes[]' is not needed, thus optimizing.
  int[] absolutes = values.clone();
  for(int i=0; i<values.lenght; i++){
    absolutes[i] = Math.abs(values[i]);
  }
  return absolutes;
}

int getSumOfAllValues(int[] values){
  int total = 0;
  for(int i=0; i<values.lenght; i++){
    total += values[i];
  }
return total;
}

int getSumOfAllAbsolutes(int[] values){
  return getSumOfAllValues(makeAllAbsolute(values));
}

Por que não você multiply that number with -1?

Como isso:

//Given x as the number, if x is less than 0, return 0 - x, otherwise return x:
return (x <= 0.0F) ? 0.0F - x : x;

Se você está interessado na mecânica do complemento de dois, aqui está a maneira absolutamente ineficiente, mas ilustrativa, de baixo nível:

private static int makeAbsolute(int number){
     if(number >=0){
        return number;
     } else{
        return (~number)+1;
     }
}

Eu recomendaria as seguintes soluções:

sem diversão divertida:

    value = (value*value)/value

(Na verdade, o acima não funciona.)

com lib diversão:

   value = Math.abs(value);

String s = "-1139627840";
BigInteger bg1 = new BigInteger(s);
System.out.println(bg1.abs());

Alternativamente:

int i = -123;
System.out.println(Math.abs(i));

A função de biblioteca Math.abs()pode ser usada.
Math.abs()retorna o valor absoluto do argumento

• se o argumento for negativo, ele retornará a negação do argumento.
• se o argumento for positivo, ele retornará o número como está.

por exemplo:

1. int x=-5;
System.out.println(Math.abs(x));

Saída: 5

2. int y=6;
System.out.println(Math.abs(y));

Saída: 6

Para converter número negativo em número positivo (isso é chamado de valor absoluto), usa Math.abs (). Esse método Math.abs () funciona assim

“number = (number < 0 ? -number : number);".

No exemplo abaixo, Math.abs(-1)irá converter o número negativo 1 em positivo 1.

exemplo

public static void main (String [] args) {

    int total = 1 + 1 + 1 + 1 + (-1);
    
    //output 3
    System.out.println("Total : " + total);
    
    int total2 = 1 + 1 + 1 + 1 + Math.abs(-1);
    
    //output 5
    System.out.println("Total 2 (absolute value) : " + total2);
    
}

Resultado

Total: 3 Total 2 (valor absoluto): 5

Eu precisava do valor absoluto de um longo e analisei profundamente o Math.abs e descobri que, se meu argumento for menor que LONG.MIN_VAL que é -9223372036854775808l, a função abs não retornará um valor absoluto, mas apenas o valor mínimo. Nesse caso, se o seu código estiver usando esse valor abs ainda mais, pode haver um problema.

Você pode tentar este?

public static int toPositive(int number) {
    return number & 0x7fffffff;
}

No kotlin você pode usar o unaryPlus

input = input.unaryPlus()

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/unary-plus.html

não faça isso

número = (número <0? -número: número);

ou

if (número <0) número = -número;

isso será um erro quando você executar o comando find bug no seu código, ele será reportado como RV_NEGATING_RESULT_OF