Dado un número entero no negativo, devuelve la diferencia absoluta entre la suma de sus dígitos pares y la suma de sus dígitos impares.

Reglas predeterminadas

• Se aplican lagunas estándar.

• Puede tomar entrada y proporcionar salida por cualquier método estándar de Entrada / Salida.

• Puede tomar la entrada como una cadena, como un entero o como una lista de dígitos.

• Este es el código de golf , por lo que gana el código más corto en bytes en cada idioma .

Casos de prueba

Entrada ~> Salida

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)

Jalea , 6 bytes

-*æ.¹A

Pruébalo en línea!

Cómo funciona

-*æ.¹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 scripts, 197 (126 + 71) bytes

Chip 1 (MC6000):

• x0: entrada como lista
• 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: salida
• 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

Toma un entero como lista. Pruébalo en línea

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

-3 bytes gracias a @ Mr.Xcoder
-1 byte gracias a @ovs

TI-Basic, 18 9 bytes

abs(sum((-1)^AnsAns

Explicación

Multiplica cada dígito de la lista por -1 a su potencia, negando cada dígito impar, antes de sumarlos.

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

Pruébalo en línea!

R, 30 29 bytes

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

d = scan() toma el número de entrada un dígito después del otro.

-1 byte gracias a @Giuseppe!

C #, 57 bytes

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

Toma datos como iy suma los enteros al convertir las probabilidades en negativas.

Mathematica, 20 bytes

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

toma como entrada una lista de dígitos

Un agradecimiento especial a @LLlAMnYP por informarme sobre las "nuevas reglas"

Japt , 8 bytes

x_*JpZÃa

¡Pruébalo en línea!

Explicación

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

Explicación:

Γ        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*⊢

Pruébalo en línea!

¿Cómo?

¯1*⊢- -1 ⁿ para nen⍵

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

⊢+.×- multiplicación verctorizada con o, luego suma

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

| - valor absoluto

JavaScript (ES6), 43 38 bytes

Toma la entrada como una cadena de una matriz de dígitos.

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

Casos de prueba

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)

EDITAR: Un enfoque más centrado en el golf:

EXCEL, 42 36 29 bytes

Guardado 6 bytes gracias a Magic Octopus Urn Guardado 7 bytes usando el enfoque Dennis '-1 ^ (que, acabo de enterar, funciona en matrices en Excel)

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

Toma una lista de enteros en la columna A para entrada. Probablemente se pueda jugar más, o usando la versión de cadena, tomando una cadena en A1 como entrada.

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

Pruébalo en línea!

Casco , 7 bytes

≠0ṁṠ!¡_

Pruébalo en línea!

Toma una lista de dígitos como entrada.

Todavía falta un "abs" incorporado, pero un buen resultado de todos modos :)

Explicación

Ṡ!¡_es una función que toma un número ny luego aplica el n-1tiempo a la función _(negación) n. Este resultado en npor extraño no -nincluso paran .

ṁ aplica una función a cada elemento de una lista y suma los resultados.

≠0 devuelve la diferencia absoluta entre un número y 0.

05AB1E , 6 bytes

Gracias a Dennis por el truco de poder -1. Toma entrada como una lista de dígitos

®sm*OÄ

Pruébalo en línea!

Explicación

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

agrega dígitos a $ssi es impar, resta si es par. Corre como tubería con-nR .

o

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

usando el -1truco de poder de Dennis .

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

Pruébalo en línea!

PHP , 57 bytes

almacenar las sumas pares e impares en una matriz

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

Pruébalo en línea!

PHP , 57 bytes

almacenar las sumas pares e impares en dos variables

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

Pruébalo en línea!

Haskell , 47 42 39 38 26 25 bytes

-1 gracias a nimi

-12 gracias a Bruce

-1 gracias a xnor

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

Pruébalo en línea!

Perl 6 , 28 bytes

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

Pruébalo en línea!

Toma una lista de dígitos como entrada.

• $_ es el argumento de entrada.
• .map(* % 2 * 2 - 1)asigna cada dígito a cualquiera 1o -1dependiendo de si el dígito es par o impar, respectivamente.
• Z* comprime la lista original de dígitos con la lista par / impar usando la multiplicación.

Braingolf , 18 bytes

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

Pruébalo en línea!

Toma entrada como una lista de dígitos

Explicación

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

En primer lugar, d = scan()toma el número como entrada, un dígito después de los otros (gracias a @Giuseppe comentario!)
Entonces, b = d %% 2 <1asociados a buna TRUEo FALSEvalor en cada índice en función de la paridad de los dígitos. Por lo tanto, blos valores son TRUEpara los números pares, y !bson TRUEpara valores impares.

Finalmente, abs(sum(d[b]) - sum(d[!b]))hace el trabajo.

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]

Pruébalo en línea!

Java (OpenJDK 8) , 55 bytes

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

Pruébalo en línea!

Implementación ingenua.

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Ä

Pruébalo en línea!

        # 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

Código de máquina x86-64, 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

El código anterior define una función que acepta una lista / matriz de dígitos enteros y devuelve la diferencia absoluta entre la suma de sus dígitos pares y la suma de sus dígitos impares.

Como en C , el lenguaje ensamblador no implementa listas o matrices como tipos de primera clase, sino que las representa como una combinación de un puntero y una longitud. Por lo tanto, he dispuesto que esta función acepte dos parámetros: el primero es un puntero al comienzo de la lista de dígitos, y el segundo es un número entero que especifica la longitud total de la lista (número total de dígitos, un índice) .

La función se ajusta a la convención de llamadas System V AMD64 , que es estándar en los sistemas Gnu / UNIX. En particular, se pasa el primer parámetro (puntero al comienzo de la lista) RDI(como se trata de un código de 64 bits, es un puntero de 64 bits) y se pasa el segundo parámetro (longitud de la lista) ESI( este es solo un valor de 32 bits, porque son dígitos más que suficientes para jugar, y naturalmente se supone que no es cero). El resultado se devuelve en el EAXregistro.

Si es más claro, este sería el prototipo C (y puede usar esto para llamar a la función desde C):

int OddsAndEvens(int *ptrDigits, int length);

Mnemónicos de ensamblaje sin golf:

; 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

Aquí hay un breve recorrido por el código:

• Primero, ponemos a cero los registros EAXy EDX, que se usarán para contener los totales de suma de dígitos pares e impares. El EAXregistro se borra XORhaciéndolo consigo mismo (2 bytes), y luego EDXse borra al extender el signo EAX ( CDQ1 byte).

• Luego, entramos en el ciclo que itera a través de todos los dígitos pasados ​​en la matriz. Recupera un dígito, prueba para ver si es par o impar (probando el bit menos significativo, que será 0 si el valor es par o 1 si es impar), y luego salta o cae en consecuencia, agregando que valor para el acumulador apropiado. En la parte inferior del bucle, disminuimos el contador de dígitos ( ESI) y continuamos haciendo el bucle siempre que no sea cero (es decir, mientras haya más dígitos restantes en la lista para recuperar).

  Lo único complicado aquí es la instrucción MOV inicial, que utiliza el modo de direccionamiento más complejo posible en x86. ^* Toma RDIcomo registro base (el puntero al comienzo de la lista), escala RSI(el contador de longitud, que sirve como índice) en 4 (el tamaño de un entero, en bytes) y lo agrega a la base, y luego resta 4 del total (porque el contador de longitud está basado en uno y necesitamos que el desplazamiento esté basado en cero). Esto proporciona la dirección del dígito en la matriz, que luego se carga en el ECXregistro.

• Después de que el ciclo ha terminado, hacemos la resta de las probabilidades de los pares ( EAX -= EDX).

• Finalmente, calculamos el valor absoluto utilizando un truco común, el mismo utilizado por la mayoría de los compiladores de C para la absfunción. No entraré en detalles sobre cómo funciona este truco aquí; vea los comentarios del código para obtener sugerencias o realice una búsqueda en la web.

__
_{* El código puede reescribirse para usar modos de direccionamiento más simples, pero no lo hace más corto. Pude idear una implementación alternativa que la desreferenciaba RDIy la incrementaba en 8 cada vez a través del ciclo, pero debido a que aún tiene que disminuir el contador ESI, resultaron ser los mismos 30 bytes. Lo que inicialmente me había dado esperanza es que add eax, DWORD PTR [rdi]solo son 2 bytes, lo mismo que agregar dos valores registrados. Aquí está esa implementación, aunque solo sea para salvar a cualquiera que intente superar mi esfuerzo :-)}

                    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

Toma la entrada como una lista. i²^Ansahorra dos bytes (-1)^Ansporque no necesitamos los paréntesis.

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

Pruébalo en línea!

explicación

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