Bei einer gegebenen Zahl N wird das Vorzeichen von N ausgegeben :

• Wenn N positiv ist, wird 1 ausgegeben
• Wenn N negativ ist, wird -1 ausgegeben
• Wenn N 0 ist, wird 0 ausgegeben

N ist eine ganze Zahl innerhalb des darstellbaren Bereichs von ganzen Zahlen in der von Ihnen gewählten Sprache.

Netzhaut , 9 Bytes

[1-9].*
1

Probieren Sie es online!

Ersetzt eine Ziffer ungleich Null und alles danach mit 1. Dies lässt ein potenzielles Vorzeichen -intakt und ändert alle Zahlen außer sich 0selbst in einen absoluten Wert 1.

C (GCC), 24 23 22 18 Bytes

Vielen Dank an @aross und @Steadybox für das Speichern eines Bytes!

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

Funktioniert nicht auf allen Systemen oder Compilern. Funktioniert mit TIO .

Mathematica, 4 Bytes

Clip

Wie wäre es, wenn Sie die eingebauten Sign4 Bytes nicht verwenden? ;)

ClipMit einem einzelnen Argument wird der Eingabewert zwischen -1und geklemmt 1. Da es sich bei den Eingaben nur um Ganzzahlen handelt, entspricht dies der Verwendung Sign.

COW, 225 213 201 Bytes

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

Probieren Sie es online!

Die Art und Weise, wie dieser Code funktioniert, ist, dass er das Vorzeichen bestimmt, indem er abwechselnd größere Zahlen addiert und subtrahiert und sieht, welche zuletzt funktioniert hat. Wenn eine Ganzzahl ungleich Null angegeben ist, subtrahieren Sie zuerst 1, addieren dann 2, subtrahieren dann 3 usw. und Sie werden schließlich 0 erreichen. Behalten Sie Ihren Zustand im Auge, indem Sie abwechselnd 2 zu einem Wert addieren und subtrahieren, der bei 0 beginnt Beispiel:

-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

Wenn Sie fertig sind, subtrahieren Sie 1 von Ihrem Zustand und Sie erhalten das positive oder negative Vorzeichen. Wenn die ursprüngliche Zahl 0 ist, tun Sie dies nicht und geben Sie einfach 0 aus.

Ausführliche Erklärung:

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.

Ich experimentiere immer noch mit dem Golfspielen (Sie werden schockiert sein, wenn Sie feststellen, dass das Golfspielen in COW ziemlich schwierig ist), sodass dies in Zukunft möglicherweise ein paar Bytes länger dauern wird.

Cubix , 10 Bytes

(W0^I?>O2@

Testen Sie es online!

Dieser Code wird in das folgende Würfelnetz eingeschlossen:

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

Der Code wird dann mit dem IP (Anweisungszeiger) beginnend Inach Osten ausgeführt. Igibt eine vorzeichenbehaftete Ganzzahl von STDIN ein und schiebt sie auf den Stapel.

Der nächste Befehl ist ?, der die Richtung der IP abhängig vom Vorzeichen des obersten Elements ändert. Wenn die Eingabe 0 ist, bewegt sie sich in dieselbe Richtung und durchläuft den folgenden Code:

• >- Richten Sie die IP nach Osten. (No-op, da wir schon nach Osten gehen.)
• O - Das oberste Element als Ganzzahl ausgeben.
• 2- 2 auf den Stapel schieben. Dies ist praktisch ein No-Op, weil ...
• @ - Beendet das Programm.

Wenn der Eingang negativ ist, wird die IP am ?; Da dies ein Würfel ist, bewegt sich die IP 0in der zweiten Reihe in Richtung Osten. 0drückt ein Literal 0, dann wird dieser Code ausgeführt:

• ^ - Richten Sie die IP nach Norden.
• W - "Sidestep" die IP einen Punkt nach links.
• ( - Verringern Sie das oberste Element.

Das TOS ist jetzt -1und die IP wickelt sich durch ein Bündel von No-Ops um den Würfel, .bis er das trifft >. Dies führt den gleichen oben erwähnten Ausgabecode aus und gibt ihn aus -1.

Wenn die Eingabe positiv ist, geschieht das Gleiche wie bei negativen Eingaben, mit einer Ausnahme: Die IP dreht sich nach rechts statt nach links ?und umschließt den Cube mit der 2, wodurch ein Literal 2 ausgelöst wird. Dies wird dann auf 1 und dekrementiert zur Ausgabe gesendet.

JavaScript (ES6), 9 Byte

Math.sign

Einfach.

Das kürzeste nicht eingebaute ist 13 Bytes:

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

Dank @Neil kann dies byteweise ausgeführt werden, allerdings auf Kosten von 32-Bit-Ganzzahlen:

n=>n>0|n>>31

Oder du könntest tun

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

Das scheint mehr Golf zu spielen, aber ich bin nicht sicher, wie.

APL (Dyalog APL) , 1 Byte

Funktioniert auch für komplexe Zahlen und gibt 1∠ θ zurück :

×

TryAPL online!

Ohne diese integrierte Funktion für Ganzzahlen (gemäß OP):

¯1⌈1⌊⊢

¯1⌈ der größte der negativen und

1⌊ der kleinste von einem und

⊢ das Argument

TryAPL online!

... und eine allgemeine:

>∘0-<∘0

>∘0 mehr als null

- Minus

<∘0 weniger als Null

TryAPL online!

> <> , 9 8 Bytes

Vielen Dank an Sp3000 für das Speichern eines Bytes.

'i$-%n/

Es gibt eine nicht druckbare 0x01vor dem /.

Probieren Sie es online!

Erläuterung

Dies ist ein Port meiner zeichencodebasierten Labyrinth-Antwort .

'     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

Dank @DJMcMayhem ein Byte gespart !

Hier ^Mist eine wörtliche Newline.

Wie @ nmjcman101 in den Kommentaren ausführte , kann :s/\v(-)=[^0].*/\11^Mstattdessen ein einzelner regulärer Ausdruck ( 20 Byte) verwendet werden. Da dies jedoch im Grunde das Gleiche ist wie eine Retina-Antwort, halte ich an meiner eigenen Methode fest.

Erläuterung:

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.

Hier ist ein GIF mit einer negativen Zahl (alte Version):

Hier läuft es mit 0:

Laufen mit positivem:

/// 52 36 Bytes

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

Ungolfed, Erklärung:

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

Grundsätzlich handelt es sich um eine MapReduce-Implementierung, dh es gibt zwei Phasen:

• Ersetzen Sie alle Vorkommen von Stellen 2- 9durch 1, zB 1230405->1110101
• Reduzieren Sie Paare von 11oder 10zu 1wiederholt, zum Beispiel 1110101->1

Wenn es -anfangs eine gab, bleibt diese bestehen und die Ausgabe erfolgt -1. Eine einzelne 0wird niemals ersetzt, was zu sich selbst führt.

Update: Sparen Sie zusätzliche 16 Bytes durch Aliasing //1/mit a, dank Martin Ender.

Probieren Sie es online mit Testfällen aus

Python 2 , 17 Bytes

lambda n:cmp(n,0)

Probieren Sie es online!

Labyrinth , 10 Bytes

?:+:)%:(%!

Probieren Sie es online!

Erläuterung

Die Kontrollflusssemantik von Labyrinth gibt Ihnen tatsächlich eine "freie" Möglichkeit, das Vorzeichen einer Zahl zu bestimmen, da der gewählte Pfad an einer 3-Wege-Gabel davon abhängt, ob das Vorzeichen negativ, null oder positiv ist. Es ist mir jedoch bisher nicht gelungen, ein Programm mit Junctions in weniger als 12 Bytes einzupassen (obwohl dies möglicherweise möglich ist).

Stattdessen ist hier eine geschlossene Lösung, die keine Verzweigungen erfordert:

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

Der Befehlszeiger stößt dann auf eine Sackgasse, dreht sich um und endet, wenn %jetzt versucht wird, durch Null zu dividieren.

Die Eingangsverdopplungs ist notwendig , diese Arbeit mit Eingaben zu machen 1und -1, sonst einer der beiden Modulo - Operationen bereits eine Division durch Null versuchen würde.

PHP, 16 Bytes

Verwendet den neuen Raumschiff-Operator.

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

Brain-Flak 74 42 40 Bytes

2 Bytes dank 1000000000 gespart

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

Probieren Sie es online!

Erläuterung:

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

*

Probieren Sie es online (mit Testfällen)!

C 24 20 19 18 Bytes

Ich missbrauche zwei C-Heldentaten, um das herunterzuspielen. Dies ist in C (GCC).

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

Probieren Sie es online!

Versionsgeschichte:

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

Revision 1: Erster Versuch. Einfache Logik

Revision 2: Missbrauch eines Speicher- / Stapel-Fehlers in GCC, bei dem, soweit ich das beurteilen kann, eine nicht zurückgebende Funktion in bestimmten Fällen die zuletzt gesetzte Variable zurückgibt.

Revision 3: Missbrauch ternären Verhaltens, bei dem undefiniertes Ergebnis bedingtes Ergebnis zurückgibt (weshalb die wahre Rendite für mein ternäres Ergebnis Null ist)

Revision 4: Subtrahieren Sie eine Bool-Besetzung ( !!) von der ternären bedingten Ersetzung für die nilin Revision 2 angegebene.

Ruby, 10 Bytes

->x{x<=>0}

Perl, 9 Bytes

Benötigt -Ekeine zusätzlichen Kosten.

say<><=>0

Verwendungszweck

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

Ich bin glücklich mit dem Fischbetreiber!

Stapel Katzen , 6 + 4 = 10 Bytes

_[:I!:

+4 Bytes für die ​ -nmFlags. nist für numerische E / A und da für Stack Cats palindromische Programme erforderlich sind, wird mimplizit der Quellcode gespiegelt, um die ursprüngliche Quelle zu erhalten

_[:I!:!I:]_

Probieren Sie es online! Wie bei allen guten Stack-Cats-Golfs wurde dies mit brachialer Gewalt herausgefunden, die manuellen Versuche weit hinter sich gelassen hat und nicht einfach in ein größeres Programm integriert werden kann.

Fügen Sie ein DFlag hinzu, wenn Sie eine schrittweise Programmablaufverfolgung -nmDanzeigen möchten , dh mit STDERR / debug ausführen und überprüfen möchten.

Stack Cats verwendet ein Band mit Stapeln, die implizit unten mit Nullen gefüllt sind. Zu Beginn des Programms werden alle Eingaben auf den Eingabestapel verschoben, mit einem -1an der Basis, um die Eingabe von den impliziten Nullen zu trennen. Am Ende des Programms wird der aktuelle Stapel mit Ausnahme einer Basis, -1falls vorhanden, ausgegeben .

Die relevanten Befehle hier sind:

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

Beachten Sie, dass alle diese Befehle invertierbar sind, wobei die Umkehrung der Spiegel des Befehls ist. Dies ist die Prämisse von Stack Cats - alle nicht-trivialen Abschlussprogramme haben eine ungerade Länge, da Programme mit gerader Länge sich selbst aufheben.

Wir beginnen mit

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

_subtrahiert, bildet den oberen Teil -1-nund [verschiebt das Ergebnis um einen Stapel nach links:

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

:tauscht die obersten zwei und Itut nichts, da der oberste Stapel jetzt Null ist. !dann negiert bitweise die obere Null in ein -1und :tauscht die oberen zwei zurück. !dann negiert bitweise die Spitze und verwandelt sich -1-nwieder in n:

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

Nun verzweigen wir basierend auf I, was auf unser Original zutrifft n:

• Wenn nnegativ, bewegen wir uns einen Stapel nach links und enden mit -neiner impliziten Null. :swappt, setzt eine Null oben drauf und ]verschiebt die Null oben auf die -1gerade abgezogene. _subtrahiert dann, wobei der endgültige Stapel unverändert bleibt [-1 -1], und es wird nur einer -1ausgegeben, da die Basis -1ignoriert wird.

• Wenn nNull ist, bewegen wir uns nicht und :tauschen, setzen -1auf. ]dann bewegt man diesen nach links -1oben nach rechts -1und _subtrahiert, wobei der letzte Stapel wie [-1 0]folgt bleibt, gibt die Null aus und ignoriert die Basis -1.

• Wenn npositiv, bewegen wir uns einen Stapel nach rechts und enden mit -na -1. :swappt, setzt den -1auf und ]verschiebt diesen nach -1rechts auf eine implizite Null. _subtrahiert dann, gibt 0 - (-1) = 1und lässt den endgültigen Stapel wie [1], der ausgegeben wird.

TI-Basic, 8 Bytes

median({1,Ans,~1

Alternative Lösungen (zögern Sie nicht, mehr vorzuschlagen):

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-

Die Eingabe kann eine Zahl oder ein Array sein. Das Ergebnis ist eine Zahl oder ein Array mit den entsprechenden Werten.

Probieren Sie es online! Oder testen Sie mehrere Fälle mithilfe der Array-Eingabe.

Erläuterung

Dies vermeidet die Verwendung der eingebauten Vorzeichenfunktion ( 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

Gelee , 1 Byte

Ṡ

TryItOnline!

Die monadischen Zeichen Atom , Ṡtut genau das, was für eine ganze Zahl Eingang angegeben ist, entweder als Voll Programm oder als ein monadischen Link (Funktion ein Argument nimmt).

Mathematica, 4 Bytes

Sign

Genau das, was es verspricht

Oktave, 26 24 Bytes

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

Dies ist meine erste Antwort auf eine Code-Golf- Oktave. Alle Golftipps sind willkommen!

Probieren Sie es online!

Die Idee für die Aufnahme asinkommt von der Frage, wo es heißt output the sign:)

Erläuterung

Hinweis: Wenn Sie die Zahl durch pidividieren und mit multiplizieren, 2entspricht dies der Division der gesamten Zahl durchpi/2

Fall 0:

asin(0)Ausbeuten 0. Den Realteil davon zu nehmen und durch zu teilen, pi/2macht keinen Unterschied für die Ausgabe.

Fall positive:

asin(1)Ausbeuten pi/2. asineiner beliebigen Anzahl größer als 1geben pi/2+ komplexe Zahl. Den Realteil davon zu nehmen, gibt pi/2und ihn durch pi/2gibt zu teilen1

Fall negative:

asin(-1)Ausbeuten -pi/2. asineiner beliebigen Anzahl kleiner als -1geben -pi/2+ komplexe Zahl. Den Realteil davon zu nehmen, gibt -pi/2und ihn durch pi/2gibt zu teilen-1

Eigentlich 1 Byte

s

Probieren Sie es online!

Ein weiterer Fall von genau dem, was auf der Dose steht - sist die Vorzeichenfunktion.

Ohne das eingebaute (4 Bytes):

;A\+

Probieren Sie es online!

;A\dividiert den absoluten Wert der Eingabe durch die Eingabe. Dies ergibt sich -1für negative Eingänge und 1für positive Eingänge. Leider wird aufgrund der Fehlerbehandlung von Actually (wenn etwas schief geht, wird der Befehl ignoriert), 0da die Eingabe zwei 0s auf dem Stapel belässt . +Korrigiert dies, indem sie hinzugefügt werden (was zu einem Fehler führt, der ignoriert wird).

Piet, 188 53 46 41 Bytes

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

Online-Dolmetscher hier verfügbar.

Dieser Piet-Code erfüllt den Standard (n>0)-(n<0), da keine Vorzeichenprüfung eingebaut ist. In der Tat gibt es nicht weniger als eingebaut, so dass eine genauere Beschreibung dieser Methode wäre (n>0)-(0>n).

Der obige Text repräsentiert das Bild. Sie können das Bild generieren, indem Sie es in das Textfeld auf der Interpreterseite einfügen. Der Einfachheit halber habe ich das folgende Bild bereitgestellt, in dem die Codelgröße 31 Pixel beträgt. Das Raster dient der Lesbarkeit und ist nicht Bestandteil des Programms. Beachten Sie auch, dass dieses Programm keine weißen Codel kreuzt. Folgen Sie den farbigen Markierungen am Bildrand, um dem Programmablauf zu folgen.

Erläuterung

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]

Um die Dateigröße weiter zu verringern, müsste ich das Programm tatsächlich ändern (keuchen), anstatt nur die Datei zu komprimieren, wie ich es getan habe. Ich möchte eine Zeile entfernen, die dies auf 36 reduziert. Ich kann auch meinen eigenen Interpreter entwickeln, der ein viel kleineres Eingabeformat hat, da es nicht darum geht, den Code tatsächlich zu ändern, um ihn kleiner zu machen.

Die Mods sagten mir, dass die gesamte Dateigröße für Piet-Code zählt. Da der Interpreter Text als gültige Eingabe akzeptiert und der unformatierte Text eine viel geringere Anzahl von Bytes aufweist als jedes Bild, ist Text die naheliegende Wahl. Ich entschuldige mich dafür, dass ich diesbezüglich frech bin, aber ich mache keine Regeln. Die Metadiskussion darüber macht meine Meinung zu diesem Thema deutlich.

Wenn Sie der Meinung sind, dass dies gegen den Geist von Piet verstößt oder Sie dies aus irgendeinem Grund weiter diskutieren möchten, lesen Sie bitte die Diskussion zu Meta .

Aufdringlich , 7 Bytes

Dies ist wahrscheinlich das seltsamste Programm, das ich je geschrieben habe ...

&?&|/;#

Probieren Sie es online!

Es verwendet sign(x) = abs(x) / x, aber mit einem expliziten sign(0) = 0Nullteilungsfehler zu vermeiden.

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

Dies funktioniert , weil x / abs(x)ist 1 , wenn x positiv ist, und -1 , wenn x negativ ist. Wenn der Eingang 0 ist, springt das Programm zum Ausgabebefehl.

4 Bytes (nicht konkurrierend)

Wegen Urlaub und zu viel Zeit habe ich den Pushy-Interpreter komplett überarbeitet. Das obige Programm funktioniert immer noch, aber da es 0 / 0jetzt standardmäßig auf 0 gesetzt ist, ist Folgendes kürzer:

&|/#

Probieren Sie es online!

R, 25 Bytes

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

Nimmt die Nummer zu STDIN. Dann wird geprüft , ob es Null ist, wenn nicht, kehrt x/|x|die entweder 1von -1und Ausgänge 0 , wenn x=0.

Dies ist signnatürlich ohne Verwendung des eingebauten .

V 14 12 Bytes

Danke @DJMcMayhem für 2 Bytes. Verwendet eine Reg-Ex, um die Substitution durchzuführen. Ein bisschen Spaß, weil es kein eingebautes ist. Ich habe eine lustigere Funktion, aber sie funktioniert nicht so, wie ich es erwartet hatte.

ͨ-©½0]/±1

Überprüfen Sie die Testfälle

Dies übersetzt nur :%s/\v(-)=[^0].*/\11die Übereinstimmungen mit einer oder mehreren, -gefolgt von einer Ausnahme von 0, gefolgt von einer beliebigen Anzahl von Malen. Es wird durch das erste Match (also entweder a -oder nichts) und a ersetzt 1. Der reguläre Ausdruck stimmt nicht mit 0 überein, so dass er selbst bleibt.

Die unterhaltsamere Art (21 Bytes)

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

TryItOnline

Dies akzeptiert die Eingabe eher als Argument als im Puffer.

é<CR> Fügen Sie eine neue Zeile ein.

ÀFühren Sie das Argument als V-Code aus. a -bewegt den Cursor in die vorherige Zeile und eine beliebige Zahl wird zum Zähler für den nächsten Befehl

é1Einfügen (count) 1‚s

2| gehe zur zweiten Spalte

D alles ab der zweiten Spalte löschen (nur ein Zeichen übrig lassen)

kJ Verbinden Sie die beiden Linien miteinander.

òhé-òübersetzt zu: "laufen hé-bis zum brechen". Wenn sich die 1 in der zweiten Zeile befand, bricht diese unmittelbar nach dem h ab. Wenn es sich in der ersten Zeile befand, wird -vor dem Brechen ein eingefügt.

ó^$/aDies behebt die Tatsache , dass -1, 0, 1wird ein leer lassen, und ersetzt eine leere mit dem Argument Register.

C #, 16 15 Bytes

Verbesserte Lösung dank Neil

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

Alternativ ist die eingebaute Methode 1 Byte länger:

n=>Math.Sign(n);

Volles Programm mit Testfällen:

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