# Subtract my odds from my evens

Given a non-negative integer, return the absolute difference between the sum of its even digits and the sum of its odd digits.

## Default Rules

• Standard Loopholes apply.

• You can take input and provide output by any standard Input / Output method.

• You may take input as a String, as an Integer or as a list of digits.

• This is , so the shortest code in bytes in every language wins!

## Test Cases

Input ~> Output

0 ~> 0 (|0-0| = 0)
1 ~> 1 (|1-0| = 1)
12 ~> 1 (|2-1| = 1)
333 ~> 9 (|0-(3+3+3)| = 9)
459 ~> 10 (|4-(5+9)| = 10)
2469 ~> 3 (|(2+4+6)-9| = 3)
1234 ~> 2 (|(2+4)-(1+3)| = 2)
• May we take input as list of ints? – Adám Jul 10 '17 at 16:43
• @Mr.Xcoder That wouldn't be too trivial. It makes the challenge unnecessarily complicated and is an arbitrary requirement that adds bytes. – Okx Jul 10 '17 at 16:46
• @Mr.Xcoder Don't make chameleon challenges. The most important sentence you might want to look at here is Combining two or more unrelated core challenges into one — consider splitting the challenge up into separate challenges or dropping unnecessary parts – Okx Jul 10 '17 at 16:51
• *chameleon challenge – CalculatorFeline Jul 10 '17 at 16:53
• I have changed the rules @Okx. Taking as a list of digits is now allowed. I still don't think it would make it to fluffy though. – Mr. Xcoder Jul 10 '17 at 16:55

# Jelly, 6 bytes

-*æ.¹A

Try it online!

### How it works

-*æ.¹A  Main link. Argument: A (digit array)

-*      Raise -1 to A's digits, yielding 1 for even digits and -1 for odd ones.
¹   Identity; yield A.
æ.    Take the dot product of the units and the digits.
A  Apply absolute value.
• You can save 1 byte by taking input as a list. – CalculatorFeline Jul 10 '17 at 17:25
• I am taking input as a list. – Dennis Jul 10 '17 at 17:26
• I'm talking about revision 2. – CalculatorFeline Jul 10 '17 at 17:46
• Raise -1 to A's digits, yielding 1 for even digits and 0 for odd ones. umm, I think you messed something a little bit or something... – Erik the Outgolfer Jul 10 '17 at 18:12
• @EriktheOutgolfer Darn off-by-one errors. – Dennis Jul 10 '17 at 18:15

# SHENZHEN I/O MCxxxx scripts, 197 (126+71) bytes

Chip 1 (MC6000):

• x0: Input as list
• x2: Chip 2 x1
• x3: MC4010
mov 0 dat
j:
mov x0 acc
mov 70 x3
mov -1 x3
mov acc x3
mul x3
mov acc x2
mov dat acc
tlt acc 3
mov acc dat
+jmp j
slx x0

Chip 2 (MC4000):

• p0: Output
• x0: MC4010
• x1: Chip 1 x2
mov x1 acc
mov 30 x0
mov 0 x0
mov acc x0
mov x0 p0
slx x1
• (You can us a <!-- --> comment to get code right after a list, instead of filler text. Or indent the code with 4 more spaces.) – Mat Jul 11 '17 at 11:16

## Python 2, 39 bytes

Takes integer as list. Try it online

lambda A:abs(sum((-1)**i*i for i in A))

-3 bytes thanks to @Mr.Xcoder
-1 byte thanks to @ovs

• Use [i,-i][i%2] instead of i%2and i or -i for 40 bytes. – Mr. Xcoder Jul 10 '17 at 17:05
• (-1)**i*i for 39 bytes – ovs Jul 10 '17 at 17:40

# TI-Basic, 18 9 bytes

abs(sum((-1)^AnsAns

Explanation

Multiplies each digit in the list by -1 to its power, negating each odd digit, before summing them.

# C (gcc), 5958 57 bytes

i;f(char*v){for(i=0;*v;v++)i+=*v%2?*v-48:48-*v;v=abs(i);}

Try it online!

• If it helps, I have changed the rules and you are now able to take input as a list. Hopefully that would save bytes. I don't know C, so it's just a suggestion. – Mr. Xcoder Jul 10 '17 at 17:08

## R, 30 29 bytes

abs(sum((d=scan())-2*d*d%%2))

d = scan() takes the input number by one digit after the other.

-1 byte thanks to @Giuseppe!

• This is quite excellent! There's a 1 byte saving to be made, though: abs(sum((d=scan())-2*d*d%%2)) – Giuseppe Jul 11 '17 at 12:31
• @Giuseppe Thanks, good tip, edited! – runr Jul 11 '17 at 18:04

# C#, 57 bytes

namespace System.Linq{i=>Math.Abs(i.Sum(n=>n%2<1?n:-n))}

Takes input as i and sums the integers by turning the odds to negative.

• First answer here. No clue if I need to wrap this whole thing into a actual C# program and count those bytes too. – TyCobb Jul 11 '17 at 21:49
• You have to include the boilerplate namespace System.Linq{ and make an actual function. See the other C# answer for reference – Mr. Xcoder Jul 11 '17 at 21:54
• @Mr.Xcoder Thanks for the info. Think I got. Almost doubled my byte count =( lol – TyCobb Jul 11 '17 at 21:59
• Yeah, C# is not really the best golfing language – Mr. Xcoder Jul 11 '17 at 22:00
• @Mr.Xcoder Nope, but I thought the rules got relaxed because I saw a slim version on the first page without the namespace stuff and didn't see a Main. Only reason I thought I'd answer with it. Oh wells. – TyCobb Jul 11 '17 at 22:02

# Mathematica, 20 bytes

Abs@Tr[(-1)^(g=#)g]&

takes as input a list of digits

special thanx to @LLlAMnYP for letting me know about the "new rules"

• beat me to it! :) You probably don't need the *. – Greg Martin Jul 11 '17 at 3:36
• now that OP has relaxed the requirements your code can be trivially much shorter. +1 – LLlAMnYP Jul 11 '17 at 10:01

# Japt, 8 bytes

x_*JpZÃa

Test it online!

### Explanation

x_  *JpZÃ a
UxZ{Z*JpZ} a
Implicit: U = list of digits
UxZ{     }      Take the sum of each item Z in U mapped through the following function:
JpZ         Return (-1) ** Z
Z*            times Z. This gives Z if even, -Z if odd.
a    Take the absolute value of the result.
Implicit: output result of last expression

# Neim, 7 bytes

ΓDᛃΞ𝐍}𝐬

Explanation:

Γ        Apply the following to each element in the input array
D         Duplicate
ᛃ        Modulo 2, then perform logical NOT
Ξ       If truthy, then:
𝐍        Multiply by -1
}  Close all currently running loops/conditionals etc
𝐬 Sum the resulting array
• Who doesn't have a builtin that mods by 2 then logically NOTs the result? – caird coinheringaahing Jul 10 '17 at 17:22
• @cairdcoinheringaahing It's basically 'check if even' – Okx Jul 10 '17 at 17:24

# APL, 8 bytes

|⊢+.×¯1*⊢

Try it online!

How?

¯1*⊢ - -1n for n in

[4 5 91 ¯1 ¯1]

⊢+.× - verctorized multiplication with o, then sum

[+/ 4 5 9 × 1 ¯1 ¯1+/ 4 ¯5 ¯9¯10]

| - absolute value

• Can you please provide a testing environment? – Mr. Xcoder Jul 10 '17 at 17:06
• @Mr.Xcoder added – Uriel Jul 10 '17 at 17:13
• |⊢+.×¯1*⊢ with the new input spec. – Adám Jul 10 '17 at 18:18
• @Adám thanks. can't believe I missed product. – Uriel Jul 10 '17 at 18:27
• can you provide more detail in the explanation? can this method be ported to J? i'm currently using key (see my answer) but this method might shave off a few bytes... – Jonah Jul 10 '17 at 18:53

## JavaScript (ES6), 43 38 bytes

Takes input as a string an array of digits.

a=>a.map(d=>s+=d&1?d:-d,s=0)&&s>0?s:-s

### Test cases

let f =

a=>a.map(d=>s+=d&1?d:-d,s=0)&&s>0?s:-s

console.log(f([1]))     // ~> 1 ( |1-0| = 1)
console.log(f([0]))     // ~> 0 ( |0-0| = 0)
console.log(f([1,2]))    // ~> 1 ( |1-2| = 1)
console.log(f([4,5,9]))   // ~> 10 ( |4-(5+9)| = 10)
console.log(f([2,4,6,9]))  // ~> 3 ( |(2+4+6)-9| = 3)
console.log(f([3,3,3]))   // ~> 9 ( |(3+3+3)-0| = 9)

EDIT: A more golf-centered approach:

## EXCEL, 4236 29 bytes

Saved 6 bytes thanks to Magic Octopus Urn Saved 7 bytes by using Dennis' -1^ approach (which, I just learned, works on arrays in excel)

=ABS(SUMPRODUCT(A:A,-1^A:A))

Takes a list of integers in A column for input. Probably can be golfed further, or by using the string version, taking a string in A1 for input.

## EXCEL, 256 bytes

=ABS(LEN(SUBSTITUTE(A1,1,""))-2*LEN(SUBSTITUTE(A1,2,""))+3*LEN(SUBSTITUTE(A1,3,""))-4*LEN(SUBSTITUTE(A1,4,""))+5*LEN(SUBSTITUTE(A1,5,""))-6*LEN(SUBSTITUTE(A1,6,""))+7*LEN(SUBSTITUTE(A1,7,""))-8*LEN(SUBSTITUTE(A1,8,""))+9*LEN(SUBSTITUTE(A1,9,""))-5*LEN(A1))

• disclaimer, only works for numbers less than 100 in length – Magic Octopus Urn Jul 11 '17 at 20:50
• Switching to A:A saves 6 bytes and removes that problem. – Mark Jul 11 '17 at 21:54
• Wow, rarely does my constructive criticism save bytes, +1 for your Excel knowledge sir. – Magic Octopus Urn Jul 11 '17 at 21:57
• Also, due to You may take input as a String, as an Integer or as a list of digits. your 42 byte answer should be the answer you use. – Magic Octopus Urn Jul 11 '17 at 21:58
• The first was a humorous attempt, but I'll switch them around. – Mark Jul 11 '17 at 21:58

# Julia 0.5, 19 bytes

!x=(-1).^x⋅x|>abs

Try it online!

# Husk, 7 bytes

≠0ṁṠ!¡_

Try it online!

Takes a list of digits as input.

Still missing an "abs" builtin, but a good result all the same :)

### Explanation

Ṡ!¡_ is a function that takes a number n and then applies n-1 times the function _ (negation) to n. This results in n for odd n or -n for even n.

applies a function to each element of a list and sums the results.

≠0 returns the absolute difference between a number and 0.

# 05AB1E, 6 bytes

Thanks to Dennis for the -1 power trick. Takes input as a list of digits

®sm*OÄ

Try it online!

### Explanation

®sm*OÄ                                               Example [4, 5, 9]
®      # Push -1                                   % STACK: -1
sm    # Take -1 to the power of every number      % STACK: [1, -1, -1]
in the input list
*   # Multiply with original input              % Multiply [1, -1, -1] with [4, 5, 9] results in STACK: [4, -5, -9]
O  # Sum them all together                     % STACK: -10
Ä # Absolute value                            % STACK: 10
# Implicit print
• I can´t follow the explanation. Would you add an example please. – Titus Jul 10 '17 at 18:05
• @Titus there you go. Hope it helps :) – Datboi Jul 10 '17 at 18:23
• And here I was with È2*<*O like a filthy casual. – Magic Octopus Urn Jul 11 '17 at 20:45

# PHP, 51 bytes

while(~$n=$argn[$i++])$s+=$n&1?$n:-$n;echo abs($s);

adds digit to $s if odd, subtracts if even. Run as pipe with -nR. or while(~$n=$argn[$i++])$s+=(-1)**$n*$n;echo abs($s);

using Dennis´ -1 power trick.

# Mathematica, 67 bytes

(s=#;Abs[Subtract@@(Tr@Select[IntegerDigits@s,#]&/@{EvenQ,OddQ})])&

# PHP, 54 bytes

for(;~$n=$argn[$i++];)${eo[$n&1]}+=$n;echo abs($e-$o);

Try it online!

# PHP, 57 bytes

store the even and odd sums in an array

for(;~$n=$argn[$i++];)$r[$n&1]+=$n;echo abs($r[0]-$r[1]);

Try it online!

# PHP, 57 bytes

store the even and odd sums in two variables

for(;~$n=$argn[$i++];)$n&1?$o+=$n:$e+=$n;echo abs($e-$o);

Try it online!

• 54 bytes: odd sum in ${1} and even sum in${0}: while(~$n=$argn[$i++])${$n&1}+=$n;echo abs(${1}-${0}); – Titus Jul 10 '17 at 17:50
• @Titus nice I think  for(;~$n=$argn[$i++];)${eo[$n&1]}+=$n;echo abs($e-$o); is also a nice variant. Or we can do it more nathematical for(;~$n=$argn[$i++];$s+=$n)$u+=($n&1)*$n;echo abs($s-2*$u); and for(;~$n=$argn[$i++];)$u+=(($n&1)-.5)*2*$n;echo abs($u); is an interesting way – Jörg Hülsermann Jul 10 '17 at 21:07 # Haskell, 4742393826 25 bytes -1 thanks to nimi -12 thanks to Bruce -1 thanks to xnor abs.sum.map(\x->x*(-1)^x) Try it online! • You can inline s: ((*)=<<((-1)^)). – nimi Jul 10 '17 at 18:03 • It's one byte shorter to just write (\x->x*(-1)^x). – xnor Jul 10 '17 at 20:46 # Perl 6, 28 bytes {abs sum$_ Z*.map(*%2*2-1)}

Try it online!

Takes a list of digits as input.

• $_ is the input argument. • .map(* % 2 * 2 - 1) maps each digit to either 1 or -1 depending on whether the digit is odd or even, respectively. • Z* zips the original list of digits with the even/odd list using multiplication. # Braingolf, 18 bytes {.2%?M|}&+v&+c-!s* Try it online! Takes input as a list of digits ## Explanation {.2%?M|}&+v&+c-!s* Implicit input from commandline args {......} Foreach loop, runs on each item in the stack.. .2% ..Parity check, push 1 if odd, 0 if even ? ..If last item != 0 (pops last item).. M ....Move last item to next stack | ..Endif &+ Sum entire stack v&+ Switch to next stack and sum entire stack c- Collapse into stack1 and subtract !s Sign check, push 1 if last item is positive, -1 if last item is negative, 0 if last item is 0 * Multiply last item by sign, gets absolute value Implicit output # R, 72 43 bytes b=(d=scan())%%2<1;abs(sum(d[b])-sum(d[!b])) First, d = scan() takes the number as input, one digit after the other (thanks to @Giuseppe comment !) Then, b = d %% 2 <1 associates to b a TRUE or FALSE value at each index depending on the digits' parity. Therefore, b values are TRUE for even numbers, and !b are TRUE for odd values. Finaly, abs(sum(d[b]) - sum(d[!b])) does the job. • <1 is one byte shorter than ==0, but note that you may take input as a list of digits as well. – Giuseppe Jul 10 '17 at 19:47 • @Giuseppe Well spotted ! Thanks ! – Frédéric Jul 10 '17 at 20:19 # Bash 141139 99 Bytes while read -n1 a; do [$[a%2] = 0 ]&&e=$[e+a]||o=$[o+a]
done
(($[e-o]>0))&&echo$[e-o]||echo \$[o-e]

Try it online!

# Java (OpenJDK 8), 55 bytes

a->{int s=0;for(int d:a)s+=d%2<1?-d:d;return s<0?-s:s;}

Try it online!

Naive implementation.

# C#, 67 bytes

namespace System.Linq{a=>Math.Abs(a.Sum(n=>n%2<1)-a.Sum(n=>n%2>1))}

# 05AB1E, 7 bytes

È2*<*OÄ

Try it online!

# Input              | 1234567
È       # Is Even?           | [0,1,0,1,0,1,0]
2*<    # (a * 2) - 1        | [-1,1,-1,1,-1,1,-1]
*   # Multiply w/ input. | [-1,2,-3,4,-5,6,-7]
O  # Sum.               | -10
Ä # Absolute value of. | 10

# x86-64 Machine Code, 30 bytes

31 C0 99 8B 4C B7 FC F6 C1 01 74 04 01 CA EB 02 01 C8 FF CE 75 ED 29 D0 99 31 D0 29 D0 C3

The above code defines a function that accepts a list/array of integer digits and returns the absolute difference between the sum of its even digits and the sum of its odd digits.

As in C, assembly language doesn't implement lists or arrays as first-class types, but rather represents them as a combination of a pointer and a length. Therefore, I have arranged for this function to accept two parameters: the first is a pointer to the beginning of the list of digits, and the second is an integer specifying the total length of the list (total number of digits, one-indexed).

The function conforms to the System V AMD64 calling convention, which is standard on Gnu/UNIX systems. In particular, the first parameter (pointer to the beginning of the list) is passed in RDI (as this is 64-bit code, it is a 64-bit pointer), and the second parameter (length of the list) is passed in ESI (this is only a 32-bit value, because that's more than enough digits to play with, and naturally it is assumed to be non-zero). The result is returned in the EAX register.

If it's any clearer, this would be the C prototype (and you can use this to call the function from C):

int OddsAndEvens(int *ptrDigits, int length);

Ungolfed assembly mnemonics:

; parameter 1 (RDI) == pointer to list of integer digits
; parameter 2 (ESI) == number of integer digits in list (assumes non-zero, of course)
OddsAndEvens:
xor  eax, eax              ; EAX = 0 (accumulator for evens)
cdq                        ; EDX = 0 (accumulator for odds)
.IterateDigits:
mov  ecx, [rdi+rsi*4-4]    ; load next digit from list
test cl, 1                 ; test last bit to see if even or odd
jz   .IsEven               ; jump if last bit == 0 (even)
.IsOdd:                       ; fall through if last bit != 0 (odd)
jmp  .Continue             ; keep looping
.IsEven:
.Continue:                    ; fall through
dec  esi                   ; decrement count of digits in list
jnz  .IterateDigits        ; keep looping as long as there are digits left

sub  eax, edx              ; subtract odds accumulator from evens accumulator

; abs
cdq                        ; sign-extend EAX into EDX
xor  eax, edx              ; XOR sign bit in with the number
sub  eax, edx              ; subtract sign bit

ret                        ; return with final result in EAX

Here's a brief walk-through of the code:

• First, we zero out the EAX and EDX registers, which will be used to hold the sum totals of even and odd digits. The EAX register is cleared by XORing it with itself (2 bytes), and then the EDX register is cleared by sign-extending the EAX into it (CDQ, 1 byte).
• Then, we go into the loop that iterates through all of the digits passed in the array. It retrieves a digit, tests to see if it is even or odd (by testing the least-significant bit, which will be 0 if the value is even or 1 if it is odd), and then jumps or falls through accordingly, adding that value to the appropriate accumulator. At the bottom of the loop, we decrement the digit counter (ESI) and continue looping as long as it is non-zero (i.e., as long as there are more digits left in the list to be retrieved).

The only thing tricky here is the initial MOV instruction, which uses the most complex addressing mode possible on x86.* It takes RDI as the base register (the pointer to the beginning of the list), scales RSI (the length counter, which serves as the index) by 4 (the size of an integer, in bytes) and adds that to the base, and then subtracts 4 from the total (because the length counter is one-based and we need the offset to be zero-based). This gives the address of the digit in the array, which is then loaded into the ECX register.

• After the loop has finished, we do the subtraction of the odds from the evens (EAX -= EDX).

• Finally, we compute the absolute value using a common trick—the same one used by most C compilers for the abs function. I won't go into details about how this trick works here; see code comments for hints, or do a web search.

__
* The code can be re-written to use simpler addressing modes, but it doesn't make it any shorter. I was able to come up with an alternative implementation that dereferenced RDI and incremented it by 8 each time through the loop, but because you still have to decrement the counter in ESI, this turned out to be the same 30 bytes. What had initially given me hope is that add eax, DWORD PTR [rdi] is only 2 bytes, the same as adding two enregistered values. Here is that implementation, if only to save anyone attempting to outgolf me some effort :-)

OddsAndEvens_Alt:
31 C0                   xor    eax, eax
99                      cdq
.IterateDigits:
F6 07 01                test   BYTE PTR [rdi], 1
74 04                   je     .IsEven
.IsOdd:
03 17                   add    edx, DWORD PTR [rdi]
EB 02                   jmp    .Continue
.IsEven:
03 07                   add    eax, DWORD PTR [rdi]
.Continue:
48 83 C7 08             add    rdi, 8
FF CE                   dec    esi
75 ED                   jne    .IterateDigits
29 D0                   sub    eax, edx
99                      cdq
31 D0                   xor    eax, edx
29 D0                   sub    eax, edx
C3                      ret

## TI-BASIC, 11 6 bytes

abs(sum(Anscos(πAns

Takes input as a list. i²^Ans saves two bytes over (-1)^Ans because we don't need the parentheses.

abs(sum(Anscos(πAns
cos(πAns                  1 for evens, -1 for odds
Ans                          Multiply by original list
abs(sum(                             Sum the list and take absolute value, which also
fixes rounding errors from cos(.

# J, 14 bytes

|-/(2&|+//.[),

Try it online!

## explanation

|                absolute value of
-/              the difference between
the items on the list returned by this fork
(2&|          is an item odd? (1 for yes, 0 for no)
+//.      the "key" verb /. which partitions on above (even / odd) then sums
[)    identity, ie, the list of digits passed
,   turn it into a list (to handle 1 element case)