Sortir le signe

67

Soit un nombre N, affiche le signe de N:

  • Si N est positif, sortie 1
  • Si N est négatif, sortie -1
  • Si N est 0, sortie 0

N sera un entier compris dans la plage d'entiers pouvant être représentée dans la langue de votre choix.

Mego
la source
45
C'est un défi trivial avec beaucoup de solutions triviales. Il existe toutefois des solutions non triviales. Aux électeurs: Veuillez lire la première phrase de cette publication avant de voter vers les fonctions intégrées.
Stewie Griffin
8
Cela pourrait probablement utiliser un classement.
Martin Ender
2
@MrLister upvote comme vous le souhaitez, mais vous devez rechercher la créativité au lieu de la longueur du code.
FlipTack
3
@ FlipTack Oh, je pensais que c'était codegolf.
M. Lister
3
@MrLister c'est le critère objectif gagnant. mais faut-il vraiment plus d'effort pour taper spour un panneau intégré ou pour utiliser quelques astuces bitshifting / maths? Regardez cette méta post
FlipTack

Réponses:

46

Retina , 9 octets

[1-9].*
1

Essayez-le en ligne!

Remplace un chiffre différent de zéro et tout ce qui suit après 1. Cela laisse -intact un potentiel et change tous les nombres sauf 0lui-même en valeur absolue 1.

Martin Ender
la source
C'est très malin :)
Mego
Fonctionne-t-il avec la notation scientifique des nombres entiers (tels que 0.42e2)?
Egor Skriptunoff
@EgorSkriptunoff Non, mais ce n'est pas une obligation.
Martin Ender
9
@EgorSkriptunoff il ne supporte pas les chiffres romains non plus. À moins que le défi ne mentionne explicitement un certain format non standard qui doit être pris en charge, l'hypothèse générale est qu'il est acceptable de traiter un format unique qui est naturel dans la langue de votre choix.
Martin Ender
3
@EgorSkriptunoff Retina n'a pas la moindre notion de nombre. C'est un langage purement basé sur des chaînes.
Martin Ender
42

C (GCC), 24 23 22 18 octets

Merci à @aross et @Steadybox pour la sauvegarde d’un octet!

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

Pas garanti de fonctionner sur tous les systèmes ou compilateurs, fonctionne sur TIO .

Betseg
la source
7
@betseg C'est parce que les votes vers le haut sur les fonctions intégrées sont maintenant mal vues.
Erik l'Outgolfer
4
Sauver 1 octet avec cecireturn n>>16|!!n;
aross
5
@GB La taille de int est probablement 2 (16, x86) ou 4 (32, x86_64), mais souvenez-vous que tout ce dont vous avez besoin est d' une architecture sur laquelle elle est valide. Ce n'est pas Stack Overlflow, la portabilité n'est pas importante.
Chat
2
f(n){n=n>>31|!!n;}fonctionne aussi. Mais il s’agit simplement d’un caprice du compilateur, et non d’une fonctionnalité de langage.
GB
2
Les bizarreries du compilateur @GB sont parfaitement valables, à condition qu'il soit possible de prouver qu'il existe un compilateur dans lequel fonctionne la bizarrerie. Heureusement, GCC a le bizarre.
Mego
34

Mathematica, 4 octets

Clip

Pourquoi ne pas utiliser les Signoctets intégrés et toujours en cours de notation? ;)

Clipavec un seul argument coupe (ou serre) la valeur d'entrée entre -1et 1. Comme les entrées ne seront que des entiers, cela revient à utiliser Sign.

Martin Ender
la source
29

VACHE, 225 213 201 octets

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

Essayez-le en ligne!

La façon dont ce code fonctionne consiste à déterminer le signe en alternant l'addition et la soustraction de nombres plus grands, et à voir lequel était le dernier qui a fonctionné. Sous tout entier non nul, soustrayez d'abord 1, puis ajoutez 2, puis soustrayez 3, etc. et vous atteindrez éventuellement 0. Gardez une trace de votre état en alternant l'addition et la soustraction de 2 à une valeur commençant à 0. Pour exemple:

-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

Lorsque vous avez terminé, soustrayez 1 de votre état et vous obtenez le signe, positif ou négatif. Si le numéro d'origine est 0, alors ne vous embêtez pas et écrivez simplement 0.

Explication détaillée:

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.

J'essaie toujours de jouer au golf (vous serez surpris de découvrir que jouer au golf dans COW est assez difficile), donc cela risque de perdre quelques octets de plus dans le futur.

Gabriel Benamy
la source
1
Et il y a un 'moo' - langue? ...
Mukul Kumar
1
@MukulKumar Il s'agit d'un dérivé de brainfuck appelé COW qui permet un certain nombre de choses que bf ne fait pas
Gabriel Benamy
On pourrait aussi appeler cela le langage du "mauvais mage". OUT OF MANA!!!
Urne Magique Octopus
18

Cubix , 10 octets

(W0^I?>O2@

Testez-le en ligne!

Ce code est encapsulé dans le cube suivant:

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

Le code est ensuite exécuté avec l’IP (pointeur d’instruction) en commençant par le Icôté est. Ientre un entier signé de STDIN, en le poussant sur la pile.

La commande suivante est ?, qui change la direction de l’IP en fonction du signe de l’élément supérieur. Si l'entrée est 0, elle continue à avancer dans la même direction, en passant par le code suivant:

  • >- Pointez l'IP à l'est. (Non-op puisque nous allons déjà à l'est.)
  • O - Affiche l’élément supérieur en tant qu’entier.
  • 2- Poussez 2 à la pile. C'est pratiquement un no-op, parce que ...
  • @ - Termine le programme.

Si l'entrée est négative, l'IP tourne à gauche au ?; comme il s’agit d’un cube, l’adresse IP se déplace vers 0la deuxième ligne, en direction est. 0pousse un 0 littéral, alors ce code est exécuté:

  • ^ - Pointez le nord de l'IP.
  • W - "Sur le pas" l'adresse IP d'un point à gauche.
  • ( - Décrémentez le premier élément.

Le TOS est maintenant -1, et la propriété intellectuelle entoure le cube à travers un tas de non-opérations .jusqu'à ce qu'il frappe le >. Ceci exécute le même code de sortie mentionné ci-dessus, en sortie -1.

Si l'entrée est positive, la même chose se produit avec les entrées négatives, à une exception près: l'IP tourne à droite au lieu de gauche à la gauche ?et tourne autour du cube jusqu'à la 2, ce qui pousse un littéral 2. Ceci est ensuite décrémenté à 1 et envoyé à la sortie.

ETHproductions
la source
4
L'animation du déroulement du programme est très agréable!
Luis Mendo
Belle langue. Pourrait-il être plus court? 4 contrôles de débit semble beaucoup. Dans operation-count, il peut s'agir de 8 octets en introduisant un autre?, Mais il utilise maintenant la moitié inférieure du cube: ..1nI? ..> O @ .........?
BlackShift
Six est possible si nous ignorons les sorties après la première: / I? NO1 En passant, cela ne fonctionne que parce que je retourne -1 dans l'interpréteur en ligne au lieu de 0 selon la spécification.
BlackShift
@BlackShift Merci pour votre intérêt! J'aime vos suggestions, mais je ne sais pas comment les améliorer. Il est certainement possible d'utiliser moins d'instructions; la partie la plus délicate utilise moins de cube ... ;-) Et merci d’avoir signalé ce bogue -1, je vais le faire réparer bientôt.
ETHproductions
@ETHproductions IMO Ce n'est pas un bug, il est logique Ide renvoyer -1 lorsque l'entrée se termine comme le font les minuscules i.
FlipTack
16

JavaScript (ES6), 9 octets

Math.sign

Simple.

Le plus court non intégré est de 13 octets:

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

Grâce à @Neil, cela peut être joué avec un octet, mais au prix de travailler uniquement sur des entiers 32 bits:

n=>n>0|n>>31

Ou tu pourrais faire

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

qui semble plus golfable, mais je ne sais pas comment.

ETHproductions
la source
2
Non-builtin en 12 octets pour entier signé 32 bits n: n=>n>>31|!!n.
Neil
@ Neil n>>31est vraiment intelligent, merci!
ETHproductions
Je ne pense pas que la troisième solution soit valable, car Javascript utilise des flottants à double précision pour les calculs. Mais je peux me tromper.
Mego
@ Mego Vous avez raison. J'ai clarifié cela dans le post.
ETHproductions
1
@ Mego Désolé, j'ai raté votre commentaire. Lors de l'utilisation d'opérateurs au niveau des bits, JS convertit implicitement ses opérandes en entiers 32 bits signés. La troisième solution fonctionne donc, mais uniquement sur les nombres compris entre -2147483648 et 2147483647.
ETHproductions
15

APL (Dyalog APL) , 1 octet

Fonctionne aussi pour les nombres complexes, en retournant 1∠ θ :

×

TryAPL en ligne!


Sans cette fonction intégrée, pour les nombres entiers (selon l'OP):

¯11⌊⊢

¯1⌈ le plus grand des négatifs et

1⌊ le plus petit de l'un et

l'argument

TryAPL en ligne!

... et un général:

>∘0-<∘0

>∘0 plus que zéro

- moins

<∘0 moins que zéro

TryAPL en ligne!

Adam
la source
1
Vous l'avez réellement fait dans UN octet ... Vous êtes une légende, monsieur. Je suis sûr que Jon Skeet serait fier.
@ Mango Vous plaisantez, non? Il existe une poignée de réponses à un octet à ce défi.
Adám
1
J'étais sarcastique, j'ai aussi dit cela parce que c'est la première réponse à un octet que j'ai vue.
14

> <> , 9 à 8 octets

Merci à Sp3000 pour la sauvegarde d’un octet.

'i$-%n/

Il y a un non imprimable 0x01avant le /.

Essayez-le en ligne!

Explication

Ceci est un port de ma réponse Labyrinth basée sur le code du personnage .

'     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.
Martin Ender
la source
Je pense que vous pouvez simplement utiliser un légal ;au lieu de celui qui n'est 0x01pas imprimable pour terminer le programme correctement :)
Erik the Outgolfer
@EriktheOutgolfer J'ai besoin 0x01de 1quoi pousser de toute façon.
Martin Ender
2
Oh, il semble que je n'ai testé que ma suggestion avec 123. Leçon apprise: test avec plus de cas.
Erik l'Outgolfer
14

Vim, 22 octets

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

Un octet enregistré grâce à @DJMcMayhem !

Voici ^Mune nouvelle ligne littérale.

Comme @ nmjcman101 l'a souligné dans les commentaires, une seule expression rationnelle peut être utilisée ( :s/\v(-)=[^0].*/\11^M, 20 octets), mais comme c'est fondamentalement la même chose qu'une réponse de Retina, je m'en tiens à ma propre méthode.

Explication:

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.

Voici un gif de celui-ci en cours d'exécution avec un nombre négatif (ancienne version):

Courir avec le négatif

La voici avec 0:

Courir à zéro

Courir avec le positif:

Courir avec positif

Loovjo
la source
1
J'aime beaucoup votre méthode, mais c'est possible en une seule expression rationnelle::s/\v(-)=[^0].*/\11
nmjcman101
GIFs de la console distante ... ??
Desty
12

///, 52 36 octets

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

Ungolfed, explication:

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

Il s’agit en gros d’une implémentation MapReduce, c’est-à-dire en deux phases:

  • Remplacer toutes les occurrences de chiffres 2- 9par 1, par exemple 1230405->1110101
  • Réduisez les paires de 11ou 10à 1plusieurs fois, par exemple 1110101->1

S'il y avait un -devant au début, il restera et la sortie sera -1. Un seul 0n'est jamais remplacé, ce qui donne lieu à lui-même.

Mise à jour: économisez 16 octets supplémentaires en créant //1/un alias avec a, grâce à Martin Ender.

Essayez-le en ligne, avec des cas de test

Cedric Reichenbach
la source
2
Ceci est extrêmement intelligent!
Mego
11

Python 2 , 17 octets

lambda n:cmp(n,0)

Essayez-le en ligne!

Dennis
la source
5
Oh tu m'as ninja.
Jonathan Allan
1
Oups. Désolé ...
Dennis
5
Dommage que vous ne puissiez pas faire (0).__rcmp__...
Sp3000
1
Vous pouvez faire -(0).__cmp__cependant.
nyuszika7h
1
@ nyuszika7h Pas tout à fait. Essayer de l'utiliser comme une fonction déclenche une TypeError .
Dennis
11

Labyrinthe , 10 octets

?:+:)%:(%!

Essayez-le en ligne!

Explication

La sémantique des flux de contrôle de Labyrinth vous donne en fait un moyen "libre" de déterminer le signe d'un nombre, car le chemin choisi à une fourchette à trois voies dépend du fait que le signe soit négatif, nul ou positif. Cependant, je n'ai pas encore réussi à adapter un programme avec des jonctions à moins de 12 octets (bien que cela puisse être possible).

Au lieu de cela, voici une solution de forme fermée, qui ne nécessite aucune branche:

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

Le pointeur d'instruction frappe ensuite une impasse, se retourne et se termine lorsque %tente maintenant une division par zéro.

Il est nécessaire de doubler les entrées pour que cela fonctionne avec des entrées 1et -1, sinon, une des deux opérations modulo tenterait déjà une division par zéro.

Martin Ender
la source
1
Votre code est heureux et devient triste:D
Stefan
2
@ Stefan Vous pouvez modifier l'ordre si vous préférez. ;)
Martin Ender
9

PHP, 16 octets

Utilise le nouvel opérateur de vaisseau spatial.

<?=$argv[1]<=>0;
Alex Howansky
la source
N'oubliez pas de mentionner qu'il s'agit uniquement d'une réponse PHP7. Et puisque vous utilisez <?=, vous devriez utiliser $_GET[n], ce qui ne prend plus d'octets. Pour l'utiliser <?=, vous devez être dans un serveur Web (comme Apache), et vous n'y aurez pas accès $argv. Vous pouvez essayer d’exécuter à <?php var_dump($argv);partir d’un fichier PHP, accessible via Apache, et cela s’affichera NULL.
Ismael Miguel
1
"Pour utiliser <? =, Vous devez être dans un serveur Web (comme Apache)", non. L' <?=opérateur fonctionne parfaitement à partir de la ligne de commande.
Alex Howansky
php -r '<?=1'Je cours PHP Parse error: syntax error, unexpected '<' in Command line code on line 1. Mais semble bien fonctionner à partir d'un fichier. Je suppose que tu as raison.
Ismael Miguel
L' -rindicateur consiste à exécuter un extrait de code. C'est source complète. Enregistrez-le dans un fichier, puis exécutez-lephp file.php
Alex Howansky
Je l'ai déjà compris. Je ne savais vraiment pas que cela fonctionnait à partir d'un fichier, en utilisant le -fparamètre (implicite) .
Ismael Miguel
9

Brain-Flak 74 42 40 Octets

Économisé 2 octets grâce à 1000000000

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

Essayez-le en ligne!

Explication:

{                                }       # 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)
Riley
la source
Vous pouvez économiser 2 octets en supprimant la monade zéro autour de vous(())
0 '
8

C, 24 20 19 18 octets

J'abuse de deux exploits C pour jouer au golf; Ceci est en C (GCC).

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

Essayez-le en ligne!


Historique des révisions:

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

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

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

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


Révision 1: première tentative. Logique simple

Révision 2: Abuse d'un bogue mémoire / pile dans GCC où, pour autant que je sache, une fonction non renvoyée renverra la dernière variable définie dans certains cas.

Révision 3: Abuse du comportement ternaire où un résultat indéfini retournera un résultat conditionnel (c'est pourquoi le retour réel sur mon ternaire est nul)

Révision 4: Soustrayez un cast bool ( !!) de la substitution conditionnelle ternaire pour nilréférencé dans la révision 2.

Albert Renshaw
la source
7

Ruby, 10 octets

->x{x<=>0}
GB
la source
Cela 0.<=>fonctionnerait -il également ou ne pouvez-vous pas référencer des méthodes comme celle-ci dans Ruby?
Nic Hartley
.<=>attend un argument, donc il finirait par être 0.<=> x, ce qui est plus long.
Seims
Vous aurez besoin de @QPaysTaxes 0.method:<=>car les appels de méthode en ruby ​​n'utilisent pas de parenthèses et 0.<=>seraient interprétés comme un appel de méthode avec trop peu d'arguments.
Cyoce
7

Perl, 9 octets

Requiert -Esans frais supplémentaires.

say<><=>0

Usage

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

Je suis heureux avec le pêcheur!

Dom Hastings
la source
1
Cela n’exige pas vraiment -E, c’est seulement si vous l’appelez à partir de la CLI au lieu d’un fichier, c’est pourquoi je suppose que vous avez dit qu’il n’y avait aucun coût supplémentaire.
nyuszika7h
@ nyuszika7h en effet, nécessite, je suppose, que les tests via -ene fonctionnent pas, mais qu’ils ne -Esoient pas acceptés plus longtemps -e. Selon consensus sur meta. J'espère que ça aide un peu!
Dom Hastings
Oui, je ne proposais pas de coûts supplémentaires pour cela, car cela fonctionne très bien lorsque ce script est exécuté normalement à partir d'un fichier.
nyuszika7h
7

Stack Cats , 6 + 4 = 10 octets

_[:I!:

+4 octets pour les ​ -nmdrapeaux. nest destiné aux entrées / sorties numériques, et comme Stack Cats exige que les programmes soient palindromiques, reproduit mimplicitement le code source pour donner le code source original.

_[:I!:!I:]_

Essayez-le en ligne! Comme c'est le cas pour tous les bons golfeurs Stack Cats, cela a été découvert par force brute, il a battu toutes les tentatives manuelles, et ne peut pas être facilement intégré à un programme plus vaste.

Ajoutez un Dindicateur si vous souhaitez voir une trace de programme étape par étape, c'est-à-dire exécuter avec -nmDet vérifier STDERR / debug.


Stack Cats utilise une bande de piles qui sont implicitement remplies de zéros au bas. Au début du programme, toutes les entrées sont placées dans la pile d'entrées, avec un -1à la base pour séparer les entrées des zéros implicites. A la fin du programme, la pile actuelle est sortie, sauf une base -1si présente.

Les commandes pertinentes ici sont:

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

Notez que toutes ces commandes sont inversables, son inverse étant le miroir de la commande. C’est la prémisse de Stack Cats - tous les programmes de terminaison non triviaux ont une longueur impaire, puisqu’ils s’annulent automatiquement.

On commence avec

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

_soustrait, en haut -1-n, et [déplace le résultat d'une pile à gauche:

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

:swaps top deux et Ine fait rien, puisque le haut de la pile est maintenant zéro. !ensuite, au niveau des bits, le zéro supérieur est inversé en un -1et :les deux premiers sont échangés. !puis au niveau du bit nie le haut, -1-nrevenant à nnouveau dans :

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

Maintenant nous avons une branche basée sur I, qui est appliquée à notre original n:

  • Si nest négatif, nous déplaçons une pile à gauche et finissons par -nun zéro implicite. :swaps, en mettant un zéro en haut, et ]déplace le zéro en haut de ce que -1nous venons de déplacer. _puis soustrait, laissant la pile finale comme [-1 -1], et une seule -1est sortie puisque la base -1est ignorée.

  • Si nest égal à zéro, nous ne bougeons pas et nous :échangeons, en mettant -1sur le dessus. ]déplace ensuite cette gauche -1en haut à droite -1et _soustrait, laissant la pile finale comme [-1 0], affichant le zéro et ignorant la base -1.

  • Si nest positif, on déplace un pile et on termine par -nun -1. :swaps, en plaçant -1le dessus, et ]déplace ce -1droit, sur un zéro implicite. _puis soustrait, donnant 0 - (-1) = 1et laissant la pile finale comme [1], qui est sortie.

Sp3000
la source
7

TI-Basic, 8 octets

median({1,Ans,~1

Solutions alternatives (n'hésitez pas à suggérer plus):

max(~1,min(Ans,1               8  bytes
0:If Ans:Ans/abs(Ans           9  bytes
(Ans>0)-(Ans<0                 10 bytes
Timtech
la source
Quel est le ~supposé être?
Conor O'Brien
@ ConorO'Brien Symbole négatif, pour différencier le symbole de soustraction de TI-Basic. Je sais que Cemetech SC utilise ~pour représenter ce jeton également.
Timtech
Oh cool. Je n'en avais aucune idée.
Conor O'Brien
@ ConorO'Brien Eh bien, maintenant vous savez. Merci d'avoir demandé :)
Timtech
1
Ceci n'est pas valide - utiliser Anscomme entrée ne remplit pas les critères pour être une méthode d'E / S par défaut valide (il n'y a pas deux fois plus de votes positifs que de votes négatifs - actuellement, il est à + 19 / -12).
Mego
7

MATL , 6 octets

0>EGg-

L'entrée peut être un nombre ou un tableau. Le résultat est un nombre ou un tableau avec les valeurs correspondantes.

Essayez-le en ligne! Ou testez plusieurs cas en utilisant une entrée de tableau.

Explication

Cela évite d'utiliser la fonction de signe intégrée ( 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
Luis Mendo
la source
MATL est plus long que Matlab et Octave ?!
Adám
4
Il aurait aussi pu utiliser le prédéfini ZScomme il est dit dans la réponse.
Stewie Griffin
6

Gelée , 1 octet

TryItOnline!

Le signe monadique atome , , fait exactement ce qui est spécifié pour une entrée de nombre entier, que ce soit en tant que programme complet ou en tant que lien monadique (fonction prenant un argument).

Jonathan Allan
la source
6

Mathematica, 4 octets

Sign

Exactement ce qu'il dit sur l'étain

Greg Martin
la source
Enregistrer un octet avecsgn
Adám
3
WolframAlpha est différent de Mathematica. cela inclut l'interprétation automatique de la saisie en langage ambigu / naturel.
Greg Martin
Donc je devrais soumettre ceci une réponse séparée?
Adám
semble raisonnable pour moi ...
Greg Martin
6

Octave, 26 à 24 octets

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

Ceci est ma première réponse Octave , tous les conseils de golf sont appréciés!

Essayez-le en ligne!

L'idée de prendre le asinvient de la question où il est dit output the sign:)

Explication

Remarque: diviser le nombre par piet le multiplier par 2revient à diviser le nombre entier parpi/2

Cas 0:

asin(0)les rendements 0. Prendre la partie réelle de celle-ci et la diviser par pi/2ne fait aucune différence pour la sortie.

Cas positive:

asin(1)les rendements pi/2. asinde tout nombre plus grand que 1donnera pi/2+ nombre complexe. En prenant la partie réelle de celui - ci donne pi/2et en le divisant par pi/2donne1

Cas negative:

asin(-1)les rendements -pi/2. asinde tout nombre inférieur à celui -1qui donnera -pi/2+ nombre complexe. En prenant la partie réelle de celui - ci donne -pi/2et en le divisant par pi/2donne-1

Kritixi Lithos
la source
@LuisMendo N will be an integerJ'ai de la chance, il est écrit dans la question :)
Kritixi Lithos
Oh, je n'avais pas lu cette partie :)
Luis Mendo
1
C l e v e r!
flawr
Vous n'avez pas besoin f=si le reste est une expression de fonction valide et non récursive.
Cyoce
@Cyoce Désolé, mais je ne préfère pas les fonctions anonymes
Kritixi Lithos
6

En fait , 1 octet

s

Essayez-le en ligne!

Un autre cas d’exactement ce qui est écrit sur l’étain - sest la fonction de signe.

Sans la fonction intégrée (4 octets):

;A\+

Essayez-le en ligne!

;A\divise la valeur absolue de l'entrée par l'entrée. Cela se traduit -1par des entrées négatives et 1par des entrées positives. Malheureusement, en raison de la gestion des erreurs par Actually (en cas de problème, la commande est ignorée), 0car l'entrée laisse deux 0secondes sur la pile. +corrige cela en les ajoutant (ce qui provoque une erreur avec quoi que ce soit d'autre, donc il est ignoré).

Mego
la source
6

Piet, 188 53 46 41 octets

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

Interprète en ligne disponible ici.

Ce code de piet fait la norme (n>0)-(n<0), car il n’ya pas de vérification de signes intégrée. En fait, il n’ya pas moins que intégré, donc une description plus précise de cette méthode serait (n>0)-(0>n).

Le texte ci-dessus représente l'image. Vous pouvez générer l'image en la collant dans la zone de texte de la page de l'interprète. Pour plus de commodité, j'ai fourni l'image ci-dessous, où la taille du code est de 31 pixels. La grille est là pour la lisibilité et ne fait pas partie du programme. Notez également que ce programme ne croise aucun code blanc; suivez les codes colorés autour de l'image pour suivre le déroulement du programme.

Explication

Programme

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]

Pour réduire davantage la taille du fichier, je devrais changer le programme (gasp) au lieu de simplement compresser le fichier comme je le faisais auparavant. Je voudrais supprimer une rangée, ce qui réduirait ce nombre à 36. Je pourrais également développer mon propre interprète, qui aurait un format de saisie beaucoup plus petit, car changer le code pour le rendre plus petit n’est pas ce dont il est question.

Les mods m'ont dit que la taille de fichier globale est ce qui compte pour le code Piet. Comme l'interprète accepte le texte comme entrée valide et que le texte brut a un nombre d'octets beaucoup plus petit que toute image, le texte est le choix évident. Je m'excuse d'être insolent à ce sujet mais je ne fais pas les règles. La méta discussion à ce sujet clarifie mes opinions à ce sujet.

Si vous pensez que cela va à l’encontre de l’esprit de Piet ou si vous souhaitez en discuter davantage pour une raison quelconque, veuillez consulter la discussion sur meta .

Mike Bufardeci
la source
2
Je crois que la convention pour Piet est de compter tous les codes.
SuperJedi224
@ SuperJedi224 Ce n'est pas ce qui a été décidé dans la méta-publication, il semble que le nombre d'octets dans l'image correspond à ce que je vais utiliser.
Mike Bufardeci
6

Pushy , 7 octets

C'est probablement le programme le plus étrange que j'ai jamais écrit ...

&?&|/;#

Essayez-le en ligne!

Il utilise sign(x) = abs(x) / x, mais avec un explicite sign(0) = 0pour éviter une erreur de division zéro.

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

Cela fonctionne car x / abs(x)est 1 lorsque x est positif et -1 lorsque x est négatif. Si l'entrée est 0, le programme saute à la commande de sortie.


4 octets (non concurrents)

A cause des vacances et du manque de temps, j’ai réécrit complètement l’interprète Pushy. Le programme ci-dessus fonctionne toujours, mais comme la 0 / 0valeur par défaut est 0, les éléments suivants sont plus courts:

&|/#

Essayez-le en ligne!

FlipTack
la source
1
Je pensais aussi à l’utilisation abs, mais je ne savais pas quoi faire du 0. Bien joué!
Kritixi Lithos
5

R, 25 octets

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

Prend le numéro à STDIN. Puis vérifie si c'est zéro, si non, retourne x/|x|ce qui est l'un 1des -1, et renvoie 0 si x=0.

Ceci sans utiliser les fonctions intégrées signbien sûr.

JAD
la source
1
En utilisant la fonction interne est bien sûr plus court, mais moins amusant: sign(scan()).
Billywob
Désolé, faut-il mentionner explicitement d'éviter les opérations intégrées?
JAD
5

V 14 12 octets

Merci @DJMcMayhem pour 2 octets. Utilise un reg-ex pour effectuer la substitution. C'est amusant, parce que ce n'est pas intégré. J'ai une fonction plus amusante, mais elle ne fonctionne pas comme prévu.

ͨ-©½0]/±1

Vérifier les cas de test

Cela ne fait que traduire :%s/\v(-)=[^0].*/\11ce qui correspond à un ou plusieurs -suivis de tout sauf 0, suivis de tout nombre quelconque de fois. Il est remplacé par le premier match (donc un -ou rien) et un 1. La regex ne correspond pas à 0, donc ça reste tout seul.

La manière la plus amusante (21 octets)

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

TryItOnline

Ceci accepte l’entrée comme un argument plutôt que dans la mémoire tampon.

é<CR> Insérer une nouvelle ligne.

Àexécutez l'argument en tant que code V. a -déplacera le curseur à la ligne précédente, et n'importe quel nombre deviendra le compte de la commande suivante

é1insérer (chiffre) 1s »

2| passer à la deuxième colonne

D tout supprimer à partir de la deuxième colonne (ne laissant qu'un seul caractère)

kJ Joignez les deux lignes ensemble.

òhé-òtraduit en: "courir hé-jusqu'à la rupture". Si le 1 était sur la deuxième ligne, cela casse immédiatement après le h. Si c'était sur la première ligne, il insérera un -avant la rupture.

ó^$/aCela corrige le fait que -1, 0, 1laissera un vide, et remplace un blanc au registre des arguments.

nmjcman101
la source
Je savais que j'aurais dû mieux lire cette page. Ce n'est pas vraiment plus court - j'ai oublié 0, mais j'essayais de prendre le nombre comme argument, puis Àé1. Un nombre positif donne une chaîne de uns, un nombre négatif DEVRAIT donner une chaîne de uns rangée plus haut, et 0 ne donnerait rien. Le bit de nombre négatif ne fonctionnait pas avec À- mais fonctionnait avecd$@"
nmjcman101
Ah Eh bien, la raison pour laquelle cela ne fonctionne pas, c'est qu'il n'y a pas d'autre rang. Si vous ajoutez, é<cr>il y aura deux lignes vides et cela fonctionnera . Je ne sais pas si vous pouvez utiliser cela pour obtenir une réponse complète
DJMcMayhem
J'avais une autre ligne à faire, mais je ne l'avais pas dit explicitement dans mon commentaire. Quel est l' --argument que vous avez ajouté?
nmjcman101
1
Cela signifie "fin des options". Depuis le -6début avec un indicateur, docopt (la bibliothèque python pour les options de ligne de commande) pense que c'est un indicateur de ligne de commande plutôt qu'un argument. Ajouter --simplement le signal qu’il s’agit d’un argument et non d’une option. Sinon, il ne s'exécutera pas du tout à cause d'un appel de ligne de commande non valide.
DJMcMayhem
5

C #, 16 15 octets

Solution améliorée grâce à Neil

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

Sinon, la méthode intégrée est 1 octet plus long:

n=>Math.Sign(n);

Programme complet avec cas de 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));
    }
}
adrianmp
la source
2
Essayez n>>31au lieu de n<0?-1:0.
Neil
1
C'est un peu triste quand la solution intégrée n'est même pas la solution la plus courte.
Mego
Disons que C # est connu pour être plutôt prolixe ...
adrianmp
1
A) Je ne pense pas que vous ayez besoin de la fin, ;car un lambda est une expression, pas une déclaration. B) Math.Signou Math::Signou quelque chose de similaire serait-il une soumission valide? Vous ne savez pas comment C # en particulier gère les méthodes. Fondamentalement, serait x = Math.Sign;une déclaration C # valide si a xété initialisé avec le bon type?
Cyoce