Given a positive integer n, output n+1 if n is odd, and output n-1 if n is even.
A positive integer. You may assume that the integer is within the handling capability of the language.
A positive integer, specified above.
input output
1 2
2 1
3 4
4 3
5 6
6 5
7 8
8 7
313 314
314 313
This is code-golf, so shortest answer in bytes wins.
Standard loopholes apply.
{$1+=$1%2*2-1}1
I could save 1 byte by using (-1)^$1, but then it would be pretty much the same as everyone else, and this is what I came up with before looking at other answers. :)
=A1-(-1)^A1
Assumes input in A1.
lambda n:n+(n&1)*2-1
print x%2?x+1:x-1
Just substitute x for desired number. Try it online here -> https://tio.run/nexus/groovy and copy the code.
kv (or jv if it is strictly 1 or 0) instead of #v_. Also, if you are using Try it online (and I recommend it), you can end the program with another & (although it will take 60 seconds), so you can get rid of the @ on the first line if you use that. here is the full list of commands for Befunge-98, although they might not all be correctly implemented in TIO, like & ending the program instead of reversing on EOF.
\$\endgroup\$
Commented
May 5, 2017 at 16:54
->n{-(-n^1)}
:-@|:^&1|:-@
:-@| negate n
:^&1| XOR it with 1
:-@ negate that
With a change I just pushed to GitHub (inspired by this question, but overall useful), it becomes 10 bytes:
:-|:^&1|:-
* *
A~#-#a
B~#~#b
C~#~#c
D~#~#d
E~#~#e
F~#~#f
G~#~#g
H~#~#h
Since Chip natively handles only byte-sized integers, this solution reads in and writes out bytes. The TIO is set up to use the \x00 notation for this.
This Chip solution uses a straightforward approach where the columns are the operations, and the rows are for each bit:
Read in an octet
|Invert all bits
||Increment
|||Invert all bits except the lowest bit
||||Increment
|||||Output the octet
||||||
* *
A~#-#a
B~#~#b
C~#~#c
D~#~#d
E~#~#e
F~#~#f
G~#~#g
H~#~#h
Uses the 000 topology.
:(1-(\))++@
1-+:?\)-(
The first bit executed is :(1-(. This puts a copy of the input and a -1 in the scope to be recalled later. This is just required set up for future computation.
The two mirrors \\ then move the ip down a level into the main loop. The main loop, unfolded, is:
)-(1-+:?\
This recalls the first number of the scope and flips its sign then decrements the tos. It will continue to flip the sign back and forth until it reaches zero. This way it will be -1 if our input was even and 1 if it was odd. Once the counter has reached zero ? stops jumping over the mirror and the pointer wraps around to the top. Now the mirror we used earlier deflects the ip to the right causing it to run the code ))++@.
This code recalls the two things from the scope (the copy of the input and the number we have been flipping) with )). And adds the top three items with ++. Since the counter is at zero the result is just the sum of the number we built and the input. Since it can be either -1 or 1 depending on the parity of the input this will flip the sign of the input.
Finally @ ends execution.
;o[++]-:
; reads a number, o[++] increments twice if the number is odd, -decrements once, : prints.
edit: changed to p to o to retrofit to a breaking change in the language.
piecewise(mod(n,2),1,-1)+n
26 bytes for the function, +1 to enter n in the parameters box.
n:2%2*+,
Explanation:
n:2%2*+,
n # take input
:2% # modulo two
2* # multiply by two
+ # add to input
, # decrement
(load library
(q((N)((i(odd? N)a s)N 1
Try it online! (Adds 4 bytes to bind the lambda function to a name for ease of testing.)
(load library)
(lambda (N)
((if (odd? N) add2 sub2) N 1))
Pretty straightforward implementation of the spec: if N is odd, add 1 to N; if not, subtract 1 from N. The main trick is that the if needs only swap out which function we're calling (addition vs. subtraction); the arguments (N and 1) are the same in either case.
Binary:
00000000: 4834 0140 c3 H4.@.
Listing:
48 DEC AX ; decrement input (parity now inverted)
34 01 XOR AL, 1 ; if LSb is 0 (odd input) add 1, otherwise subtract 1
40 INC AX ; increment
C3 RET ; return to caller
Callable function, input/output is AL.
Explanation:
Classic XOR shenanigans to accomplish this equivalent if/else pseudocode:
AL = AL - 1
if ( AL & 1 == 0 ) AL = AL + 1
else AL = AL - 1
AL = AL + 1
Edit:
Well heck:
Silly me for not looking at existing submissions before starting. This approach was suggested by Ilmari Karonen in 2017!
,>,>,>,>,>,>,>+<<<<<<<+[>+]<[<]>+[>]+<[+<]>;>;>;>;>;>;>;
Yes, a real solution using Boolfuck.
Works on 7-bit integers, reads and writes in raw semibytes.
There might still be some optimization room here.
I mostly wanted to avenge my ,+; meme.
,>,>,>,>,>,>, read 7 bits
>+<<<<<<<+[>+]<[<]> decrement
+ xor 1
[>]+<[+<] increment
>;>;>;>;>;>;>; print
/O\.2%2v
@M/+t* <
/M\.2%2*t+/O@
/M\ # Reads an argument and put it on the slack
.2%2*t+ # Calculates input + (input mod 2) * 2 - 1
/O@ # Prints the top of the stack and exit
s/^/%/ #insert % at begining
s/../&%/g #put % after char pairs
s/.%.$// #if odd, delete 2 chars
s/%//g #remove the percents
takes input as any unary char other than %.
a(int b){return b%2?b+1:b-1;}
@cmd/cset/a"-(1^-%1)
Independently rediscovered @feersum's algorithm, honest!
I~x^ox%2{0}{@xvo}
Explanation:
I~x - Stores input in a variable called x
x^o - Increments x and outputs
x%2{0}{ } - If x mod 2 == 0, do code inside brackets
@ - Clear screen
xvo - Decrements x and outputs
