Zmień liczbę ujemną na dodatnią

Mam metodę Java, w której sumuję zbiór liczb. Jednak chcę, aby wszystkie liczby ujemne były traktowane jako pozytywne. Zatem (1) + (2) + (1) + (- 1) powinno wynosić 5.

Jestem pewien, że można to zrobić w bardzo prosty sposób - po prostu nie wiem jak.

Wystarczy zadzwonić do Math.abs . Na przykład:

int x = Math.abs(-5);

Który będzie ustawiony xna 5.

Pojęcie, które opisujesz, nazywa się „wartością bezwzględną”, a Java ma funkcję o nazwie Math.abs, która zrobi to za Ciebie. Lub możesz uniknąć wywołania funkcji i zrobić to sam:

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

lub

if (number < 0)
    number = -number;

Szukasz wartości absolutnej, kolego. Math.abs(-5)zwraca 5 ...

Użyj absfunkcji:

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

Ten kod nie jest bezpieczny przy korzystaniu z liczb dodatnich.

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

Spróbuj tego (minus przed x jest prawidłowy, ponieważ jest operatorem jednoargumentowym, więcej informacji znajdziesz tutaj ):

int answer = -x;

Dzięki temu możesz zamienić pozytywne w negatywne i negatywne w pozytywne.

Jednakże , jeśli chcesz tylko dokonać liczba ujemna dodatnia, to spróbuj tego:

int answer = Math.abs(x);

LUB , jeśli z jakiegoś powodu nie chcesz używać metody abs (), spróbuj tego:

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

Mam nadzieję, że to pomoże! Powodzenia!

Pytasz o wartości bezwzględne?

Math.abs (...) to funkcja, której prawdopodobnie potrzebujesz.

Chcesz zawinąć każdą liczbę w Math.abs(). na przykład

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

wypisuje "1".

Jeśli chcesz uniknąć pisania Math.-part, możesz statycznie dołączyć narzędzie Math. Tylko napisz

import static java.lang.Math.abs;

wraz z importem i możesz odwołać się do abs()-funkcji po prostu pisząc

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

Najłatwiejszym, jeśli rozwlekłym sposobem na to jest zawinięcie każdej liczby w wywołaniu Math.abs (), więc należy dodać:

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

ze zmianami logiki, aby odzwierciedlić strukturę kodu. Być może gadatliwy, ale robi to, co chcesz.

Kiedy musisz przedstawić wartość bez pojęcia straty lub braku (wartość ujemna), nazywa się to „wartością bezwzględną”.

Układ logiczny, aby uzyskać wartość bezwzględna jest bardzo prosta "If it's positive, maintain it. If it's negative, negate it".

Oznacza to, że Twoja logika i kod powinny działać w następujący sposób:

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

Istnieją 2 sposoby na zanegowanie wartości:

1. Cóż, negując jego wartość: value = (-value);
2. Mnożąc ją przez „100% ujemne” lub „-1”: value = value * (-1);

Obie są w rzeczywistości dwiema stronami tej samej monety. Po prostu zazwyczaj nie pamiętasz, że value = (-value);tak jest value = 1 * (-value);.

Cóż, jeśli chodzi o sposób, w jaki faktycznie to robisz w Javie, jest to bardzo proste, ponieważ Java zapewnia już odpowiednią funkcję w Math class:value = Math.abs(value);

Tak, zrobienie tego bez Math.abs()to tylko wiersz kodu z bardzo prostą matematyką, ale po co sprawiać, by kod wyglądał brzydko? Po prostu użyj Math.abs()funkcji dostarczonej przez Javę ! Zapewniają to z jakiegoś powodu!

Jeśli absolutnie potrzebujesz pominąć tę funkcję, możesz użyć value = (value < 0) ? (-value) : value;, która jest po prostu bardziej zwartą wersją kodu, o którym wspomniałem w sekcji logiki (3.), używając operatora trójargumentowego ( ? :) .

Ponadto mogą zaistnieć sytuacje, w których chcesz zawsze przedstawiać utratę lub nieobecność w funkcji, która może otrzymywać zarówno wartości dodatnie, jak i ujemne.

Zamiast wykonywać skomplikowane sprawdzenie, możesz po prostu uzyskać wartość bezwzględną i zanegować ją: negativeValue = (-Math.abs(value));

Mając to na uwadze i biorąc pod uwagę przypadek z sumą wielu liczb, takich jak twoja, dobrym pomysłem byłoby zaimplementowanie funkcji:

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

W zależności od prawdopodobieństwa, że ​​będziesz potrzebować ponownie pokrewnego kodu, dobrym pomysłem może być dodanie ich do własnej biblioteki „narzędzi”, rozdzielając najpierw takie funkcje na ich podstawowe komponenty i utrzymując ostatnią funkcję po prostu jako zbiór wywołań podzielone teraz funkcje głównych komponentów:

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

Dlaczego nie multiply that number with -1?

Lubię to:

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

Jeśli interesuje Cię mechanika dopełnienia do dwóch, oto absolutnie nieefektywny, ale ilustrujący, niskopoziomowy sposób tego:

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

Poleciłbym następujące rozwiązania:

bez lib zabawy:

    value = (value*value)/value

(Powyższe faktycznie nie działa.)

z zabawą lib:

   value = Math.abs(value);

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

Alternatywnie:

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

Math.abs()Można użyć funkcji biblioteki .
Math.abs()zwraca wartość bezwzględną argumentu

• jeśli argument jest ujemny, zwraca negację argumentu.
• jeśli argument jest dodatni, zwraca liczbę taką, jaka jest.

na przykład:

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

Wyjście: 5

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

Wyjście: 6

Aby przekonwertować liczbę ujemną na liczbę dodatnią (nazywa się to wartością bezwzględną), używa funkcji Math.abs (). Ta metoda Math.abs () działa w ten sposób

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

W poniższym przykładzie Math.abs(-1)zamieni ujemną liczbę 1 na dodatnią 1.

przykład

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

Wynik

Suma: 3 Suma 2 (wartość bezwzględna): 5

Potrzebowałem wartości bezwzględnej long i zagłębiłem się w Math.abs i stwierdziłem, że jeśli mój argument jest mniejszy niż LONG.MIN_VAL, czyli -9223372036854775808l, to funkcja abs nie zwróciłaby wartości bezwzględnej, ale tylko wartość minimalną. W takim przypadku, jeśli Twój kod dalej używa tej wartości abs, może wystąpić problem.

Czy możesz spróbować tego?

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

W kotlinie możesz użyć unaryPlus

input = input.unaryPlus()

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

nie rób tego

liczba = (liczba <0? -numer: liczba);

lub

if (liczba <0) liczba = -liczba;

to będzie błąd, gdy uruchomisz znajdź błąd w swoim kodzie, zgłosi go jako RV_NEGATING_RESULT_OF