Преобразовать положительное число в отрицательное в C #

Вы можете преобразовать отрицательное число в положительное, например так:

int myInt = System.Math.Abs(-5);

Есть ли эквивалентный способ сделать положительное число отрицательным?

 recursive28 авг. 2009 г., 18:43
280Z28: это эквивалентно myInt = -1.
 QMaster21 апр. 2018 г., 16:48
Я удивлен таким большим количеством ответов на этот маленький вопрос, но шокирован тем, что не обнаружил никаких дискуссий о сравнении производительности различных решений!
 Cecil Has a Name28 авг. 2009 г., 18:49
@ 280Z28: Это работает только для нечетных чисел, в противном случае это 'То же самое, что сделать отрицательное число, а затем вычесть 1.
 backslash1728 авг. 2009 г., 19:16
Это'Проще спросить, чем думать! Тот'доказанный факт.
 MusiGenesis28 авг. 2009 г., 18:48
Это должно быть сообщество вики, из-за его развлекательной ценности, а также из-за того, что он является предостерегающим рассказом об опасности создания головы из Legos.
 Charles Bretana28 авг. 2009 г., 19:18
@ 280Z28, что я написал не 'отрицающая» число, которое должно быть эквивалентно минус абсолютное значение числа, которое отличается. отрицание отрицательного результата привело бы к положительному результату. Я предположил, что спрашивающий хочет порождать негатив из любого числа положительного или отрицательного ...
 Sam Harwell28 авг. 2009 г., 19:08
@ Чарльз, если ты неЕсли вы хотите учесть отрицательные числа, вы можете отменить число с помощью(myInt = ~myInt + 1), То, как у вас это просто(myInt = myInt - 2147483647 - 1) для положительных чисел (отрицательный без изменений), что примерно так же полезно, как тот, который я положил в первом комментарии. :) Для чисел с плавающей запятой, битовая манипуляция, как у вас, работает.
 Austin Salonen28 авг. 2009 г., 18:33
 Chris Dwyer28 авг. 2009 г., 18:53
Для ясности кода я нея думаю, что вы должны использовать System.Math.Abs (), если хотите простопреобразовать отрицательное число в положительное, Математически этоЭто не абсолютная ценность, даже если вы получите желаемый результат. В зависимости от вашего алгоритмического контекста, вы должны использовать решение, которое выМы согласились ниже с переходом от отрицательного к положительному.
 Sam Harwell28 авг. 2009 г., 18:58
все, должно быть, полностью пропустили мой лол. Я просто взял положительное число в отрицательное число. : о
 Sam Harwell28 авг. 2009 г., 18:28
myInt |= -1; лол
 Charles Bretana28 авг. 2009 г., 18:49
должен быть myInt | = int.MinValue;
 kokbira20 авг. 2012 г., 15:39
Вы знаете силу сигнала минус?
 Matt28 авг. 2009 г., 20:13
Хороший, Ник. Теперь, если вы удалите свой вопрос, вы можете получить значок давления со стороны сверстников! OTOH, если вы дадите ему немного времени и еще пару человек понизите голос, тогда Джим У и Дж. Данкерли могут получить значок реверса. :-)»
 H.B.08 февр. 2011 г., 13:02
Преобразовать положительное число в отрицательное это не то же самое, что просить отрицательный эквивалентMath.Absи принятый ответ также не делает этого, он просто инвертирует знак любого числа. Поэтому вы должны синхронизировать 1.Title, 2.Question & 3. Принятый ответ.
 MusiGenesis28 авг. 2009 г., 18:58
Это "приведи сына / дочь на рабочий день на StackOverflow или что-то?
 Aran Mulholland01 апр. 2012 г., 13:47
@MusiGenesis множественное число от Lego - это Lego, нет такой вещи, как Legos.

Ответы на вопрос(22)

long negativeNumber = (long)positiveInt - (long)(int.MaxValue + 1);

Никто не сказал, что это должно бытьконкретный отрицательное число.

 MusiGenesis19 окт. 2011 г., 01:44
@ Гуффа: этошутка здесь, на самом деле.
 Guffa19 окт. 2011 г., 00:12
Байт можетбыть отрицательным ...
 Beska28 авг. 2009 г., 19:13
Эм, если ты нене волнует, что это должно бытьконкретный отрицательное число, вы могли бы упростить это доlong absoluteNumber = -1; "
 MusiGenesis28 авг. 2009 г., 19:41
Эх, просто сделай это байтом. :)

поставьте перед ним отрицательный знак.

var positive = 6;
var negative = -positive;
 recursive28 авг. 2009 г., 18:29
Все забывают унарный минус.
 xofz08 сент. 2010 г., 17:51
Это должен быть принятый ответ.
 Inisheer28 авг. 2009 г., 18:35
+1 .. бей меня к этому.
 random6553721 мая 2012 г., 05:47
В чем практическая разница между этим и этим ответом:stackoverflow.com/questions/1348080/...  int myNegInt = System.Math.Abs(myNumber) * (-1);
 Joe White21 мая 2012 г., 15:24
@ makerofthings7, на который вы ссылаетесь, гораздо больше инструкций ЦП - операция с абсолютным значением (по крайней мере,три инструкции на x86), за которым следует MUL (или, возможно, NEG, если компилятор умен). Этот ответ представляет собой простой, легкий код операции NEG, ничего более или менее того, что вам нужно. Конечно, два ответа ведут себя по-разному, когда введенное число уже отрицательно; если (в отличие от этого вопроса) ваш вклад может быть отрицательным, это решение за вас.

вы просто используете оператор знака:

myInt = -myInt;

Чтобы сделать его отрицательным независимо от того, является ли исходное значение отрицательным или нет, вы сначала используете метод Abs:

myInt = -Math.Abs(myInt);
 Clive Galway03 сент. 2018 г., 11:39
Неправильно. Не работает сint.MinValue
int negInt = 0 - myInt;

Или гарантированно будет отрицательным.

int negInt = -System.Math.Abs(someInt);

Может быть, это?

int n;

.... some coding....

n = n<=0? n:0-n;
 kokbira20 авг. 2012 г., 15:42
лучшее решение

int.MinValue * -1 == int.MinValue

Это действительно зависит от вашего приложения, но для моего (инвертирование осей джойстика) я хочу убедиться, что все крайности все еще достижимы, и поддерживать как можно большую точность.

Для этого я сопоставляю Макса <-> Мин и все промежуточное получает* -1

Используя эту технику, -32767 недоступен при инвертировании.

private static int Invert(int value) { if (value == int.MaxValue) return int.MinValue; if (value == int.MinValue) return int.MaxValue; return value * -1; }

Хотя я'Я опоздал на вечеринку здесь, яЯ собираюсь войти с некоторыми полезными уловками из моих аппаратных дней. Все они предполагают 2 'Комплимент представления для подписанных номеров.

int negate = ~i+1;
int positiveMagnitude = (i ^ (i>>31)) - (i>>31);
int negativeMagnitude = (i>>31) - (i ^ (i>>31));
 Clive Galway03 сент. 2018 г., 11:36
Хотите объяснить это больше? сi == int.MinValueтогда все переменные-2147483648

льного в положительное:

public static decimal Reverse(this decimal source)
{
     return source * decimal.MinusOne;
}

Это неправильно для положительных входов ... Я сделал ошибку, забыв, что остальные биты в -x (значение 2s-Complement) являются 'напротив' их значения в + х, а не то же самое. ТАК, что просто изменение знакового бита НЕ будет работать для положительных чисел.

оставлю это здесь для целей ...

Или хитрый способ (я думаю) ...

int y = x | ~ Int.MaxValue;

cause int.MaxValue is 0111 1111 1111 1111 1111 1111 1111 1111

так

~int.MaxValue is      1000 0000 0000 0000 0000 0000 0000 0000

и, следовательно, любой int32 илиed с этим установит 1 в бит знака (делая его отрицательным) и оставит все остальные биты такими же ...

: на самом деле, так как 1000 0000 0000 0000 0000 0000 0000 0000 на самом деле Minvalue, это также должно работать:

   int y = x | int.MinValue; // or, to do it to itself,
   x |= int.MinValue;
 Charles Bretana30 авг. 2009 г., 04:48
@ Mehrdad, да тыЯ забыл это.
 Charles Bretana29 авг. 2009 г., 01:20
... и благодаря @Mehrad 'Ответ ниже, это единственный подход, который работает, когда input int.MinValue ...
 recursive28 авг. 2009 г., 18:42
Итак, отрицательный ноль равен int.MinValue?
 MusiGenesis28 авг. 2009 г., 19:10
+1, потому что никто не заслуживает того, чтобы его понизили за ответ на вопрос типа "какое письмо идет после А, но до С?
 Charles Bretana28 авг. 2009 г., 18:46
Нет, в дополнении двойки нет отрицательного нуля. все из них отрицательные 1. Подписанный 8-битный Int: 10000000 -128
 Mehrdad Afshari29 авг. 2009 г., 01:40
Чарльз: Это неправильно. Для отрицательных чисел это работает, но для положительных чисел, просто щелкнув бит знака нет сделать.-number1 это все нули и один. Или это сint.MinValue приведет к 10000000000000000000000000000001, который не равен-1 (все.)

я используюmyInt = -myInt;

Так просто и легко

Если хочешь иметь только позитив

myInt = myInt>0 ? myInt : -myInt;
 Clive Galway03 сент. 2018 г., 11:32
Не работает.-int.MinValue все еще отрицательный.
 Mathieu Brouwers28 нояб. 2016 г., 15:11
Я искал этот ответ в несколько иной ситуации, как в ОП. Я хочу, чтобы 2 значения отрицали друг друга, если одно из них равно -5, а другое должно быть 5, поэтому это мое лучшее решение = D
 CMS03 сент. 2018 г., 18:37
вы получите переполнение, так какint.MaxValue является2147483647, четноеvar i = int.MaxValue; i++; не будет работать

Просто для удовольствия:

int myInt = Math.Min(hisInt, -hisInt);

int myInt = -(int)Math.Sqrt(Math.Pow(Math.Sin(1), 2) + Math.Pow(Math.Cos(-1), 2))
            * Math.Abs(hisInt);
 MusiGenesis28 авг. 2009 г., 19:07
Слишком рискованно, ИМХО. Что если изменится определение круга?
 Mike Dunlavey28 авг. 2009 г., 19:10
Хорошо, как 'насчет Math.Sin (-Math.Pi / 2) * ...

Примечание для всех, кто ответил

- Math.Abs(myInteger)

или же

0 - Math.Abs(myInteger)

или же

Math.Abs(myInteger) * -1

как способ сохранить отрицательные числа отрицательными и превратить положительные в отрицательные.

У этого подхода есть один недостаток. Это нет работает для всех целых чисел. ДиапазонInt32 тип от "-231" на "231 - 1. " Это значит, чтоеще один "негативный» число. Как следствие,Math.Abs(int.MinValue) бросает.OverflowException

Правильный способ заключается в использовании условных операторов:

int neg = n < 0 ? n : -n;

Этот подход работает для "все" integers.I»

 Clive Galway03 сент. 2018 г., 11:47
Сказав, что отрицательная шкала больше положительной, вы идете и предлагаете код, который не учитывает это. Еслиn является-32768 затем-n это также-32768 !!! более тогоint neg = n < 0 ? n : -n; не может работать во всех случаях, так как одна из троиц не делает абсолютно ничего.
 Mehrdad Afshari28 авг. 2009 г., 23:30
Стивен: Иногда вы решаете проблему (например,Abs) это может'возможно работатьint.MinValue (при условии,int тип возврата.) В этом случае это 'все в порядке, чтобы бросить исключение. Тем не менее, эта конкретная проблема имеет "действительный» результат дляint.MinValue но выдает исключение, если вы беретеAbs маршрут.
 Steven Sudit28 авг. 2009 г., 23:23
Я расскажу вам о правильности, но любой код, который зависит от того, кто не принимает Abs MinValue, является хрупким.
 Charles Bretana29 авг. 2009 г., 01:18
но x | = int.MinValue работает для всех целых чисел, включая MinValue ...
int myInt = - System.Math.Abs(-5);

int negativeInt = int.Parse(String.Format("{0}{1}", 
    "-", positiveInt.ToString()));

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

int negativeInt = int.Parse(String.Format("{0}{1}", 
    "thisisthedumbestquestioninstackoverflowhistory", positiveInt.ToString()));
int negInt = -System.Math.Abs(myInt)
 ThunderGr30 янв. 2014 г., 13:43
@ StevenSudit Нет, не лучше, чем * -1. Умножение на -1 нетрюк" это математический способ превратить число в отрицательное. -Number это просто сокращение от -1 * Number. Кроме того, использование Abs для сохранения отрицательного числа является излишним.myInt
 Steven Sudit28 авг. 2009 г., 21:30
Да, потому что отрицание является целью, поэтому унарный минус - правильный оператор. С другой стороны, умножение на отрицательное является просто уловкой, чтобы свести на нет значение.
 Steven Sudit28 авг. 2009 г., 23:21
Это'Это хитрость, потому что она рассчитывает на побочный эффект, а не основной эффект. Основной эффект унарного минуса - отрицание. Основным эффектом умножения является умножение. Так уж получилось, что умножение на -1 сводит на нет. Это понятнее?
 Shog928 авг. 2009 г., 22:37
Трюк? Кого ты дурачишь?

X=*-1 может не работать на всех компиляторах ... так как он читает 'умножать» 'SUBTRACT» 1 вместо ОТРИЦАТЕЛЬНОГО лучше альтX=(0-X), [Что отличается от]X-=X

 kokbira20 авг. 2012 г., 15:43
... ты имеешь в виду X * = - 1?

Просто то, чем я хочу поделиться.

public decimal NumberReevaluate(decimal number, bool isPositive)
{
    var tempNumber = System.Math.Abs(number);
    return isPositive ? tempNumber : -tempNumber;
}

Простой способ:

myInt *= -1;
 Brian Scott06 авг. 2012 г., 12:38
Собирался опубликовать то же самое, все должны показать * = немного любви :-)

Умножьте это на -1.

Используйте двоичный файл и удалите последний бит, который отвечает за отрицательный знак.

Или используйте двоичный файл или добавьте знак к типу данных.

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

Если вы нет эксперимент с тем, что я разместил этот пост, может выглядеть дерьмом: D

Например, для int:

Int - это 32-битный тип данных, поэтому последний бит (32-й) определяет знак.

И со значением, которое имеет 0 в 32 месте и остальные 1. Это будет преобразовывать отрицательное нет в + ve.

Для прямо противоположного или со значением с 1 на 32-м месте и отдыха 0.

Решение Вопроса

Как насчет

myInt = myInt * -1

 Julian8975705 мар. 2018 г., 08:39
Хорошо, Я служу тебе
 Clive Galway03 сент. 2018 г., 11:21
НЕ ВСЕГДА РАБОТАЕТ !!int.MinValue * -1 == int.MinValue
 Vitaliy Terziev06 февр. 2017 г., 21:57
myInt = myInt - myInt * 2; еще один
 kokbira20 авг. 2012 г., 15:40
как насчет ?myInt = - Myint
 Aaron Franke12 февр. 2019 г., 18:38
Каков наилучший способ сделать это?myInt *= -1 или же ?myInt = -myInt
 Alex Vallejo12 июн. 2014 г., 01:42
как насчет возможности переполнения, если вы используете этот ответ?
 mike james23 февр. 2014 г., 22:04
В качестве альтернативы? ~ n + 1
 Pawel Cioch18 авг. 2015 г., 17:01
Это победилоt работать с long.MinValue, значение все равно будет отрицательным, если у меня нет вируса в .NET :)
 DataDink28 авг. 2009 г., 18:39
У меня сложилось впечатление, что вы можете просто вставить "-" перед чем-либо, чтобы отрицать это ... -myInt Это будет отрицательным значением в myInt ... -ABS (myInt) будет гарантированно отрицательным.
 sotondolphin12 мая 2016 г., 05:19
Есть ли побочные эффекты между умножением на (-1) или вычитанием в 0?
 Broots Waymb20 июл. 2015 г., 17:36
Я неНе понимаю, почему этот ответ был принят. Это'определенно НЕ отрицательный эквивалент System.Math.Abs (...). Вход -5. Хотя он преобразует положительный в отрицательный, он неЯ думаю, что изначально задуманный вопрос.
 nawfal03 нояб. 2013 г., 17:55
или еще короче?myInt *= - 1
 Will Eddins28 авг. 2009 г., 18:30
Это отличное решение, потому что оно также может конвертировать негатив в позитив! Genius!
 AaronLS22 нояб. 2013 г., 22:46
К вашему сведению, если вы попробуете Кокбираметод с коротким,myShort = (short) -myShort приведение необходимо, потому что короткое становится int, когда отрицается.
int myNegInt = System.Math.Abs(myNumber) * (-1);
 MusiGenesis28 авг. 2009 г., 18:50
Только 26 голосов за этот ответ? Есть ли ТАК пользователи, которые думают, что это нет работаешь?
 MusiGenesis28 авг. 2009 г., 23:34
Я нене нравится это Ваш код должен выдавать недопустимое исключение аргумента, если myNumber отрицателен.
 xofz08 сент. 2010 г., 17:50
-1 за то, что не прочитал вопрос как указано. Число положительное.
 ThunderGr30 янв. 2014 г., 13:37
Шутки в сторону? Использование ABS только для изменения знака числа? Каким образом это лучше, чемint myNegInt = myNumber < 0 ? MyNumber : -MyNumber;, даже если для сохранения результата всегда требовался отрицательный результат?
 David28 авг. 2009 г., 18:26
+1 за то, что запомнилуже отрицательный тыиметь противоположный эффект. Ваш ответ - единственный, который всегда будет давать отрицательное число независимо от того, положительный или отрицательный myNumber.
 mmmmmmmm28 авг. 2009 г., 18:53
30 голосов? Уже вопрос так прост. И этот чрезмерно сложный ответ (-System.Math.Abs (myNumber) также подойдет) получает 30 голосов вверх ????
 Rex M28 авг. 2009 г., 18:58
@rstevens каждый, кто пытается совместно указать, что этот ответ гораздо более правильный, чем принятый. Кроме того, - vs * -1 определенно нет "чрезмерно сложным».
 Beska28 авг. 2009 г., 19:11
Мне нравится этот ответ лучше, чем -System.Math.Abs, так как с первого взгляда немного более очевидно, что происходит ... Я думаю, что было бы немного легче пропустить "-" перед заявлением.
 David A. Gray03 июл. 2017 г., 01:57
Беска отметил, что было бы немного легче пропустить "-" перед заявлением. Тот'Это случилось со мной так много раз, что я включил свое постоянное решение в целочисленную константу, MagicNumbers.MINUS_ONE, которая легко доступна для всего моего кода благодаря включению одного пространства имен WizardWrx и добавлению ссылки на одну библиотеку WizardWrx.Common. .dll.

Ваш ответ на вопрос