Учитывая число N, выведите знак N:

• Если N положительно, выведите 1
• Если N отрицательно, выведите -1
• Если N равно 0, выведите 0

N будет целым числом в пределах представимого диапазона целых чисел в выбранном вами языке.

Сетчатка , 9 байт

[1-9].*
1

Попробуйте онлайн!

Заменяет ненулевую цифру и все после нее на 1. Это оставляет потенциальный ведущий -нетронутым и меняет все числа, кроме 0себя, на абсолютное значение 1.

C (GCC), 24 23 22 18 байт

Спасибо @aross и @Steadybox за сохранение байта!

f(n){n=!!n|n>>31;}

Не гарантируется работа на всех системах или компиляторах, работает на TIO .

Mathematica, 4 байта

Clip

Как насчет того, чтобы не использовать встроенный Signи все еще выиграть 4 байта? ;)

Clipс одним аргументом обрезает (или зажимает) входное значение между -1и 1. Поскольку входные данные будут только целыми числами, это то же самое, что и использование Sign.

COW, 225 213 201 байт

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

Попробуйте онлайн!

Способ работы этого кода заключается в том, что он определяет знак, чередуя сложение и вычитание больших чисел и выясняя, какой из них работал последним. Для любого ненулевого целого числа сначала вычтите 1, затем добавьте 2, затем вычтите 3 и т. Д., И вы в конечном итоге достигнете 0. Отслеживайте свое состояние, чередуя сложение и вычитание 2 со значением, которое начинается с 0. Для пример:

-5  - 1  = -6  (current state: 0 + 2 = 2)
-6  + 2  = -4  (current state: 2 - 2 = 0)
-4  - 3  = -7  (current state: 0 + 2 = 2)
-7  + 4  = -3  (current state: 2 - 2 = 0)
-3  - 5  = -8  (current state: 0 + 2 = 2)
-8  + 6  = -2  (current state: 2 - 2 = 0)
-2  - 7  = -9  (current state: 0 + 2 = 2)
-9  + 8  = -1  (current state: 2 - 2 = 0)
-1  - 9  = -10 (current state: 0 + 2 = 2)
-10 + 10 =  0  (current state: 2 - 2 = 0)
value is now at 0.  state - 1 = 0 - 1 = -1
sign of original number is -1

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

Детальное объяснение:

oom                                        ;Read an integer into [0]
MOO                                        ;Loop while [0] is non-empty
    moOmoOmoOmoOMoOMoOmOomOomOo            ;    Decrement [4] twice
    MoOMMMmoOMMM                           ;    Increment [1], then copy [1] to [2]
    MOO                                    ;    Loop while [2] is non-empty
        MOomOomOoMOomoOmoO                 ;        Decrement [0] and [2]
    moo                                    ;    End loop now that [2] is empty
    mOomOoMMMmoOmoOmoOMMM                  ;    Navigate to [0], and copy to [3]
    MOO                                    ;    Perform the next steps only if [3] is non-zero
        OOOmoOMOoMOomOomOomOoMoOMMMmoOMMM  ;        Clear [3], increment [4] twice, increment [1], and copy it to [2]
        MOO                                ;        Loop while [2] is non-empty
            MOomOomOoMoOmoOmoO             ;            Decrement [2] and increment [0]
        moo                                ;        End loop now that [2] is empty
    moO                                    ;        Navigate back to [3]
    moo                                    ;    End the condition
    mOomOomOo                              ;    Navigate back to [0]
moo                                        ;End loop once [0] is empty.
moO                                        ;Navigate to [1]. If [1] is 0, then input was 0.  Otherwise, [4] contains (sign of [0] + 1)
MOO                                        ;Perform the next steps only if [1] is non-zero
    moOmoOmoOMOoMMMOOO                     ;    Navigate to [4], copy it to the register, and clear [4].
moo                                        ;End condition
MMMOOM                                     ;If the register contains something (which is true iff the condition ran), paste it and print it.  Otherwise, no-op and print 0.

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

Cubix , 10 байт

(W0^I?>O2@

Проверьте это онлайн!

Этот код переносится в следующую сеть кубов:

    ( W
    0 ^
I ? > O 2 @ . .
. . . . . . . .
    . .
    . .

Затем код запускается с IP (указатель инструкции), начиная Iс восточной стороны. Iвводит целое число со знаком из STDIN, помещая его в стек.

Следующая команда ?, которая изменяет направление IP в зависимости от знака верхнего элемента. Если ввод 0, он продолжает двигаться в том же направлении, пропуская следующий код:

• >- Укажите IP на восток. (Нет, так как мы уже идем на восток.)
• O - Вывести верхний элемент в виде целого числа.
• 2- Нажмите 2 в стек. Это практически не работает, потому что ...
• @ - Завершает программу.

Если вход отрицательный, IP поворачивается налево на ?; поскольку это куб, IP перемещается 0во второй ряд и направляется на восток. 0толкает литерал 0, затем запускается этот код:

• ^ - Направь IP на север.
• W - «Sidestep» IP на одну точку слева.
• ( - Уменьшить верхний элемент.

TOS теперь -1, и IP обволакивает куб через кучу неактивных операций, .пока не достигнет >. Это запускает тот же код вывода, упомянутый выше, вывод -1.

Если вход положительный, то же самое происходит и с отрицательными входами, за одним исключением: IP-адрес поворачивается направо, а не налево на ?, и оборачивается вокруг куба на 2, что толкает литерал 2. Затем оно уменьшается до 1 и отправлено на выход.

JavaScript (ES6), 9 байт

Math.sign

Непосредственная.

Самый короткий не встроенный составляет 13 байтов:

n=>n>0|-(n<0)

Благодаря @Neil, это может быть обработано байтом, но за счет работы только с 32-битными целыми числами:

n=>n>0|n>>31

Или вы могли бы сделать

n=>n>0?1:!n-1

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

APL (Dyalog APL) , 1 байт

Работает и для комплексных чисел, возвращая 1∠ θ :

×

Попробуй APL онлайн!

Без этого встроенного, для целых чисел (согласно OP):

¯1⌈1⌊⊢

¯1⌈ самый большой из отрицательных и

1⌊ самый маленький из одного и

⊢ Аргумент

Попробуй APL онлайн!

... и общий:

>∘0-<∘0

>∘0 больше, чем ноль

- минус

<∘0 меньше, чем ноль

Попробуй APL онлайн!

> <> , 9 8 байт

Спасибо Sp3000 за сохранение байта.

'i$-%n/

Там есть непечатный 0x01перед /.

Попробуйте онлайн!

объяснение

Это порт моего лабиринтного ответа на основе кодировки символов .

'     Push the entire program (except ' itself) onto the stack, which ends 
      with [... 1 47].
i     Read the first character of the input.
$-    Subtract the 47.
%     Take the 1 modulo this value.
n     Output the result as an integer.
0x01  Unknown command, terminates the program.

Vim, 22 байта

xVp:s/-/-1^M:s/[1-9]/1^M

Сохраненный один байт благодаря @DJMcMayhem !

Здесь ^Mбуквальный перевод строки.

Как отметил @ nmjcman101 в комментариях, :s/\v(-)=[^0].*/\11^Mвместо этого можно использовать одно регулярное выражение ( 20 байт), но, поскольку это в основном то же, что и ответ Retina, я придерживаюсь своего собственного метода.

Объяснение:

xVp                        Delete everything except the first character. If the number is negative, this leaves a -, a positive leaves any number between 1 and 9, and 0 leaves 0.
   :s/-/-1^M               Replace a - with a -1
            :s/[1-9]/1^M   Replace any number between 1 and 9 with 1.

Вот гифка с отрицательным числом (старая версия):

Вот это работает с 0:

Бег с позитивом:

///, 52 36 байт

/a/\/1\/\///2a3a4a5a6a7a8a9a10a11/1/

Ungolfed, объяснение:

/2/1/
/3/1/
/4/1/
/5/1/
/6/1/
/7/1/
/8/1/
/9/1/
/10/1/
/11/1/

Это в основном реализация MapReduce, то есть есть две фазы:

• Заменить все вхождения цифр 2- 9от 1, например , 1230405->1110101
• Уменьшите пары 11или 10до 1нескольких раз, например 1110101->1

Если -изначально было впереди, оно останется и будет вывод -1. Сингл 0никогда не заменяется, что приводит к самому себе.

Обновление: Сохранить дополнительные 16 байт альясингом //1/с a, благодаря Мартин Эндер.

Попробуйте онлайн с тестовыми примерами

Python 2 , 17 байт

lambda n:cmp(n,0)

Попробуйте онлайн!

Лабиринт , 10 байт

?:+:)%:(%!

Попробуйте онлайн!

объяснение

Семантика потока управления Лабиринта фактически дает вам «свободный» способ определения знака числа, потому что выбранный путь на 3-сторонней развилке зависит от того, является ли знак отрицательным, нулевым или положительным. Однако до сих пор я не смог уместить программу с переходами менее чем в 12 байтов (хотя это возможно).

Вместо этого, вот решение в закрытой форме, которое не требует ветвей:

Code    Comment             Example -5      Example 0       Example 5
?       Read input.         [-5]            [0]             [5]
:+      Double.             [-10]           [0]             [10]
:)      Copy, increment.    [-10 -9]        [0 1]           [10 11]
%       Modulo.             [-1]            [0]             [10]
:(      Copy, decrement.    [-1 -2]         [0 -1]          [10 9]
%       Modulo.             [-1]            [0]             [1]
!       Print.              []              []              []

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

Удвоение входных данных необходимо для выполнения этой работы с входными данными, 1а в -1противном случае одна из двух операций по модулю уже предпримет попытку деления на ноль.

PHP, 16 байт

Использует новый оператор космического корабля.

<?=$argv[1]<=>0;

Brain-Flak 74 42 40 Bytes

Сохранено 2 байта благодаря 1000000000

{([({}<([()])>)]<>(())){({}())<>}}{}({})

Попробуйте онлайн!

Объяснение:

{                                }       # if 0 do nothing
   (          )                          # push:                           
    {}<     >                            # the input, after 
       (    )                            # pushing:
        [  ]                             # negative:
         ()                              # 1

 (                    )                  # Then push:
  [            ]                         # the negative of the input
                <>                       # on the other stack with:
                   ()                    # a 1 
                  (  )                   # pushed under it

                       {        }        # while 1: 
                        ({}())           # increment this stack and...
                              <>         # switch stacks

                                 {}      # pop the top (the counter or 0 from input)
                                   (  )  # push:
                                    {}   # the top (this is a no-op, or pushes a 0)

J , 1 байт

*

Попробуйте онлайн (с тестовыми примерами)!

C 24 20 19 18 байт

Я злоупотребляю двумя подвигами С, чтобы играть в гольф; Это в C (GCC).

f(a){a=a>0?:-!!a;}

Попробуйте онлайн!

Лист регистраций изменений:

1) f(a){return(a>0)-(a<0);}// 24 байта

2) f(a){a=(a>0)-(a<0);}// 20 байт

3) f(a){a=a>0?:-1+!a;}// 19 байт

4) f(a){a=a>0?:-!!a;}// 18 байт

Редакция 1: Первая попытка. Простая логика

Редакция 2: Злоупотребляет ошибкой памяти / стека в GCC, где, насколько я могу судить, невозвратная функция в некоторых случаях возвращает последнюю переменную набора.

Редакция 3: злоупотребляет троичным поведением, когда неопределенный результат будет возвращать условный результат (именно поэтому истинное возвращение для моей троичной переменной равно нулю)

Редакция 4: Вычтите приведение типа bool ( !!) из троичной условной замены для nilссылки в ревизии 2.

Рубин, 10 байт

->x{x<=>0}

Perl, 9 байт

Требуется -Eбез каких-либо дополнительных затрат.

say<><=>0

использование

perl -E 'say<><=>0' <<< -9999
-1
perl -E 'say<><=>0' <<< 9999
1
perl -E 'say<><=>0' <<< -0
0

Я доволен рыбным оператором!

Стека кошек , 6 + 4 = 10 байт

_[:I!:

+4 байта для ​ -nmфлагов. nпредназначен для числового ввода-вывода, и поскольку Stack Cats требует, чтобы программы были палиндромными, mнеявно отражает исходный код, чтобы дать исходный исходный код

_[:I!:!I:]_

Попробуйте онлайн! Как и в случае со всеми хорошими гольфами Stack Cats, это было обнаружено грубой силой, превзошло любые ручные попытки длинным выстрелом и не может быть легко включено в большую программу.

Добавьте Dфлаг, если вы хотите увидеть пошаговую трассировку программы, т. -nmDЕ. Запустить с и проверить STDERR / debug.

Stack Cats использует ленту стеков, которые неявно заполнены нулями внизу. В начале программы все входные данные помещаются в стек ввода, а -1в основе находится символ «а», чтобы отделить входные данные от неявных нулей. В конце программы выводится текущий стек, кроме базы, -1если она есть.

Соответствующие команды здесь:

_           Perform subtraction [... y x] -> [... y y-x], where x is top of stack
[           Move left one stack, taking top of stack with you
]           Move right one stack, taking top of stack with you
:           Swap top two of stack
I           Perform [ if top is negative, ] if positive or don't move if zero. Then
                negate the top of stack.
!           Bitwise negate top of stack (n -> -n-1)

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

Начнем с

               v
               n
              -1
...  0    0    0    0    0  ...

_вычитает, делая вершину -1-n, и [перемещает результат влево на одну стопку:

           v
       -1-n   -1
...  0    0    0    0    0  ...

:меняет две верхние и Iничего не делает, так как вершина стека теперь равна нулю. !затем поразрядно обнуляет верхний ноль в a -1и :меняет два верхних обратно. !затем поразрядно отменяет вершину, -1-nснова превращаясь в n:

          v
          n
         -1   -1
...  0    0    0    0    0  ...

Теперь мы разветвляемся на основе I, который применяется к нашему оригиналу n:

• Если nоно отрицательное, мы перемещаемся влево на один стек и заканчиваем -nнеявным нулем. :переставляет, ставит ноль на вершину, и ]перемещает ноль на вершину, которую -1мы только что съехали _затем вычитает, оставляя последний стек подобным [-1 -1], и -1выводится только один, так как база -1игнорируется.

• Если nноль, мы не двигаемся и :меняемся местами -1. ]затем перемещает это влево -1на вершину справа -1и _вычитает, оставляя последний стек подобным [-1 0], выводя ноль и игнорируя основание -1.

• Если nположительно, мы перемещаемся вправо на один стек и заканчиваем -nна -1. :переставляет, помещая -1сверху, и ]перемещает это -1вправо, поверх неявного нуля. _затем вычитает, давая 0 - (-1) = 1и оставляя окончательный стек как [1], который выводится.

TI-Basic, 8 байтов

median({1,Ans,~1

Альтернативные решения (не стесняйтесь предлагать больше):

max(~1,min(Ans,1               8  bytes
0:If Ans:Ans/abs(Ans           9  bytes
(Ans>0)-(Ans<0                 10 bytes

MATL , 6 байтов

0>EGg-

Входные данные могут быть числом или массивом. Результатом является число или массив с соответствующими значениями.

Попробуйте онлайн! Или протестируйте несколько случаев с использованием массива.

объяснение

Это позволяет избежать использования встроенной функции знака ( ZS).

0>   % Take input implicitly. Push 1 if positive, 0 otherwise
E    % Multiply by 2
Gg   % Push input converted to logical: 1 if nonzero, 0 otherwise
-    % Subtract. Implicitly display

Желе , 1 байт

Ṡ

TryItOnline!

Монадическая знак атом , Ṡ, делает именно то, что указано для целого ввода, либо в качестве полной программы или как монадическая связь (функция принимает один аргумент).

Mathematica, 4 байта

Sign

Именно то, что написано на банке

Октава, 26 24 байта

f=@(x)real(asin(x))/pi*2

Это мой первый ответ на октавский код-гольф , любые советы по игре в гольф приветствуются!

Попробуйте онлайн!

Идея взять что-то asinпроисходит от вопроса, где говорится output the sign:)

объяснение

Примечание: деление числа на piи умножение его 2эквивалентно делению всего числа наpi/2

Дело 0:

asin(0)доходность 0. Взяв реальную часть и разделив ее, pi/2не имеет значения для результата.

Дело positive:

asin(1)доходность pi/2. asinлюбого числа больше, чем 1даст pi/2+ комплексное число. Взяв реальную часть этого дает pi/2и делит это pi/2дает1

Дело negative:

asin(-1)доходность -pi/2. asinлюбого числа меньше, чем -1даст -pi/2+ комплексное число. Взяв реальную часть этого дает -pi/2и делит это pi/2дает-1

На самом деле , 1 байт

s

Попробуйте онлайн!

Еще один случай того, что именно написано на банке - sэто функция знака.

Без встроенного (4 байта):

;A\+

Попробуйте онлайн!

;A\делит абсолютное значение ввода на вход. Это приводит -1к отрицательным входам и 1для положительных входов. К сожалению, из-за фактической обработки ошибок (если что-то идет не так, команда игнорируется), так 0как ввод оставляет два 0s в стеке. +исправляет это, добавляя их (что приводит к ошибке с чем-либо еще, поэтому игнорируется).

Пит, 188 53 46 41 байт

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

Онлайн переводчик доступен здесь.

Этот код соответствует стандарту (n>0)-(n<0), так как нет встроенной проверки знака. На самом деле, есть не что иное, как встроенный, так что более точное описание этого метода будет (n>0)-(0>n).

Текст выше представляет изображение. Вы можете создать изображение, вставив его в текстовое поле на странице переводчика. Для удобства я предоставил изображение ниже, где размер кодека составляет 31 пиксель. Сетка предназначена для удобства чтения и не является частью программы. Также обратите внимание, что эта программа не пересекает какие-либо белые кодеки; следуйте цветным кодам вокруг границы изображения, чтобы следить за ходом программы.

объяснение

Instruction    Δ Hue   Δ Lightness   Stack
------------   -----   -----------   --------------------
In (Number)    4       2             n
Duplicate      4       0             n, n
Push [1]       0       1             1, n, n
Duplicate      4       0             1, 1, in, in
Subtract       1       1             0, in, in
Duplicate      4       0             0, 0, in, in
Push [4]       0       1             4, 0, 0, in, in
Push [1]       0       1             1, 4, 0, 0, in, in
Roll           4       1             0, in, in, 0
Greater        3       0             greater, in, 0
Push [3]       0       1             3, greater, in, 0
Push [1]       0       1             1, 3, greater, in, 0
Roll           4       1             in, 0, greater
Greater        3       0             less, greater
Subtract       1       1             sign
Out (Number)   5       1             [Empty]
[Exit]         [N/A]   [N/A]         [Empty]

Чтобы еще больше уменьшить размер файла, мне нужно было бы изменить программу (вздох), а не просто сжать файл, как я это делал. Я хотел бы убрать одну строку, которая бы увеличила это до 36. Я также мог бы разработать свой собственный интерпретатор, который имел бы намного меньший формат ввода, так как изменение кода для его уменьшения - это не то, о чем говорит гольф.

Моды сказали мне, что общий размер файла - это то, что имеет значение для кода Piet. Поскольку интерпретатор принимает текст в качестве допустимого ввода, а необработанный текст имеет намного меньшее количество байтов, чем любое изображение, текст является очевидным выбором. Я прошу прощения за то, что был дерзким по этому поводу, но я не делаю правила. Мета обсуждение по этому поводу делает мое мнение по этому вопросу ясно.

Если вы считаете, что это идет вразрез с духом Пита или хотели бы обсудить это по какой-либо причине, пожалуйста, ознакомьтесь с обсуждением мета .

Напористый , 7 байтов

Это, наверное, самая странная программа, которую я когда-либо писал ...

&?&|/;#

Попробуйте онлайн!

Он использует sign(x) = abs(x) / x, но с явным, sign(0) = 0чтобы избежать ошибки деления на ноль.

          \ Take implicit input
&?   ;    \ If the input is True (not 0):
  &|      \  Push its absolute value
    /     \  Divide
      #   \ Output TOS (the sign)

Это работает , потому что x / abs(x)это 1 , если х положительна и -1 , если х является отрицательным. Если вход равен 0, программа переходит к выходной команде.

4 байта (не конкурирующие)

Из-за праздников и слишком большого количества времени я полностью переписал переводчика Pushy. Вышеприведенная программа все еще работает, но поскольку 0 / 0теперь по умолчанию 0, следующее короче:

&|/#

Попробуйте онлайн!

R, 25 байт

'if'(x<-scan(),x/abs(x),0)

Принимает номер к STDIN. Затем проверяет, равен ли он нулю, если нет, возвращает значение, равное x/|x|любому 1из -1, и выдает 0, если x=0.

Это без использования встроенного signконечно.

V 14 12 байт

Спасибо @DJMcMayhem за 2 байта. Использует reg-ex для замены. Это весело, потому что это не встроенный. У меня есть более веселая функция, но она работает не так, как я ожидал.

ͨ-©½0]/±1

Проверьте тестовые случаи

Это просто означает, :%s/\v(-)=[^0].*/\11что соответствует одному или нескольким, -за которым следует что угодно, кроме 0, а затем любое количество раз. Он заменяется первым соответствием (так что либо a, -либо ничего) и a 1. Регулярное выражение не соответствует 0, так что оно остается само собой.

Более веселый путь (21 байт)

é
Àé12|DkJòhé-òó^$/a

TryItOnline

Это принимает входные данные в качестве аргумента, а не в буфере.

é<CR> Вставьте новую строку.

Àзапустить аргумент как V-код. a -переместит курсор на предыдущую строку, и любое число станет счетчиком для следующей команды

é1вставки (счет) 1«ы

2| перейти ко второму столбцу

D удалить все, начиная со второго столбца (оставив только один символ)

kJ Соедините две линии вместе.

òhé-òпереводится как: «беги hé-до взлома». Если 1 был на второй строке, это прерывается сразу после h. Если он был в первой строке, он вставит -перед разрывом.

ó^$/aЭто фиксирует тот факт , что -1, 0, 1оставит пустое, и заменяет пробел с реестром аргумента.

C #, 16 15 байт

Улучшенное решение благодаря Нилу

n=>n>0?1:n>>31;

Кроме того, встроенный метод на 1 байт длиннее:

n=>Math.Sign(n);

Полная программа с тестовыми примерами:

using System;

public class P
{
    public static void Main()
    {
        Func<int,int> f =
        n=>n>0?1:n>>31;

        // test cases:
        for (int i=-5; i<= 5; i++)
            Console.WriteLine(i + " -> " + f(i));
    }
}