67
\$\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.

\$\endgroup\$
  • 45
    \$\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

141 Answers 141

0
\$\begingroup\$

Braingolf, 1 byte

s

Try it online!

Yep.

\$\endgroup\$
0
\$\begingroup\$

T-SQL, 36 bytes

CREATE PROC s @ INT AS PRINT SIGN(@)

Usage:

EXECUTE s -5464
\$\endgroup\$
0
\$\begingroup\$

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
\$\endgroup\$
0
\$\begingroup\$

Husk, 1 byte

±

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Implicit, 1 byte

±

Try it online!

After implicits, this program looks like:

$±%
$    read integer input
 ±   push sign
  %  print
\$\endgroup\$
0
\$\begingroup\$

REXX, 16 bytes

say sign(arg(1))
\$\endgroup\$
0
\$\begingroup\$

Add++, 9 bytes

L,d0<@0>_

Try it online!

How it works

L,  - Create a lambda.
           Example argument: -8
  d - Duplicate;    STACK = [-8 -8]
  0 - Push 0;       STACK = [-8 -8 0]
  < - Less than;    STACK = [-8  0]
  @ - Reverse;      STACK = [ 0 -8]
  0 - Push 0;       STACK = [ 0 -8 0]
  > - Greater than; STACK = [ 0  1]
  _ - Subtract;     STACK = [-1]
      Implicitly return      -1
\$\endgroup\$
0
\$\begingroup\$

Deorst, 11 bytes

i:l0<@l0>@-

Try it online!

Boring (n>0)-(n<0) solution

\$\endgroup\$
0
\$\begingroup\$

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

If you're interested, here is an article that talks more about this definition which is worth a read.

\$\endgroup\$
0
\$\begingroup\$

Yabasic, 16 bytes

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

input""n
?sig(n)

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Perl 5, 9 + 1 (-p) = 10 bytes

$_=$_<=>0

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Pyt, 1 byte

±

Try it online!

Boring built-in answer (padding for body length)

\$\endgroup\$
0
\$\begingroup\$

Lua (51 Bytes)

n=tonumber(...) print(n<0 and -1 or n>0 and 1 or 0)

... is the variable that represents arguments in lua, tonumber(...) converts the first argument to a number.

also in lua a and b or c is a structure that returns b if a is truthy or c if a is falsy, you can nest this structure as well

\$\endgroup\$
  • \$\begingroup\$ Answers should be either functions or full programs. This doesn't seem to be able to take input. N is also guaranteed to be an integer \$\endgroup\$ – Jo King Feb 17 '18 at 2:01
0
\$\begingroup\$

Stax, 2 bytes

:+

Run and debug online!

Explanation

Added for completeness. It is a builtin, but all built-ins starting with a colon in Stax is actually a macro defined using other Stax operations.

Internally it is defined as c0>s0<-, which is simply (x>0)-(x<0).

\$\endgroup\$
0
\$\begingroup\$

SHELL ( 20 Bytes )

sed s/[1-9][0-9]*/1/

tests:

echo "789" | sed s/[1-9][0-9]*/1/
1

echo "-789" | sed s/[1-9][0-9]*/1/
-1

echo "0" | sed s/[1-9][0-9]*/1/
0
\$\endgroup\$
0
\$\begingroup\$

Swift, 44 bytes

func s(i:Int)->Int{return i>0 ?1:i<0 ? -1:0}

Strange spacing around the ternary options, I know, but this was the shortest way.

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Brain-Flueue, 40 bytes

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

Try it online!

Readable version

{
 ([({})])
 {
  ({}())<>
  ([{}()()])<>
 }
}
(<>[]{})
\$\endgroup\$
0
\$\begingroup\$

MachineCode, 26 bytes

31c085ff0f9fc0c1ef1f29f8c3

Requires the i flag for integer output. Input must be appended to the code on a separate line. This is equivalent to the C code (n>0)-(n<0). Try it online!

Alternatives with the same bytecount:

  • 31c085ff0f95c0c1ff1f09f8c3 - Try it online! Equivalent to the highest voted C submission.
  • 89f8c1ff1ff7d8c1e81f01f8c3 - Try it online! Equivalent to this C code.
\$\endgroup\$
0
\$\begingroup\$

Gol><>, 11 bytes

I:0(qm$0)+h

Try it online!

How it works

I:0(qm$0)+h

I            Input as number
 :           Duplicate top
  0(         Change top to "top < 0"
    q        If top is true...
     m$      Push -1 and swap top two; the stack is [-1 x]
             Otherwise, skip two commands (m$); the stack is [x]
       0)    Change top to "top > 0"
         +   Add top two
          h  Print top as number and halt
\$\endgroup\$
  • \$\begingroup\$ How about I:0)$0(-h for 9 bytes \$\endgroup\$ – Jo King May 6 '18 at 20:21
0
\$\begingroup\$

Canvas, 3 2 bytes

⤢÷

Try it here!

This might be the shortest solution without a builtin that does the problem for you (I'm looking at you, Jelly.)

Explanation:
⤢÷ | *Full code*
 ÷ | Divide
   | The input (implicit)
⤢  | By its absolute value
\$\endgroup\$
  • 1
    \$\begingroup\$ Canvas doesn't interpret 0/0 as 0, it actually errors & removes the 2 items without pushing anything (though I'm about to change that as 0 makes much more sense than nothing). The reason that 0 is outputted is that the stack contains an infinite amount of the inputs. And because of that you can actually remove the for 2 bytes \$\endgroup\$ – dzaima May 5 '18 at 13:46
0
\$\begingroup\$

F#, 140 bytes

open Checked
let s n=
 if n=0 then 0
 else
  try
   let mutable p=n
   while p<>0 do
    p<-p+1
   -1
  with| :? System.OverflowException->1

Try it online!

Basically, if the number is non-zero, keep adding 1 to it until you get either 0 (so the original value was negative) or an overflow (so the original value was positive).

That's all right, isn't it?

\$\endgroup\$

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.