# Output the sign

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.

## 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 COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.

/* App */

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

}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(a) {
});
comment_page = 1;
}
});
}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(c) {
if (c.owner.user_id === OVERRIDE_USER)
});
else process();
}
});
}

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

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

function process() {
var valid = [];

var body = a.body;
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],
});
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;

.replace("{{NAME}}", a.user)
.replace("{{LANGUAGE}}", a.language)
.replace("{{SIZE}}", a.size)

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)
language = jQuery(language);
jQuery("#languages").append(language);
}

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

width: 290px;
float: left;
}

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

font-weight: bold;
}

table td {
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div id="language-list">
<h2>Shortest Solution by Language</h2>
<table class="language-list">
<tr><td>Language</td><td>User</td><td>Score</td></tr>
<tbody id="languages">

</tbody>
</table>
</div>
<tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>

</tbody>
</table>
</div>
<table style="display: none">
</tbody>
</table>
<table style="display: none">
<tbody id="language-template">
</tbody>
</table>

• 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. Dec 20, 2016 at 10:10
• This could probably use a leaderboard. Dec 20, 2016 at 11:13
• @MrLister upvote how you want, but really you should look for creativity instead of code length. Dec 28, 2016 at 20:13
• @FlipTack Oh, I thought it was codegolf. Dec 28, 2016 at 20:23
• @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 Dec 28, 2016 at 20:25

# Japt, 2 bytes

Ug


Test it online!

U is the input number, and g is the sign function on numbers. Output is implicit.

# Pyth, 2 bytes

._


herokuapp

Pyth's sign function.

## Matlab, 4 bytes

sign


Matlab as well has a builtin for it.

# Octave, 4 bytes

As with many others, a built-in:

sign


# WolframAlpha, 3 bytes

Try it online: sgn

# Befunge, 11 bytes

&:0\0\-.@


Try it online!

This is just the obvious (N > 0) - (0 < N) calculation.

&               Read N from stdin.
:              Make a duplicate copy.
0            Calculate N > 0.
\           Swap the second copy to the top of the stack.
0\        Calculate 0 > N.
-       Subtract the two comparisons: (N > 0) - (0 < N)
.@     Output the result and exit.


As Martin Ender pointed out, there's potentially a 2-byte shorter solution, using the same idea as his ><> answer:

1~"/"-%.@


Unfortunately this only works if the result of a modulo operation takes the sign of the divisor, which is not that common in Befunge implementations (in particular the reference interpreter doesn't work this way).

1               Push 1 onto the stack for later use.
~              Read a character of input (this will be '-' or an ASCII digit).
"/"-          Subtract 47.
%         Take the modulo of the 1 we pushed earlier with this difference.
.@       Output the result and exit.


If you want to try this out you'll probably need to use one of the Python-based interpreters like PyFunge or Befungee. I suspect Fungi might work too.

• I think the arithmetic solution I used for my ><> answer and one of my Labyrinth answers would be 2 bytes shorter. Dec 20, 2016 at 13:46
• If you use that approach you can save another byte with Befunge-98 which supports '/ for "/". (Provided any 98 interpreters exist with the correct modulo.) Dec 20, 2016 at 14:54

# SAS Macro Language, 43 bytes

In the extremely wordy language...

%macro s(n);%put(%sysfunc(sign(&n)));%mend;


## Jellyfish, 3 or 6 bytes

3 bytes with built-in:

p*i


Print (p) the sign (*) of the input (i). Automatically threads over lists.

6 bytes without built-ins:

p%S
+i


Print (p) the division (%) of the input (i, taken from south with S) by the absolute value (+) of the input. Conveniently, division by 0 yields 0 in Jellyfish. This version also threads over lists. Try it online!

Clojure, 23 bytes

#(condp > % 0 -1 1 0 1)


This condp macro expands to "if less than 0 return -1, if less than 1 return 0 else 1".

(macroexpand '(condp > % 0 -1 1 0 1))
(let* [pred__7749 > expr__7750 %] (if (pred__7749 0 expr__7750) -1 (if (pred__7749 1 expr__7750) 0 1)))


# PHP, 39 38 bytes

## no comparison operators

<?=($n=$argv[1])&PHP_INT_MIN?-1:1-!$n;  should work on most systems. PHP_INT_MIN has only one bit set: the most significant one. If this is set in the input, it is negative. !$n (cast to integer by the subtraction) evaluates to 0 for positive values and 1 for 0.

lame solution, 30 bytes

<?=($n=$argv[1])?abs($n)/$n:0;


works also on floats.

# Python 2, 57 bytes but no conditionals or comparitors

Just to be different, here's a solution that avoids all those ugly arithmetic functions:

def s(n):
try:r=len([1][:n])*2-n/n
except:r=0
return r


Slicing a non-empty sequence [1][:n] returns [1] when n is positive and [] when negative or zero, so to distinguish these cases, n/n throws a divide by zero error for n=0.

## QBIC, 18 8 bytes

:?sgn(a)


This utilizes Qbasic's SGN() function. : gets the input in variable a, ? prints.

Original version, before I learnt that QBasic has a SGN() function:

:~a=b|?a\?a/abs(a)


18 bytes. Explanation

:           Get 'a' from the command line
~a=b        If a == b (and b==0 by default)
|?a         Then print a
\?a/abs(a)  Else, print a / abs(a) --> -2/2 leaves the req. -1, 4/4 = 1


## Javascript, 37 bytes

function s(n){return n>0?1:n<0?-1:0}

• Sorry, updated! Dec 21, 2016 at 15:35
• You could use a lambda: n=>n>0?1:n<0?-1:0
– user45941
Dec 23, 2016 at 14:45

# Go, 49 bytes

func s(x int)int{return(x>>63)|int(uint(-x)>>63)}


Note: this won't work on the playground until Go 1.8 is released due to this bug: https://github.com/golang/go/issues/16203

• Possibly doesn't work for the minimum integer (-1<<63)?
– Neil
Dec 21, 2016 at 10:30
• @Neil nope! Should work for all 64 bit integers. Dec 21, 2016 at 16:12
• Oh, I see now, you just get -1|1 in that case, which is still -1.
– Neil
Dec 21, 2016 at 20:13

## brainfuck, 23 bytes

-<,
[
[
>-[-<]
>
]
->[>+>]
]
<.


This takes a single byte from stdin and interprets it as a signed char, printing \xff for negative, \x00 for zero, and \x01 for positive.

Try it online.

Viewed as an unsigned char, we are checking whether it is greater than 127, with 0 as a special case. We can do the comparison by decrementing from 255 twice at a time.

• Doing I/O as decimal strings could be fun too. Dec 21, 2016 at 16:48
• You could argue that all numbers in BF are positive, so ,>+. is a valid answer. Dec 22, 2016 at 4:38
• @Challenger5 Even if that were modified to handle zero, e.g. with ,[>+>]<., I don't think that could be argued as anything other than a loophole. Dec 22, 2016 at 5:49
• Definitely, but it's funny. Dec 22, 2016 at 5:50
• @Challenger5 That would be abusing native number types to trivialize the challenge. The solution Mitch has used (interpreting the input as an 8-bit two's complement integer) is valid, and the only valid way to do this in brainfuck other than interpreting decimal strings (unless there's another way and I'm not seeing it).
– user45941
Dec 23, 2016 at 14:44

# MarioLANG, 868 bytes

;
=
[@:
=======================================================
))    <
======================================================"
@ ((((++
=======            <
==========="
@ -)+)+)+((([!))+((
=============#====    (<
===="
@ +)-[!)))
======#==      )  <
========"
>([!)
"==#        ))  <
@ -(-)[!+   ==========="
=======#:          >(([!!
"===##
@ +((-))[!-
=========#:


;[>
==                                                                                                   output zero
[@                                                                                            :                                                                      * start
move pointer back to arg  ))    <
=================================================================================="===
increase counter limit
@   ((((++
=================    set counters
<
@ -)+)+)+ ((([! ))+((
==============#======
reset limit
(<
======="
@ +)-   [! )))
=========#====   try subtraction
)  <
==========="
> ( [! )
"====#==
========#                   ))  <
==============="
> (( [!  !
"=====#==#
@  +((-)) [!
===========#

output one       output minus one
+:                -:
===               ===


### What's going on?

The program maintains 5 memory fields (right to left):

• Input value, continuously edited in search of zero
• Counter for search in negative direction (subtraction)
• Counter for search in positive direction (addition)
• Helper to reset search radius (limit)
• Current search interval radius (limit, k)

The algorithm keeps on searching for zero in both (+ and -) directions, starting at the input value. It does k negative and k+1 positive steps on each iteration, then increases k by 2. Once zero has been found, 1 or -1 is output, depending from which side it was reached.

Detection of zero as input is a special case, handled right at the beginning.

Try it online (commented, ungolfed version)

# JavaScript (ES6), 14 bytes

No conditionals, no Math lib usage

x=>(x>0)-(x<0)


## Explanation

x > 0 is true/false for positives/non-positives and cast to number (1/0) in case for subtraction. x < 0 is analogous for negatives, so we end up with 1-0 for positives, 0-0 for zero and 0-1 for negatives.

# Python 3, 13 bytes

n//abs(n-.1)

• Welcome to the site, and nice first answer! Just so you know, this is only a REPL snippet, which aren't a default valid form of output. You could wrap this in a lambda to make a function submission though. lambda n:n//abs(n-.1) Dec 24, 2016 at 7:27

# C, 23 bytes

A more portable (I think) 23-byte solution in C:

f(n){return(n|1)%2-!n;}


# C#, 40 bytes

b=>System.Console.Write(b>0?1:b<0?-1:0);


Or with a built-in:

# C#, 44 bytes

using System;b=>Console.Write(Math.Sign(b));


Unfortunately it's longer, then the first solution.

# MATLAB + Octave, 15bytes

There are a few other Octave/MATLAB answers, but two of the others are simply using a built in, and the other is significantly longer.

The anonymous function:

@(a)(a>0)-(a<0)


Quite simple. If a>0, the answer will be (1-0)=1. If a<0, the answer will be (0-1)=-1. If a==0 the answer will be (0-0)=0.

You can try online here. Simply run the above code and then try with ans(input).

• @(a)2/(0^a+1)-1 also works, at the same length of 15 bytes. Mar 22 at 12:05

# Symbolic Python, 24 bytes

Like many other solutions, this uses the formula s(x) = (x > 0) - (x < 0). Note that this solution is non-competing as the language postdates the challenge.

__={}>{}
_=(_>__)-(_<__)


Symbolic Python is a restricted source version of Python: all alphanumeric characters are banned.

The interpreter automatically puts input in the variable _. From there, the code works like so:

• {}>{} generates the value False. This is then assigned to the variable __. Although it's technically a boolean, we use this as the integer 0:
• (_>__) checks whether the input is greater than 0. (_<__) checks whether the input is smaller than 0. These booleans are then interpreted as integers, and the first is subtracted from the second.
• The result of this is put in the variable _, which is automatically printed after execution.

# Java 8, 33, 17, 14 bytes

i->i>0?1:i>>31


Does not rely on any questionable code constructs or fragments. This is a complete functional interface implementation.

• You can reduce to (int i)->i<0?-1:i>0?1:0 (or even further to i->i<0?-1:i>0?1:0) which are all accepted solutions here on codegolf (codegolf.stackexchange.com/a/16100/16236). Dec 24, 2016 at 0:23
• @OlivierGrégoire thanks, for some reason I was not thinking "this is a single expression, so the lambda can be reduced."
– user18932
Dec 24, 2016 at 19:12
• It can be reduced to this: i->i>0?1:i>>31 (14 bytes) Jan 10, 2017 at 10:49

# Scala, 16 bytes

n=>n compareTo 0


# Common Lisp, 21 6 bytes

signum


Try it online!

# dc, 22 bytes

[pq]sqd0=qdd*vr1-d*v-p


Try it online!

I don't like that 10 bytes of this is eaten up testing for zero, will continue to mull over that. The second half, dd*vr1-d*v-p uses the square root of the square to calculate the absolute value of both our value to test and that value less one. Subtracting the latter from the former yields 1 for a positive value, -1 for a negative.

# Aceto, 4 bytes

riyp

ri reads input as integer
y puts sign on stack
p prints it


Try it online!

# dc, 15 bytes

[_1*]sa?dd0>a/p


Try it online!

### Explanation

This (ab)uses the fact that dc keeps the stack as is, if you're trying to divide by 0 which really helps for this challenge:

[_1*]sa          # store the macro in register a (macro negates the top)
?         # push input to stack
d        # duplicate top
d0>a    # if top is negative, execute macro
/   # divides top two values
p  # print the top of the stack


# Functoid, 30 28 bytes

In functoid there is no support for negative integers since numbers are handled as Church numerals. This solution redefines numbers in a way that supports negative numbers (please refer to the explanation):

<|12K0K$BbB r<@.1,"-" )<@.([  Try it online! (Here is an input generator) ### Explanation The definition of negative numbers extends the Church numerals by simply introducing another lambda abstraction that encodes the sign of a number (the first argument, ie. x3). Here is how the numbers -2,-1,0,1,2 would look like in this notation: Decimal number | extended Church numerals | absolute value as Church numeral ---------------+--------------------------+--------------------------------- -2 | λλλ(x3 (x2 (x2 x1))) | λλ(x2 (x2 x1)) -1 | λλλ(x3 (x2 x1)) | λλ(x2 x1) 0 | λλλ(x1) | λλ(x1) 1 | λλλ(x2 x1) | λλ(x2 x1) 2 | λλλ(x2 (x2 x1)) | λλ(x2 (x2 x1))  Now for the explanation of the above code: The characters < will change the direction to left, this saves us four bytes but makes it more difficult to read.. Here's how the code would look like without doing this: BbB$K0K21|
@.1,"-"r<
@.([)<


The combinator BbB ensures that K0 and K2 get grouped as one expression each, here's the more verbose code:

$(K0)(K2)1| @.1,"-"r< @.([)<  Okay now it's quite readable: First $ will apply the input so we'll have a sign-extended Church numeral as current expression. Applying K0 (constant 0) will evaluate to KK0 (which will "swallow" the next two arguments) in the case of a negative number, in the case of a non-negative number it simply vanishes. In the case of a positive number we'll have K2 which will swallow the argument 1 and else we'll finally get 1.

Summing up the function \$(K0)(K2)1 gives the following numbers (regular Church numerals):

if input < 0:
return 0
elif input > 0:
return 2
else:
return 1


The command | will set the direction down iff the current expression evaluates to 0 and up in the other case.

• The second line is thus only relevant if the input was negative and it simply prints -1 and terminates
• In the other case (ie. hitting the third line) it applies the current expression to [ which decrements it by 1, prints the expression (as a numeral) and terminates

### Disclaimer

It might look like the above extension was done just to make this task easier, however this is not the case. In fact most definitions in the untyped (or rather uni-typed) lambda calculus are made because they simplify a lot of operations that one could be interested (such as Booleans or the Church numerals themselves).

As an example the function abs could be "implemented" by just applying the identity function to such an extended numeral which will get rid of one lambda abstraction (and in case of a negative number, keep the absolute value as is).

Anonymous function that takes input as a number, n, and output to STDOUT
input""n