Emita o sinal


67

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.


45
Este é um desafio trivial com muitas soluções triviais. No entanto, existem algumas soluções não triviais também. Para os eleitores: Leia a primeira frase desta meta postagem antes de votar nas funções internas.
Stewie Griffin

8
Provavelmente, isso poderia usar uma tabela de classificação.
Martin Ender

2
@MrLister votou como quiser, mas na verdade você deve procurar criatividade em vez do tamanho do código.
FlipTack

3
@ FlipTack Oh, eu pensei que era codegolf.
Lister

3
@ MrLister, esse é o critério de ganho objetivo. mas é realmente necessário mais esforço para digitar sum sinal embutido ou usar algum deslocamento de bits inteligente / matemática para resolver isso? Dê uma olhada neste meta post
FlipTack

Respostas:


46

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.


Isso é muito inteligente :)
Mego

Funciona com notação científica de números inteiros (como 0.42e2)?
Egor Skriptunoff

@EgorSkriptunoff Não, mas isso não é um requisito.
Martin Ender

9
@EgorSkriptunoff também não suporta números romanos. A menos que o desafio mencione explicitamente um determinado formato não-padrão que precisa ser suportado, a suposição geral é de que é bom lidar com um único formato natural do seu idioma preferido.
Martin Ender

3
@EgorSkriptunoff Retina não tem nenhum conceito de números. É uma linguagem puramente baseada em strings.
Martin Ender

42

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 .


7
@betseg Isso ocorre porque os upvotes nos built-ins agora são desaprovados.
Erik the Outgolfer

4
Salvando 1 byte com issoreturn n>>16|!!n;
aross

5
@GB O tamanho de int é provavelmente 2 (16, x86) ou 4 (32, x86_64), mas lembre-se, tudo o que é necessário é uma arquitetura na qual seja válida. Isso não é Stack Overlflow, a portabilidade não é importante.
cat

2
f(n){n=n>>31|!!n;}funciona também Mas isso é apenas uma peculiaridade do compilador, não um recurso de linguagem.
GB

2
As peculiaridades do @ GB Compiler são perfeitamente válidas, desde que se prove que existe um compilador no qual a peculiaridade funciona. Felizmente, o gcc tem a peculiaridade.
Mego

34

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.


29

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.


11
E há um 'moo' - linguagem ...?
Mukul Kumar

11
@MukulKumar É um derivado brainfuck chamado COW que permite um par de coisas que bf não
Gabriel Benamy

Também poderia chamar isso de "mago ruim". OUT OF MANA!!!
Urna de polvo mágico

18

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.


4
A animação do fluxo do programa é muito legal!
Luis Mendo

Linguagem agradável. Poderia ser mais curto? 4 controles de fluxo parecem muito. Na contagem de operações, pode ter 8 bytes introduzindo outro?, Mas agora ele usa a metade inferior do cubo: ..1nI? ..> O @ .........?
BlackShift

Seis são possíveis se ignorarmos as saídas após o primeiro: / I? NO1 A propósito, isso só funciona porque retorno -1 no intérprete online em vez de 0 de acordo com a especificação.
BlackShift

@BlackShift Obrigado pelo seu interesse! Gosto das suas sugestões, mas não sei como melhorá-las. Definitivamente, é possível usar menos instruções; a parte complicada é usar menos do cubo ... ;-) E obrigado por apontar esse -1 erro, eu vou consertar isso em breve.
ETHproductions

@ETHproductions IMO Não é um bug, faz sentido Iretornar -1 quando a entrada termina da mesma forma que as minúsculas i.
FlipTack

16

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.


2
Não incorporado em 12 bytes para 32-bit inteiro assinado n: n=>n>>31|!!n.
Neil

@ Neil n>>31é realmente inteligente, obrigado!
ETHproductions

Não acho que a terceira solução seja válida, pois o Javascript usa flutuadores de precisão dupla para números. Mas eu posso estar errado.
Mego

@Mego Você está correto. Eu esclareci isso no post.
ETHproductions

11
@Mego Desculpe, eu perdi o seu comentário. Ao usar operadores bit a bit, o JS lança implicitamente seus operandos para números inteiros de 32 bits assinados, para que a terceira solução funcione, mas apenas nos números de -2147483648 a 2147483647.
ETHproductions

15

APL (Dyalog APL) , 1 byte

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

×

TryAPL online!


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

¯11⌊⊢

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


11
Você realmente fez isso em UM byte ... Você é uma lenda. Tenho certeza que Jon Skeet ficaria orgulhoso.

@ Mango Você está brincando, certo? Existem algumas respostas de byte único para esse desafio.
Adám

11
Eu estava sendo sarcástico, também disse isso porque essa é a primeira resposta de byte único que vi.

14

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

Eu acho que você pode apenas usar um legal ;, em vez de que impublicável 0x01para terminar o programa corretamente :)
Erik o Outgolfer

@EriktheOutgolfer Eu preciso 0x01pressionar um de 1qualquer maneira.
Martin Ender

2
Parece que só testei minha sugestão 123. Lição aprendida: teste com mais casos.
Erik the Outgolfer

14

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

Correndo com negativo

Aqui está executando com 0:

Correndo com zero

Executando com positivo:

Correndo com positivo


11
Eu realmente gosto do seu método, mas é possível em um único regex::s/\v(-)=[^0].*/\11
nmjcman101 20/12/19

GIFs de console pontilhado ... ??
Destino 26/12

12

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


2
Isso é extremamente inteligente!
Mego


11

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.


11
Seu código é feliz e se transforma triste:D
Stefan

2
@ Stefan Você pode alterar a ordem, se preferir. ;)
Martin Ender

9

PHP, 16 bytes

Usa o novo operador de nave espacial.

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

Não se esqueça de mencionar que esta é apenas uma resposta do PHP7. E como você está usando <?=, você deve usar $_GET[n], o que não leva mais bytes. Para usar <?=, você precisa estar dentro de um servidor da web (como o Apache) e não terá acesso a ele $argv. Você pode tentar executar a <?php var_dump($argv);partir de um arquivo PHP, acessado através do Apache, e ele será exibido NULL.
Ismael Miguel

11
"Para usar <? =, Você precisa estar dentro de um servidor da web (como o Apache)". Não. O <?=operador funciona muito bem na linha de comando.
Alex Howansky

Correndo php -r '<?=1'eu entendo PHP Parse error: syntax error, unexpected '<' in Command line code on line 1. Mas parece funcionar bem em um arquivo. Acho que você está certo.
Ismael Miguel

O -rsinalizador é para executar um trecho de código. Esta é a fonte completa. Salve-o em um arquivo e execute-o #php file.php
Alex Howansky

Eu já descobri. Eu realmente não sabia que funcionava a partir de um arquivo, usando o -fparâmetro (implícito) .
Ismael Miguel

9

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)


Você pode salvar 2 bytes removendo a mônada zero(())
0


8

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.


7

Ruby, 10 bytes

->x{x<=>0}

Será que 0.<=>também funcionam, ou você não pode fazer referência a métodos como que em Ruby?
Nic Hartley

.<=>espera 1 argumento, então acabaria sendo 0.<=> x, o que é mais longo.
Seims

@QPaysTaxes de que você precisaria 0.method:<=>porque as chamadas de método em ruby ​​não usam parênteses e 0.<=>seriam interpretadas como uma chamada de método com poucos argumentos.
Cyoce 07/01

7

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!


11
Realmente não "exige" -E, isso é apenas se você chamá-lo da CLI em vez de um arquivo, e é por isso que acho que você disse que não há nenhum custo extra.
nyuszika7h

@ nyuszika7h, de fato, requer , eu acho, da maneira que o teste via -enão funcionará, mas -Eé aceito como não mais do que -e. Conforme consenso em meta. Espero que isso ajude um pouco!
Dom Hastings

Sim, eu não estava sugerindo exigir nenhum custo extra para isso, pois funciona bem quando esse script é executado normalmente a partir de um arquivo.
usar o seguinte código

7

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.


7

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

Qual é o ~suposto ser?
Conor O'Brien

@ ConorO'Brien Símbolo negativo, para diferenciar o símbolo de subtração da TI-Basic. Eu sei que o Cemetech SC também usa ~para representar esse token.
Timtech

Oh legal. Eu não fazia ideia.
Conor O'Brien

@ ConorO'Brien Bem, agora você sabe. Obrigado por perguntar :)
Timtech

11
Isso não é válido - usar Anscomo entrada não atende aos critérios para ser um método de E / S padrão válido (ele não possui duas vezes mais votos positivos do que votos negativos - atualmente é + 19 / -12).
Mego

7

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

MATL é mais longo que Matlab e Octave ?!
Adám

4
Ele também poderia ter usado o built-in ZScomo diz a resposta.
Stewie Griffin


6

Mathematica, 4 bytes

Sign

Exatamente o que diz na lata


Salvar um byte comsgn
Adám

3
WolframAlpha não é o mesmo que Mathematica; inclui interpretação automática de entrada de linguagem ambígua / natural.
Greg Martin

Então, devo enviar uma resposta separada?
Adám

me parece razoável ...
Greg Martin

6

Oitava, 26 24 bytes

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

Esta é a minha primeira resposta de oitava de , 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/21

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/2-1


@LuisMendo N will be an integerTenho sorte diz que na questão :)
Kritixi Lithos

Oh, eu não tinha lido que parte :)
Luis Mendo

11
C l e v e r!
flawr

Você não precisa f=se o resto é uma expressão de função válida e não recursiva.
Cyoce

@Cyoce Desculpe, mas eu não preferem funções anônimas
Kritixi Lithos

6

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


6

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

Programa

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 .


2
Eu acredito que a convenção para Piet é contar todos os codels.
precisa saber é o seguinte

@ SuperJedi224 Isso não foi o que foi decidido no meta post, parece que o número de bytes na imagem é o que eu vou seguir.
Mike Bufardeci

6

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!


11
Eu também estava pensando em usar abs, mas não tinha ideia do que fazer com o 0. Bem feito!
Kritixi Lithos

5

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.


11
Usando o builtin é, naturalmente, mais curto, mas menos divertido: sign(scan()).
Billywob

Desculpe, shouldve explicitamente mencionado evitando o builtin
JAD

5

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.


Eu sabia que deveria ter lido melhor essa página. Na verdade, não é mais curto - eu esqueci 0, mas eu estava tentando pegar o número como argumento e depois Àé1. Um número positivo fornece uma sequência de unidades, um número negativo DEVE fornecer uma sequência de unidades uma linha acima e 0 não daria nada. O bit de número negativo não funcionou À, mas funcionou comd$@"
nmjcman101

Ah Bem, a razão que não funciona é porque não há outra linha para ela entrar. Se você adicionar, é<cr>ele terá duas linhas vazias e isso funcionará . Não tenho certeza se você pode usá-lo para obter uma resposta completa.
DJMcMayhem

Eu tinha outra linha, mas não disse isso explicitamente no meu comentário. Qual foi o --argumento que você adicionou?
nmjcman101

11
Significa "fim das opções". Desde que -6começa com um sinalizador, o docopt (a biblioteca python para opções de linha de comando) considera que é um sinalizador da linha de comando e não um argumento. Adicionar --apenas sinais de que é um argumento, não uma opção. Caso contrário, ele não será executado por causa da chamada inválida da linha de comando.
DJMcMayhem

5

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

2
Tente em n>>31vez de n<0?-1:0.
21416 Neil

11
É um pouco triste quando o builtin não é nem a solução mais curta.
Mego

Digamos que C # é conhecido por ser bastante detalhado ...
adrianmp

11
A) Eu acho que você não precisa seguir a trilha, ;pois uma lambda é uma expressão, não uma declaração. B) seria Math.Signou Math::Signou algo similar ser uma submissão válida? Não tenho certeza de como o C #, em particular, lida com métodos. Basicamente, seria x = Math.Sign;uma instrução C # válida se xfosse inicializada com o tipo certo?
Cyoce
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.