Dado um número inteiro não negativo, retorne a diferença absoluta entre a soma de seus dígitos pares e a soma de seus dígitos ímpares.

Regras padrão

• Aplicam-se brechas padrão.

• Você pode receber e fornecer saída por qualquer método padrão de entrada / saída.

• Você pode receber a entrada como uma String, como um número inteiro ou como uma lista de dígitos.

• Isso é código-golfe , então o código mais curto em bytes em todos os idiomas vence!

Casos de teste

Entrada ~> Saída

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)

Gelatina , 6 bytes

-*æ.¹A

Experimente online!

Como 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.

Scripts SHENZHEN I / O MCxxxx, 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: Saída
• 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

Leva inteiro como lista. Experimente online

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

-3 bytes graças a @ Mr.Xcoder
-1 byte graças a @ovs

TI-Basic, 18 9 bytes

abs(sum((-1)^AnsAns

Explicação

Multiplica cada dígito da lista por -1 à sua potência, negando cada dígito ímpar, antes de somar.

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

Experimente online!

R, 30 29 bytes

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

d = scan() pega o número de entrada um dígito após o outro.

-1 byte graças a @ Giuseppe!

C #, 57 bytes

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

Toma a entrada como ie soma os números inteiros, transformando as probabilidades em negativas.

Mathematica, 20 bytes

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

toma como entrada uma lista de dígitos

um agradecimento especial a @LLlAMnYP por me informar sobre as "novas regras"

Japonês , 8 bytes

x_*JpZÃa

Teste online!

Explicação

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

Explicação:

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

Experimente online!

Quão?

¯1*⊢- -1 ⁿ para nem⍵

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

⊢+.×- multiplicação verctorized com o, então soma

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

| - valor absoluto

JavaScript (ES6), 43 38 bytes

Aceita como string uma matriz de dígitos.

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

Casos de teste

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: Uma abordagem mais centrada no golfe:

EXCEL, 42 36 29 bytes

Economizei 6 bytes graças ao Magic Octopus Urn Economizei 7 bytes usando a abordagem -1 de Dennis (que, acabei de aprender, funciona em matrizes no Excel)

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

Leva uma lista de números inteiros na coluna A para entrada. Provavelmente, você pode jogar golfe ainda mais, ou usando a versão em cadeia, usando uma cadeia em A1 para 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

Experimente online!

Casca , 7 bytes

≠0ṁṠ!¡_

Experimente online!

Leva uma lista de dígitos como entrada.

Ainda falta um "abs" embutido, mas um bom resultado é o mesmo :)

Explicação

Ṡ!¡_é uma função que pega um número ne depois aplica n-1vezes a função _(negação) a n. Isso resulta em nímpar nou -npar n.

ṁ aplica uma função a cada elemento de uma lista e soma os resultados.

≠0 retorna a diferença absoluta entre um número e 0.

05AB1E , 6 bytes

Obrigado a Dennis pelo truque de poder -1. Recebe a entrada como uma lista de dígitos

®sm*OÄ

Experimente online!

Explicação

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

adiciona dígito a $s se ímpar, subtrai se for par. Corra como cano com -nR.

ou

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

usando -1o truque 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);

Experimente online!

PHP , 57 bytes

armazena as somas pares e ímpares em uma matriz

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

Experimente online!

PHP , 57 bytes

armazene as somas pares e ímpares em duas variáveis

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

Experimente online!

Haskell , 47 42 39 38 26 25 bytes

-1 graças a nimi

-12 graças a Bruce

-1 graças a xnor

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

Experimente online!

Perl 6 , 28 bytes

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

Experimente online!

Leva uma lista de dígitos como entrada.

• $_ é o argumento de entrada.
• .map(* % 2 * 2 - 1)mapeia cada dígito para um 1ou-1 dependendo se o dígito é ímpar ou par, respectivamente.
• Z* fecha a lista original de dígitos com a lista par / ímpar usando multiplicação.

Braingolf , 18 bytes

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

Experimente online!

Recebe a entrada como uma lista de dígitos

Explicação

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

Primeiro, d = scan()leva o número como entrada, um dígito após os outros (graças ao comentário @Giuseppe!)
Então, b = d %% 2 <1associados a buma TRUEou FALSEvalor em cada índice dependendo da paridade dos dígitos. Portanto, os bvalores são TRUEpara números pares e !bsãoTRUE para valores ímpares.

Finalmente, abs(sum(d[b]) - sum(d[!b]))faz o trabalho.

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]

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

Experimente online!

Implementação ingênua.

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Ä

Experimente 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

Código da 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

O código acima define uma função que aceita uma lista / matriz de dígitos inteiros e retorna a diferença absoluta entre a soma de seus dígitos pares e a soma de seus dígitos ímpares.

Como em C , a linguagem assembly não implementa listas ou matrizes como tipos de primeira classe, mas os representa como uma combinação de um ponteiro e um comprimento. Portanto, organizei essa função para aceitar dois parâmetros: o primeiro é um ponteiro para o início da lista de dígitos e o segundo é um número inteiro que especifica o comprimento total da lista (número total de dígitos, um indexado) .

A função está em conformidade com a convenção de chamada do System V AMD64 , que é padrão nos sistemas Gnu / UNIX. Em particular, o primeiro parâmetro (ponteiro para o início da lista) é passado RDI(como esse é um código de 64 bits, é um ponteiro de 64 bits) e o segundo parâmetro (comprimento da lista) é passado ESI( esse é apenas um valor de 32 bits, porque são dígitos mais do que suficientes para brincar e, naturalmente, supõe-se que seja diferente de zero). O resultado é retornado no EAXregistro.

Se for mais claro, esse seria o protótipo C (e você pode usar isso para chamar a função de C):

int OddsAndEvens(int *ptrDigits, int length);

Mnemônicos de montagem não destruídos:

; 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

Aqui está uma breve explicação do código:

• Primeiro, zeramos os registros EAXe EDX, que serão usados ​​para armazenar a soma dos dígitos pares e ímpares. O EAXregistro é limpo com XORele próprio (2 bytes) e, em seguida, o EDXregistro é limpo com a extensão do sinal do EAX para ele ( CDQ1 byte).

• Em seguida, entramos no loop que itera através de todos os dígitos passados ​​na matriz. Ele recupera um dígito, testa para ver se é par ou ímpar (testando o bit menos significativo, que será 0 se o valor for par ou 1 se for ímpar) e, em seguida, salta ou cai de acordo, acrescentando que valor ao acumulador apropriado. Na parte inferior do loop, decrementamos o contador de dígitos ( ESI) e continuamos o loop desde que não seja zero (ou seja, desde que haja mais dígitos na lista a serem recuperados).

  A única coisa complicada aqui é a instrução MOV inicial, que usa o modo de endereçamento mais complexo possível no x86. ^* Ele pega RDIcomo registro base (o ponteiro para o início da lista), escala RSI(o contador de comprimento, que serve como índice) por 4 (o tamanho de um número inteiro, em bytes) e o adiciona à base, e subtrai 4 do total (porque o contador de comprimento é baseado em um e precisamos que o deslocamento seja baseado em zero). Isso fornece o endereço do dígito na matriz, que é carregado no ECXregistro.

• Depois que o loop termina, fazemos a subtração das probabilidades dos pares ( EAX -= EDX).

• Finalmente, calculamos o valor absoluto usando um truque comum - o mesmo usado pela maioria dos compiladores C para a absfunção. Não vou entrar em detalhes sobre como esse truque funciona aqui; consulte os comentários do código para obter dicas ou faça uma pesquisa na web.

__
_{* O código pode ser reescrito para usar modos de endereçamento mais simples, mas não o torna mais curto. Consegui criar uma implementação alternativa que a desreferenciou RDIe incrementou em 8 a cada vez no loop, mas como você ainda precisa diminuir o contador ESI, isso acabou sendo os mesmos 30 bytes. O que inicialmente me deu esperança é que add eax, DWORD PTR [rdi]sejam apenas 2 bytes, o mesmo que adicionar dois valores registrados. Aqui está essa implementação, apenas para salvar alguém tentando me superar um pouco de esforço :-)}

                    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

Leva a entrada como uma lista. i²^Anseconomiza dois bytes (-1)^Ansporque não precisamos dos parênteses.

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

Experimente online!

explicação

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