Implement the `<=>` three-way comparison operator on numbers

Question

In C++, there exists a a <=> b three-way comparison operator that, for numerical types, does the following:

If a < b, then return a negative number.
If a = b, then return a (mathematically speaking) sign-less number.
If a > b, then return a positive number.

The Challenge

Implement the shortest full program, function, method, or custom operator such that, when given two numbers of the same type a and b,

If a < b, then return -1.
If a = b, then return 0.
If a > b, then return 1.

Notes

If you're writing in x86 assembly, this question may be of use to you.
This is code-golf, so shortest answer in bytes wins!

Do we have to handle all combinations of inputs? (I.e. can we assume that a - b will yield the arithmetic result, even when a is the lowest representable value and b is the highest?) — Toby Speight, Mar 20 at 13:15
@TobySpeight You will need to handle all combinations of inputs. — bigyihsuan, Mar 20 at 13:22
Note that the C++ 3-way comparison is actually "compares equal to 0" and "compares less than 0" and "compares greater than 0". 1 and -1 are explicitly not required, by design, unlike your ask. I only mention this because your first paragraphs are not true. — Yakk, Mar 21 at 14:57
If a language has support for multiple numeric types, such as integers and floating point numbers, does it need to support all of them? Basically every solution using subtraction and supporting floating point numbers doesn't work. — Tyilo, Mar 22 at 9:47
@Tyilo the original draft of this challenge in sandbox had a bonus for supporting multiple numeric types, but was cut because "bonuses are bad". Pick whichever numeric type leads to the shortest solution. — bigyihsuan, Mar 22 at 13:04

Nate Eldredge · Accepted Answer · 2023-03-22 02:11:39Z

AArch64 machine code, 16 bytes

AArch64's conditional select instructions get their time to shine.

0000000000000000 <spaceship>:
   0:   eb01001f    cmp x0, x1
   4:   9a9f07e0    cset x0, ne
   8:   da80a400    cneg x0, x0, lt
   c:   d65f03c0    ret

cset sets the destination register to 1 or 0 according to whether the condition code is true or false. (Fun fact: it's actually an alias for csinc x0, xzr, xzr, eq, where csinc X, Y, Z, cond sets X to Y if the condition is true, and to Z+1 if false.)

cneg X, Y, cond sets X either to -Y or Y according to whether the condition is true or false. (Alias for csneg X, Y, Y, cond.)

Several other permutations are also possible, such as

cset x0, gt              // x0 = (a > b) ? 1 : 0
csinv x0, x0, xzr, lt    // x0 = (a < b) ? x0 : ~0

orthocresol · Accepted Answer · 2023-03-23 13:58:03Z

2

Haskell, 24 23 bytes

a#b|a<b= -1|a>b=1|0<1=0

Try it online!

-1, thanks to Unrelated String!

The 'nicer' solution of ((pred.fromEnum).).compare is 26 bytes.

edited Mar 23 at 13:58

answered Mar 22 at 23:16

orthocresol

3611 silver badge5 bronze badges

1

\$\begingroup\$ True -> 0<1 for -1 \$\endgroup\$
– Unrelated String
Mar 23 at 1:40

Add a comment |

Deadcode · Accepted Answer · 2023-03-24 04:59:20Z

2

Lua, 45 bytes

load"a,b=...return a>b and 1or a<b and-1or 0"

Try it online!

Lua has a strict type system, and there is no shorter way than a and 1or 0 to convert a boolean to an integer.

This version works for all comparable types (e.g. integer, floating point, and string).

Lua, 35 bytes

load"a,b=...return-1+2/(0^(a-b)+1)"

Try it online!

This is based on my answer to Output the sign. It gives the correct result for all floating point inputs, and most integer inputs.

It doesn't meet the requirements of this challenge for integer inputs, as it will fail when passed, for example, math.maxinteger and math.mininteger (as demonstrated in the test harness), because subtracting one from the other results in an overflow. But it does fully work for all floating point inputs, thus meeting the challenge's requirements for that type.

edited Mar 24 at 4:59

answered Mar 22 at 11:07

Deadcode

11.4k63 silver badges50 bronze badges

\$\begingroup\$ You can save six bytes by taking in program arguments and printing out the answer instead of using the load function like this \$\endgroup\$
– bluswimmer
Apr 10 at 11:37
\$\begingroup\$ @bluswimmer Thanks, but I chose a function because it's a more elegant form of presentation, takes its input in an actual type instead of as strings, and can easily process more than one input in the test harness. I don't know if it's even possible to make a TIO or ATO test harness in Lua that demonstrates more than one input with a full program. So you could consider my choice of language is "Lua function", which means that a full program wouldn't beat it, since it wouldn't be in the same language. \$\endgroup\$
– Deadcode
Apr 10 at 16:43
\$\begingroup\$ @bluswimmer Case in point: The TIO you gave me is comparing the input as strings, not numbers. Without yet having tried it yet, I'm guessing a full program to compare numbers will actually be longer due to the need to convert the strings to numbers. \$\endgroup\$
– Deadcode
Apr 10 at 16:49

Add a comment |

att · Accepted Answer · 2023-03-24 06:23:50Z

2

Wolfram Language (Mathematica), 5 bytes

Order

Try it online!

Input Order[b, a]. Works on any atomic numbers.

Note the reversed order of inputs.

answered Mar 24 at 6:23

att

19.4k2 gold badges14 silver badges56 bronze badges

Add a comment |

James Flores · Accepted Answer · 2023-03-24 21:04:47Z

2

PowerShell, 19 bytes

[math]::Sign($a-$b)

Try it online!

answered Mar 24 at 21:04

James Flores

3714 bronze badges

Add a comment |

user117658user117658 · Accepted Answer · 2023-04-15 03:12:07Z

minigolf, 18 bytes

TiiT*+1+,:1+s,T+__

Attempt This Online! (Since minigolf is not properly added to ATO yet, I'm using a Python runner here.)

Explanation

We use -1 as the base of our output. If a-b >= 0, we increment -1 a-b+1 times. However, if our output reaches 2, we decrement it back to 1.

T                 0, Base our signum output on -1 _
iiT*+             0, a + b * -1 _
1+                0, increment the result _
,                 0, Repeat that many times: _
  :1+s            0, Increment signum but keep the original value _
                  0, This is useful because we only want to _
                  0, decrement once in the 2 case _
  ,               0, If our previous signum value is 1: do this once _
    T+            0, Add signum value by -1 _
  _               0, End foreach loop _
_                 0, End foreach loop _

0, Implicit output the signum value left on the stack _
```

\$\begingroup\$ Welcome to Code Golf, and nice answer/language! \$\endgroup\$
– Rydwolf Programs
Apr 15 at 3:13 — Rydwolf Programs, Apr 15 at 3:13

Jonathan Allan · Accepted Answer · 2023-03-20 00:13:08Z

1

Jelly, 2 bytes

_Ṡ

A dyadic Link that accepts \$a\$ on the left and \$b\$ on the right and yields \$a \lt = \gt b\$.

Try it online!

How?

_Ṡ - Link: a, b
_  - (a) subtract (b)
 Ṡ - sign -> -1, 0, or 1

answered Mar 20 at 0:13

Jonathan Allan

102k7 gold badges62 silver badges266 bronze badges

Add a comment |

ATaco · Accepted Answer · 2023-03-20 01:11:49Z

1

ARBLE, 25 15 bytes

lt(a,b)-gt(a,b)

Same as Arnauld's JS solution. Unfortunately Verbose, throwing away the advantages of the langauge.

Try it online!

edited Mar 20 at 1:11

answered Mar 20 at 0:49

ATaco

10.1k26 silver badges74 bronze badges

Add a comment |

noodle man · Accepted Answer · 2023-03-20 01:58:57Z

1

Japt, 2 bytes

gV

Try it

g   # sign of the difference of implicit first input and
 V  # second input

edited Mar 20 at 1:58

answered Mar 20 at 1:21

noodle man

3,9761 gold badge8 silver badges41 bronze badges

\$\begingroup\$ What does V do, then? \$\endgroup\$
– Seggan
Mar 20 at 1:55
1

\$\begingroup\$ @Seggan This program transpiles to the JS U.g(V), where U is the first input and V is the second \$\endgroup\$
– noodle man
Mar 20 at 1:56

Add a comment |

The Thonnu · Accepted Answer · 2023-03-20 07:29:23Z

1

Thunno, \$ 3\log_{256}(96)\approx\$ 2.47 bytes

_za

Attempt This Online!

Sign of a-b.

answered Mar 20 at 7:29

The Thonnu

17.5k3 gold badges13 silver badges73 bronze badges

Add a comment |

Fatalize · Accepted Answer · 2023-03-20 12:57:02Z

1

Brachylog, 2 bytes

-ṡ

Try it online!

Same answer as many other esolangs.

Explanation

-     Subtract
 ṡ    Sign

answered Mar 20 at 12:57

Fatalize

38.3k5 gold badges65 silver badges160 bronze badges

Add a comment |

G B · Accepted Answer · 2023-03-20 15:46:14Z

1

Ruby, 12 bytes

->a,b{a<=>b}

Try it online!

(feels like cheating)

answered Mar 20 at 15:46

G B

20.8k1 gold badge19 silver badges51 bronze badges

2

\$\begingroup\$ I suggest adding this to the CW for languages with the exact <=> operator. \$\endgroup\$
– Dominic van Essen
Mar 20 at 15:53
2

\$\begingroup\$ ->{_1<=>_2} is one byte shorter. \$\endgroup\$
– south
Mar 21 at 1:17
\$\begingroup\$ @south ->{_1<=>_2} doesn't seem to work when copy-pasted into TIO... \$\endgroup\$
– Dominic van Essen
Mar 21 at 9:05
\$\begingroup\$ TIO uses an out-of-date ruby version. Implicit block parameters were added after 2.5.5. \$\endgroup\$
– south
Mar 21 at 20:35
2

\$\begingroup\$ proc &:<=> is 10 bytes. \$\endgroup\$
– naffetS
Mar 22 at 3:54

Add a comment |

Ismael Miguel · Accepted Answer · 2023-03-20 23:27:53Z

simply, 8 bytes

Does exactly the expected.

&compare

This is a built-in function that simply returns the expected result.

Example:

Code-like

// Should output 1
echo &compare(2, 1);

Plain-English-like

// Should output -1
Show the result of calling &compare with the arguments 1, 2.

Test code:

This shows test results in a nice pretty table.

// Test data - self-explanatory
// Example 5 shows an error, as an example
$tests = &json_decode(<<<JSON
[
    {"a": 0, "b": 1, "result": -1},
    {"a": 1, "b": 2, "result": -1},
    {"a": 2, "b": 1, "result": 1},
    {"a": 2, "b": 2, "result": 0},
    {"a": 3, "b": 2, "result": 0}
]
JSON);

// Make the table pretty
$settings = call !TABLE->getDefaultSettings();
$settings->classHeader = &str_concat($settings->classHeader, " table-dark");
$settings->classBodyCell = &str_concat(
    $settings->classBodyCell,
    " text-center"
);
$settings->classBodyFirstCol = &str_concat(
    $settings->classBodyFirstCol,
    " text-center table-dark"
);
$settings->classHeaderItems = &str_concat(
    $settings->classHeaderItems,
    " w-25"
);

// Create the table
$table = call !TABLE->create($settings);

call $table->setHeader(["", "A", "B", "Result"]);

each $test in $tests {
    // This is where the function runs
    $result = &compare($test['a'], $test['b']);
    
    call $table->addRow(
        &iff(
            $result == $test["result"],
            "✔️",
            &str_concat("❌ (", $test["result"], ")")
        ),
        $test['a'],
        $test['b'],
        $result
    );
}

call $table->show();

Result:

This is an example of how the table will look like.

Aiden Chow · Accepted Answer · 2023-03-22 01:42:05Z

1

Desmos, 15 bytes

f(a,b)=sgn(a-b)

Try It On Desmos!

edited Mar 22 at 1:42

answered Mar 21 at 1:46

Aiden Chow

12.3k1 gold badge12 silver badges51 bronze badges

Add a comment |

SuperJedi224 · Accepted Answer · 2023-03-23 00:54:14Z

1

Binary-encoded Golfical, 27 bytes

Hexdump of binary encoding:

00 30 07 15 14 14 14 14 17 17 0c 01 14 14 14 17
00 01 02 01 1c 15 3b 4e 23 26 1d

Original program image:

enter image description here

Magnified 40x with RGB colors labeled:

enter image description here

Based on my answer here.

edited Mar 23 at 0:54

answered Mar 23 at 0:49

SuperJedi224

11.9k1 gold badge44 silver badges66 bronze badges

Add a comment |

AlephSquirrel · Accepted Answer · 2023-03-25 21:02:27Z

1

Common Lisp, 28 bytes

(lambda(a b)(signum(- a b)))

answered Mar 25 at 21:02

AlephSquirrel

4818 bronze badges

Add a comment |

NoLongerBreathedIn · Accepted Answer · 2023-04-01 22:52:34Z

MMIX machine language, 2 instrs (8 bytes)

For s64:

00000000: 30000001 f8010000                    0¡¡¢ẏ¢¡¡

Disassembled:

    CMP $0,$0,$1        // x = x <=> y
    POP 1,0             // return x

For u64:

00000000: 32000001 f8010000                    2¡¡¢ẏ¢¡¡

Disassembled, the only change is the first instruction is now CMPU.

For f64:

00000000: 01000001 f8010000                    ¢¡¡¢ẏ¢¡¡

And this time the first instruction is FCMP.

All of these functions are excellent candidates for inlining.

cnamejj · Accepted Answer · 2023-04-02 01:03:59Z

Ly, 14 bytes

nns=!rlLfp2*,*

Try it online!

Longer than I'd hoped, but I couldn't find a shorter way to do it given the instructions available...

nns             - read in two numbers, stash the second one away
   =!           - are they equal? invert result so "0" is set for equal
     rl         - reverse stack, recover the second number
       L        - do "less than" comparison
        fp      - delete the first number (it's still on the stack)
          2*,   - converts "0" to "-1" and "1" stays "1"
             *  - multiple by "are they equal?" val to get "0" as needed

The Empty String Photographer · Accepted Answer · 2023-04-06 16:27:12Z

1

Python, 31 Bytes

lambda a,b:(x:=a-b)and x/abs(x)

-7 Bytes from The Thonnu.

abs(x) gets the absolute value of x (think of it as scissors that can cut the - sign off numbers).

edited Apr 6 at 16:27

answered Apr 6 at 11:53

The Empty String Photographer

1,6694 silver badges23 bronze badges

\$\begingroup\$ I would recommend using either Try it online! or Attempt This Online! before submitting an answer. It allows you and others to test your program, and you can also copy the submission from there instead of writing it up yourself. \$\endgroup\$
– The Thonnu
Apr 6 at 13:18
1

\$\begingroup\$ Also, 32 bytes, or 31 bytes in Python 3.8+ \$\endgroup\$
– The Thonnu
Apr 6 at 13:21

Add a comment |

alephalpha · Accepted Answer · 2023-04-09 06:03:46Z

1

PARI/GP, 3 bytes

cmp

Attempt This Online!

answered Apr 9 at 6:03

alephalpha

45.5k7 gold badges57 silver badges169 bronze badges

Add a comment |

coredump · Accepted Answer · 2023-04-18 12:18:54Z

1

Common Lisp, 24 bytes

(compose'floor'signum'-)

This is the functional composition of functions floor, signum and -.

The signum function computes the sign and return the expected values, but for floating point values the result is also a float, either -1.0, -0.0, +0.0 or +1.0. That's why the floor operation is used to convert the result back to an integer.

answered Apr 18 at 12:18

coredump

6,76023 silver badges46 bronze badges

Add a comment |

Ferro Luca · Accepted Answer · 2023-04-18 14:21:40Z

1

Gaia, 1 byte

Try it online!

edited Apr 18 at 14:21

answered Apr 18 at 14:19

Ferro Luca

2014 bronze badges

Add a comment |

The Thonnu · Accepted Answer · 2023-05-27 07:29:11Z

1

Thunno 2, 1 byte

ṛ

Attempt This Online!

Built-in. Inputs in reverse order, b then a. Requires \$\le 2.2.0\$, as this was changed in Thunno \$2.2.1\$.

Thunno 2, 2 bytes

_ʂ

Same as most other answers: sign of a-b. Inputs in normal order, a then b. Works in all versions.

Attempt This Online!

edited May 27 at 7:29

answered May 2 at 12:53

The Thonnu

17.5k3 gold badges13 silver badges73 bronze badges

Add a comment |

chunes · Accepted Answer · 2023-03-20 15:22:54Z

0

Arturo, 7 bytes

compare

Try it

Builtin.

(In Arturo, <=> is the between operator. 5 <=> 1 10 would return true.)

Arturo, 33 bytes

$[a b][(a>b)?->1->(a=b)?->0->0-1]

Try it

Non-builtin.

Arturo doesn't have a sign function or integer booleans, so I couldn't think of anything better than a nested ternary.

answered Mar 20 at 15:22

chunes

20.8k3 gold badges19 silver badges49 bronze badges

Add a comment |

chunes · Accepted Answer · 2023-03-21 22:35:04Z

0

Factor, 9 bytes

[ - sgn ]

Try it online!

Sign of difference. Factor has a <=> word, but it returns +lt+, +eq+, and +gt+ symbols.

answered Mar 21 at 22:35

chunes

20.8k3 gold badges19 silver badges49 bronze badges

Add a comment |

Dadsdy · Accepted Answer · 2023-05-30 05:40:38Z

0

Desmoslang Assembly, 5 Bytes

I-IOT

I belive you had said that any negative or positive number works.

edited May 30 at 5:40

answered May 30 at 5:33

Dadsdy

1,9953 silver badges24 bronze badges

Add a comment |

Implement the `<=>` three-way comparison operator on numbers

The Challenge

Notes

56 Answers 56

AArch64 machine code, 16 bytes

Haskell, 24 23 bytes

Lua, 45 bytes

Lua, 35 bytes

Wolfram Language (Mathematica), 5 bytes

PowerShell, 19 bytes

minigolf, 18 bytes

Explanation

Jelly, 2 bytes

How?

ARBLE, 25 15 bytes

Japt, 2 bytes

Thunno, \$ 3\log_{256}(96)\approx\$ 2.47 bytes

Brachylog, 2 bytes

Explanation

Ruby, 12 bytes

simply, 8 bytes

Example:

Code-like

Plain-English-like

Test code:

Result:

Desmos, 15 bytes

Binary-encoded Golfical, 27 bytes

Common Lisp, 28 bytes

MMIX machine language, 2 instrs (8 bytes)

Ly, 14 bytes

Python, 31 Bytes

PARI/GP, 3 bytes

Common Lisp, 24 bytes

Gaia, 1 byte

Thunno 2, 1 byte

Thunno 2, 2 bytes

Arturo, 7 bytes

Arturo, 33 bytes

Factor, 9 bytes

Desmoslang Assembly, 5 Bytes

Your Answer

Sign up or log in

Post as a guest

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

Linked

Related

Hot Network Questions

Not the answer you're looking for? Browse other questions tagged
code-golf
number
comparison
or ask your own question.