Dado um número N, dê o sinal de N:

• Se N for positivo, a saída 1
• Se N for negativo, a saída -1
• Se N for 0, saída 0

N será um número inteiro dentro do intervalo representável de números inteiros no idioma escolhido.

Retina , 9 bytes

[1-9].*
1

Experimente online!

Substitui um dígito diferente de zero e tudo depois dele por 1. Isso deixa -intacto um líder em potencial e altera todos os números, exceto 0ele próprio, para valor absoluto 1.

C (GCC), 24 23 22 18 bytes

Agradecemos a @aross e @Steadybox por salvar um byte!

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

Não é garantido que funcione em todos os sistemas ou compiladores, funciona no TIO .

Mathematica, 4 bytes

Clip

Que tal não usar o built-in Signe ainda marcar 4 bytes? ;)

Clipcom um único argumento clipes (ou grampos) o valor de entrada entre -1e 1. Como as entradas serão apenas números inteiros, é o mesmo que usar Sign.

VACA, 225 213 201 bytes

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

Experimente online!

A maneira como esse código funciona é que ele determina o sinal alternando a adição e subtração de números maiores e vendo qual foi o último que funcionou. Dado qualquer número inteiro diferente de zero, primeiro subtraia 1 e, em seguida, adicione 2, depois subtraia 3, etc. e você chegará a 0. Mantenha o controle de seu estado alternando a adição e subtração de 2 a um valor que comece em 0. Para exemplo:

-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

Quando terminar, subtraia 1 do seu estado e você recebe o sinal, positivo ou negativo. Se o número original for 0, não se preocupe em fazer isso e apenas imprima 0.

Explicação detalhada:

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.

Eu ainda estou experimentando jogar golfe (você ficará chocado ao descobrir que jogar golfe no COW é bastante difícil), então isso pode diminuir mais alguns bytes no futuro.

Cubix , 10 bytes

(W0^I?>O2@

Teste online!

Esse código é agrupado na seguinte rede de cubos:

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

O código é então executado com o IP (ponteiro de instrução) começando no I, voltado para o leste. Iinsere um número inteiro assinado de STDIN, empurrando-o para a pilha.

O próximo comando é ?, que altera a direção do IP, dependendo do sinal do item superior. Se a entrada for 0, ela continua se movendo na mesma direção, executando o seguinte código:

• >- Aponte o IP para o leste. (No-op, já que estamos indo para o leste.)
• O - Envie o item superior como um número inteiro.
• 2- Pressione 2 para a pilha. Isso é praticamente um no-op, porque ...
• @ - Finaliza o programa.

Se a entrada for negativa, o IP vira à esquerda no ?; porque este é um cubo, o IP se move para 0a segunda linha, na direção leste. 0empurra um 0 literal, então este código é executado:

• ^ - Aponte o IP para o norte.
• W - "Sidestep" o ponto IP à esquerda.
• ( - Diminua o item superior.

O TOS é agora -1e o IP envolve o cubo através de um monte de no-ops .até atingir o >. Isso executa o mesmo código de saída mencionado acima, produzindo -1.

Se a entrada for positiva, o mesmo acontece com as entradas negativas, com uma exceção: o IP vira para a direita em vez de para a esquerda no ?, e envolve o cubo para o 2, o que empurra um literal 2. Isso é decrementado para 1 e enviado para a saída.

JavaScript (ES6), 9 bytes

Math.sign

Direto.

O menor não incorporado é 13 bytes:

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

Graças ao @Neil, isso pode ser obtido por um byte, mas com o custo de trabalhar apenas com números inteiros de 32 bits:

n=>n>0|n>>31

Ou você poderia fazer

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

que parece mais jogável, mas não sei ao certo como.

APL (Dyalog APL) , 1 byte

Também funciona para números complexos, retornando 1∠ θ :

×

TryAPL online!

Sem isso, para números inteiros (conforme OP):

¯1⌈1⌊⊢

¯1⌈ o maior dos negativos e

1⌊ o menor de um e

⊢ o argumento

TryAPL online!

... e um geral:

>∘0-<∘0

>∘0 mais que zero

- menos

<∘0 menos que zero

TryAPL online!

> <> , 9 8 bytes

Obrigado ao Sp3000 por salvar um byte.

'i$-%n/

Há um imprimível 0x01antes do /.

Experimente online!

Explicação

Esta é uma porta da minha resposta Labirinto baseada em código de caracteres .

'     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 bytes

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

Guardou um byte graças a @DJMcMayhem !

Aqui ^Mestá uma nova linha literal.

Como @ nmjcman101 apontou nos comentários, um único regex pode ser usado ( :s/\v(-)=[^0].*/\11^M, 20 bytes), mas como esse é basicamente o mesmo que uma resposta da Retina, estou seguindo o meu próprio método.

Explicação:

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.

Aqui está um gif dele sendo executado com um número negativo (versão antiga):

Aqui está executando com 0:

Executando com positivo:

///, 52 36 bytes

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

Ungolfed, explicação:

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

É basicamente uma implementação do MapReduce, ou seja, existem duas fases:

• Substitua todas as ocorrências de dígitos 2- 9por 1, por exemplo 1230405- ->1110101
• Reduza pares de 11ou 10para 1repetidamente, por exemplo 1110101->1

Se havia um -na frente inicialmente, ele permanecerá e a saída será -1. Um único 0nunca é substituído, resultando em si mesmo.

Atualização: economize 16 bytes adicionais fazendo alias //1/com a, graças a Martin Ender.

Experimente online, com casos de teste

Python 2 , 17 bytes

lambda n:cmp(n,0)

Experimente online!

Labirinto , 10 bytes

?:+:)%:(%!

Experimente online!

Explicação

A semântica do fluxo de controle do labirinto na verdade fornece uma maneira "livre" de determinar o sinal de um número, porque o caminho escolhido em uma bifurcação de três direções depende se o sinal é negativo, zero ou positivo. No entanto, até agora não consegui ajustar um programa com junções em menos de 12 bytes (embora isso seja possível).

Em vez disso, aqui está uma solução de formulário fechado, que não requer ramificações:

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.              []              []              []

O ponteiro de instruções atinge um beco sem saída, vira-se e termina quando %agora tenta uma divisão por zero.

É necessário dobrar a entrada para fazer isso funcionar com entradas 1e -1, caso contrário, uma das duas operações do módulo já tentaria uma divisão por zero.

PHP, 16 bytes

Usa o novo operador de nave espacial.

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

Brain-Flak 74 42 40 bytes

Economizou 2 bytes graças a 1000000000

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

Experimente Online!

Explicação:

{                                }       # 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 byte

*

Experimente online (com casos de teste)!

C, 24 20 19 18 bytes

Abuso duas explorações C para jogar golfe; Isso está em C (GCC).

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

Experimente online!

Histórico de Revisão:

1) f(a){return(a>0)-(a<0);}// 24 bytes

2) f(a){a=(a>0)-(a<0);}// 20 bytes

3) f(a){a=a>0?:-1+!a;}// 19 bytes

4) f(a){a=a>0?:-!!a;}// 18 bytes

Revisão 1: Primeira tentativa. Lógica simples

Revisão 2: Abusa de um erro de memória / pilha no GCC, onde, até onde eu sei, uma função que não retorna retornará a última variável definida em certos casos.

Revisão 3: Abusa do comportamento ternário em que resultado indefinido retornará resultado condicional (e é por isso que o verdadeiro retorno no meu ternário é nulo)

Revisão 4: Subtraia um bool cast ( !!) da substituição condicional ternária nilreferenciada na revisão 2.

Ruby, 10 bytes

->x{x<=>0}

Perl, 9 bytes

Requer -Esem custo extra.

say<><=>0

Uso

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

Estou feliz com o operador de peixe!

Stack Cats , 6 + 4 = 10 bytes

_[:I!:

+4 bytes para os ​ -nmsinalizadores. né para E / S numérica e, como o Stack Cats exige que os programas sejam palíndricos, mespelha implicitamente o código-fonte para fornecer a fonte original

_[:I!:!I:]_

Experimente online! Tal como acontece com basicamente todos os bons jogadores de golfe da Stack Cats, isso foi encontrado por força bruta, superou todas as tentativas manuais a longo prazo e não pode ser facilmente incorporado a um programa maior.

Adicione um Dsinalizador se desejar ver um rastreio passo a passo do programa, ou seja, execute -nmDe marque STDERR / debug.

O Stack Cats usa uma fita de pilhas que são implicitamente preenchidas com zeros na parte inferior. No início do programa, todas as entradas são enviadas para a pilha de entradas, com um -1na base para separar a entrada dos zeros implícitos. No final do programa, a pilha atual é impressa, exceto uma base, -1se presente.

Os comandos relevantes aqui são:

_           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)

Observe que todos esses comandos são invertíveis, sendo o inverso o espelho do comando. Essa é a premissa do Stack Cats - todos os programas de término não triviais têm uma duração ímpar, uma vez que os programas de duração par se auto-cancelam.

Começamos com

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

_subtrai, fazendo o topo -1-ne [move o resultado para a esquerda uma pilha:

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

:troca os dois primeiros e Inão faz nada, já que o topo da pilha agora é zero. !em seguida, bit a bit anula o zero superior em um -1e :troca os dois superiores novamente. !depois, bit a bit anula a parte superior, voltando a -1-nser nnovamente:

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

Agora, ramificamos com base no Ique é aplicado ao nosso original n:

• Se nfor negativo, movemos para a esquerda uma pilha e terminamos com -num zero implícito. :troca, colocando um zero em cima e ]move o zero em cima do -1que acabamos de sair. _então subtrai, deixando a pilha final como [-1 -1], e apenas uma -1é gerada, uma vez que a base -1é ignorada.

• Se nfor zero, não nos movemos e :trocamos, colocando -1em cima. ]então move esta esquerda -1no canto superior direito -1e _subtrai, deixando a pilha final como [-1 0], produzindo o zero e ignorando a base -1.

• Se nfor positivo, movemos para a direita uma pilha e terminamos com -na -1. :troca, colocando o -1topo e ]move-o para a -1direita, em cima de um zero implícito. _subtrai, dando 0 - (-1) = 1e deixando a pilha final como [1], que é produzida.

TI-Basic, 8 bytes

median({1,Ans,~1

Soluções alternativas (fique à vontade para sugerir mais):

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

MATL , 6 bytes

0>EGg-

A entrada pode ser um número ou uma matriz. O resultado é número ou uma matriz com os valores correspondentes.

Experimente online! Ou teste vários casos usando a entrada da matriz.

Explicação

Isso evita o uso da função de sinal incorporada ( 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

Geléia , 1 byte

Ṡ

TryItOnline!

O sinal monádico átomo , Ṡ, faz exatamente o que é especificado para uma entrada inteiro, como um programa completo ou como um link monádico (função recebendo um argumento).

Mathematica, 4 bytes

Sign

Exatamente o que diz na lata

Oitava, 26 24 bytes

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

Esta é a minha primeira resposta de código- oitava de golfe , todas as dicas de golfe são apreciadas!

Experimente online!

A idéia de tirar asinprovém da pergunta onde diz output the sign:)

Explicação

Nota: dividir o número pie multiplicá-lo por 2é o equivalente a dividir o número inteiro porpi/2

Caso 0:

asin(0)rendimentos 0. Tomar a parte real e dividi-la por pi/2não faz diferença para a saída.

Caso positive:

asin(1)rendimentos pi/2. asinde qualquer número maior do que 1dará pi/2+ número complexo. Tomando a parte real dela dá pi/2e dividindo por pi/2dá1

Caso negative:

asin(-1)rendimentos -pi/2. asinde qualquer número menor do que -1dará -pi/2+ número complexo. Tomando a parte real dela dá -pi/2e dividindo por pi/2dá-1

Na verdade , 1 byte

s

Experimente online!

Outro caso exatamente do que diz na lata - sé a função do sinal.

Sem o builtin (4 bytes):

;A\+

Experimente online!

;A\divide o valor absoluto da entrada pela entrada. Isso resulta -1em entradas negativas e 1entradas positivas. Infelizmente, devido ao tratamento de erros do Actually (se algo der errado, o comando será ignorado), 0pois a entrada deixa dois 0s na pilha. +corrige isso adicionando-os (o que causa um erro em qualquer outra coisa, por isso é ignorado).

Piet, 188 53 46 41 bytes

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

Intérprete online disponível aqui.

Este código piet faz o padrão (n>0)-(n<0), pois não há verificação de sinal embutida. De fato, não há nada menos do que embutido, portanto uma descrição mais precisa desse método seria (n>0)-(0>n).

O texto acima representa a imagem. Você pode gerar a imagem colando-a na caixa de texto na página do intérprete. Por conveniência, forneci a imagem abaixo, onde o tamanho do codel é 31 pixels. A grade existe para facilitar a leitura e não faz parte do programa. Observe também que este programa não cruza nenhum código branco; siga os codels coloridos ao redor da borda da imagem para seguir o fluxo do programa.

Explicação

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]

Para reduzir ainda mais o tamanho do arquivo, eu precisaria alterar o programa (gasp) em vez de apenas comprimir o arquivo como eu estava fazendo. Gostaria de remover uma linha que reduzisse para 36. Também posso desenvolver meu próprio intérprete, que teria um formato de entrada muito menor, pois alterar o código para torná-lo menor não é o objetivo do código golf.

Os mods me disseram que o tamanho total do arquivo é o que conta para o código Piet. Como o intérprete aceita texto como entrada válida e o texto bruto possui uma contagem de bytes muito menor do que qualquer imagem, o texto é a escolha óbvia. Peço desculpas por ser atrevido com isso, mas não faço as regras. A meta discussão sobre isso deixa clara minha opinião sobre o assunto.

Se você acha que isso vai contra o espírito de Piet ou gostaria de discutir isso por qualquer motivo, confira a discussão sobre meta .

Pushy , 7 bytes

Este é provavelmente o programa de aparência mais estranha que eu já escrevi ...

&?&|/;#

Experimente online!

Ele usa sign(x) = abs(x) / x, mas com um explícito, sign(0) = 0para evitar erro de divisão zero.

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

Isso funciona porque x / abs(x)é 1 quando x é positivo e -1 quando x é negativo. Se a entrada for 0, o programa salta para o comando de saída.

4 bytes (não concorrentes)

Por causa das férias e por ter muito tempo, reescrevi completamente o intérprete Pushy. O programa acima ainda funciona, mas como 0 / 0agora o padrão é 0, o seguinte é mais curto:

&|/#

Experimente online!

R, 25 bytes

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

Leva o número para STDIN. Em seguida, verifica se é zero, se não, retorna x/|x|qual é um 1dos -1e gera 0 se x=0.

Isso é sem usar o built-in, é signclaro.

V 14 12 bytes

Obrigado @DJMcMayhem por 2 bytes. Usa um reg-ex para fazer a substituição. Divertido, porque não é um built-in. Eu tenho uma função mais divertida, mas não está funcionando da maneira que eu esperava.

ͨ-©½0]/±1

Verificar casos de teste

Isso apenas traduz para o :%s/\v(-)=[^0].*/\11que corresponde a um ou mais, -seguido por qualquer coisa, exceto 0, seguido por qualquer coisa várias vezes. É substituído pela primeira correspondência (portanto, uma -ou nada) e a 1. O regex não corresponde a 0, portanto, ele permanece em si.

A maneira mais divertida (21 bytes)

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

TryItOnline

Isso aceita a entrada como argumento e não no buffer.

é<CR> Inserir uma nova linha.

Àexecute o argumento como código V. a -moverá o cursor para a linha anterior e qualquer número se tornará a contagem para o próximo comando

é1inserir (Quantidade) 1de

2| mover para a segunda coluna

D exclua tudo da segunda coluna em diante (deixando apenas um caractere)

kJ Junte as duas linhas juntas.

òhé-òtraduz para: "corra hé-até quebrar". Se o 1 estiver na segunda linha, isso será interrompido imediatamente após o h. Se estiver na primeira linha, ele inserirá um -antes de quebrar.

ó^$/aIsso corrige o fato de que -1, 0, 1vai deixar um espaço em branco, e substitui um espaço em branco com o registo argumento.

C #, 16 15 bytes

Solução aprimorada graças a Neil

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

Como alternativa, o método interno tem 1 byte a mais:

n=>Math.Sign(n);

Programa completo com casos de teste:

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