74
\$\begingroup\$

Given a number N, output the sign of N:

  • If N is positive, output 1
  • If N is negative, output -1
  • If N is 0, output 0

N will be an integer within the representable range of integers in your chosen language.

The Catalogue

The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:

## [><>](https://esolangs.org/wiki/Fish), 121 bytes

/* Configuration */

var QUESTION_ID = 103822; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body {
  text-align: left !important;
  display: block !important;
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 500px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

\$\endgroup\$
  • 47
    \$\begingroup\$ This is a trivial challenge with a lot of trivial solutions. There are however some non-trivial solutions too. To voters: Please read the first sentence of this meta post before upvoting builtin functions. \$\endgroup\$ – Stewie Griffin Dec 20 '16 at 10:10
  • 8
    \$\begingroup\$ This could probably use a leaderboard. \$\endgroup\$ – Martin Ender Dec 20 '16 at 11:13
  • 2
    \$\begingroup\$ @MrLister upvote how you want, but really you should look for creativity instead of code length. \$\endgroup\$ – FlipTack Dec 28 '16 at 20:13
  • 3
    \$\begingroup\$ @FlipTack Oh, I thought it was codegolf. \$\endgroup\$ – Mr Lister Dec 28 '16 at 20:23
  • 3
    \$\begingroup\$ @MrLister that's the objective winning criterion. but does it really take more effort to type s for a sign builtin, or use some clever bitshifting/maths to work it out? Have a look at this meta post \$\endgroup\$ – FlipTack Dec 28 '16 at 20:25

158 Answers 158

5
\$\begingroup\$

Brain-Flak, 48 46 40 bytes

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

Try it Online

Explanation

{                                }{}({}) #Do nothing if zero
   ({}<([()])>)                          #Put a -1 under input
 ([            ]<>(()))                  #Put 1 and a negative copy of input on the off stack
                       {        }        #Until zero
                        ({}())           #Increment
                              <>         #Swap
| improve this answer | |
\$\endgroup\$
5
\$\begingroup\$

Python 3, 20 bytes

Since Python 3 doesn't have access to cmp like Python 2 does, it's a little longer

lambda n:(n>0)-(n<0)
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Practically the same as this answer: codegolf.stackexchange.com/a/103831/41805 \$\endgroup\$ – user41805 Dec 21 '16 at 11:35
  • 1
    \$\begingroup\$ @KritixiLithos practically but it's also an entirely different llanguage \$\endgroup\$ – Dillanm Dec 21 '16 at 11:37
  • 1
    \$\begingroup\$ How about n//abs(n) for two bytes \$\endgroup\$ – Phlarx Dec 21 '16 at 21:28
  • 1
    \$\begingroup\$ @Dillanm ah, right. Didn't catch that, obvious in hindsight :P \$\endgroup\$ – Phlarx Dec 22 '16 at 16:16
  • 2
    \$\begingroup\$ @Dillanm You can, actually, but it's several bytes longer: n and n//abs(n) \$\endgroup\$ – Phlarx Dec 23 '16 at 16:19
5
\$\begingroup\$

Befunge 93, 14 13 bytes

Golfed off a byte by combining the 2 1s

1~50p :0`_.@.

Try it Online!

This one is interesting, as it takes the first character of the number and alters the code accordingly.

 ~50p         Stores the first character in the space (labeled <char> here)
1    <char>   If the number is negative, it performs subtraction, giving 1 - 0 == -1
              If it is 0, 0 is on top. If it is positive, a positive # will be.

 :0`_         This checks the top number to see if it is positive.
     .@       If it is <1, it is printed. (0 or -1)
1     @.      Otherwise, the IP loops back harmlessly, and prints 1
| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

05AB1E, 3 bytes

0.S

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Oh wow! (I mean, how did you get it so long?) \$\endgroup\$ – user85052 Jan 26 at 23:38
  • \$\begingroup\$ @a'_' Well, there wasn't any way of doing it shorter than this. \$\endgroup\$ – Emigna Jan 27 at 20:36
  • \$\begingroup\$ Don't use the legacy version and you have 2 bytes \$\endgroup\$ – Steffan Mar 27 at 20:13
  • \$\begingroup\$ 2 bytes is possible even on the legacy version \$\endgroup\$ – Grimmy Apr 24 at 9:59
4
\$\begingroup\$

Labyrinth, 8 bytes

1,_47-%!

Try it online!

I'm posting this as a separate answer because my other Labyrinth answer is based on arithmetic on the actual numerical input value, whereas this mostly ignores the number and works with the character code of the first character instead.

Explanation

So yeah, this reads the first character code which is either 45 (-, which should yield -1), 48 (0, which should yield 0) or 49 to 57 (1-9, which should yield 1). This mapping can be accomplished via the simple formula 1 % (x - 47). To see why this works, here is the breakdown of the code for 3 different examples:

Code    Comment             Example -5      Example 0       Example 5
1       Push 1.             [1]             [1]             [1]
,       Read character.     [1 45]          [1 48]          [1 53]
_47-    Subtract 47.        [1 -2]          [1 1]           [1 6]
%       Modulo.             [-1]            [0]             [1]
!       Print.              []              []              []

The instruction pointer then hits a dead end, turns around and terminates when % now attempts a division by zero.

Another simple computation that works:

x -= 46
x %= x-1
| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

Turing Machine code, 65 bytes

0 0 0 * halt
0 - - r 2
0 * 1 r 3
2 * 1 r 3
3 * _ r 3
3 _ _ * halt

Try it online.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Could you link to an interpreter? \$\endgroup\$ – Mego Dec 23 '16 at 15:00
  • \$\begingroup\$ couldn't you output using halt state here :P \$\endgroup\$ – ASCII-only Apr 12 '19 at 7:19
4
\$\begingroup\$

Hexagony, 13 bytes

?</!~/~@$\!@

Expanded:

  ? < /
 ! ~   /
~ @ $ \ !
 @ . . .
  . . .

Try it online!

Hexagony truthy/falsiness for numbers checks based on being positive or not. This makes singling out zero a bit tricky, so we check if a number and its negation are both non-positive to check for zero. Uses the unprintable character 0x01 to literally store 1 in a memory edge to save a byte zeroing the edge first. In the expanded version it is between the ~ and the / on the second line.

Breakdown:

For positive numbers the code is very simple. We start at the top left moving eastward, then take the fork to the right. The rest of the program is "linear" along the surface of the code, giving: ?<0x01\.!@ where both \ and . are no-ops. 0x01 sets the current memory edge to 1 and then ! prints that and @ ends the program.

For negative numbers and zero, we start the same but turn left at the <. This leads us back around to the \ but this time approaching from the southwest. This time it acts as a mirror and redirects the instruction pointer westward. The $ allows us to skip the program-ending @. Next we hit ~ which negates the value that we read in. If the number was negative it is now positive, and if it was zero it is still not positive.

When hitting the edge of the hexagon we wrap to the right if the value was positive and to the left if the value was negative or zero. Negative numbers will then wrap to the right and begin moving westwards from the top right. Hitting some mirrors leads us to a familiar looking path starting with the edge being set to 1. Then ~ negates it and ! prints giving -1. We wrap around and hit the other @.

Zero will instead wrap to the bottom, which has nothing but no-ops. Then it wraps back to the middle and is printed by !. Then some mirrors redirect us to the @ to end the program.

| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

Excel, 8 bytes

=Sign(n)

Pretty basic, but the only language I feel complete confidence in.

Without a builtin!

Excel, 23 bytes

=If(n>0,1,If(n<0,-1,0))

not so confident

Crystal Reports Formula (Noncompete), 24 bytes

IIF(n>0,1,IIF(n<0,-1,0))
| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

Minecraft Functions (18w11a, 1.13 snapshots), 131 bytes

Number signs in minecraft

Uses a function named a in the minecraft namespace

execute if score @p n matches 0 run say 0
execute if score @p n matches 1.. run say 1
execute if score @p n matches ..-1 run say -1

"Takes input" from a scoreboard objective named n, create it with /scoreboard objectives add n dummy and then set it using /scoreboard players set @p n 8. Then call the function using /function a

| improve this answer | |
\$\endgroup\$
4
\$\begingroup\$

Hexagony, 18 15 bytes

~.?>.)<<!!.&,.@

Try it online!

n > 0

  ~ . ?
 . . . .
< . ! . .
 , . @ .
  . . .

n == 0

  ~ . ?
 > . ) <
< . ! . &
 . . @ .
  . . .

n < 0

  ~ . ?
 > . ) <
< ! . . .
 , . @ .
  . . .

Abuses the same EOF trick used in Jo Kings answer.

Sadly I currently don't have access to these neat visual tools used in other solutions.

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Mathematica, 28 bytes

Limit[2ArcTan@x#/Pi,x->∞]&

Mathematica, 30 bytes

2HeavisideTheta@#-1/._[_]->1/2&

Mathematica, 76 bytes

Round@Integrate[E^(2#+I t#)/(2+I t)/Pi,{t,-∞,∞},PrincipalValue->True]-1&

Just to be different :)

| improve this answer | |
\$\endgroup\$
  • 2
    \$\begingroup\$ Median@{#,1,-1} and #~Min~1~Max~-1 if you want some more ideas ;) \$\endgroup\$ – Martin Ender Dec 20 '16 at 12:09
  • \$\begingroup\$ Personal challenge to you: find an implementation that's longer than 76 bytes, but fully golfed for its algorithm (can you be turned to the dark side?!). \$\endgroup\$ – Greg Martin Dec 20 '16 at 18:43
  • \$\begingroup\$ Can I take you up on this challenge? \$\endgroup\$ – Gabriel Benamy Dec 20 '16 at 23:29
  • \$\begingroup\$ Of course! .. :) \$\endgroup\$ – Greg Martin Dec 21 '16 at 0:13
3
\$\begingroup\$

Forth, 22 bytes

Golfed

: S dup 0< swap 0> - ;

Test

: S dup 0< swap 0> - ;  ok

0 S . 0  ok
1 S . 1  ok
-1 S . -1  ok
12345 S . 1  ok
-12345 S . -1  ok

Try It Online !

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Nice. I was going to post something similar that I wrote several months ago. \$\endgroup\$ – mbomb007 Dec 20 '16 at 22:38
3
\$\begingroup\$

x86_64 machine language on Linux, 13 bytes

 0:   31 c0                   xor    %eax,%eax
 2:   85 ff                   test   %edi,%edi
 4:   0f 9f c0                setg   %al
 7:   c1 ef 1f                shr    $0x1f,%edi
10:   29 f8                   sub    %edi,%eax
12:   c3                      retq

The input (first function parameter) is passed into %edi. To try it out, compile and run the following C program

#include<stdio.h>
#include<stdlib.h>
#define s(x) ((int(*)(int))"\x31\xc0\x85\xff\xf\x9f\xc0\xc1\xef\x1f\x29\xf8\xc3")(x)
int main(){
  printf( "%d %d %d\n", s(-5), s(0), s(44) );
}
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ I'm a bit surprised that x86 doesn't have a builtin for sign. \$\endgroup\$ – Mego Dec 23 '16 at 15:00
  • \$\begingroup\$ Casting a C string to a function pointer? That's nasty. \$\endgroup\$ – Fund Monica's Lawsuit Dec 26 '16 at 1:08
  • 1
    \$\begingroup\$ @QPaysTaxes, that is also an elegant/horrifying way to make lambdas in C qsort(a,sizeof a/4,4,"\x8b\7+\6\xc3"); \$\endgroup\$ – ceilingcat Dec 29 '16 at 5:17
  • \$\begingroup\$ I got virtually the same solution in a language I created that is based off of C lambdas. What C code did you use to generate this machine code? \$\endgroup\$ – MD XF Mar 27 '18 at 18:50
3
\$\begingroup\$

Plain English 101 81 bytes

To put a n number's sign into a s number:
Get the sign of the n returning the s.

Ungolfed version:

To put a number's sign into another number:
  Get the sign of the number returning the other number.

Either version can be used to golf the client code -- and make the client code more readable. For example, the following line of code displays a Windows message box containing the number -1 in the message body:

Debug -456's sign.

The Plain English IDE is available at github.com/Folds/english. The IDE runs on Windows. It compiles to 32-bit x86 code.

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ ... I don't think that the Ungolfed version was really necessary \$\endgroup\$ – Taylor Scott Aug 1 '17 at 18:36
3
\$\begingroup\$

Haskell, 23 characters

A true approach, not using built-ins but function composition (the dot):

(1-).fromEnum.compare 0

(or with more space)

(1-) . fromEnum . compare 0

Explanation:

compare 0 : partially applying the compare function to
                the first argument 0 results in a function which takes
                a number and compares it to 0. 
                  (compare 0) n = compare 0 n =
                      LT    : if 0 < n
                      EQ    : if 0 = n
                      GT    : if 0 > n
fromEnum  : it maps LT to 0, EQ to 1 and GT to 2
(1-)      : n -> 1 - n
| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ You can save 3 bytes by replacing pred with (1-) which allows you to replace (`compare`0) with compare 0. \$\endgroup\$ – 0 ' Oct 20 '17 at 7:27
3
\$\begingroup\$

LOLCODE, 191 bytes

HAI 1.3
I HAS A J ITZ A NUMBR
GIMMEH J
BIGGR OF J AN 0, O RLY?
	YA RLY
		VISIBLE "1"
	NO WAI
		BOTH SAEM "0" AN J, O RLY?
			YA RLY
				VISIBLE "0"
			NO WAI
				VISIBLE "-1"
	OIC
OIC
KTHXBYE

Try it online!

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ This is surprisingly readable. \$\endgroup\$ – Reinstate Monica -- notmaynard Nov 21 '17 at 18:17
  • \$\begingroup\$ @iamnotmaynard funny right? \$\endgroup\$ – FantaC Nov 21 '17 at 19:31
3
\$\begingroup\$

Befunge-93 (PyFunge), 12 bytes

~"1"%90p1X.@

Try it online!

Note that the X can be anything (except a new line), as it gets written over during run-time. It's just easier for explanation

Similar to my other Befunge answer, but this time it mods the first character by the ASCII for 1 first, so that a positive first digit will turn into a no-op, leaving the 1 on the top of the stack:

~               Read the first *character* of input - either a digit or "-"
 "1"%           Mod the character by the ASCII value of 1. After this step, the character
                is a '-' for negative numbers, '0' for 0, and small, unprintable
                characters for positive numbers

     90p        Puts the character in the space with the X.
        1       Pushes a 1

         X      3 different options based on the character that was put here:
         -      Negative: Subtract the 1 from the implicit 0 to get -1
         0      Zero:     Push 0
               Positive: A no-op, which leaves the 1 on top

          .     Prints out the top of the stack
           @    Ends the program
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Hexagony, 16 bytes

...!/~.?.<.!1@.,

Try it online!

Not much smaller than the previous answer, but strangely elegant in comparison.

Expanded:

   . . .
  ! / ~ .
 ? . < . !
  1 @ . ,
   . . .
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

TIS -n 1 1, 57 bytes

@0
MOV UP ACC
ADD 998
SUB 998
SUB 998
ADD 998
MOV ACC ANY

Try it online!

The integral data type supported by TIS ranges from -999 to 999. Any value in input, code, or calculations is silently coerced (clamped) into that range (instead of truncation, overflowing, etc.).

So, by adding 998 to any number, then subtracting the same amount, it becomes 1 is it was positive, and stays untouched otherwise. We then do the same to coerce all negative numbers to -1.

We need to subtract across two separate operations, due to the coercion mentioned above.

If you are familiar with TIS-100, you will be used to a 3x4 array of computational nodes, however, this solutions only uses one such node, nominally taking input from above and giving it below.

| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Python 3, 30 bytes

Just here to share another solution.

lambda x:eval(f'x and {x}**0')

Try it online!

Explanation

lambda x:                      # Lambda function with the variable x
         eval(f'      {x}**0') # Raise x to the power of 0
                x and          # Since 0 ** 0 = 1, we prevent that
                               # by using logical and.
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Python 3, 26 25 bytes

An interesting way to approach this problem using the irregularity of Python 3 hash function.

lambda x:x/abs(~hash(~x))

Try it online!

Explanation

The big idea is to return x/abs(x). However, this causes division by 0 if x is 0.

hash(i) (where \$i\$ is an integer) returns \$i\$ most of the time, with the exception of hash(-1) returning \$-2\$. Thus ~hash(~x) (where ~ denotes bitwise negation) evaluates to:

  • If x != 0: ~hash(~x) == ~~x == x
  • If x == 0: ~hash(~0) == ~hash(-1) == ~(-2) == 1

Thus instead of dividing by abs(x), we divides by abs(~hash(~x)) which can never be 0.

Note: This will not work for large integers (\$\ge2^{61}\$), since hash of long integer is calculated differently.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Clojure, 14 bytes

#(compare % 0)

This uses the built-in compare function of clojure: it returns a 1 if the first arg is greater than the second arg, 0 if it's equal, and -1 if it's smaller.

Usage:

(#(...) {number})
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Haskell, 6 bytes

signum

Just a boring built-in.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Perl 6, 9 bytes

+(*cmp 0)

Try it online!

Explanation:

+(     # turn into a number

  *    # Whatever (input)
  cmp  # compared to
  0    # 0

)
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

CJam, 1 byte

g

Try it online!

Another built-in, just for the sake of completeness.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Wonder, 4 bytes

sign

Usage:

sign 1

Builtin.

Bonus solution (no builtin), 7 bytes

tt cmp0

Usage:

(tt cmp0)5

Uses a compare function with 0.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Javascript, 18 bytes

x=>x/Math.abs(x)|0

x/Math.abs(x) is always 1 if x is positive and -1 if x is negative. If x is 0, it returns Nan, which we transform to 0 with the |0 bit.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Gema, 9 characters

Just a rewrite of Jordan's Sed solution.

0=0
<D>=1

Sample run:

bash-4.3$ gema '0=0;<D>=1' <<< $'-303\n-12\n-5\n0\n1\n20\n404'
-1
-1
-1
0
1
1
1

Gema, 19 characters

*=@cmpn{*;0;-1;0;1}

Posted just because Gema has a nice function for this task:

@cmpn{number;number;less-value;equal-value;greater-value}
Compare numbers.

Sample run:

bash-4.3$ gema '*=@cmpn{*;0;-1;0;1}' <<< -303
-1

bash-4.3$ gema '*=@cmpn{*;0;-1;0;1}' <<< 0
0

bash-4.3$ gema '*=@cmpn{*;0;-1;0;1}' <<< 404
1
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Batch, 23 bytes

@cmd/cset/a"%1>>31|!!%1

>>31 evaluates to -1 if the input is negative and 0 if it is positive, while !! evaluates to 1 if it is nonzero and 0 if it is zero, so we just have to bitwise OR the two results together.

| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Java 1.8, 11 bytes

Math.signum

In the comments, some people pointed out that this might not technically be valid, if so, here's another version at 12 bytes:

Math::signum
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ This is not a full program neither an (anonymous) function, but rather just a code excerpt, which can not be reused directly, so I guess this does not qualify. \$\endgroup\$ – zeppelin Dec 20 '16 at 21:29
  • 3
    \$\begingroup\$ It is technically a function, just referencing an already existing one, you can call it the same way as an anonymous function, but I don't know if such solutions are/should be allowed. \$\endgroup\$ – nyuszika7h Dec 20 '16 at 22:15
  • \$\begingroup\$ @zeppelin From everything I've seen, this is as acceptable as a loose anonymous function. \$\endgroup\$ – Carcigenicate Dec 20 '16 at 22:22
  • \$\begingroup\$ It would be acceptable in a language like Javascript, where evaluating the expression like "Math.sign" will evaluate to a function reference, which you can then invoke or assign to a variable. But (AFAIK) 'Math.signum' does not make a valid standalone expression in Java. Probably you can replace it with a "method reference" (i.e. Math::signum) which will produce a Function<>, which can then be assigned to a variable and invoked, to make it qualify. \$\endgroup\$ – zeppelin Dec 21 '16 at 9:17
  • \$\begingroup\$ @nyuszika7h "you can call it the same way as an anonymous function" I don't think you can, w/o changing it to Math.signum(yourArgument), which involves rewriting the program text, and that is clearly not acceptable. (and you will still have to pass an argument in somehow). \$\endgroup\$ – zeppelin Dec 21 '16 at 9:18

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.