Dato un numero N, genera il segno N:

• Se N è positivo, emettere 1
• Se N è negativo, emettere -1
• Se N è 0, emettere 0

N sarà un numero intero all'interno dell'intervallo rappresentabile di numeri interi nella lingua prescelta.

Retina , 9 byte

[1-9].*
1

Provalo online!

Sostituisce una cifra diversa da zero e tutto il resto con 1. Questo lascia un potenziale leader -intatto e cambia tutti i numeri tranne se 0stesso in valore assoluto 1.

C (GCC), 24 23 22 18 byte

Grazie a @aross e @Steadybox per aver salvato un byte!

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

Non è garantito il funzionamento su tutti i sistemi o compilatori, funziona su TIO .

Mathematica, 4 byte

Clip

Che ne dici di non usare il built-in Signe ancora segnare 4 byte? ;)

Clipcon un singolo argomento aggancia (o blocca) il valore di input tra -1e 1. Dato che gli input saranno solo numeri interi, questo è lo stesso che usare Sign.

MUCCA, 225 213 201 byte

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

Provalo online!

Il modo in cui funziona questo codice è che determina il segno alternando l'aggiunta e la sottrazione di numeri più grandi, e vedendo quale era l'ultimo che ha funzionato. Dato un numero intero diverso da zero, sottrarre prima 1, quindi aggiungere 2, quindi sottrarre 3, ecc. E alla fine si raggiunge 0. Tenere traccia del proprio stato alternando l'aggiunta e la sottrazione di 2 a un valore che inizia da 0. esempio:

-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

Al termine, sottrai 1 dal tuo stato e otterrai il segno, positivo o negativo. Se il numero originale è 0, non preoccuparti di fare questo e basta stampare 0.

Spiegazione dettagliata:

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.

Sto ancora sperimentando il golf (sarai scioccato nello scoprire che giocare a golf in COW è piuttosto difficile), quindi in futuro questo potrebbe ridursi di qualche byte in più.

Cubix , 10 byte

(W0^I?>O2@

Provalo online!

Questo codice è racchiuso nella seguente rete cubica:

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

Il codice viene quindi eseguito con l'IP (puntatore istruzioni) a partire da I, rivolto verso est. Iimmette un numero intero con segno da STDIN, spingendolo nello stack.

Il comando successivo è ?, che cambia la direzione dell'IP in base al segno dell'elemento in alto. Se l'ingresso è 0, continua a muoversi nella stessa direzione, scorrendo il seguente codice:

• >- Punta l'IP verso est. (No-op poiché stiamo già andando ad est.)
• O - Stampa l'elemento superiore come numero intero.
• 2- Premi 2 nella pila. Questo è praticamente un non-op, perché ...
• @ - Termina il programma.

Se l'ingresso è negativo, l'IP gira a sinistra in corrispondenza di ?; poiché si tratta di un cubo, l'IP si sposta sulla 0seconda riga, in direzione est. 0invia uno 0 letterale, quindi viene eseguito questo codice:

• ^ - Punta l'IP verso nord.
• W - "Sidestep" l'IP un punto a sinistra.
• ( - Decrementa l'elemento in alto.

Il TOS è ora -1e l'IP si avvolge attorno al cubo attraverso una serie di operazioni non operative .fino a quando non colpisce >. Questo esegue lo stesso codice di output sopra menzionato, in uscita -1.

Se l'input è positivo, la stessa cosa accade con gli input negativi, con una sola eccezione: l'IP gira a destra invece che a sinistra in corrispondenza del ?, e si avvolge attorno al cubo verso il 2, che spinge un letterale 2. Questo viene quindi ridotto a 1 e inviato all'output.

JavaScript (ES6), 9 byte

Math.sign

Semplice.

Il non-builtin più breve è di 13 byte:

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

Grazie a @Neil, questo può essere golfato da un byte, ma al costo di lavorare solo su numeri interi a 32 bit:

n=>n>0|n>>31

Oppure potresti farlo

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

che sembra più golfabile, ma non sono sicuro di come.

APL (Dyalog APL) , 1 byte

Funziona anche per numeri complessi, restituendo 1∠ θ :

×

ProvaAPL online!

Senza quello incorporato, per numeri interi (come da OP):

¯1⌈1⌊⊢

¯1⌈ il più grande di quello negativo e

1⌊ il più piccolo di uno e

⊢ l'argomento

ProvaAPL online!

... e generale:

>∘0-<∘0

>∘0 più che zero

- meno

<∘0 di meno-zero

ProvaAPL online!

> <> , 9 8 byte

Grazie a Sp3000 per aver salvato un byte.

'i$-%n/

C'è un non stampabile 0x01prima del /.

Provalo online!

Spiegazione

Questa è una porta della mia risposta Labyrinth basata sul codice del personaggio .

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

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

Salvato un byte grazie a @DJMcMayhem !

Ecco, ^Mè una newline letterale.

Come ha sottolineato @ nmjcman101 nei commenti, è possibile utilizzare un solo regex ( :s/\v(-)=[^0].*/\11^M, 20 byte), ma poiché questa è sostanzialmente la stessa di una risposta Retina, sto seguendo il mio metodo.

Spiegazione:

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.

Ecco una gif che gira con un numero negativo (vecchia versione):

Eccolo in esecuzione con 0:

In esecuzione con positivo:

///, 52 36 byte

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

Ungolfed, spiegazione:

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

Fondamentalmente è un'implementazione di MapReduce, cioè ci sono due fasi:

• Sostituisci tutte le occorrenze delle cifre 2- 9con 1, ad es. 1230405->1110101
• Ridurre coppie di 11o 10per 1più volte, ad esempio 1110101->1

Se all'inizio c'era un -fronte, rimarrà e l'output sarà -1. Un singolo 0non viene mai sostituito, risultando in se stesso.

Aggiornamento: salva altri 16 byte aliasando //1/con a, grazie a Martin Ender.

Provalo online, con casi di test

Python 2 , 17 byte

lambda n:cmp(n,0)

Provalo online!

Labirinto , 10 byte

?:+:)%:(%!

Provalo online!

Spiegazione

La semantica del flusso di controllo di Labyrinth ti offre in realtà un modo "libero" per determinare il segno di un numero, perché il percorso scelto in un fork a 3 vie dipende dal fatto che il segno sia negativo, zero o positivo. Tuttavia, finora non sono stato in grado di adattare un programma con giunzioni in meno di 12 byte (anche se potrebbe essere possibile).

Invece, ecco una soluzione a modulo chiuso, che non richiede rami:

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

Il puntatore dell'istruzione quindi colpisce un vicolo cieco, si gira e termina quando %ora tenta una divisione per zero.

È necessario raddoppiare l'input per far funzionare questo con input 1e -1, altrimenti una delle due operazioni del modulo tenterebbe già di dividere per zero.

PHP, 16 byte

Utilizza il nuovo operatore di astronave.

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

Brain-Flak 74 42 40 byte

Salvato 2 byte grazie a 1000000000

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

Provalo online!

Spiegazione:

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

*

Provalo online (con casi di test)!

C, 24 20 19 18 byte

Abuso due exploit C per giocare a golf; Questo è in C (GCC).

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

Provalo online!

Cronologia delle revisioni:

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

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

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

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

Revisione 1: primo tentativo. Logica semplice

Revisione 2: abusa di un bug di memoria / stack in GCC in cui, per quanto ne so, una funzione di non ritorno restituirà l'ultima variabile impostata in alcuni casi.

Revisione 3: abusa del comportamento ternario in cui il risultato indefinito restituirà il risultato condizionale (motivo per cui il vero ritorno sul mio ternario è zero)

Revisione 4: sottrarre un bool cast ( !!) dalla sostituzione condizionale ternaria a cui fare nilriferimento nella revisione 2.

Rubino, 10 byte

->x{x<=>0}

Perl, 9 byte

Richiede -Esenza costi aggiuntivi.

say<><=>0

uso

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

Sono contento dell'operatore del pesce!

Stack Cats , 6 + 4 = 10 byte

_[:I!:

+4 byte per i ​ -nmflag. nè per l'I / O numerico e poiché Stack Cats richiede che i programmi siano palindromici, mrispecchia implicitamente il codice sorgente per fornire l'origine originale

_[:I!:!I:]_

Provalo online! Come praticamente tutti i buoni golf Stack Cats, questo è stato trovato con la forza bruta, ha battuto qualsiasi tentativo manuale da un tiro lungo e non può essere facilmente incorporato in un programma più ampio.

Aggiungi un Dflag se desideri vedere una traccia del programma passo-passo, ovvero esegui con -nmDe controlla STDERR / debug.

Stack Cats usa un nastro di pile che sono implicitamente riempite con zero nella parte inferiore. All'inizio del programma, tutti gli input vengono inseriti nello stack di input, con una -1alla base per separare l'input dagli zero impliciti. Alla fine del programma, viene emesso lo stack corrente, tranne una base -1se presente.

I comandi rilevanti qui sono:

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

Si noti che tutti questi comandi sono invertibili, con il suo inverso che è il mirror del comando. Questa è la premessa di Stack Cats: tutti i programmi di terminazione non banali hanno una lunghezza dispari, poiché i programmi di lunghezza pari si annullano automaticamente.

Iniziamo con

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

_sottrae, creando la parte superiore -1-ne [sposta il risultato a sinistra di uno stack:

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

:scambia le prime due e Inon fa nulla, poiché la parte superiore dello stack ora è zero. !quindi nega bit per bit lo zero superiore in a -1e :scambia i primi due indietro. !quindi nega bit per bit la parte superiore, tornando di -1-nnuovo in n:

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

Ora ci basiamo su I, che viene applicato al nostro originale n:

• Se nè negativo, spostiamo a sinistra di uno stack e finiamo con -nuno zero implicito. :scambia, mettendo uno zero in cima e ]sposta lo zero in cima a quello che -1abbiamo appena spostato. _quindi sottrae, lasciando lo stack finale simile [-1 -1]e ne -1viene emesso solo uno poiché la base -1viene ignorata.

• Se nè zero, non ci muoviamo e :scambiamo, mettendo -1in cima. ]quindi sposta questo a sinistra -1in alto a destra -1e _sottrae, lasciando lo stack finale simile [-1 0], producendo lo zero e ignorando la base -1.

• Se nè positivo, spostiamo a destra di uno stack e finiamo con -na -1. :scambia, posizionando il -1primo e ]spostandolo a -1destra, sopra uno zero implicito. _quindi sottrae, dando 0 - (-1) = 1e lasciando lo stack finale simile [1], che viene emesso.

TI-Basic, 8 byte

median({1,Ans,~1

Soluzioni alternative (sentiti libero di suggerire di più):

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

MATL , 6 byte

0>EGg-

L'input può essere un numero o un array. Il risultato è un numero o un array con i valori corrispondenti.

Provalo online! Oppure prova diversi casi usando l'input dell'array.

Spiegazione

Questo evita di usare la funzione builtin sign ( 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!

Il segno monadic atomo , Ṡ, fa esattamente ciò che viene specificato un valore intero, sia come un programma completo o come collegamento monadic (funzione prendendo un argomento).

Mathematica, 4 byte

Sign

Esattamente quello che dice sulla latta

Ottava, 26 24 byte

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

Questa è la mia prima risposta Octave di code-golf , tutti i suggerimenti per il golf sono apprezzati!

Provalo online!

L'idea di prendere il asinviene dalla domanda in cui si dice output the sign:)

Spiegazione

Nota: dividere il numero per pie moltiplicarlo per 2equivale a dividere l'intero numero perpi/2

Caso 0:

asin(0)rese 0. Prendere la parte reale di essa e dividerla per pi/2non fa differenza per l'output.

Caso positive:

asin(1)rese pi/2. asindi qualsiasi numero più grande di quello 1che darà pi/2+ numero complesso. Prendere la parte reale di essa dà pi/2e dividerla per pi/2dà1

Caso negative:

asin(-1)rese -pi/2. asindi qualsiasi numero minore di -1fornirà -pi/2+ numero complesso. Prendere la parte reale di essa dà -pi/2e dividerla per pi/2dà-1

In realtà , 1 byte

s

Provalo online!

Un altro caso di ciò che dice esattamente sulla latta sè la funzione del segno.

Senza il builtin (4 byte):

;A\+

Provalo online!

;A\divide il valore assoluto dell'input per l'input. Ciò risulta -1per input negativi e 1input positivi. Sfortunatamente, a causa della gestione degli errori di Actually (se qualcosa va storto, il comando viene ignorato), 0poiché l'input lascia due 0s nello stack. +rettifica questo aggiungendoli (che provoca un errore con qualsiasi altra cosa, quindi viene ignorato).

Piet, 188 53 46 41 byte

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

Interprete online disponibile qui.

Questo codice piet è lo standard (n>0)-(n<0), in quanto non è presente alcun segno di controllo incorporato. In realtà, non c'è niente di meno che incorporato, quindi sarebbe una descrizione più accurata di questo metodo (n>0)-(0>n).

Il testo sopra rappresenta l'immagine. È possibile generare l'immagine incollandola nella casella di testo nella pagina dell'interprete. Per comodità, ho fornito l'immagine qui sotto in cui la dimensione del codice è di 31 pixel. La griglia è lì per la leggibilità e non fa parte del programma. Si noti inoltre che questo programma non attraversa alcun codice bianco; seguire i codici colorati attorno al bordo dell'immagine per seguire il flusso del programma.

Spiegazione

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]

Per ridurre ulteriormente le dimensioni del file, avrei bisogno di cambiare il programma (gasp) invece di comprimere il file come ho fatto. Vorrei rimuovere una riga che porterebbe a golf fino a 36. Potrei anche sviluppare il mio interprete che avrebbe un formato di input molto più piccolo, dato che cambiare il codice per renderlo più piccolo non è ciò di cui si occupa il golf.

Le mod mi hanno detto che la dimensione complessiva del file è ciò che conta per il codice Piet. Poiché l'interprete accetta il testo come input valido e il testo non elaborato ha un numero di byte molto inferiore rispetto a qualsiasi immagine, il testo è la scelta più ovvia. Mi scuso per essere sfacciato su questo, ma non faccio le regole. La meta discussione su questo chiarisce le mie opinioni in merito.

Se ritieni che ciò vada contro lo spirito di Piet o desideri discuterne ulteriormente per qualsiasi motivo, consulta la discussione su meta .

Pushy , 7 byte

Questo è probabilmente il programma più strano che abbia mai scritto ...

&?&|/;#

Provalo online!

Usa sign(x) = abs(x) / x, ma con un esplicito sign(0) = 0per evitare errori di divisione zero.

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

Questo funziona perché x / abs(x)è 1 quando x è positivo e -1 quando x è negativo. Se l'ingresso è 0, il programma passa al comando di uscita.

4 byte (non concorrenti)

A causa delle vacanze e avendo troppo tempo, ho fatto una riscrittura completa dell'interprete Pushy. Il programma sopra funziona ancora, ma poiché 0 / 0ora è impostato su 0, il seguente è più breve:

&|/#

Provalo online!

R, 25 byte

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

Porta il numero a STDIN. Quindi controlla se è zero, in caso contrario, restituisce x/|x|quale è una 1delle due -1e genera 0 se x=0.

Questo senza signovviamente usare il builtin .

V 14 12 byte

Grazie @DJMcMayhem per 2 byte. Usa un reg-ex per fare la sostituzione. Un po 'divertente, perché non è integrato. Ho una funzione più divertente, ma non funziona come mi aspettavo.

ͨ-©½0]/±1

Verifica casi di test

Questo si traduce solo in :%s/\v(-)=[^0].*/\11corrispondenza di una o più corrispondenze -seguite da qualsiasi cosa tranne 0, seguite da qualsiasi numero qualsiasi di volte. Viene sostituito con la prima corrispondenza (quindi a -o niente) e a 1. Il regex non corrisponde a 0, quindi rimane se stesso.

The More Fun Way (21 byte)

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

TryItOnline

Questo accetta l'input come argomento anziché nel buffer.

é<CR> Inserisci una nuova riga.

Àeseguire l'argomento come codice V. a -sposta il cursore sulla riga precedente e qualsiasi numero diventerà il conteggio per il comando successivo

é1inserisci (conta) 1's

2| passa alla seconda colonna

D elimina tutto dalla seconda colonna in poi (lasciando solo un carattere)

kJ Unire le due linee insieme.

òhé-òsi traduce in: "corri hé-fino alla rottura". Se l'1 era sulla seconda riga, questo si interrompe immediatamente dopo la h. Se era sulla prima riga, inserirà un -prima di interrompere.

ó^$/aQuesto risolve il fatto che -1, 0, 1lascerà un vuoto, e sostituisce un vuoto con il registro l'argomento.

C #, 16 15 byte

Soluzione migliorata grazie a Neil

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

In alternativa, il metodo integrato è più lungo di 1 byte:

n=>Math.Sign(n);

Programma completo con casi di test:

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