Rendre un nombre négatif positif

J'ai une méthode Java dans laquelle je additionne un ensemble de nombres. Cependant, je veux que tous les nombres négatifs soient traités comme positifs. Donc (1) + (2) + (1) + (- 1) doit être égal à 5.

Je suis sûr qu'il existe un moyen très simple de faire cela - je ne sais tout simplement pas comment.

Appelez simplement Math.abs . Par exemple:

int x = Math.abs(-5);

Ce qui sera défini xsur 5.

Le concept que vous décrivez est appelé «valeur absolue», et Java a une fonction appelée Math.abs pour le faire pour vous. Ou vous pouvez éviter l'appel de fonction et le faire vous-même:

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

ou

if (number < 0)
    number = -number;

Vous recherchez une valeur absolue, mon pote. Math.abs(-5)renvoie 5 ...

Utilisez la absfonction:

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

Ce code n'est pas sûr d'être appelé sur des nombres positifs.

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

Essayez ceci (le négatif devant le x est valide puisqu'il s'agit d'un opérateur unaire, en savoir plus ici ):

int answer = -x;

Avec cela, vous pouvez transformer un positif en négatif et un négatif en positif.

Cependant , si vous souhaitez uniquement rendre un nombre négatif positif, essayez ceci:

int answer = Math.abs(x);

OU , si vous préférez ne pas utiliser la méthode abs () pour une raison quelconque, essayez ceci:

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

J'espère que ça aide! Bonne chance!

Vous vous interrogez sur les valeurs absolues?

Math.abs (...) est la fonction que vous souhaitez probablement.

Vous voulez insérer chaque numéro dans Math.abs(). par exemple

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

imprime "1".

Si vous voulez éviter d'écrire le Math.-part, vous pouvez inclure l'utilitaire Math de manière statique. Ecrivez

import static java.lang.Math.abs;

avec vos importations, et vous pouvez vous référer à la abs()-fonction simplement en écrivant

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

Le moyen le plus simple, si détaillé de le faire, consiste à envelopper chaque nombre dans un appel Math.abs (), vous devez donc ajouter:

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

avec des changements de logique pour refléter la structure de votre code. Verbose, peut-être, mais il fait ce que vous voulez.

Lorsque vous avez besoin de représenter une valeur sans le concept de perte ou d'absence (valeur négative), cela s'appelle «valeur absolue».

La logique pour obtenir la valeur absolue est très simple: "If it's positive, maintain it. If it's negative, negate it".

Cela signifie que votre logique et votre code doivent fonctionner comme suit:

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

Il existe 2 façons d'annuler une valeur:

1. En niant sa valeur: value = (-value);
2. En le multipliant par "100% négatif" ou "-1": value = value * (-1);

Les deux sont en fait les deux faces d'une même médaille. Il est juste que vous ne vous souvenez pas généralement que value = (-value);est en réalité value = 1 * (-value);.

Eh bien, quant à la façon dont vous le faites réellement en Java, c'est très simple, car Java fournit déjà une fonction pour cela, dans le Math class:value = Math.abs(value);

Oui, le faire sans Math.abs()n'est qu'une ligne de code avec des mathématiques très simples, mais pourquoi rendre votre code laid? Utilisez simplement la Math.abs()fonction fournie par Java ! Ils le fournissent pour une raison!

Si vous devez absolument ignorer la fonction, vous pouvez utiliser value = (value < 0) ? (-value) : value;, qui est simplement une version plus compacte du code que j'ai mentionné dans la section logique (3e), en utilisant l' opérateur ternaire ( ? :) .

En outre, il peut y avoir des situations dans lesquelles vous souhaitez toujours représenter une perte ou une absence dans une fonction qui peut recevoir des valeurs positives et négatives.

Au lieu de faire une vérification compliquée, vous pouvez simplement obtenir la valeur absolue et l'annuler: negativeValue = (-Math.abs(value));

Dans cet esprit, et en considérant un cas avec une somme de plusieurs nombres comme le vôtre, ce serait une bonne idée d'implémenter une fonction:

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

En fonction de la probabilité que vous ayez à nouveau besoin de code associé, il peut également être judicieux de les ajouter à votre propre bibliothèque "utils", en divisant d'abord ces fonctions en leurs composants de base et en conservant la fonction finale simplement comme un nid d'appels à les fonctions désormais divisées des composants de base:

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

Pourquoi pas toi multiply that number with -1?

Comme ça:

//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 vous êtes intéressé par la mécanique du complément à deux, voici la manière absolument inefficace, mais illustrative, de bas niveau:

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

Je recommanderais les solutions suivantes:

sans lib fun:

    value = (value*value)/value

(Ce qui précède ne fonctionne pas réellement.)

avec lib fun:

   value = Math.abs(value);

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

Alternativement:

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

La fonction de bibliothèque Math.abs()peut être utilisée.
Math.abs()renvoie la valeur absolue de l'argument

• si l'argument est négatif, il renvoie la négation de l'argument.
• si l'argument est positif, il renvoie le nombre tel quel.

par exemple:

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

Sortie: 5

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

Sortie: 6

Pour convertir un nombre négatif en nombre positif (c'est ce qu'on appelle la valeur absolue), utilise Math.abs (). Cette méthode Math.abs () fonctionne comme ceci

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

Dans l'exemple ci-dessous, Math.abs(-1)convertira le nombre négatif 1 en positif 1.

exemple

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

Production

Total: 3 Total 2 (valeur absolue): 5

J'avais besoin de la valeur absolue d'un long, et j'ai regardé profondément dans Math.abs et j'ai trouvé que si mon argument est inférieur à LONG.MIN_VAL qui est -9223372036854775808l, alors la fonction abs ne renverrait pas une valeur absolue mais seulement la valeur minimale. Dans ce cas, si votre code utilise davantage cette valeur abs, il peut y avoir un problème.

Pouvez-vous essayer celui-ci?

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

Dans kotlin, vous pouvez utiliser unaryPlus

input = input.unaryPlus()

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

ne fais pas ça

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

ou

if (nombre <0) nombre = -nombre;

ce sera un bogue lorsque vous exécutez find bug sur votre code, il le signalera comme RV_NEGATING_RESULT_OF