Hacer un número negativo positivo

Tengo un método Java en el que estoy sumando un conjunto de números. Sin embargo, quiero que los números negativos se traten como positivos. Entonces (1) + (2) + (1) + (- 1) debería ser igual a 5.

Estoy seguro de que hay una manera muy fácil de hacer esto, simplemente no sé cómo.

Simplemente llame a Math.abs . Por ejemplo:

int x = Math.abs(-5);

Que se establecerá xen 5.

El concepto que está describiendo se llama "valor absoluto", y Java tiene una función llamada Math.abs para hacerlo por usted. O puede evitar la llamada a la función y hacerlo usted mismo:

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

o

if (number < 0)
    number = -number;

Estás buscando un valor absoluto, amigo. Math.abs(-5)devuelve 5 ...

Usa la absfunción:

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

Este código es no seguro para ser llamada en números positivos.

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

Pruebe esto (lo negativo delante de la x es válido ya que es un operador unario, encuentre más aquí ):

int answer = -x;

Con esto, puede convertir lo positivo en negativo y lo negativo en positivo.

Sin embargo , si solo desea que un número negativo sea positivo, intente esto:

int answer = Math.abs(x);

O , si prefiere no usar el método abs () por alguna razón, intente esto:

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

¡Espero eso ayude! ¡Buena suerte!

¿Estás preguntando sobre valores absolutos?

Math.abs (...) es la función que probablemente desee.

Desea envolver cada número en Math.abs(). p.ej

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

imprime "1".

Si desea evitar escribir la parte Math., puede incluir la utilidad matemática estáticamente. Solo escribe

import static java.lang.Math.abs;

junto con sus importaciones, y puede consultar la abs()función simplemente escribiendo

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

La manera más fácil, si es una forma detallada de hacer esto, es envolver cada número en una llamada Math.abs (), por lo que agregaría:

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

con cambios lógicos para reflejar cómo está estructurado su código. Detallado, tal vez, pero hace lo que quieres.

Cuando necesita representar un valor sin el concepto de pérdida o ausencia (valor negativo), eso se denomina "valor absoluto".

La lógica para obtener el valor absoluto es muy simple: "If it's positive, maintain it. If it's negative, negate it".

Lo que esto significa es que su lógica y código deberían funcionar de la siguiente manera:

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

Hay 2 formas de negar un valor:

1. Por, bueno, negando su valor: value = (-value);
2. Al multiplicarlo por "100% negativo" o "-1": value = value * (-1);

Ambas son en realidad dos caras de la misma moneda. Es solo que generalmente no recuerdas que value = (-value);es realmente value = 1 * (-value);.

Bueno, en cuanto a cómo lo haces realmente en Java, es muy simple, porque Java ya proporciona una función para eso, en Math class:value = Math.abs(value);

Sí, hacerlo sin él Math.abs()es solo una línea de código con matemática muy simple, pero ¿por qué hacer que su código se vea feo? ¡Solo use la Math.abs()función proporcionada por Java ! Lo proporcionan por una razón!

Si realmente necesita omitir la función, puede usar value = (value < 0) ? (-value) : value;, que es simplemente una versión más compacta del código que mencioné en la sección lógica (3ra), usando el operador Ternary ( ? :) .

Además, puede haber situaciones en las que desee representar siempre la pérdida o ausencia dentro de una función que pueda recibir valores positivos y negativos.

En lugar de hacer una comprobación complicada, simplemente puede obtener el valor absoluto y negarlo: negativeValue = (-Math.abs(value));

Con eso en mente, y considerando un caso con una suma de múltiples números como el tuyo, sería una buena idea implementar una función:

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

Dependiendo de la probabilidad de que pueda necesitar código relacionado nuevamente, también podría ser una buena idea agregarlos a su propia biblioteca "utils", dividiendo dichas funciones en sus componentes principales primero y manteniendo la función final simplemente como un nido de llamadas a las funciones ahora divididas de los componentes principales:

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

Porque no multiply that number with -1 ?

Me gusta esto:

//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;

Si está interesado en la mecánica del complemento de dos, esta es la forma absolutamente ineficiente, pero ilustrativa de bajo nivel que se hace:

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

Yo recomendaría las siguientes soluciones:

sin diversión lib:

    value = (value*value)/value

(Lo anterior en realidad no funciona).

con diversión lib:

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

Math.abs()Se puede usar la función de biblioteca .
Math.abs()devuelve el valor absoluto del argumento

• Si el argumento es negativo, devuelve la negación del argumento.
• Si el argumento es positivo, devuelve el número tal como está.

p.ej:

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

Salida: 5

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

Salida: 6

Para convertir un número negativo en un número positivo (esto se llama valor absoluto), usa Math.abs (). Este método Math.abs () funciona así

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

En el siguiente ejemplo, Math.abs(-1)convertirá el número negativo 1 en positivo 1.

ejemplo

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

Salida

Total: 3 Total 2 (valor absoluto): 5

Necesitaba el valor absoluto de un largo, y busqué profundamente en Math.abs y descubrí que si mi argumento es menor que LONG.MIN_VAL, que es -9223372036854775808l, entonces la función abs no devolvería un valor absoluto sino solo el valor mínimo. En este caso, si su código está usando este valor de abs más, entonces podría haber un problema.

¿Puedes probar este?

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

En kotlin puedes usar unaryPlus

input = input.unaryPlus()

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

no hagas esto

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

o

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

esto será un error cuando ejecute find bug en su código, lo informará como RV_NEGATING_RESULT_OF