给定数字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。由于输入仅是整数，因此与using相同Sign。

COW，225个 213 201字节

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

在线尝试！

该代码的工作方式是通过交替增加和减少更大的数字并确定哪个数字是最后一个数字来确定符号。给定任何非零整数，请先减去1，然后相加2，再减去3，依此类推，最终您将达到0。通过交替地对从0开始的值进行加减2来跟踪状态。例：

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

然后以I面向东方的IP（指令指针）开始运行代码。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.

这是带有负数（旧版本）的gif图像：

它以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

如果-最初有一个in，它将保留下来，输出将是-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字节

由于1000000000，节省了2个字节

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

在线尝试！

说明：

{                                }       # 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漏洞来打击它；这是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：滥用未定义结果将返回条件结果的三元行为（这就是为什么我的三元数的真实回报为nil的原因）

修订版4：!!从nil修订版2中引用的三元条件替换项中减去bool cast（）。

Ruby，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!:

​ -nm标志的+4个字节。n用于数字I / O，并且由于Stack Cats需要回文程序，因此m隐式镜像了源代码以提供原始源

_[:I!:!I:]_

在线尝试！与基本上所有优秀的Stack Cats高尔夫一样，这是通过蛮力发现的，可以远距离击败任何手动尝试，并且不能轻易地合并到更大的程序中。

D如果您想查看逐步的程序跟踪，请添加一个标志，例如，运行-nmD并检查STDERR / debug。

Stack Cats使用一堆堆栈带，这些堆栈带在底部隐式填充零。在程序开始时，所有输入都被压入输入堆栈，-1在底端有一个a ，以将输入与隐式零分开。在程序结束时，输出当前堆栈，除非存在基础堆栈-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  ...

_减去，得出top -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基本，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正输入。不幸的是，由于Actual的错误处理（如果出现问题，该命令将被忽略），0因为输入将两个0s留在堆栈上。+通过添加它们来纠正此问题（这会导致其他错误，因此将被忽略）。

Piet，188 53 46 41字节

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

可在此处在线翻译。

(n>0)-(n<0)由于没有内置的符号检查功能，因此此piet代码执行标准操作。实际上，没有比内置函数少的多的，因此将更准确地描述此方法(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]

为了进一步减小文件大小，我需要实际更改程序（gasp），而不是像我一直在压缩文件一样。我想删除一行，将其打高尔夫球到36。我也可能会开发自己的解释器，该解释器的输入格式要小得多，因为实际上更改代码以使其更小并不是高尔夫的目的。

国防部告诉我，整个文件大小是Piet代码的关键。由于解释器接受文本作为有效输入，并且原始文本的字节数比任何图像小得多，因此文本是显而易见的选择。对此我不敢恭维，但我没有制定规则。关于这一点的元讨论使我对此事的看法明确。

如果您认为这与Piet的精神背道而驰，或者出于任何原因想要进一步讨论，请查看有关meta的讨论。

Pushy，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时，X为正和-1当X为负。如果输入为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个字节。使用正则表达式进行替换。有点乐趣，因为它不是内置的。我有一个更有趣的功能，但是它没有按我预期的方式工作。

ͨ-©½0]/±1

验证测试案例

这只是转换为与:%s/\v(-)=[^0].*/\11哪个或多个匹配，然后匹配-除0以外的任何值，然后匹配任意多次。它替换为第一场比赛（所以不管是-或没有）和1。正则表达式不匹配0，因此保持不变。

更有趣的方式（21字节）

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

在线试用

这接受输入作为参数，而不是在缓冲区中。

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