Dar salida a la señal


67

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.


45
Este es un desafío trivial con muchas soluciones triviales. Sin embargo, también hay algunas soluciones no triviales. A los votantes: Lea la primera oración de esta meta publicación antes de votar a favor de las funciones integradas.
Stewie Griffin

8
Esto probablemente podría usar una tabla de clasificación.
Martin Ender

2
@MrLister vota de la forma que quieras, pero realmente debes buscar la creatividad en lugar de la longitud del código.
FlipTack

3
@FlipTack Oh, pensé que era codegolf.
Sr. Lister

3
@MrLister ese es el criterio ganador objetivo. pero, ¿realmente se necesita más esfuerzo para escribir suna señal incorporada, o utilizar algunos cambios de bits / matemáticas inteligentes para resolverlo? Echa un vistazo a esta meta publicación
FlipTack

Respuestas:


46

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.


Esto es muy inteligente :)
Mego

¿Funciona con notación científica de números enteros (como 0.42e2)?
Egor Skriptunoff

@EgorSkriptunoff No, pero eso no es un requisito.
Martin Ender

9
@EgorSkriptunoff tampoco admite números romanos. A menos que el desafío mencione explícitamente un cierto formato no estándar que debe ser compatible, la suposición general es que está bien tratar con un formato único que sea natural en el idioma que elija.
Martin Ender

3
@EgorSkriptunoff Retina no tiene ningún concepto de números. Es un lenguaje puramente basado en cadenas.
Martin Ender

42

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 .


77
@betseg Eso se debe a que los votos a favor de los integradores ahora están mal vistos.
Erik the Outgolfer

44
Ahorrando 1 byte con estoreturn n>>16|!!n;
aross

55
@GB El tamaño de int es probablemente 2 (16, x86) o 4 (32, x86_64), pero recuerde, todo lo que se necesita es una arquitectura en la que sea válida. Esto no es Stack Overlflow, la portabilidad no es importante.
gato

2
f(n){n=n>>31|!!n;}también funciona Pero esto es solo una peculiaridad del compilador, no una función de lenguaje.
GB

2
Las peculiaridades del compilador @GB son perfectamente válidas, siempre que pueda demostrarse que existe un compilador en el que funciona la peculiaridad. Afortunadamente, gcc tiene la peculiaridad.
Mego

34

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.


29

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.


1
¿Y hay un 'moo' - idioma? ...
Mukul Kumar

1
@MukulKumar Es un derivado de brainfuck llamado COW que permite un par de cosas que bf no
Gabriel Benamy

También podría llamarse a esto el lenguaje "mago malo". OUT OF MANA!!!
Urna mágica del pulpo

18

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.


44
¡La animación del flujo del programa es muy bonita!
Luis Mendo

Buen lenguaje ¿Podría ser más corto? 4 controles de flujo parecen mucho. En el recuento de operaciones, puede tener 8 bytes introduciendo otro?, Pero ahora usa la mitad inferior del cubo: ..1nI? ..> O @ .........?
BlackShift

Seis es posible si ignoramos las salidas después de la primera: / I? NO1 Por cierto, esto solo funciona porque devuelvo -1 en el intérprete en línea en lugar de 0 según la especificación.
BlackShift

@BlackShift ¡Gracias por su interés! Me gustan sus sugerencias, pero no estoy seguro de cómo mejorarlas. Definitivamente es posible usar menos instrucciones; la parte difícil es usar menos cubo ... ;-) Y gracias por señalar ese error -1, lo arreglaré pronto.
ETHproductions

@ETHproductions IMO No es un error, tiene sentido Idevolver -1 cuando la entrada termina al igual que las minúsculas i.
FlipTack

16

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.


2
No incorporado en 12 bytes para entero con signo de 32 bits n: n=>n>>31|!!n.
Neil

@Neil n>>31es realmente inteligente, ¡gracias!
ETHproductions

No creo que la tercera solución sea válida, ya que Javascript usa flotantes de doble precisión para los números. Pero podría estar equivocado.
Mego

@Mego Tienes razón. He aclarado esto en la publicación.
ETHproductions

1
@Mego Lo siento, me perdí tu comentario. Cuando se utilizan operadores bit a bit, JS convierte implícitamente sus operandos a enteros de 32 bits con signo, por lo que la tercera solución funciona, pero solo en números del -2147483648 al 2147483647.
ETHproductions

15

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

¯11⌊⊢

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


1
Realmente lo hiciste en UN byte ... Señor, eres una leyenda. Estoy seguro de que Jon Skeet estaría orgulloso.

@Mango Estás bromeando, ¿verdad? Hay un puñado de respuestas de un solo byte para este desafío.
Adám

1
Estaba siendo sarcástico, también dije eso porque esta es la primera respuesta de un solo byte que vi.

14

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

Creo que puedes usar un documento legal en ;lugar de uno que no se 0x01puede imprimir para finalizar el programa correctamente :)
Erik the Outgolfer

@EriktheOutgolfer Necesito 0x01presionar un de 1todos modos.
Martin Ender

2
Oh, parece que solo probé mi sugerencia con 123. Lección aprendida: prueba con más casos.
Erik the Outgolfer

14

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

Corriendo con negativo

Aquí está corriendo con 0:

Corriendo con cero

Corriendo con positivo:

Corriendo con positivo


1
Realmente me gusta su método, pero es posible en una sola expresión regular::s/\v(-)=[^0].*/\11
nmjcman101

¿Consola GIF GIF ... ??
Desty

12

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


2
¡Esto es extremadamente inteligente!
Mego


11

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.


1
Su código es feliz y se pone triste:D
Stefan

2
@Stefan Puede cambiar el orden si lo prefiere. ;)
Martin Ender

9

PHP, 16 bytes

Utiliza el nuevo operador de nave espacial.

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

No olvide mencionar que esta es solo una respuesta PHP7. Y ya que está usando <?=, debe usar $_GET[n], que no toma más bytes. Para usarlo <?=, debe estar dentro de un servidor web (como Apache), y allí no tendrá acceso $argv. Puede intentar ejecutar <?php var_dump($argv);desde un archivo PHP, accedido a través de Apache, y se mostrará NULL.
Ismael Miguel

1
"Para usar <? =, Debe estar dentro de un servidor web (como Apache)". No. El <?=operador funciona bien desde la línea de comandos.
Alex Howansky

Corriendo php -r '<?=1'lo consigo PHP Parse error: syntax error, unexpected '<' in Command line code on line 1. Pero parece funcionar bien desde un archivo. Supongo que tienes razón.
Ismael Miguel

La -rbandera es para ejecutar un fragmento de código. Esta es la fuente completa. php file.php
Guárdelo

Ya lo descubrí. Realmente no sabía que funcionaba desde un archivo, usando el -fparámetro (implícito) .
Ismael Miguel

9

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)


Puede guardar 2 bytes eliminando la mónada cero(())
0 '


8

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.


7

Rubí, 10 bytes

->x{x<=>0}

Sería 0.<=>también el trabajo, o puede no hacer referencia a métodos como el de Ruby?
Nic Hartley

.<=>espera 1 argumento, por lo que terminaría siendo 0.<=> x, que es más largo.
Seims

@QPaysTaxes que necesitaría 0.method:<=>porque las llamadas a métodos en ruby ​​no usan paréntesis y 0.<=>se interpretarían como llamadas a métodos con muy pocos argumentos.
Cyoce

7

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!


1
Realmente no "requiere" -E, eso es solo si lo llama desde la CLI en lugar de un archivo, por lo que supongo que dijo que no hay costo adicional.
nyuszika7h

@ nyuszika7h, de hecho, requiere , supongo, en la forma en que las pruebas a través de -eno funcionarán, pero -Ese acepta como no más que -e. Según el consenso sobre meta. ¡Espero que eso ayude un poco!
Dom Hastings

Sí, no estaba sugiriendo que se requiera ningún costo adicional para eso, ya que funciona bien cuando ese script se ejecuta normalmente desde un archivo.
nyuszika7h

7

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.


7

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

¿Qué se ~supone que es?
Conor O'Brien

@ ConorO'Brien Símbolo negativo, para diferenciar entre el símbolo de resta de TI-Basic. Sé que Cemetech SC también usa ~para representar este token.
Timtech

Oh genial No tenía ni idea.
Conor O'Brien

@ ConorO'Brien Bueno, ya lo sabes. Gracias por preguntar :)
Timtech

1
Esto no es válido: el uso Anscomo entrada no cumple los criterios para ser un método de E / S predeterminado válido (no tiene el doble de votos positivos que votos negativos; actualmente está en + 19 / -12).
Mego

7

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

¿MATL es más largo que Matlab y Octave ?
Adám

44
También podría haber usado el incorporado ZScomo se dice en la respuesta.
Stewie Griffin

6

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


6

Mathematica, 4 bytes

Sign

Exactamente lo que dice en la lata


Ahorre un byte consgn
Adám

3
WolframAlpha no es lo mismo que Mathematica; incluye interpretación automática de entrada de lenguaje ambiguo / natural.
Greg Martin

Entonces, ¿debo enviar esta respuesta por separado?
Adám

me parece razonable ...
Greg Martin

6

Octava, 26 24 bytes

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

Esta es mi primera respuesta de octava de , ¡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


@LuisMendo N will be an integerTengo suerte, dice eso en la pregunta :)
Kritixi Lithos

Oh, no había leído esa parte :)
Luis Mendo

1
C l e v e r!
flawr

No necesita f=si el resto es una expresión de función válida, no recursiva.
Cyoce

@Cyoce Lo siento, pero no prefiero las funciones anónimas
Kritixi Lithos

6

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


6

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

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


2
Creo que la convención para Piet es contar todos los códeles.
SuperJedi224

@ SuperJedi224 Eso no fue lo que se decidió en la meta publicación, parece que el número de bytes en la imagen es lo que voy a utilizar.
Mike Bufardeci

6

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!


1
También estaba pensando en usar abs, pero no tenía idea de qué hacer con el 0. ¡Bien hecho!
Kritixi Lithos

5

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.


1
Utilizando la orden interna es, por supuesto, más corto, pero menos divertido: sign(scan()).
Billywob

Lo siento, debería haber mencionado explícitamente que evitaba la construcción
JAD

5

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.


Sabía que debería haber leído esa página mejor. En realidad no es más corto: olvidé 0, pero estaba tratando de tomar el número como argumento y luego Àé1. Un número positivo da una cadena de unos, un número negativo DEBE dar una cadena de unos una fila hacia arriba, y 0 no daría nada. El bit de número negativo no funcionó À, pero sí cond$@"
nmjcman101

Ah Bueno, la razón por la que no funciona es porque no hay otra fila para que continúe. Si agrega é<cr>, tendrá dos líneas vacías y eso sí funciona . No estoy seguro de si puedes usar eso para obtener una respuesta completa
DJMcMayhem

Tenía otra línea para hacer, pero no lo dije explícitamente en mi comentario. ¿Cuál es el --argumento que agregaste?
nmjcman101

1
Significa "fin de opciones". Como -6comienza con un indicador, docopt (la biblioteca de Python para las opciones de línea de comando) cree que es un indicador de línea de comando en lugar de un argumento. Agregar --solo indica que es un argumento, no una opción. De lo contrario, no se ejecutará en absoluto debido a una invocación de línea de comando no válida.
DJMcMayhem

5

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

2
Intenta en n>>31lugar de n<0?-1:0.
Neil

1
Es un poco triste cuando la construcción no es la solución más corta.
Mego

Digamos que se sabe que C # es bastante detallado ...
adrianmp

1
A) No creo que necesites el seguimiento ;ya que una lambda es una expresión, no una declaración. B) ¿ Math.Signo Math::Signalgo similar sería una presentación válida? No estoy seguro de cómo C # en particular maneja los métodos. Básicamente, ¿ x = Math.Sign;sería una declaración válida de C # si xse inicializara con el tipo correcto?
Cyoce
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.