Bei einer nicht negativen Ganzzahl wird die absolute Differenz zwischen der Summe der geraden und der Summe der ungeraden Stellen zurückgegeben.

Standardregeln

• Es gelten Standard-Regelungslücken.

• Sie können mit jeder Standard-Eingabe- / Ausgabemethode Eingaben vornehmen und Ausgaben bereitstellen.

• Sie können Eingaben als Zeichenfolge, als Ganzzahl oder als Ziffernliste annehmen.

• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes in jeder Sprache !

Testfälle

Eingabe ~> Ausgabe

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)

Gelee , 6 Bytes

-*æ.¹A

Probieren Sie es online!

Wie es funktioniert

-*æ.¹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.

SHENZHEN I / O MCxxxx-Skripte, 197 (126 + 71) Bytes

Chip 1 (MC6000):

• x0: Eingabe als Liste
• 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
add 1
tlt acc 3
mov acc dat
+jmp j
slx x0

Chip 2 (MC4000):

• p0: Ausgabe
• x0: MC4010
• x1: Chip 1 x2

mov x1 acc
add x1
add x1
mov 30 x0
mov 0 x0
mov acc x0
mov x0 p0
slx x1

Python 2, 39 Bytes

Übernimmt eine Ganzzahl als Liste. Probieren Sie es online aus

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

-3 Byte dank @ Mr.Xcoder
-1 Byte dank @ovs

TI-Basic, 18 9 Bytes

abs(sum((-1)^AnsAns

Erläuterung

Multipliziert jede Ziffer in der Liste mit -1 und negiert jede ungerade Ziffer, bevor sie summiert wird.

C (gcc) , 59 58 57 Bytes

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

Probieren Sie es online!

R 30 29 Bytes

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

d = scan() Nimmt die eingegebene Nummer um eine Stelle nach der anderen.

-1 Byte danke an @Giuseppe!

C #, 57 Bytes

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

Nimmt die Eingabe als iund summiert die ganzen Zahlen, indem die Quote auf negativ gesetzt wird.

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"

Japt , 8 Bytes

x_*JpZÃa

Testen Sie es online!

Erläuterung

 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ᛃΞ𝐍}𝐬

Erläuterung:

Γ        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

APL, 8 bytes

|⊢+.ׯ1*⊢

Try it online!

How?

¯1*⊢ - -1ⁿ for n in ⍵

_{[4 5 9 → 1 ¯1 ¯1]}

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

_{[+/ 4 5 9 × 1 ¯1 ¯1 → +/ 4 ¯5 ¯9 → ¯10]}

| - absolute value

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, 42 36 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))

Julia 0,5 , 19 Bytes

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

Probieren Sie es online!

Schale , 7 Bytes

≠0ṁṠ!¡_

Probieren Sie es online!

Takes a list of digits as input.

Fehlt noch ein "abs" eingebaut, aber trotzdem ein gutes Ergebnis :)

Erläuterung

Ṡ!¡_ist eine Funktion, die eine Zahl annimmt nund dann n-1mal die Funktion _(Negation) auf anwendet n. Dies führt nzu ungeraden noder geraden -nWerten n.

ṁ Wendet eine Funktion auf jedes Element einer Liste an und summiert die Ergebnisse.

≠0 Gibt die absolute Differenz zwischen einer Zahl und 0 zurück.

05AB1E , 6 Bytes

Danke an Dennis für den -1 Power Trick. Übernimmt die Eingabe als Ziffernliste

®sm*OÄ

Probieren Sie es online!

Erläuterung

®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

PHP, 51 Bytes

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

addiert Ziffer zu $sungerade, subtrahiert wenn gerade. Als Rohr mit laufen lassen -nR.

oder

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

mit Dennis ' -1Power-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!

Haskell, 47 42 39 38 26 25 bytes

-1 thanks to nimi

-12 thanks to Bruce

-1 thanks to xnor

abs.sum.map(\x->x*(-1)^x)

Try it online!

Perl 6 , 28 Bytes

{abs sum $_ Z*.map(*%2*2-1)}

Probieren Sie es online!

Nimmt eine Ziffernliste als Eingabe.

• $_ ist das Eingabeargument.
• .map(* % 2 * 2 - 1)ordnet jede Ziffer entweder 1oder -1abhängig davon zu, ob die Ziffer gerade oder ungerade ist.
• Z* Zippt die ursprüngliche Ziffernliste mit der geraden / ungeraden Liste durch Multiplikation.

Braingolf , 18 Bytes

{.2%?M|}&+v&+c-!s*

Probieren Sie es online!

Übernimmt die Eingabe als Ziffernliste

Erläuterung

{.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]))

d = scan()Nimmt zuerst die Zahl als Eingabe, eine Ziffer nach der anderen (dank @ Giuseppe-Kommentar!)
. b = d %% 2 <1Assoziiert dann zu beinem TRUEoder FALSE-Wert an jedem Index, abhängig von der Parität der Ziffern. Daher bWerte sind TRUEfür gerade Zahlen, und !bsindTRUE für ungerade Werte.

Endlich, abs(sum(d[b]) - sum(d[!b]))macht den Job.

Bash 141 139 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Ä

Probieren Sie es 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-Maschinencode, 30 Byte

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.

Wie 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).

Die Funktion entspricht der System V AMD64-Aufrufkonvention , die auf Gnu / UNIX-Systemen Standard ist. Insbesondere wird der erste Parameter (Zeiger auf den Anfang der Liste) übergeben RDI(da dies ein 64-Bit-Code ist, handelt es sich um einen 64-Bit-Zeiger), und der zweite Parameter (Länge der Liste) wird übergeben ESI( Dies ist nur ein 32-Bit-Wert, da das mehr als genug Stellen sind, um damit zu spielen, und natürlich wird davon ausgegangen, dass es nicht Null ist. Das Ergebnis wird im EAXRegister zurückgegeben.

Wenn es klarer ist, wäre dies der C-Prototyp (und Sie können dies verwenden, um die Funktion von C aus aufzurufen):

int OddsAndEvens(int *ptrDigits, int length);

Ungolfed Assembler-Mnemonik:

; 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)
   add  edx, ecx              ; add value to odds accumulator
   jmp  .Continue             ; keep looping
.IsEven:
   add  eax, ecx              ; add value to evens accumulator
.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

Hier ist eine kurze Einführung in den Code:

• Zuerst setzen wir die EAXund -Register auf Null, die EDXverwendet werden, um die Gesamtsummen von geraden und ungeraden Ziffern zu halten. Das EAXRegister wird gelöscht, indem XORes mit sich selbst (2 Bytes) EDXgelöscht wird , und dann wird das Register gelöscht, indem der EAX mit Vorzeichen darin erweitert wird (CDQ 1 Byte) .

• Dann gehen wir in die Schleife, die alle im Array übergebenen Ziffern durchläuft. Es ruft eine Ziffer ab, prüft, ob sie gerade oder ungerade ist (indem es das niedrigstwertige Bit prüft, das 0 ist, wenn der Wert gerade ist, oder 1, wenn es ungerade ist), und springt oder fällt dann entsprechend durch und fügt dies hinzu Wert auf den entsprechenden Akku. Am Ende der Schleife dekrementieren wir den Ziffernzähler (ESI ) und setzen die Schleife fort, solange er nicht Null ist (dh solange noch weitere Ziffern in der abzurufenden Liste vorhanden sind).

  Das einzige, was hier schwierig ist, ist der anfängliche MOV-Befehl, der den komplexesten Adressierungsmodus verwendet, der auf x86 möglich ist. ^* Es nimmt RDIals Basisregister (den Zeiger zum Anfang der Liste), skaliert RSI(den Längenzähler, der als Index dient) um 4 (die Größe einer Ganzzahl in Bytes) und fügt das zur Basis hinzu, und dann subtrahiert man 4 von der Summe (weil der Längenzähler einsbasiert ist und der Offset nullbasiert sein muss). Dies gibt die Adresse der Ziffer im Array an, die dann in das ECXRegister geladen wird .

• Nachdem die Schleife beendet ist, subtrahieren wir die Gewinnchancen von den Evens ( EAX -= EDX).

• Schließlich berechnen wir den Absolutwert mit einem allgemeinen Trick, der auch von den meisten C-Compilern für die absFunktion verwendet wird. Ich werde hier nicht näher darauf eingehen, wie dieser Trick funktioniert. In den Codekommentaren finden Sie Hinweise, oder führen Sie eine Websuche durch.

__
_{* Der Code kann umgeschrieben werden, um einfachere Adressierungsmodi zu verwenden, verkürzt ihn jedoch nicht. Ich konnte mir eine alternative Implementierung einfallen lassen, die die Referenz RDIjedes Mal um 8 dereferenzierte und inkrementierte, aber da Sie den Zähler immer noch dekrementieren müssen ESI, stellte sich heraus, dass dies die gleichen 30 Bytes waren. Was mir anfangs Hoffnung gegeben hatte, ist, dass add eax, DWORD PTR [rdi]es nur 2 Bytes sind, was dem Hinzufügen von zwei registrierten Werten entspricht. Hier ist diese Implementierung, wenn auch nur, um jedem zu ersparen, der versucht, mich zu übertreiben :-)}

                    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

Übernimmt die Eingabe als Liste. i²^Ansspart zwei Bytes, (-1)^Answeil wir keine Klammern brauchen.

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&|+//.[),

Probieren Sie es online!

Erläuterung

|                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)