41
\$\begingroup\$

Blatant rip-off of a rip-off. Go upvote those!

Your task, if you wish to accept it, is to write a program/function that outputs/returns its integer input/argument. The tricky part is that if I reverse your source code, the output must be the original integer negated.

Examples

Let's say your source code is ABC and its input is 4. If I write CBA instead and run it, the output must be -4.

Let's say your source code is ABC and its input is -2. If I write CBA instead and run it, the output must be 2.

An input of 0 may give 0 or -0, however, if you do support signed zero, -0 should give 0.

\$\endgroup\$
5
  • 5
    \$\begingroup\$ Why do we need a copy of the same question? \$\endgroup\$
    – Christian
    Sep 18, 2019 at 7:30
  • 5
    \$\begingroup\$ @Christian That one outputs a constant number (and its negation) whereas this one has to take input and return/negate it. A very different job in a lot of languages. \$\endgroup\$
    – Adám
    Sep 18, 2019 at 7:32
  • 6
    \$\begingroup\$ A yes, now I see the difference. One needs to read VERY carefully \$\endgroup\$
    – Christian
    Sep 18, 2019 at 7:34
  • \$\begingroup\$ If using a structured language like C#, are you just reversing lines? \$\endgroup\$ Sep 19, 2019 at 2:31
  • \$\begingroup\$ @PerpetualJ No, look at the source like list of characters, some of which are line breaks. \$\endgroup\$
    – Adám
    Sep 19, 2019 at 5:42

61 Answers 61

24
\$\begingroup\$

J, 3 bytes

-&0

Try it online!

-&0 is "argument minus 0"

0&- is "0 minus argument"

\$\endgroup\$
2
  • 3
    \$\begingroup\$ this is really quite nice :) \$\endgroup\$ Sep 18, 2019 at 2:59
  • 3
    \$\begingroup\$ Clever, I didn't think of that one, but rather ][- etc. \$\endgroup\$
    – Adám
    Sep 18, 2019 at 5:35
19
\$\begingroup\$

PowerShell, 18 14 bytes

$args#"sgra$"-

Try it online! !enilno ti yrT

First of the trivial comment-abuse answers

\$\endgroup\$
2
  • 5
    \$\begingroup\$ Oh, God. Not this again. \$\endgroup\$
    – S.S. Anne
    Sep 17, 2019 at 19:57
  • 3
    \$\begingroup\$ "First of the trivial comment-abuse answers" Redeemed by the TIO links! \$\endgroup\$
    – Jonah
    Sep 18, 2019 at 22:06
15
\$\begingroup\$

JavaScript, 11 bytes

n=>n//n->=n

Try it Online! | Reversed

\$\endgroup\$
14
\$\begingroup\$

x86 machine code, 3 bytes

C3 D8 F7

The above bytes of code define a function that is a no-op: it simply returns control to the caller. That function is followed by two garbage bytes that will not be executed, since they come after a return—they are in "no man's land". In assembler mnemonics:

ret                     ; C3    
fdiv  st(0), st(7)      ; D8 F7

Okay, so now some troll comes by and reverses the order of the bytes:

F7 D8 C3

These bytes now define a function that takes an integer argument in the EAX register, negates it, and returns control to the caller. In assembler mnemonics:

neg  eax     ; F7 D8
ret          ; C3

So…that was simple. :-)

Note that we can make the "negation" instruction be anything we want, since it is never executed in the "forward" orientation and only executed in the "reversed" orientation. Therefore, we can follow the same pattern to do arbitrarily more complicated stuff. For example, here we take an integer argument in a different register (say, EDI, to follow the System V calling convention commonly used on *nix systems), negate it, and return it in the conventional EAX register:

C3      ret
D8 F7   fdiv  st(0), st(7)      ;  \ garbage bytes that
F8      clc                     ;  | never get executed,
89      .byte 0x89              ;  / so nobody cares

  ↓ ↓

89 F8   mov  eax, edi
F7 D8   neg  eax
C3      ret
\$\endgroup\$
12
\$\begingroup\$

Jelly, 2 bytes

oN

Try it online! and its reverse.

oN - (input) OR ((input) negated)

No - ((input) negated) OR (input)
\$\endgroup\$
2
  • \$\begingroup\$ Heh, you can also do ḷN, no need for the OR logic. :D \$\endgroup\$ Sep 17, 2019 at 21:54
  • 10
    \$\begingroup\$ Na, words give aN aesthetic effect :) \$\endgroup\$ Sep 17, 2019 at 22:05
8
\$\begingroup\$

Haskell, 8 bytes

Anonymous identity function, turning into subtraction from 0 when reversed.

id--)-0(

Try it online!

Reversed:

(0-)--di

Try it online!

\$\endgroup\$
2
  • 3
    \$\begingroup\$ You’ve managed to break the code highlighting with your reversed version! \$\endgroup\$
    – Tim
    Sep 19, 2019 at 9:57
  • \$\begingroup\$ @Tim Curious. Testing suggests it fails when a comment starts right after a right parenthesis. \$\endgroup\$ Sep 20, 2019 at 2:07
8
\$\begingroup\$

Whitespace, 48 bytes

S S S N
S N
S T N
T   T   T   T   T   T   N
S T N
N
N
T   S N
T   N
S S T   N
T   T   S S T   T   T   T   T   N
T   S N
S N
S S S 

Letters S (space), T (tab), and N (new-line) added as highlighting only.

Minor modification of my Whitespace answer for the I reverse the source code, you negate the output! challenge.

Try it online or try it online reversed (with raw spaces, tabs and new-lines only).

Explanation:

Utilizing the Exit Program builtin being a short palindrome NNN.
The regular program will:

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

The reverse program will:

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
SSTTN  # Push -1 to the stack
TSSN   # Multiply the top two values on the stack together
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

Small additional explanation of pushing a number:

  • First S: Enable Stack Manipulation
  • Second S: Push a number to the stack
  • S or T: Positive/negative respectively
  • Some S/T followed by a trailing N: number in binary, where S=0 and T=1

I.e. SSTTSTSN pushes -10. For the 0 we don't need an explicit S=0, so simply SSSN or SSTN is enough.

\$\endgroup\$
8
\$\begingroup\$

R, 23 bytes

I decided to give it a go without the comment trick.

Forward

`+`=scan;""+-0;nacs=`+`

Try it online!

Reverse

`+`=scan;0-+"";nacs=`+`

Try it online!

In the forward version + is acting a binary operator, and - is a unary operator.

In the reverse the + becomes unary and the - is binary. So scan function takes the arguments: file="" which means stdin and what=0, which are also defaults. So when the + is unary the first argument is on the right, when it is binary the first argument is on the left.

The

;nacs=`+`

part of the code does nothing really useful, so in a sense my code is not really very much more valid than using the comment trick.

\$\endgroup\$
1
  • 2
    \$\begingroup\$ This is very smart (+1). We often redefine the R operators to golf bytes, but I think this is the first time I have seen + redefined to be used as both unary and binary. It took me a minute to understand how this was parsed… No other operator name would have done the job. \$\endgroup\$ Sep 19, 2019 at 15:45
6
\$\begingroup\$

C (clang), 23 bytes

f(*x){}//};x*-=x*{)x*(g

Try it online!

\$\endgroup\$
5
\$\begingroup\$

Labyrinth / Hexagony, 6 bytes

Labyrinth:

?!@!`?

Try it online! and its reverse.

Hexagony:

?!@!~?

Try it online! and its reverse.

How?

?       - take a signed integer
(` / ~) - negate
!       - output top-of-stack / current-memory-edge
@       - exit
\$\endgroup\$
5
\$\begingroup\$

Perl 6 / Raku, 3 bytes

*-0

Try it online!

Creates a Whatever code block. Read in normally its standard block equivalent is -> \x {x - 0}, but in reverse it becomes -> \x {0 - x}.

\$\endgroup\$
5
\$\begingroup\$

Python 3, 22 bytes

lambda x:x#x-:x adbmal

Try it online!

A lambda which implements the identity function (or negation)

\$\endgroup\$
5
\$\begingroup\$

MarioLANG, 22 bytes

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

Try it online!

He just inputs and outputs the number before he falls to EOF

reversed:

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

Try it online!

He loops until the input value is 0 and the output value is -input, the he says the number.

\$\endgroup\$
5
\$\begingroup\$

Brain-Flak, 7 bytes

#)]}{[(

Try it online!

Reversed:

([{}])#

Try it online!

Note: Only works in interpreters that support comments (e.g. works in Rain-Flak, but not in BrainHack)


If we also swap opening/closing brackets instead of just reversing the bytes we can do this in 8 bytes without using comments:

({}[{}])

Try it online!
Try it reversed!

\$\endgroup\$
8
  • \$\begingroup\$ Is this undefined behaviour abuse? I don't think Brain-Flak specification allows such parenthesis. \$\endgroup\$
    – null
    Sep 18, 2019 at 14:06
  • \$\begingroup\$ @TwilightSparkle The # starts a comment, so the parenthesis in the original version are ignored. \$\endgroup\$
    – Riley
    Sep 18, 2019 at 14:08
  • \$\begingroup\$ Oh yeah, I forgot! But it only works in Rain-Flak then(It's the official intepreter though). You will probably need to mention it? \$\endgroup\$
    – null
    Sep 18, 2019 at 14:12
  • \$\begingroup\$ @TwilightSparkle added a note for clarification. Thanks. \$\endgroup\$
    – Riley
    Sep 18, 2019 at 14:21
  • \$\begingroup\$ Fun little challenge: Can you do this without comments if you also swap opening/closing brackets instead of just reversing? \$\endgroup\$
    – DJMcMayhem
    Sep 18, 2019 at 21:42
4
\$\begingroup\$

Haskell, 12 bytes

f=id;x-0=x f

Try it online! Reverse:

f x=0-x;di=f

Try it online!

Not as short as Ørjan Johansen's answer, but without comments.

\$\endgroup\$
4
\$\begingroup\$

Perl 5 (-p), 7 6 bytes

-1 thanks to @primo

$_*=$#

TIO

A comment doesn't change input

#1-=*_$

Negate the input

$_*=-1#

TIO

\$\endgroup\$
5
  • \$\begingroup\$ -1: $_*=$# TIO. Note that the # must be the very last byte of the program, otherwise it will be interpreted as the variable $#, rather than the last index of the array with name <empty>. \$\endgroup\$
    – primo
    Sep 18, 2019 at 16:32
  • 1
    \$\begingroup\$ however i don't understand how it works because trying to print $# gives either an error (if # is not the last character) or nothing \$\endgroup\$ Sep 18, 2019 at 18:08
  • \$\begingroup\$ Seems to only work with -p or -n. I suspect the boilerplate has something to do with it... \$\endgroup\$
    – primo
    Sep 19, 2019 at 11:26
  • 2
    \$\begingroup\$ @primo It works because -p/-n adds a ; after the code. Which means that $# is actually $#;: the size of the array @;. If the size of @; changes, the result isn't correct anymore (TIO). Anyway, this is super clever, well done! :) \$\endgroup\$
    – Dada
    Sep 20, 2019 at 15:31
  • \$\begingroup\$ that's the explanation could be seen with perl -MO=Deparse -p <(echo -n '$_*=$#'), because it seems perl -MO=Deparse -pe '$_*=$#' adds a newline \$\endgroup\$ Sep 21, 2019 at 6:18
4
\$\begingroup\$

Gaia, 2 bytes

_@

Try it online!

_	| implicit push input and negate
 @	| push next input OR push last input (when all inputs have been pushed)
	| implicit print TOS

Reversed:

@	| push input
 _	| negate
	| implicit print TOS
\$\endgroup\$
4
\$\begingroup\$

Backhand, 6 5 bytes

I@-Ov

Try it online! Try it doubled!

Made a little complex due to the nature of the pointer in Backhand. I don't think it's possible to get any shorter haha, turns out I was wrong. This duplicates no instruction and reuses both the input, output and terminate commands between the two programs. Now I think it is optimal, since you need all of the IO-@ commands to work, and in a 4 byte program you can only execute two of those commands.

Explanation:

The pointer in Backhand moves at three cells a tick and bounces off the boundaries of the cell, which means the general logic is overlapping. However you can manipulate this speed with the v and ^ commands.

The original program executes the instructions IO-@, which is input as number, output as number, subtract, terminate. Obviously the subtract is superfluous. In the code these are:

I@-Ov
^  ^    Reflect
  ^     Reflect again
 ^

The reversed program executes v-I-vO-@. The v reduces the pointer steps between ticks, and the - subtracts from the bottom of the stack, which is implicitly zero. The extra - commands do nothing. The program executes like

vO-@I
v       Reduce pointer speed to 2
  -     Subtract zero from zero
    I   Get input as number and reflect off boundary
  -     Subtract input from zero
v       Reduce pointer speed to 1
 O      Output as number
  -     Subtract zero from zero
   @    Terminate

\$\endgroup\$
4
\$\begingroup\$

R, 14 bytes

scan()#)(nacs-

Try it online!

A full program that reads a number, or reads and negates a number. The reverse functionality is protected by an inline comment

\$\endgroup\$
2
  • \$\begingroup\$ Your brackets are the wrong way around in the commented part. \$\endgroup\$ Sep 18, 2019 at 22:17
  • \$\begingroup\$ @AaronHayman thanks! \$\endgroup\$ Sep 18, 2019 at 22:29
4
\$\begingroup\$

Python 3, 22 14 bytes

int#__bus__. 0

Try it online!

Uses the int class's constructor and a built-in pseudo-private method.

\$\endgroup\$
2
  • \$\begingroup\$ Huh. Why is the space before the attribute mandatory? \$\endgroup\$
    – Jo King
    Sep 19, 2019 at 1:25
  • 2
    \$\begingroup\$ @JoKing 0. would be interpreted as a number, which is followed by a symbol \$\endgroup\$
    – att
    Sep 19, 2019 at 8:22
3
\$\begingroup\$

Wolfram Language (Mathematica), 9 bytes

1&0+#-0&1

Try it online!

Forward: read ((1)&*0+#-0)&*1=#&

Backward: read ((1)&*0-#+0)&*1=-#&

\$\endgroup\$
3
\$\begingroup\$

APL (Dyalog Unicode), 13 3 bytes

-∘0

Try it online!

Trivial answer. Returns arg or ¯arg.

Saved 10 bytes by not being dumb (thanks Adám).

Altered the resulting 3-byter to a more fitting function.

\$\endgroup\$
3
  • \$\begingroup\$ Whoa, this can be done trivially in three bytes! \$\endgroup\$
    – Adám
    Sep 17, 2019 at 20:31
  • \$\begingroup\$ Interestingly, you already have a 3-byte answer embedded as a substring of this. \$\endgroup\$
    – Adám
    Sep 18, 2019 at 9:01
  • \$\begingroup\$ @Adám yeah, I knew there was a simple answer in there somewhere. Thanks. \$\endgroup\$
    – J. Sallé
    Sep 18, 2019 at 12:54
3
\$\begingroup\$

Batch, 34 bytes

@ECHO.%1 2>MER@
@REM>2 1%=-aa/TES@

Echoes (ECHO.) the input (%1). The rest of the first line technically redirects STDERR to a file called MER@, but this isn't impactful.
Second line is commented out (REM...).

Reversed

@SET/aa-=%1 2>MER@
@REM>2 1%.OHCE@

Uses the arithmetic mode of the set command (SET /a) to subtract (-=) the input (%1) from an undefined variable (a) which is equivalent to 0 - input. Again, the rest of the first line technically redirects STDERR to a file called MER@, but this isn't impactful.
Second line is commented out (REM...).

\$\endgroup\$
2
  • \$\begingroup\$ This looks interesting. Care to explain? \$\endgroup\$
    – Adám
    Sep 25, 2019 at 5:34
  • \$\begingroup\$ @Adám Added an explanation, and also realised that I had the programs around backwards. \$\endgroup\$
    – Οurous
    Sep 25, 2019 at 6:34
3
\$\begingroup\$

Excel VBA, 12

?[A1]']1A[-?

Reversed:

?-[A1]']1A[?

Input is cell A1 of the ActiveSheet. Comments still work in the Immediate Window :)

\$\endgroup\$
2
  • 1
    \$\begingroup\$ I get what you are going for here, but I am pretty sure that you meant to answer ?[A1]']1A[-? \$\endgroup\$ Jan 3, 2020 at 12:53
  • \$\begingroup\$ @TaylorScott A good catch, oops \$\endgroup\$ Jan 3, 2020 at 15:52
3
\$\begingroup\$

Vyxal, 2 bytes

#N

Try it Online!

!enilnO ti yrT

#N is a comment, so nothing happens and the input is outputted unchanged.

N# negates the input, which is then outputted implicitly.

If you’re not a fan of using comments for something like this, the # can be replaced with any of ? , ₴ ⁰, etc.

\$\endgroup\$
2
\$\begingroup\$

05AB1E, 2 bytes

(I

Try it online!

Reversed

(    negates nothing
  I  pushes input

I    pushes input
  (  negates input
\$\endgroup\$
3
  • 1
    \$\begingroup\$ It is supposed to only negate the input in one direction, leaving it as-is in the other. Clearly, 1-character solution cannot be valid. \$\endgroup\$
    – Adám
    Sep 17, 2019 at 19:49
  • \$\begingroup\$ My bad, I misunderstood \$\endgroup\$
    – jasanborn
    Sep 17, 2019 at 19:52
  • \$\begingroup\$ Your answer has a couple mistakes. First of all, the explanation for (I is slightly flawed: it doesn't negate nothing, it negates the (implicit) input. But pushing the input with I means the output is the input instead. Your other problem is that both links you put link to I(. \$\endgroup\$
    – Makonede
    Apr 1, 2021 at 23:19
2
\$\begingroup\$

Befunge-98 (FBBI), 6 bytes

&.@.-&

Try it online! Try it reversed!

\$\endgroup\$
2
\$\begingroup\$

Klein, 2 bytes

Works in all 12 topologies!

@-

Try it online!

Reverse

-@

Try it online!

- negates the input and @ ends the program

\$\endgroup\$
2
2
\$\begingroup\$

Turing Machine Language, 39 bytes

The Positive

1 r - _ 0
0 l * * 0
0 - _ l 0
0 _ _ r 0

The Negative

0 r _ _ 0
0 l _ - 0
0 * * l 0
0 _ - r 1

This one was a bit trickier than I thought, mostly because I had to get past my prejudices of having code that runs with 'compile' errors.

\$\endgroup\$
2
\$\begingroup\$

><>, 5 4 bytes

n-r0

uses stack initialisation with the -v option, put your input variable there.

Try it online!

Or try the reversal

Explanation

n       Prints whatever is on the stack as a number
 -      Subtract the top 2 elements on the stack.
        There aren't 2 elements, so it crashes.
  r0    Never gets executed

or reversed:

0       Push a 0 onto the stack
 r      reverse the stack (now 0, -v)
  -     Subtract top 2 elements and push result (0-v, ie negated)
   n    Print as number
        The code wraps around and executes again. 
        It crashes on the - as there is only one
        item on the stack: 0.
\$\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.