Dado un número N, muestra el signo de N:

• Si N es positivo, salida 1
• Si N es negativo, salida -1
• Si N es 0, salida 0

N será un número entero dentro del rango representable de números enteros en el idioma elegido.

Retina , 9 bytes

[1-9].*
1

Pruébalo en línea!

Reemplaza un dígito que no es cero y todo lo que sigue con él 1. Esto deja un potencial líder -intacto y cambia todos los números excepto a 0sí mismo a un valor absoluto 1.

C (GCC), 24 23 22 18 bytes

¡Gracias a @aross y @Steadybox por guardar un byte!

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

No se garantiza que funcione en todos los sistemas o compiladores, funciona en TIO .

Mathematica, 4 bytes

Clip

¿Qué tal no usar el incorporado Signy aún anotar 4 bytes? ;)

Clipcon un solo argumento recorta (o sujeta) el valor de entrada entre -1y 1. Como las entradas solo serán enteras, esto es lo mismo que usar Sign.

VACA, 225 213 201 bytes

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

Pruébalo en línea!

La forma en que funciona este código es que determina el signo alternando sumando y restando números más grandes, y viendo cuál fue el último que funcionó. Dado cualquier número entero distinto de cero, primero reste 1, luego sume 2, luego reste 3, etc. y eventualmente llegará a 0. Mantenga un registro de su estado alternando sumando y restando 2 a un valor que comience en 0. Para ejemplo:

-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

Cuando haya terminado, reste 1 de su estado y obtendrá el signo, positivo o negativo. Si el número original es 0, no se moleste en hacer nada de esto y simplemente imprima 0.

Explicación detallada:

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.

Todavía estoy experimentando con el golf (te sorprenderá descubrir que jugar al golf en COW es bastante difícil), por lo que esto puede reducirse unos pocos bytes más en el futuro.

Cubix , 10 bytes

(W0^I?>O2@

¡Pruébelo en línea!

Este código está envuelto en la siguiente red de cubos:

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

Luego, el código se ejecuta con la IP (puntero de instrucción) comenzando en I, hacia el este. Iingresa un entero con signo de STDIN, empujándolo a la pila.

El siguiente comando es ?, que cambia la dirección de la IP según el signo del elemento superior. Si la entrada es 0, sigue moviéndose en la misma dirección, ejecutando el siguiente código:

• >- Apunte la IP hacia el este. (Sin operaciones ya que ya vamos hacia el este).
• O - Salida del elemento superior como un entero.
• 2- Empuja 2 a la pila. Esto es prácticamente un no-op, porque ...
• @ - Termina el programa.

Si la entrada es negativa, la IP gira a la izquierda en ?; Como se trata de un cubo, la IP se mueve hacia 0la segunda fila, en dirección este. 0empuja un 0 literal, luego se ejecuta este código:

• ^ - Apunte la IP al norte.
• W - "Sidestep" el IP un punto a la izquierda.
• ( - Disminuir el elemento superior.

El TOS es ahora -1, y la IP se envuelve alrededor del cubo a través de un montón de no-ops .hasta que golpea el >. Esto ejecuta el mismo código de salida mencionado anteriormente, la salida -1.

Si la entrada es positiva, sucede lo mismo que con las entradas negativas, con una excepción: la IP gira a la derecha en lugar de a la izquierda en el ?, y se envuelve alrededor del cubo hacia el 2, que empuja un literal 2. Esto luego se reduce a 1 y enviado a la salida.

JavaScript (ES6), 9 bytes

Math.sign

Sencillo.

El más corto no incorporado es de 13 bytes:

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

Gracias a @Neil, esto se puede jugar por un byte, pero a costa de trabajar solo en enteros de 32 bits:

n=>n>0|n>>31

O podrías hacer

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

que parece más golfable, pero no estoy seguro de cómo.

APL (Dyalog APL) , 1 byte

También funciona para números complejos, devolviendo 1∠ θ :

×

TryAPL en línea!

Sin eso incorporado, para enteros (según OP):

¯1⌈1⌊⊢

¯1⌈ el mayor de uno negativo y

1⌊ el más pequeño de uno y

⊢ el argumento

TryAPL en línea!

... y uno general:

>∘0-<∘0

>∘0 más que cero

- menos

<∘0 menos que cero

TryAPL en línea!

> <> , 9 8 bytes

Gracias a Sp3000 por guardar un byte.

'i$-%n/

Hay un no imprimible 0x01antes del /.

Pruébalo en línea!

Explicación

Este es un puerto de la respuesta Labyrinth basada en mi código de personaje .

'     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

¡Guardado un byte gracias a @DJMcMayhem !

Aquí, ^Mhay una nueva línea literal.

Como @ nmjcman101 señaló en los comentarios, se puede usar una sola expresión regular ( :s/\v(-)=[^0].*/\11^M, 20 bytes), pero dado que esto es básicamente lo mismo que sería una respuesta de Retina, me quedo con mi propio método.

Explicación:

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.

Aquí hay un gif que se ejecuta con un número negativo (versión anterior):

Aquí está corriendo con 0:

Corriendo con positivo:

///, 52 36 bytes

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

Ungolfed, explicación:

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

Básicamente es una implementación de MapReduce, es decir, hay dos fases:

• Reemplace todas las apariciones de dígitos 2- 9por 1, por ejemplo, 1230405->1110101
• Reduzca pares de 11o 10a 1repetidamente, p 1110101. Ej. ->1

Si -inicialmente hubo un frente, permanecerá y la salida será -1. Un solo 0nunca se reemplaza, lo que resulta en sí mismo.

Actualización: Ahorre 16 bytes adicionales aliasing //1/con a, gracias a Martin Ender.

Pruébelo en línea, con casos de prueba

Python 2 , 17 bytes

lambda n:cmp(n,0)

Pruébalo en línea!

Laberinto , 10 bytes

?:+:)%:(%!

Pruébalo en línea!

Explicación

La semántica de flujo de control de Labyrinth realmente le brinda una forma "libre" de determinar el signo de un número, porque la ruta elegida en una bifurcación de 3 vías depende de si el signo es negativo, cero o positivo. Sin embargo, hasta ahora no he podido ajustar un programa con uniones en menos de 12 bytes (aunque puede ser posible).

En cambio, aquí hay una solución de forma cerrada, que no requiere ninguna rama:

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

El puntero de instrucción luego llega a un callejón sin salida, se da vuelta y termina cuando %ahora intenta una división por cero.

Es necesario duplicar la entrada para que esto funcione con entradas 1y -1, de lo contrario, una de las dos operaciones de módulo ya intentaría una división por cero.

PHP, 16 bytes

Utiliza el nuevo operador de nave espacial.

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

Brain-Flak 74 42 40 Bytes

Guardado 2 bytes gracias a 1000000000

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

Pruébalo en línea!

Explicación:

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

*

¡Pruébelo en línea (con casos de prueba)!

C, 24 20 19 18 bytes

Abuso de dos hazañas en C para jugar golf; Esto está en C (GCC).

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

Pruébalo en línea!

Revisión histórica:

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

Revisión 1: primer intento. Lógica simple

Revisión 2: Abusa de un error de memoria / pila en GCC donde, por lo que puedo decir, una función que no regresa devolverá la última variable establecida en ciertos casos.

Revisión 3: Abusa del comportamiento ternario donde el resultado indefinido devolverá un resultado condicional (es por eso que el verdadero retorno de mi ternario es nulo)

Revisión 4: reste un bool cast ( !!) de la sustitución condicional ternaria a la que se hace nilreferencia en la revisión 2.

Rubí, 10 bytes

->x{x<=>0}

Perl, 9 bytes

Requiere -Esin costo adicional.

say<><=>0

Uso

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

¡Estoy contento con el operador de pescado!

Pila de gatos , 6 + 4 = 10 bytes

_[:I!:

+4 bytes para las ​ -nmbanderas. nes para E / S numéricas, y dado que Stack Cats requiere que los programas sean palindrómicos, mrefleja de manera implícita el código fuente para proporcionar la fuente original

_[:I!:!I:]_

Pruébalo en línea! Al igual que con todos los buenos campos de golf de Stack Cats, esto fue encontrado por la fuerza bruta, venció cualquier intento manual por un tiro largo y no puede incorporarse fácilmente en un programa más grande.

Agregue una Dmarca si desea ver un seguimiento del programa paso a paso, es decir, ejecutar -nmDy verificar STDERR / debug.

Stack Cats utiliza una cinta de pilas que se rellenan implícitamente con ceros en la parte inferior. Al comienzo del programa, toda la entrada se inserta en la pila de entrada, con un -1en la base para separar la entrada de los ceros implícitos. Al final del programa, se emite la pila actual, excepto una base -1si está presente.

Los comandos relevantes aquí son:

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

Tenga en cuenta que todos estos comandos son invertibles, siendo su inverso el espejo del comando. Esta es la premisa de Stack Cats: todos los programas de terminación no triviales tienen una longitud impar, ya que los programas de longitud par se cancelan automáticamente.

Empezamos con

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

_resta, haciendo la parte superior -1-n, y [mueve el resultado a la izquierda una pila:

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

:intercambia los dos primeros y Ino hace nada, ya que la parte superior de la pila ahora es cero. !luego, a nivel de bits, niega el cero superior en a -1y :cambia los dos superiores hacia atrás. !a continuación, bit a bit niega la parte superior, convirtiendo -1-nde nuevo en notra vez:

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

Ahora nos ramificamos según I, que se aplica a nuestro original n:

• Si nes negativo, nos movemos hacia la izquierda una pila y terminamos con -nun cero implícito. :intercambia, coloca un cero en la parte superior y ]mueve el cero en la parte superior de la -1que acabamos de mover. _luego resta, dejando la pila final como [-1 -1], y solo -1se emite uno ya que -1se ignora la base .

• Si nes cero, no nos movemos y :cambiamos, poniéndonos -1en la parte superior. ]luego mueve esta izquierda -1arriba de la derecha -1y _resta, dejando la pila final como [-1 0], sacando el cero e ignorando la base -1.

• Si nes positivo, nos movemos a la derecha una pila y terminamos con -na -1. :intercambia, coloca la -1parte superior y ]mueve esta -1derecha, encima de un cero implícito. _luego resta, dando 0 - (-1) = 1y dejando la pila final como [1], que es la salida.

TI-Basic, 8 bytes

median({1,Ans,~1

Soluciones alternativas (siéntase libre de sugerir más):

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-

La entrada puede ser un número o una matriz. El resultado es un número o una matriz con los valores correspondientes.

Pruébalo en línea! O pruebe varios casos utilizando la entrada de matriz.

Explicación

Esto evita usar la función de signo incorporado ( 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

Gelatina , 1 byte

Ṡ

TryItOnline!

El signo monádico átomo , Ṡ, hace exactamente lo que se especifica para una entrada de número entero, ya sea como un programa completo o como un enlace monádico (función de tomar un argumento).

Mathematica, 4 bytes

Sign

Exactamente lo que dice en la lata

Octava, 26 24 bytes

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

Esta es mi primera respuesta de octava de código de golf , ¡se agradece cualquier consejo de golf!

Pruébalo en línea!

La idea para tomar asinviene de la pregunta donde dice output the sign:)

Explicación

Nota: dividir el número por piy multiplicarlo por 2es el equivalente a dividir el número entero porpi/2

Caso 0:

asin(0)rendimientos 0. Tomar la parte real de la misma y dividirla no pi/2hace ninguna diferencia en la salida.

Caso positive:

asin(1)rendimientos pi/2. asinde cualquier número mayor que 1dará pi/2+ número complejo. Tomar la parte real de eso da pi/2y dividirlo por pi/2da1

Caso negative:

asin(-1)rendimientos -pi/2. asinde cualquier número menor que -1dará -pi/2+ número complejo. Tomar la parte real de eso da -pi/2y dividirlo por pi/2da-1

En realidad , 1 byte

s

Pruébalo en línea!

Otro caso de exactamente lo que dice en la lata ses la función de signo.

Sin el incorporado (4 bytes):

;A\+

Pruébalo en línea!

;A\divide el valor absoluto de la entrada por la entrada. Esto da -1como resultado entradas negativas y 1entradas positivas. Desafortunadamente, debido al manejo de errores de Actually (si algo sale mal, el comando se ignora), 0ya que la entrada deja dos 0s en la pila. +rectifica esto al agregarlos (lo que causa un error con cualquier otra cosa, por lo que se ignora).

Piet, 188 53 46 41 bytes

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

Intérprete en línea disponible aquí.

Este código piet cumple con el estándar (n>0)-(n<0), ya que no hay signos de verificación incorporados. De hecho, no hay nada menos que incorporado, por lo que sería una descripción más precisa de este método (n>0)-(0>n).

El texto de arriba representa la imagen. Puede generar la imagen pegándola en el cuadro de texto en la página del intérprete. Por conveniencia, he proporcionado la imagen a continuación donde el tamaño del códel es de 31 píxeles. La cuadrícula está ahí para facilitar la lectura y no forma parte del programa. También tenga en cuenta que este programa no cruza ningún códec blanco; siga los códeles de colores alrededor del borde de la imagen para seguir el flujo del programa.

Explicación

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 reducir aún más el tamaño del archivo, necesitaría cambiar el programa (jadeo) en lugar de simplemente comprimir el archivo como lo he estado haciendo. Me gustaría eliminar una fila que reduciría esto a 36. También puedo desarrollar mi propio intérprete que tendría un formato de entrada mucho más pequeño, ya que cambiar el código para hacerlo más pequeño no es de lo que se trata el código golf.

Las modificaciones me dijeron que el tamaño de archivo general es lo que cuenta para el código Piet. Como el intérprete acepta el texto como entrada válida y el texto sin procesar tiene un recuento de bytes mucho menor que cualquier imagen, el texto es la opción obvia. Pido disculpas por ser descarado al respecto, pero no hago las reglas. La meta discusión sobre esto deja en claro mis opiniones sobre el asunto.

Si cree que eso va en contra del espíritu de Piet o le gustaría discutir esto más a fondo por cualquier motivo, consulte la discusión sobre meta .

Pushy , 7 bytes

Este es probablemente el programa de aspecto más extraño que he escrito ...

&?&|/;#

Pruébalo en línea!

Utiliza sign(x) = abs(x) / x, pero con un explícito sign(0) = 0para evitar el error de división cero.

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

Esto funciona porque x / abs(x)es 1 cuando x es positivo y -1 cuando x es negativo. Si la entrada es 0, el programa salta al comando de salida.

4 bytes (no competitivos)

Debido a las vacaciones y a tener demasiado tiempo, he hecho una reescritura completa del intérprete Pushy. El programa anterior aún funciona, pero como 0 / 0ahora está predeterminado a 0, lo siguiente es más corto:

&|/#

Pruébalo en línea!

R, 25 bytes

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

Lleva el número a STDIN. Luego comprueba si es cero, si no, devuelve x/|x|cuál es cualquiera 1de los dos -1y emite 0 si x=0.

Esto es sin usar el incorporado signpor supuesto.

V 14 12 bytes

Gracias @DJMcMayhem por 2 bytes. Utiliza un reg-ex para hacer la sustitución. Un poco divertido, porque no está integrado. Tengo una función más divertida, pero no funciona como esperaba.

ͨ-©½0]/±1

Verificar casos de prueba

Esto solo se traduce a :%s/\v(-)=[^0].*/\11qué coincide uno o más -seguido de cualquier cosa que no sea 0, seguido de cualquier cosa cualquier cantidad de veces. Se reemplaza con el primer partido (por lo tanto, a -o nada) y a 1. La expresión regular no coincide con 0, por lo que se queda sola.

La forma más divertida (21 bytes)

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

TryItOnline

Esto acepta la entrada como un argumento en lugar de en el búfer.

é<CR> Insertar una nueva línea.

Àejecuta el argumento como código V. a -moverá el cursor a la línea anterior, y cualquier número se convertirá en el recuento para el siguiente comando

é1inserte (cuenta) 1's

2| pasar a la segunda columna

D eliminar todo desde la segunda columna en adelante (dejando solo un carácter)

kJ Une las dos líneas juntas.

òhé-òse traduce como: "correr hé-hasta romper". Si el 1 estaba en la segunda línea, esto se rompe inmediatamente después de la h. Si estaba en la primera línea, insertará un -antes de romper.

ó^$/aEsto soluciona el hecho de que -1, 0, 1dejará un espacio en blanco, en lugar de un espacio en blanco con el registro de argumentos.

C #, 16 15 bytes

Solución mejorada gracias a Neil

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

Alternativamente, el método incorporado es 1 byte más largo:

n=>Math.Sign(n);

Programa completo con casos de prueba:

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