Давши число 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 .

Математика, 4 байти

Clip

Як щодо того, щоб не використовувати вбудований Signі все-таки набрати 4 байти? ;)

Clipз одним аргументом затискає (або затискає) вхідне значення між -1та 1. Оскільки вхідними даними будуть лише цілі числа, це те саме, що використовувати Sign.

КОРО, 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 онлайн!

Без цього вбудованого для цілих чисел (відповідно до ОП):

¯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.

Вім, 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/

Безголовка, пояснення:

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

Брейн-Флак 74 42 40 байт

Збережено 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 байт

Я зловживаю двома подвигами С, щоб спустити цей гольф; Це в С (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 cast ( !!) від потрійної умовної заміни для 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 / налагодження.

Stack Cats використовує стрічку з стеків, яка неявно заповнена нулями внизу. На початку програми весь вхід висувається на вхідний стек, з a -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на неявний нуль. :swaps, ставлячи нуль зверху, і ]переміщає нуль зверху на -1щойно ми відійшли. _потім віднімаємо, залишаючи остаточний стек як [-1 -1], і тільки один -1виводиться, оскільки база -1ігнорується.

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

• Якщо nє позитивним, переміщуємо право на один стек і закінчуємо -nна a -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 байт

Ṡ

СпробуйтеItOnline!

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

Математика, 4 байти

Sign

Саме так написано на жерсті

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

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

Це моя перша відповідь з кодом-гольф Octave, будь-які поради щодо гольфу цінуються!

Спробуйте в Інтернеті!

Ідея приймати 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оскільки вхід залишає два 0стеки на стеку. +виправляє це, додаючи їх (що спричиняє помилку з чим-небудь іншим, тому воно ігнорується).

Піт, 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 1. Режекс не відповідає 0, так що він залишається сам.

Більш веселий спосіб (21 байт)

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

TryItOnline

Це приймає вхід як аргумент, а не в буфері.

é<CR> Вставте новий рядок.

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

é1вставити (рахувати) 1's

2| перейти до другої колонки

D видалити все з другого стовпця далі (залишивши лише один символ)

kJ З’єднайте два рядки разом.

òhé-òперекладається на: "бігати, hé-поки не зламаються". Якщо 1 знаходився на другому рядку, це переривається відразу після h. Якщо він був на першому рядку, він буде вставляти a -перед розривом.

ó^$/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));
    }
}