Machen Sie eine negative Zahl positiv

Ich habe eine Java-Methode, bei der ich eine Reihe von Zahlen summiere. Ich möchte jedoch, dass negative Zahlen als positive behandelt werden. Also sollte (1) + (2) + (1) + (- 1) gleich 5 sein.

Ich bin sicher, es gibt einen sehr einfachen Weg, dies zu tun - ich weiß nur nicht wie.

Rufen Sie einfach Math.abs an . Beispielsweise:

int x = Math.abs(-5);

Welche gesetzt wird xzu 5.

Das Konzept, das Sie beschreiben, heißt "absoluter Wert", und Java hat eine Funktion namens Math.abs , die dies für Sie erledigt . Oder Sie können den Funktionsaufruf vermeiden und selbst ausführen:

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

oder

if (number < 0)
    number = -number;

Du suchst nach einem absoluten Wert, Kumpel. Math.abs(-5)gibt 5 zurück ...

Verwenden Sie die absFunktion:

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

Dieser Code kann nicht sicher bei positiven Zahlen aufgerufen werden.

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

Versuchen Sie dies (das Negativ vor dem x ist gültig, da es sich um einen unären Operator handelt. Weitere Informationen finden Sie hier ):

int answer = -x;

Damit können Sie ein Positiv in ein Negativ und ein Negativ in ein Positiv verwandeln.

Allerdings , wenn Sie wollen nur eine negative Zahl positiv machen dann versuchen Sie dies:

int answer = Math.abs(x);

ODER , wenn Sie die abs () -Methode aus irgendeinem Grund nicht verwenden möchten, versuchen Sie Folgendes:

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

Ich hoffe es hilft! Viel Glück!

Fragen Sie nach absoluten Werten?

Math.abs (...) ist die Funktion, die Sie wahrscheinlich wollen.

Sie möchten jede Zahl einschließen Math.abs(). z.B

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

druckt "1" aus.

Wenn Sie das Schreiben des Math.Teils vermeiden möchten , können Sie das Math-Util statisch einschließen. Einfach schreiben

import static java.lang.Math.abs;

zusammen mit Ihren Importen, und Sie können auf die abs()-funktion nur durch Schreiben verweisen

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

Der einfachste, wenn auch ausführliche Weg, dies zu tun, besteht darin, jede Nummer in einen Math.abs () -Aufruf zu verpacken. Sie würden also hinzufügen:

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

mit logischen Änderungen, um die Struktur Ihres Codes widerzuspiegeln. Vielleicht ausführlich, aber es macht, was Sie wollen.

Wenn Sie einen Wert ohne das Konzept eines Verlusts oder einer Abwesenheit (negativer Wert) darstellen müssen, wird dies als "absoluter Wert" bezeichnet.

Die Logik zum Erhalten des Absolutwerts ist sehr einfach : "If it's positive, maintain it. If it's negative, negate it".

Dies bedeutet, dass Ihre Logik und Ihr Code wie folgt funktionieren sollten:

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

Es gibt zwei Möglichkeiten, einen Wert zu negieren:

1. Indem man seinen Wert negiert: value = (-value);
2. Durch Multiplikation mit "100% negativ" oder "-1": value = value * (-1);

Beide sind eigentlich zwei Seiten derselben Medaille. Es ist nur so, dass Sie sich normalerweise nicht daran erinnern, dass dies value = (-value);tatsächlich der Fall ist value = 1 * (-value);.

Nun, wie Sie es tatsächlich in Java machen, es ist sehr einfach, da Java bereits eine Funktion dafür bereitstellt Math class:value = Math.abs(value);

Ja, es ohne Math.abs()ist nur eine Codezeile mit sehr einfacher Mathematik, aber warum sollte Ihr Code hässlich aussehen? Verwenden Sie einfach die von Java bereitgestellte Math.abs()Funktion! Sie bieten es aus einem Grund!

Wenn Sie die Funktion unbedingt überspringen müssen, können Sie value = (value < 0) ? (-value) : value;mit dem ternären Operator ( ? :) einfach eine kompaktere Version des Codes verwenden, den ich im Abschnitt Logik (3.) erwähnt habe .

Darüber hinaus kann es Situationen geben, in denen Sie Verlust oder Abwesenheit innerhalb einer Funktion immer darstellen möchten, die sowohl positive als auch negative Werte erhalten.

Anstatt eine komplizierte Prüfung durchzuführen, können Sie einfach den absoluten Wert abrufen und ihn negieren: negativeValue = (-Math.abs(value));

Vor diesem Hintergrund und in Anbetracht eines Falls mit einer Summe mehrerer Zahlen wie Ihrer wäre es eine gute Idee, eine Funktion zu implementieren:

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

Abhängig von der Wahrscheinlichkeit, dass Sie erneut verwandten Code benötigen, ist es möglicherweise auch eine gute Idee, diese zu Ihrer eigenen "Utils" -Bibliothek hinzuzufügen, diese Funktionen zuerst in ihre Kernkomponenten aufzuteilen und die endgültige Funktion einfach als Nest von Aufrufen zu verwalten die jetzt geteilten Funktionen der Kernkomponenten:

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

Warum gehst du nicht multiply that number with -1?

So was:

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

Wenn Sie sich für die Mechanik des Zweierkomplements interessieren, finden Sie hier die absolut ineffiziente, aber anschauliche Methode auf niedriger Ebene:

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

Ich würde folgende Lösungen empfehlen:

ohne lib spaß:

    value = (value*value)/value

(Das oben genannte funktioniert nicht wirklich.)

mit lib spaß:

   value = Math.abs(value);

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

Alternative:

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

Die Bibliotheksfunktion Math.abs()kann verwendet werden.
Math.abs()Gibt den absoluten Wert des Arguments zurück

• Wenn das Argument negativ ist, wird die Negation des Arguments zurückgegeben.
• Wenn das Argument positiv ist, wird die Zahl so zurückgegeben, wie sie ist.

z.B:

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

Ausgabe: 5

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

Ausgabe: 6

Verwenden Sie Math.abs (), um eine negative Zahl in eine positive Zahl umzuwandeln (dies wird als absoluter Wert bezeichnet). Diese Math.abs () -Methode funktioniert folgendermaßen

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

Im folgenden Beispiel Math.abs(-1)wird die negative Zahl 1 in die positive 1 umgewandelt.

Beispiel

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

Ausgabe

Gesamt: 3 Gesamt 2 (absoluter Wert): 5

Ich brauchte den absoluten Wert eines Long und schaute tief in Math.abs hinein und stellte fest, dass die abs-Funktion keinen absoluten Wert zurückgeben würde, sondern nur den minimalen Wert, wenn mein Argument kleiner als LONG.MIN_VAL ist, was -9223372036854775808l ist. In diesem Fall liegt möglicherweise ein Problem vor, wenn Ihr Code diesen abs-Wert weiter verwendet.

Kannst du das bitte versuchen?

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

In Kotlin können Sie unaryPlus verwenden

input = input.unaryPlus()

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

Tu das nicht

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

oder

if (number <0) number = -number;

Dies ist ein Fehler, wenn Sie einen Suchfehler in Ihrem Code ausführen, der als RV_NEGATING_RESULT_OF gemeldet wird