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

# Triangular, 26 15 bytes

$\:-|0U%<g/l0P<  Formats into this triangle: $
\ :
- | 0
U % < g
/ l 0 P <


Try it online!

Old broken version that I understand:

$\:-%0U..g/l0P<  Try it online! Currently nonworking until Dennis pulls; found some interpreter bugs. Formats into this triangle: $
\ :
- % 0
U . . g
/ l 0 P <


How it works: The code, without directionals, is read as $:0gP0lU-%. • $ reads an integer from standard input.
stack: i
• : duplicates the top stack value.
stack: i,i
• 0 pushes 0 to the stack.
stack: i,i,0
• g pushes i>0 to the stack and discards both values used (thanks, Luis Mendo).
stack: i,i>0
• P pops the top stack value into the register.
stack: i
• 0 pushes 0 to the stack.
stack: i,0
• l pushes i<0 to the stack and discards the values used.
stack: i<0
• U pulls the register onto the stack.
stack: i<0,i>0
• - computes a postfix subtract.
stack: i<0-i>0
• % prints the top stack value as an integer.

Idea thanks to caird.

• This fails, by outputting the inverse sign. However, this is correct, and is the same length. – caird coinheringaahing Oct 31 '17 at 18:42

# GolfScript, 13 bytes

~.{.abs/}{}if


Try it online!

How it Works

Divide by itself if 0 otherwise do nothing, and leaving a zero on the stack to be printed.

# 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


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

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

# Hexagony, 16 bytes

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


Try it online!

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

Expanded:

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


# 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

## PowerShell, 22 bytes

[math]::sign($args[0])  Boring built-in, calls the .NET function that does exactly what it says on the tin. Ho-hum. Try it online! For 26 bytes however, we get the classic greater-than less-than equation param($b)($b-gt0)-($b-lt0)


This, at least, has a little bit of logic and thought put into it. Try it online!

Best yet, though is 44 bytes, where we roll our own solution.

param($b)if("$b".indexof('-')){+!!$b;exit}-1  Here we take input $b, stringify it, take the .IndexOf('-') on it, and use it in an if clause. If the negative sign isn't found, this returns -1, which is truthy in PowerShell, so we turn $b into a Boolean with !, invert the Boolean with another !, cast it as an int with +, leave it on the pipeline, and exit. This turns a positive integer (which is truthy) into $false, then $true, then 1, while turning 0 into $true, then $false, then 0. Otherwise, the .IndexOf returned 0 (meaning it was the first character in the string), which is falsey, so we skip the if and just place a -1 on the pipeline. In either case, output via implicit Write-Output happens at program completion. Try it online! # 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. – Martin Ender Dec 20 '16 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.) – Martin Ender Dec 20 '16 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! – Ostbullen Dec 21 '16 at 15:35 • You could use a lambda: n=>n>0?1:n<0?-1:0 – Mego Dec 23 '16 at 14:45 ## awk, 17 bytes !$0||$0=$0<0?-1:1


Test it:

$echo 0 | awk '!$0||$0=$0<0?-1:1'
0
$echo 2 | awk '!$0||$0=$0<0?-1:1'
1
$echo -2 | awk '!$0||$0=$0<0?-1:1'
-1


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

# 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) – James Dec 24 '16 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).

# 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). – Olivier Grégoire Dec 24 '16 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 '16 at 19:12
• It can be reduced to this: i->i>0?1:i>>31 (14 bytes) – Kevin Cruijssen Jan 10 '17 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!