iHateOddNumbers

Question

Task

Given a non-negative number, check if it's odd or even. In case it's even, output that number. Otherwise, throw any exception/error that your language supports, and stop the program.

Example with Python

Input: 1
Output:

Traceback (most recent call last):
  File ".code.tio", line 1, in <module>
    IfYouWantThenThrowThis
NameError: name 'IfYouWantThenThrowThis' is not defined

Another example

Input: 2
Output: 2

Rules

• This is code-golf, so the answer with shortest bytes wins.
• These loopholes are, obviously, forbidden.
• Standard code-golf rules apply.
• Please specify the language you are using and the amount of bytes.
• It would be great if you would put a link to a sandbox where your code can be ran in action, such as TIO.
• Explaining your code is very welcomed.

---

LEADERBOARD

<script>var QUESTION_ID=229052,OVERRIDE_USER=0;</script><style>body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script>var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(d){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(d,e){return"https://api.stackexchange.com/2.2/answers/"+e.join(";")+"/comments?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){answers.push.apply(answers,d.items),answers_hash=[],answer_ids=[],d.items.forEach(function(e){e.comments=[];var f=+e.share_link.match(/\d+/);answer_ids.push(f),answers_hash[f]=e}),d.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){d.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),d.has_more?getComments():more_answers?getAnswers():process()}})}getAnswers();var SCORE_REG=function(){var d=String.raw`h\d`,e=String.raw`\-?\d+\.?\d*`,f=String.raw`[^\n<>]*`,g=String.raw`<s>${f}</s>|<strike>${f}</strike>|<del>${f}</del>`,h=String.raw`[^\n\d<>]*`,j=String.raw`<[^\n<>]+>`;return new RegExp(String.raw`<${d}>`+String.raw`\s*([^\n,]*[^\s,]),.*?`+String.raw`(${e})`+String.raw`(?=`+String.raw`${h}`+String.raw`(?:(?:${g}|${j})${h})*`+String.raw`</${d}>`+String.raw`)`)}(),OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(d){return d.owner.display_name}function process(){var d=[];answers.forEach(function(n){var o=n.body;n.comments.forEach(function(q){OVERRIDE_REG.test(q.body)&&(o="<h1>"+q.body.replace(OVERRIDE_REG,"")+"</h1>")});var p=o.match(SCORE_REG);p&&d.push({user:getAuthorName(n),size:+p[2],language:p[1],link:n.share_link})}),d.sort(function(n,o){var p=n.size,q=o.size;return p-q});var e={},f=1,g=null,h=1;d.forEach(function(n){n.size!=g&&(h=f),g=n.size,++f;var o=jQuery("#answer-template").html();o=o.replace("{{PLACE}}",h+".").replace("{{NAME}}",n.user).replace("{{LANGUAGE}}",n.language).replace("{{SIZE}}",n.size).replace("{{LINK}}",n.link),o=jQuery(o),jQuery("#answers").append(o);var p=n.language;p=jQuery("<i>"+n.language+"</i>").text().toLowerCase(),e[p]=e[p]||{lang:n.language,user:n.user,size:n.size,link:n.link,uniq:p}});var j=[];for(var k in e)e.hasOwnProperty(k)&&j.push(e[k]);j.sort(function(n,o){return n.uniq>o.uniq?1:n.uniq<o.uniq?-1:0});for(var l=0;l<j.length;++l){var m=jQuery("#language-template").html(),k=j[l];m=m.replace("{{LANGUAGE}}",k.lang).replace("{{NAME}}",k.user).replace("{{SIZE}}",k.size).replace("{{LINK}}",k.link),m=jQuery(m),jQuery("#languages").append(m)}}</script><link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> 

Answer 1

Python 2, 16 bytes

lambda n:n<<n%-2

Try it online!

The expression n%-2 equals 0 for even n and -1 for odd n. Bit-shifting n by 0 positions leaves it unchanged, but for -1 positions it gives an error for "negative shift count".

Answer 2

Jelly, 3 bytes

MḂ¡

Try it online! (even) and Try it online! (odd)

How it works

M is an atom meaning "Given a list, yield the indices of that maximal elements". Now, typically, when given integer arguments to its array functions, Jelly promotes them to either a range, to digits, or just wraps it. Unfortunately, (I'm guessing due to M's age - it was one of the earliest builtins in Jelly), M doesn't do this, and throws an error as it can't iterate over an integer.

How the code actually works:

MḂ¡ - Main link. Takes N on the left
 Ḃ  - Bit; Calculate N % 2
  ¡ - Do the following a number of times equal to N % 2:
M   -   Run the M builtin on N

If the input N is even, then Ḃ yields 0 and ¡ runs M on N 0 times i.e. an identity function.

If the input is odd, then Ḃ yields 1 and ¡ runs M once, which is enough to error it

Answer 3

Hexagony, 13 bytes

?#\.@!:.!_@\|

Try it online!

Expanded: (Made using Hexagony Colorer)

This code is built around Hexagony's # operator. Hexagony initializes with 6 IP's, 1 in each corner of the code box, with the 0th one, the one in the top left, being active in the beginning. The # operator takes the value of the current memory cell mod 6, and then sets the corresponding IP as the active one. So making an even/odd checker is a matter of using the # operator and then having IP's 1,3, and 5 perform the 'odd' action, and IP's 0,2, and 4 perform the 'even' action. The consequence of doing it this way is that there are 6 separate paths that each need to be mapped to the correct endpoint, hence the mess of paths. In this case, the odd action is : (attempt to divide two non-existent values, resulting in a divide by zero error) and the even action is !@ (print and terminate). To make it hopefully a bit more readable, here's a very low-tech drawing of the paths:

The paths are:

• n%6 == 0 : Green
• n%6 == 1 : Yellow
• n%6 == 2 : Blue
• n%6 == 3 Pink
• n%6 == 4 : Orange
• n%6 == 5 : Red

I'm pretty confident 12 bytes is possible, and potentially even shorter. Not sure if there's a better approach entirely, but with this method, it seems just about brute-force-able. It seems it should only require ?,#, no more than 3 each of @,!, and :, and some control flow characters.

Answer 4

x86 Machine Code, 5 bytes

A8 01 74 01 F4

Takes the integer value of your choice in the EAX register, halts the CPU if the number is odd, or continues execution harmlessly if the number is even.

Ungolfed assembly language mnemonics:

A8 01         test   al, 1
74 01         jz     IsEven
F4            hlt
          IsEven:

The first two instructions (test+jz) are the fastest and smallest way to check whether an integer value is even or odd in x86 machine code. The reason they work is hopefully obvious: for binary numbers, the least-significant bit (bit 0) is only set if the number is odd (for even numbers, the least-significant bit is clear). Therefore, testing the least-significant bit and seeing if it is non-zero is the easiest, simplest, smallest, and fastest way to see whether a number is even.

Here, I've used jz to jump if the zero flag (ZF) is set—i.e., if the bit we tested (bit 0) was zero, which means that it jumps if the number was even. Note that it jumps over the halt (hlt) instruction if the input value was even. If the input value was odd, then execution falls through the jump, and ends up halting the CPU.

If you don't like hlt because you don't think that counts as throwing an exception/error, then replace it with an int 3 instruction, which is also only 1 byte (0xCC), and thus doesn't change the overall code size (5 bytes). The int 3 instruction is the trap to a debugger.

The only way you could really argue that this code is cheating is that it doesn't "output" that number. I'd say it does: it allows execution to continue past the point where that number was generated, which is a lot like outputting it. You don't get any output for odd inputs; you can only get output for even inputs. Besides that, I think this is allowed by many, many different agreed-upon input/output methods.

---

x86 Machine Code, 6 bytes (non-competing)

A division by 0 is another obvious solution, but it doesn't save any bytes. Even if you are willing to allow clobbering the input value, in order to arrange for a division by zero, you have to negate somewhere (either the original value, or the isolated LSB), and that requires an extra instruction (either XORing with 1, or a NOT), which means 2 extra bytes.

A8 01         test   al, 1
34 01         xor    al, 1
F6 F0         div    al

That's 6 bytes, and I'm not even sure that I can figure out how to justify this clobbering of the original input value as being consistent with the requirements of the challenge to "output" the value.

To avoid clobbering, there are a few different options. For example, we can stipulate that the input is taken in a different register (say, ECX). But this means that we can't use the short "implied accumulator" encoding of test and xor, so it costs us at least two bytes. (We could use not with the full register before the test to invert the bits, which is encoded in only 2 bytes, but that defeats the point, which is to avoid clobbering the input.) Or, we could push and pop the input, but that also costs two extra bytes (one for each, push and pop). Maybe I'm missing something obvious, but I'm not seeing a better solution here.

Answer 5

Java (JDK), 10 bytes

n->n/=~n&1

Try it online!

Explanations

This code basically divides by zero when the input number is odd or by one when it is even.

~n

The ~ character negates each bit of n because n&1 returns 0 when n is even and 1 when it's odd, but we want the opposite: 0 when odd (to make it fail) and 1 when even to return it, so ~ is the easiest way to negate the last bit.

~n&1

This is the part that reduces n to either 0 or 1. ~n&1 is not exactly the same as ~n%2 because, in Java, %2 keeps the signum of n, and since we definitely swap the signum with ~, we'd always end up with negative number, not matter what n is: if n<0 we'd get negative divided by positive, and if n>=0, we'd get positive divided by negative.

We want to divide by 0 or by 1, nothing else. Only &1 can guarantee that. No matter what, the operator priority will first evaluate ~n so no parenthesis are required.

/=

This bit is weird. Why do we do divide and assign, instead of just dividing? Technically, n/~n&1 will be parsed as x=n/~n then x&1. This is not the behavior we want: n/~n is always equal to 0. What we want is to have n/(~n&1). It could work well, but the whole answer would be n->n/(~n&1). The /= operator is a shortcut to that as it evaluates the right-hand side entirely, so we can get rid of parenthesis, gaining one byte. Assigning is a side effect we can live with.

Answer 6

MATLAB/Octave, 17 13 12 bytes

-4 bytes thanks to Sisyphus

@(x)x(i^2^x)

Try it online!
Anonymous function. Throws indexing error for odd numbers.

This function returns element from input at index i^2^x = (-1)^x, so

• at index 1 for even numbers (which is input itself)
• at index -1 for odd numbers (which is invalid index since indices in MATLAB start at 1)

Answer 7

Wolfram Language (Mathematica), 10 bytes

I think this uses an approach that isn't yet represented in the other answers.

–1 byte thanks to att!

#+0^I^#^2&

Try it online! Here I represents the imaginary number i. Since the square of every even number is a multiple of 4, I^#^2 equals 1 when the input is even, and so 0^I^#^2 becomes \$0^1\$ which is a perfectly nice 0 to add to the input. However, since the square of every odd number is one more than a multiple of 4, I^#^2 equals i when the input is odd, and so 0^I^#^2 becomes \$0^i\$ which throws an "Indeterminate expression " error.

first submission: 11 bytes

#+0^(-1)^#&

Try it online! Since –1 to an even power equals 1, 0^(-1)^# becomes \$0^1\$ when the input is even, which is a perfectly nice 0 to add to the input; however, since –1 to an odd power equals –1, 0^(-1)^# becomes \$0^{-1}\$ (the reciprocal of 0) when the input is odd, which throws an error.

Answer 8

Vyxal, 2 bytes

₂ḭ

Try it Online!

-1 thanks to Aaron Miller

₂  # Is_even(n) (Vyxal has no booleans, only 0 and 1)
 ḭ # Integer division (ordinary division doesn't error on 0)

Answer 9

PowerShell, 31 25 14 19 bytes

-6 bytes thanks to @mazzy

param($n)$n/!($n%2)

Try it online!

Calculates the modulo of the input number and 2, implicitly converts the result to a boolean in order to negate it, then divides the input number by the negation. Inadvertently ditched the spec for a while there, sorry!

Answer 10

R, 20 bytes

n=scan();n+(n%%2&&a)

Try it online!

The && operator is logical AND, evaluating left to right until the result is determined. If n is even then n%%2 is 0, coerced to FALSE, and the a part of the expression is therefore not evaluated. We then output n+0, ie n.

If n is odd, then n%%2 is 1, coerced to TRUE, and we need to evaluate the a part of the expression to determine the result of n%%2&&a. Since a is undefined, this produces an error.

This strategy comes out 3 bytes shorter than Dominic's strategy with if.

Answer 11

Python 2, 17 bytes

lambda n:n/(~n%2)

Try it online!

thanks to @hyper-neutrino for -4 bytes

Python 3, 24 bytes

lambda n:n%2and 1/0 or n

Try it online!

Answer 12

JavaScript (Node.js), 10 bytes

n=>n%2?_:n

Try it online!

Not a very hard answer

Answer 13

MMIX, 12 bytes (3 instrs)

ihateodds   PBEV  $0,0F     // if(n even) goto ret;
            LDVTS $0,$0,6   // privileged instruction
0H          POP   1,0       // ret: return n

The LDVTS tries to make whatever memory page the input points to RWX in the cache, though not in the page table (if the input is one more than a multiple of 8). This is a privileged instruction for obvious reasons.

Answer 14

Python 3, 17 bytes

lambda x:[x][x%2]

Try it online!

It's very simple - construct a list with a single (zeroth) number and take an element of it with index equal to that number modulo 2. Since there is no element 1, it will obviously throw an exception on odd input.

Answer 15

PHP, 14.

die($argv[0]);

There's no need to differentiate odd and even. The criteria say odd numbers can display any error, while even ones should be displayed.

Since the criteria allow for ANY error on an even number, and die() displays an error and terminates, the input is fine as an error.

The criteria allow for even numbers to be displayed in any manner, including as an error, so again, the input is fine as an error.

But if die() isn't accepted as an error, and a genuine terminating error's required... 27 26 bytes. Sadly we can't use die() here...

echo($a=$argv[1])%2?$b:$a;

If warnings are acceptable as errors, then in the comments Matthew Anderson's suggestion to use division by zero also gives us 26 bytes:

echo($a=$argv[1])/!($a%2);

Answer 16

Factor, 15 bytes

[ 2 / 1 shift ]

Try it online!

Thanks to @umnikos

Factor, 19 bytes

[ dup 1 + 2 mod / ]

Try it online!

Throws a divide by zero error on odd numbers, while returning even numbers.

Explanation:

• dup Duplicate the input.

  Stack: (e.g.) 2 2

• 1 + Add one.

  Stack: 2 3

• 2 mod Modulo two.

  Stack: 2 1

• / Divide. (Here is where the error happens for odd input.)

  Stack: 2

Here's a slightly longer version that simply asserts the number is not odd:

[ dup odd? f assert= ]

Answer 17

Retina 0.8.2, 13 bytes

+`[13579]$
99

Try it online! Explanation: If the number is odd, simply keeps appending 9s until Retina eventually runs out of memory, or until TIO kills it, whichever is sooner.

If you want a more direct error, then for 21 bytes:

[13579]$
9999999999$*

Try it online! Explanation: Tries to append more than a 32-bit integer length of 9s to the odd input, which throws an OverflowException.

Answer 18

Wolfram Language (Mathematica), 13 bytes

#/Mod[#+1,2]&

Try it online!

-1 byte from @att

Answer 19

APL (Dyalog Unicode), 7 bytes (SBCS)

Anonymous tacit prefix function

⊢÷1-2|⊢

Try it online!

⊢ the argument

÷ divided by

1- one minus

2| the division remainder when 2 divides

⊢ the argument

Or in other words:$$x\over{1-\Big({x\over2}-\big\lfloor{x\over2}\big\rfloor}\Big)$$

Answer 20

Perl 5 -p, 9 bytes

$_%2&&die

Try it online!

Answer 21

Japt, 6 5 bytes

Throws a TypeError an overflow error on odd numbers. Still convinced there must be a much shorter way 🤔 /v would work if JavaScript errored on division by 0.

*v ªß

Try it

*v ªß     :Implicit input of integer
*         :Multiply by
 v        :  Divisible by 2?
   ª      :Logical OR with
    ß     :A recursive call

Answer 22

R, 25 23 22 bytes

Edit: -2 bytes after looking at ophact's answer, and then -1 byte thanks to Robin Ryder

`if`((n=scan())%%2,,n)

Try it online!

Throws an 'argument is missing' error when n is odd and the if expression tries to read the missing expression that should be between the two commas.

Answer 23

C (gcc), 28 15 14 bytes

-13 thanks to Jonathan Allan
-1 thanks to Olivier Grégoire

f(a){a/=~a&1;}

Try it online!

How ~a&1 works is explained in this solution.

Answer 24

AWK, 11 10 bytes

1/($1%2-1)

Try it online!

Thanks to tail spark rabbit ear for helping drop one char...

Divides by zero if the number is odd, otherwise the test is truthy and the default action prints the commandline..

Answer 25

05AB1E, 3 bytes

Èи¿

Try it online!

or

È×F

Try it online!

È checks if the input is even. Returns 1 for even numbers, 0 for odd numbers.

• и creates a list of this many copies of the input, and ¿ calculates the gcd of the list and throws an error for empty lists
• × repeats the input as a string this many times. This results in the input for even inputs and the empty string for odd inputs. F is a for loop which crashes if it gets the empty string as an argument. In the end the stack is empty and the input is implicitly printed. F could be any of E, F, G and ƒ.

Answer 26

Zsh (math function), 14 bytes

((1/1&~$1,$1))

Try it online!

Unlike in Bash, C and many other languages, in Zsh & binds more tightly than / by default, allowing us to get division by zero on odd numbers with just 1 / 1 & ~$1.

(Zsh does have a C_PRECEDENCES option which changes arithmetic binding to the traditional order.)

Answer 27

Jelly, 4 bytes

ḂNXo

Try it online!

Jelly, 5 bytes

%2NXo

Try it online!

Look ma, no unicode!

ḂNXo  Main Link
Ḃ     Same thing as %2. 1 if it's odd, 0 if it's even.
 N    Negate. -1 if it's odd, 0 if it's even.
  X   Random number. Errors with -1 as input, returns 0 with 0 as input.
   o  Logical OR. If the input was odd, the program's already errored. Otherwise, it's 0,
      so logical OR gives the right value, which is the input.

Unfortunately, since dividing by zero isn't actually an error in Jelly, I cannot use that. Although, it wouldn't save me any bytes: %2C:@ is the same length.

Answer 28

><>, 7 bytes

:2%?Cn;

The input should be put onto the stack using the -v command-line argument.

Try it even!
Try it odd!

---

Explanation:

Initially, the stack contains the input number, \$ n \$.

• : duplicates the top of stack: [\$n\$, \$n\$]
• 2 pushes \$2\$ onto stack: [\$n\$, \$n\$, \$2\$]
• % pops two values and pushes their modulo: [\$n\$, \$n \% 2\$]
• ? pops the top value, and if it is \$0\$, the next instruction is skipped: [\$n\$]

If \$n \% 2 \neq 0\$:

• C is not a valid instruction, so the program crashes.

If \$n \% 2 = 0\$:

• n pops off the top value (\$n\$) and prints it: []
• ; terminates the program.

Answer 29

R, 20 19 bytes

(x=scan())[[!x%%2]]

Try it online!

R 4.1, 15 14 bytes

\(x)x[[!x%%2]]

Takes advantage of the fact that an R numeric is automatically a vector.

-1 byte by using a different indexing error due to Dominic van Essen.

Answer 30

Whitespace, 44 bytes

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][S N
S _Duplicate_input][S S S T S N
_Push_2][T  S T T   _Modulo][N
T   S N
_If_0_Jump_to_Label_EVEN][N
S N
S N
_Jump_to_nonexistent_Label][N
S S N
_Create_Label_Even][T   N
S T _Print_as_integer]

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

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

Explanation in pseudo-code:

Integer input = STDIN as integer
Integer temp = input modulo-2
If (temp == 0):
  Go to label EVEN
Go to nonexistent label (causing an error)

Label EVEN:
  Print input as integer
  (also shows an error: no exit defined; could be prevented by adding three trailing newlines)