Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
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.
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\$
May 5, 2017 at 16:54
->n{-(-n^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!
lambda n:n+n%2*2-1
Explanation: Take the modulo of "n" and double it
Subtract that off the original "n" and subtract another 1
Basically, the same but easier to understand:
lambda n:n-(1-n%2*2)
,>,>,>,>,>,>,>+<<<<<<<+[>+]<[<]>+[>]+<[+<]>;>;>;>;>;>;>;
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
def f(n):return n+(-1)**(n%2+1)
lambda n:abs((-1)**n-n).
\$\endgroup\$
def f(n):return n+(-1)**(n%2+1) works
\$\endgroup\$
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
D1(sm-Ä
Explanation:
D1(sm-Ä
Input (implicit). Is 3 for example. Stack: [3]
D Duplicate input. Stack: [3, 3]
1 Push 1. Stack: [3, 3, 1]
( Push opposite of top of stack. Stack: [3, 3, -1]
s Swap the top 2 items on the stack. Stack: [3, -1, 3]
m Push -1**3. Stack: [3, -1]
- Subtract. Stack: [4].
Ä Absolute value. Stack: [4].
Implicit output.
=A1-(-1)^A1
Assumes input in A1.
%macro t(n);%put%eval(&n+%sysfunc(ifn(%sysfunc(mod(&n,2)),1,-1)));%mend;
I'm new to Pyth, so please tell me if there are any things I can golf.
_x1_
Explanation:
_ Negate input
x1 Bitwise XOR with 1
_ Negate
[a2]=iif(n mod 2=0,n-1,n+1)
:?a-(-1)^a
Saved a lot by using a different calculation.
Explanation:
: Get a number frm the cmd line as var a
? PRINT
a-(-1)^a a decreased by 1 for when even, or -1 (adding one) when odd.
QBasic (and QBIC) need the parenteses around (-1), because code like -1^2 is otherwise seen as negate 1*1 = negate 1 = -1...
