Если задано неотрицательное целое число, вернуть абсолютную разницу между суммой его четных цифр и суммой его нечетных цифр.

Правила по умолчанию

• Стандартные лазейки применяются.

• Вы можете получить ввод и обеспечить вывод любым стандартным методом ввода / вывода.

• Вы можете принять ввод как строку, как целое число или как список цифр.

• Это код-гольф , поэтому выигрывает самый короткий код в байтах на каждом языке !

Тестовые случаи

Вход ~> Выход

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)

Желе , 6 байт

-*æ.¹A

Попробуйте онлайн!

Как это устроено

-*æ.¹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 MCxxxx, 197 (126 + 71) байт

Микросхема 1 (MC6000):

• x0: ввод в виде списка
• х2: чип 2 х1
• х3: 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

Микросхема 2 (MC4000):

• p0: выход
• х0: MC4010
• х1: чип 1 х2

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

Python 2, 39 байт

Принимает целое число как список. Попробуйте онлайн

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

-3 байта благодаря @ Mr.Xcoder
-1 байт благодаря @ovs

TI-Basic, 18 9 байтов

abs(sum((-1)^AnsAns

объяснение

Умножает каждую цифру в списке на -1 до ее степени, сводя к нулю каждую нечетную цифру, прежде чем их суммировать.

C (gcc) , 59 58 57 байт

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

Попробуйте онлайн!

R, 30 29 байт

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

d = scan() принимает входной номер на одну цифру за другой.

-1 байт благодаря @Giuseppe!

C #, 57 байт

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

Принимает ввод как iи суммирует целые числа, превращая шансы в минус.

Mathematica, 20 байтов

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

принимает в качестве входных данных список цифр

Отдельное спасибо @LLlAMnYP за сообщение о «новых правилах»

Japt , 8 байт

x_*JpZÃa

Проверьте это онлайн!

объяснение

 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

Нейм , 7 байт

ΓDᛃΞ𝐍}𝐬

Объяснение:

Γ        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 байт

|⊢+.ׯ1*⊢

Попробуйте онлайн!

Как?

¯1*⊢- -1 ^п для nв⍵

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

⊢+.×- вертикованное умножение с o, затем сумма

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

| - абсолютная величина

JavaScript (ES6), 43 38 байт

Вводит в виде строки массив цифр.

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

Контрольные примеры

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)

РЕДАКТИРОВАТЬ: более ориентированный на гольф подход:

EXCEL, 42 36 29 байт

Сохранено 6 байтов благодаря Magic Octopus Urn. Сохранено 7 байтов с использованием подхода Денниса -1 ^ (который, как я только что узнал, работает с массивами в Excel)

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

Принимает список целых чисел в столбце A для ввода. Вероятно, можно продолжить игру или использовать строковую версию, взяв строку в A1 для ввода.

EXCEL, 256 байт

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

Юлия 0,5 , 19 байт

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

Попробуйте онлайн!

Шелуха , 7 байт

≠0ṁṠ!¡_

Попробуйте онлайн!

Принимает список цифр в качестве ввода.

Все еще отсутствует встроенный "abs", но все равно хороший результат :)

объяснение

Ṡ!¡_является функцией, которая принимает число, nа затем применяет n-1время, к которому функция _(отрицание) n. Это приводит nк нечетным nили -nчетным n.

ṁ применяет функцию к каждому элементу списка и суммирует результаты.

≠0 возвращает абсолютную разницу между числом и 0.

05AB1E , 6 байтов

Спасибо Деннису за трюк -1. Принимает ввод в виде списка цифр

®sm*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 байт

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

добавляет цифру к $sесли нечетное, вычитает если четное. Беги как труба с -nR.

или

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

используя трюк -1силы Денниса .

Mathematica, 67 байт

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

PHP , 54 байта

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

Попробуйте онлайн!

PHP , 57 байт

хранить четные и нечетные суммы в массиве

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

Попробуйте онлайн!

PHP , 57 байт

хранить четные и нечетные суммы в двух переменных

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

Попробуйте онлайн!

Haskell , 47 42 39 38 26 25 байт

-1 спасибо Ними

-12 благодаря Брюсу

-1 спасибо xnor

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

Попробуйте онлайн!

Perl 6 , 28 байт

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

Попробуйте онлайн!

Принимает список цифр в качестве ввода.

• $_ является входным аргументом.
• .map(* % 2 * 2 - 1)отображает каждую цифру в одну 1или в -1зависимости от того, является ли цифра нечетной или четной, соответственно.
• Z* Сжатие исходного списка цифр с четным / нечетным списком с использованием умножения.

Брайнгольф , 18 байт

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

Попробуйте онлайн!

Вводит в виде списка цифр

объяснение

{.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 байта

b=(d=scan())%%2<1;abs(sum(d[b])-sum(d[!b]))

Первый, d = scan() принимает число в качестве входных данных, одну цифру за другой (благодаря комментарию @Giuseppe!).
Затем b = d %% 2 <1ассоциируется bсо значением TRUEили FALSEв каждом индексе в зависимости от четности цифр. Таким образом, bзначения TRUEдля четных чисел, и !bявляютсяTRUE для нечетных значений.

Наконец, abs(sum(d[b]) - sum(d[!b]))делает работу.

Баш 141 139 99 байт

while read -n1 a; do
[ $[a%2] = 0 ]&&e=$[e+a]||o=$[o+a]
done
(($[e-o]>0))&&echo $[e-o]||echo $[o-e]

Попробуйте онлайн!

Java (OpenJDK 8) , 55 байт

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

Попробуйте онлайн!

Наивная реализация.

C #, 67 байт

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

05AB1E , 7 байтов

È2*<*OÄ

Попробуйте онлайн!

        # 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, 30 байт

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

Приведенный выше код определяет функцию, которая принимает список / массив целочисленных цифр и возвращает абсолютную разницу между суммой четных цифр и суммой нечетных цифр.

Как в С , язык ассемблера не реализует списки или массивы как первоклассные типы, а скорее представляет их как комбинацию указателя и длины. Поэтому я организовал для этой функции прием двух параметров: первый - указатель на начало списка цифр, а второй - целое число, определяющее общую длину списка (общее количество цифр, одноиндексированное) ,

Функция соответствует соглашению о вызовах System64 AMD64 , стандартному для систем Gnu / UNIX. В частности, первый параметр (указатель на начало списка) передается RDI(так как это 64-разрядный код, это 64-разрядный указатель), а второй параметр (длина списка) передается в ESI( это всего лишь 32-битное значение, потому что для этого более чем достаточно цифр, и, естественно, предполагается, что оно ненулевое). Результат возвращается в EAXрегистр.

Если это будет более понятным, это будет прототип C (и вы можете использовать это для вызова функции из C):

int OddsAndEvens(int *ptrDigits, int length);

Неуправляемая сборка мнемоники:

; 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

Вот краткий обзор кода:

• Во- первых, мы обнулить EAXи EDXрегистры, которые будут использоваться для хранения сумм суммы четных и нечетных цифр. EAXРегистр очищается от XORING его с собой (2 байта), а затем EDXрегистр очищается от входа продлевая EAX в него ( CDQ1 байт).

• Затем мы идем в цикл, который перебирает все цифры, передаваемые в массиве. Он извлекает цифру, проверяет, является ли она четным или нечетным (проверяя младший значащий бит, который будет равен 0, если значение является четным, или 1, если он нечетный), а затем, соответственно, перепрыгивает или падает, добавляя, что значение для соответствующего аккумулятора. В нижней части цикла мы уменьшаем счетчик цифр ( ESI) и продолжаем цикл до тех пор, пока он не равен нулю (т. Е. До тех пор, пока в списке осталось больше цифр, которые нужно извлечь).

  Единственная сложность здесь - это начальная инструкция MOV, которая использует наиболее сложный режим адресации, возможный на x86. ^* Он принимает RDIв качестве базового регистра (указатель на начало списка), масштабирует RSI(счетчик длины, который служит индексом) на 4 (размер целого числа в байтах) и добавляет его к базе, и затем вычитает 4 из общей суммы (потому что счетчик длины основан на единице, и нам нужно, чтобы смещение было на основе нуля). Это дает адрес цифры в массиве, который затем загружается в ECXрегистр.

• После завершения цикла мы делаем вычитание шансов из четных ( EAX -= EDX).

• Наконец, мы вычисляем абсолютное значение, используя общий прием - тот же, который используется большинством компиляторов Си для absфункции. Я не буду вдаваться в подробности о том, как этот трюк работает здесь; см. комментарии к коду для подсказок или выполните поиск в Интернете.

__
_{* Код можно переписать, чтобы использовать более простые режимы адресации, но это не делает его короче. Я смог придумать альтернативную реализацию, которая разыменовывала RDIи увеличивала его на 8 каждый раз в цикле, но, поскольку вам все еще нужно уменьшить счетчик ESI, это оказалось теми же 30 байтами. То, что изначально дало мне надежду, это то, что add eax, DWORD PTR [rdi]это всего 2 байта, то же самое, что добавить два зарегистрированных значения. Вот эта реализация, хотя бы для того, чтобы спасти любого, кто пытается переиграть меня :-)}

                    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 байтов

abs(sum(Anscos(πAns

Принимает ввод в виде списка. i²^Ansсохраняет два байта, (-1)^Ansпотому что нам не нужны скобки.

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 байт

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

Попробуйте онлайн!

объяснение

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