# I reverse the source code, you negate the input!

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.

• Why do we need a copy of the same question? – Christian Sep 18 at 7:30
• @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. – Adám Sep 18 at 7:32
• A yes, now I see the difference. One needs to read VERY carefully – Christian Sep 18 at 7:34
• If using a structured language like C#, are you just reversing lines? – PerpetualJ Sep 19 at 2:31
• @PerpetualJ No, look at the source like list of characters, some of which are line breaks. – Adám Sep 19 at 5:42

# Japt, 3 bytes

TnU


Same method as my earlier solution, with T being 0 and U being the input.

# V (vim), 5 bytes

É-ó--


Try it online!

Hexdump:

00000000: c92d f32d 2d                             .-.--


# Stax, 2 bytes

pN


Run and debug it

# Klein, 2 bytes

Works in all 12 topologies!

@-


Try it online!

# Reverse

-@


Try it online!

- negates the input and @ ends the program

# Ruby -p , 7+1 = 8 bytes

• I don't think you need the ^ at the end. Also, Retina 1 would save a byte on $*. – Martin Ender Sep 21 at 10:15 # BitCycle-U, 15 bytes First, a word about the -U flag. Internally, BitCycle only deals in 1's and 0's, so to allow working with decimal integers, it has flags to convert decimal input to unary. In particular, -U allows for signed integers by adding a 0 to the front of any nonpositive integer's unary representation: 4 is 1111, -4 is 01111, and 0 is 0. The same transformation is applied in reverse to the output, with the convenient addition that empty output is treated as 0. ### Forward ^> ?!+? <0/  Try it online! The leftmost ? gets the input, which goes straight into the ! to be output unchanged. ### Reverse  /0< ?+!? >^  Try it online! The leftmost ? gets the input. The + sends the leading 0 bit, if any, left (north), and the 1 bits right (south). If there is a leading 0 bit, it hits the splitter / and turns east, deactivating the splitter. The < sends it west again, through the deactivated splitter and off the playfield. The 0 bit that started on the playfield also hits the < and goes through the deactivated splitter and off the playfield. Meanwhile, the 1 bits are directed around by the > and ^ and reach the !, where they are output. If there is no leading 0 bit, the 0 bit that starts on the playfield hits the < and goes west to the splitter /. Since the splitter has not been deactivated, it directs the bit south, and the + sends it west into the output !. Meanwhile, the 1 bits are directed to the output, with enough delay to make sure they get there after the 0 bit. TL;DR: Nonpositive inputs have their leading 0 bit stripped and their magnitude is output. Positive inputs have a leading 0 bit added and are thus output as negative numbers of the same magnitude. • @JoKing That's clever! It's really different from mine; do you want to post it yourself? – DLosc Sep 24 at 17:00 • Posted – Jo King Sep 24 at 21:54 # BitCycle-U, 14 bytes < ^ v/?! +~ +  Try it online! And reversed + ~+ !?/v ^ <  Try it online! The -U flag translates input/output to signed Unary, i.e. unary 1s with a zero in front if the number is negative. The first program just pipes input (?) to the output (!) directly right of it. The reverse instead takes only the first bit of the number with the / command and dupnegs (~). If it is a 1 then it sends 0 left and 1 right, where the +s redirect them to join the flow to the output. If the first bit is 0 instead, the 0 goes right and the 1 goes left, and the + redirect them away from the output. All in all, this has the behaviour of stripping a leading zero if the input has one, otherwise prepending a zero if it doesn't, which means inverting the sign of the input. # PHP, 20 bytes <?=$argn;#;ngra\$-=?<


Try it online!

# Cubix, 5 bytes

@IO\n


Try it online!

Try it reversed!

# Lua, 23 bytes

print(...)--)...-(tnirp


Try it online!

Comment abuse all over again.

# -
&#


Try it online!

and reversed:

#&
- #


Try it online!

I think this is the optimal answer for this question. In order to negate the input, we have to use the - operator, which means the code must be at least three wide so the left and the right operands aren't the same. It must then be two tall to have not loop infinitely. That means at least one row must be three wide, and the other has to be two wide, since if it was one wide, it must be the redirect to the #, which would have to be directly under it. Feel free to prove me wrong though.

### Explanation:

For the initial program, we only execute # (integer output) on & (integer input). Basically, the only instructions that matter are:

#
&


For the reversed program, the # on the second line leads to - (left minus right). This wraps around the program, with the right being the &, and the left as an empty space, which is zero. This results in 0 - input, which is the negated input.