Сделайте отрицательное число положительным

У меня есть метод Java, в котором я суммирую набор чисел. Однако я хочу, чтобы любые отрицательные числа рассматривались как положительные. Таким образом, (1) + (2) + (1) + (- 1) должно быть равно 5.

Я уверен, что есть очень простой способ сделать это - я просто не знаю как.

Просто позвоните Math.abs . Например:

int x = Math.abs(-5);

Который будет установлен xв 5.

Концепция, которую вы описываете, называется «абсолютной величиной», и в Java есть функция Math.abs, которая сделает это за вас. Или вы можете избежать вызова функции и сделать это самостоятельно:

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

или

if (number < 0)
    number = -number;

Вы ищете абсолютную ценность, приятель. Math.abs(-5)возвращает 5 ...

Используйте absфункцию:

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

Этот код не безопасно быть вызван положительными числами.

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

Попробуйте это (минус перед x действителен, так как это унарный оператор, узнайте больше здесь ):

int answer = -x;

При этом вы можете превратить положительное в отрицательное и отрицательное в положительное.

Однако , если вы хотите, чтобы только отрицательное число было положительным, попробуйте следующее:

int answer = Math.abs(x);

ИЛИ , если вы по какой-то причине предпочитаете не использовать метод abs (), попробуйте следующее:

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

Надеюсь, поможет! Удачи!

Вы спрашиваете об абсолютных значениях?

Math.abs (...) - это функция, которую вы, вероятно, хотите.

Вы хотите обернуть каждый номер в Math.abs(). например

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

распечатывает «1».

Если вы хотите избежать написания Math.-part, вы можете использовать Math статически. Просто пиши

import static java.lang.Math.abs;

вместе с вашим импортом, и вы можете обратиться к abs()-функции просто написав

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

Самый простой, если многословный способ сделать это - это обернуть каждый номер в вызове Math.abs (), поэтому вы должны добавить:

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

с изменениями логики, чтобы отразить, как ваш код структурирован. Возможно, многословно, но оно делает то, что вы хотите.

Когда вам нужно представить значение без понятия потери или отсутствия (отрицательное значение), это называется «абсолютным значением».

Логика , чтобы получить абсолютное значение очень просто: "If it's positive, maintain it. If it's negative, negate it".

Это означает, что ваша логика и код должны работать следующим образом:

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

Есть два способа отменить значение:

1. Ну, отрицая это значение: value = (-value);
2. Умножив его на «100% отрицательный» или «-1»: value = value * (-1);

Обе они на самом деле две стороны одной медали. Просто ты обычно не помнишь, что value = (-value);на самом деле value = 1 * (-value);.

Что касается того, как вы на самом деле делаете это в Java, это очень просто, потому что Java уже предоставляет функцию для этого в Math class:value = Math.abs(value);

Да, без этого Math.abs()- просто строка кода с очень простой математикой, но зачем делать ваш код уродливым? Просто используйте Math.abs()функцию Java ! Они предоставляют это по причине!

Если вам абсолютно необходимо пропустить функцию, вы можете использовать ее value = (value < 0) ? (-value) : value;, которая является просто более компактной версией кода, который я упомянул в разделе логики (3-й), с использованием оператора Ternary ( ? :) .

Кроме того, могут быть ситуации, когда вы хотите всегда представлять потерю или отсутствие в функции, которая может принимать как положительные, так и отрицательные значения.

Вместо сложной проверки вы можете просто получить абсолютное значение и опровергнуть его: negativeValue = (-Math.abs(value));

Имея это в виду и рассматривая случай с суммой нескольких чисел, таких как ваше, было бы неплохо реализовать функцию:

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

В зависимости от вероятности, что вам может понадобиться снова связанный код, также может быть хорошей идеей добавить их в вашу собственную библиотеку «utils», сначала разделить такие функции на их основные компоненты и поддерживать конечную функцию просто как гнездо вызовов для разделенные функции основных компонентов:

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

Почему не ты multiply that number with -1?

Как это:

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

Если вы заинтересованы в механике дополнения до двух, вот абсолютно неэффективный, но иллюстративный низкоуровневый способ сделать это:

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

Я бы порекомендовал следующие решения:

без веселья

    value = (value*value)/value

(Выше не работает.)

с lib fun:

   value = Math.abs(value);

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

В качестве альтернативы:

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

Библиотечная функция Math.abs()может быть использована.
Math.abs()возвращает абсолютное значение аргумента

• если аргумент отрицательный, он возвращает отрицание аргумента.
• если аргумент положительный, он возвращает число как есть.

например:

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

Выход: 5

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

Выход: 6

Чтобы преобразовать отрицательное число в положительное число (это называется абсолютным значением), используется Math.abs (). Этот метод Math.abs () работает следующим образом

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

В приведенном ниже примере, Math.abs(-1)будет преобразовывать отрицательное число 1 в положительное 1.

пример

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

Вывод

Всего: 3 Всего 2 (абсолютное значение): 5

Мне нужно было абсолютное значение long, и я внимательно изучил Math.abs и обнаружил, что если мой аргумент меньше LONG.MIN_VAL, который равен -9223372036854775808l, то функция abs не будет возвращать абсолютное значение, а только минимальное значение. В этом случае, если ваш код использует это значение abs дальше, то это может быть проблемой.

Можете ли вы попробовать это?

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

В kotlin вы можете использовать unaryPlus

input = input.unaryPlus()

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

не делай этого

число = (число <0? -номер: число);

или

if (число <0) число = -номер;

это будет ошибка, когда вы запустите поиск ошибки в вашем коде, он сообщит об этом как RV_NEGATING_RESULT_OF