Subtraia minhas chances dos meus pares

19

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 é , 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)
Mr. Xcoder
fonte
11
Podemos considerar a entrada como lista de entradas?
Adám
4
@ Mr.Xcoder Isso não seria muito trivial. Isso torna o desafio desnecessariamente complicado e é um requisito arbitrário que adiciona bytes.
Okx 10/07/19
4
@ Mr.Xcoder Não faça desafios de camaleão . A frase mais importante que você pode querer olhar para aqui é combinação de dois ou mais não relacionados principais desafios em um - considere dividir o desafio-se em desafios separados ou deixar cair partes desnecessárias
Okx
11
* chamel e sobre o desafio
CalculatorFeline
11
Eu mudei as regras @Okx. Tomar como uma lista de dígitos agora é permitido . Eu ainda não acho que isso tornaria fofo.
Mr. Xcoder

Respostas:

8

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.
Dennis
fonte
Você pode economizar 1 byte, inserindo a entrada como uma lista.
CalculatorFeline
Eu estou tomando entrada como uma lista.
1013 Dennis
Estou falando da revisão 2.
CalculatorFeline
Raise -1 to A's digits, yielding 1 for even digits and 0 for odd ones.humm, acho que você mexeu em algo um pouco ou algo assim ...
Erik the Outgolfer
2
@EriktheOutgolfer Darn erros pontuais.
Dennis
8

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
CalculatorFeline
fonte
11
(Você pode-nos um <!-- -->comentário para obter direito de código depois de uma lista, em vez de texto de enchimento ou recuar o código com mais 4 espaços..)
Mat
5

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

Gambá morto
fonte
11
Use em [i,-i][i%2]vez de i%2and i or -ipara 40 bytes .
Mr. Xcoder
2
(-1)**i*ipara 39 bytes
ovs
5

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.

Timtech
fonte
4

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!

cleblanc
fonte
11
Se ajudar, alterei as regras e agora você pode receber informações como uma lista. Espero que isso economize bytes. Eu não sei C, então é apenas uma sugestão.
Mr. Xcoder
4

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!

Nutle
fonte
Isso é excelente! Porém, há uma economia de 1 byte a ser feita:abs(sum((d=scan())-2*d*d%%2))
Giuseppe
@ Giuseppe Obrigado, boa dica, editado!
Nutle
4

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.

TyCobb
fonte
Primeira resposta aqui. Não faço idéia se eu preciso agrupar tudo isso em um programa C # real e contar esses bytes também.
21417 TyCobb
Você precisa incluir o padrão namespace System.Linq{e criar uma função real. Veja a outra resposta C # para referência
Mr. Xcoder
@ Mr.Xcoder Obrigado pela informação. Acho que entendi. Quase dobrou minha contagem de bytes = (lol
TyCobb 11/17/17
Sim, C # não é realmente a melhor linguagem para golfe
Sr. Xcoder
@ Mr.Xcoder Não, mas achei que as regras estavam relaxadas porque vi uma versão reduzida na primeira página sem o material do namespace e não vi a Main. A única razão pela qual pensei em responder com isso. Oh, poços.
21417 TyCobb
4

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"

J42161217
fonte
bata-me a isso! :) Você provavelmente não precisa do *.
9788 Greg Martin
agora que o OP relaxou os requisitos, seu código pode ser trivialmente muito menor. 1
LLlAMnYP
3

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
ETHproductions
fonte
3

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
Okx
fonte
Quem não tem um modificador embutido que modifica por 2 e NÃO logicamente o resultado?
caird coinheringaahing
@cairdcoinheringaahing É basicamente 'seleção se mesmo'
Okx
3

APL, 8 bytes

|⊢+.ׯ1*⊢

Experimente online!

Quão?

¯1*⊢- -1 n para nem

[ 4 5 91 ¯1 ¯1]

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

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

| - valor absoluto

Uriel
fonte
Você pode fornecer um ambiente de teste?
Mr. Xcoder
@ Mr.Xcoder adicionou
Uriel
|⊢+.ׯ1*⊢com a nova especificação de entrada.
Adám
@ Adám obrigado. Não acredito que perdi o produto.
Uriel
você pode fornecer mais detalhes na explicação? este método pode ser portado para J? Atualmente estou usando a chave (ver minha resposta), mas este método pode raspar alguns bytes ...
Jonah
3

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

Arnauld
fonte
3

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

insira a descrição da imagem aqui

Marca
fonte
11
aviso legal, só funciona para números menos de 100 de comprimento
Magia Octopus Urna
11
Mudar para A: A salva 6 bytes e remove esse problema.
Mark
Uau, raramente minhas críticas construtivas economizam bytes, +1 para o seu conhecimento em Excel, senhor.
Magic Octopus Urn
Além disso, devido à You may take input as a String, as an Integer or as a list of digits.sua resposta de 42 bytes, deve ser a resposta que você usa.
Magic Octopus Urn
A primeira foi uma tentativa bem-humorada, mas vou trocá-las.
Mark
2

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.

Leo
fonte
2

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
Datboi
fonte
Não consigo seguir a explicação. Você poderia adicionar um exemplo, por favor.
Titus
@ Titus lá vai você. Espero que ajude :) #
1144 Datboi
E aqui estava eu ​​com È2*<*Oum casual imundo.
Magic Octopus Urn
2

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 .

Titus
fonte
2

Mathematica, 67 bytes

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

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!

Jörg Hülsermann
fonte
54 bytes: soma ímpar em ${1}e soma par em ${0}:while(~$n=$argn[$i++])${$n&1}+=$n;echo abs(${1}-${0});
Titus
@Titus nice Eu acho que `for (; ~ $ n = $ argn [$ i ++];) $ {eo [$ n & 1]} + = $ n; echo abs ($ e- $ o);` também é uma boa variante . Ou podemos fazer isso mais nathematical for(;~$n=$argn[$i++];$s+=$n)$u+=($n&1)*$n;echo abs($s-2*$u);e for(;~$n=$argn[$i++];)$u+=(($n&1)-.5)*2*$n;echo abs($u);é uma maneira interessante
Jörg Hülsermann
2

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!

bartavelle
fonte
11
Pode in-line s: ((*)=<<((-1)^)).
nimi
11
É um byte mais curto para escrever (\x->x*(-1)^x).
Xnor
1

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.
Sean
fonte
1

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
Skidsdev
fonte
1

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.

Frédéric
fonte
<1é um byte menor que ==0, mas observe que você também pode inserir entradas como uma lista de dígitos.
Giuseppe
@Giuseppe Bem avistado! Obrigado !
Frédéric
1

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!

ADDB
fonte
1

C #, 67 bytes

namespace System.Linq{a=>Math.Abs(a.Sum(n=>n%2<1)-a.Sum(n=>n%2>1))}
TheLethalCoder
fonte
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
Urna de polvo mágico
fonte
1

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

Cody Gray
fonte
1

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(.
lirtosiast
fonte
1

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