Враховуючи невід'ємне ціле число, поверніть абсолютну різницю між сумою його парних цифр і сумою його непарних цифр.

Правила за замовчуванням

• Застосовуються стандартні лазівки.

• Ви можете приймати введення та забезпечувати вихід будь-яким стандартним методом вводу / виводу.

• Ви можете приймати дані як рядки, як цілі, або як список цифр.

• Це код-гольф , тому найкоротший код у байтах кожною мовою виграє!

Випробування

Вхід ~> Вихід

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 I / O MCxxxx, 197 (126 + 71) байт

Чіп 1 (MC6000):

• x0: Введіть як список
• x2: Чіп 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

Чіп 2 (MC4000):

• p0: вихід
• x0: MC4010
• x1: Чіп 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 байт

Бере ціле число як список. Спробуйте в Інтернеті

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і підсумовує цілі числа, перетворюючи коефіцієнт на негативний.

Математика, 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)

EDIT: Більш орієнтований на гольф підхід:

EXCEL, 42 36 29 байт

Збережено 6 байт завдяки Magic Octopus Urn Збережено 7 байтів за допомогою підходу Денніса -1 ^ (який, я щойно дізнався, працює над масивами в excel)

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

Бере список цілих чисел у стовпці A для введення. Ймовірно, можна пограти далі в гольф, або скориставшись рядковою версією, взявши рядок в А1 для введення.

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ṁṠ!¡_

Спробуйте в Інтернеті!

Візьме список цифр як вхідний.

Ще не вистачає "абс" вбудованого, але хороший результат все-таки :)

Пояснення

Ṡ!¡_це функція, яка приймає число, 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силовий трюк Денніса .

Математика, 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* переносить оригінальний список цифр за допомогою парного / непарного списку, використовуючи множення.

Braingolf , 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зіставляє або значення за кожним показником в залежності від парності чисел. Таким чином, значення для парних чисел, і є для непарних значень.bTRUEFALSEbTRUE!bTRUE

Нарешті, abs(sum(d[b]) - sum(d[!b]))робить роботу.

Bash 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

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

Як у С , мова складання не реалізує списки або масиви як першокласні типи, а представляє їх як комбінацію вказівника та довжини. Тому я домоглася, щоб ця функція приймала два параметри: перший - вказівник на початок списку цифр, а другий - ціле число, що визначає загальну довжину списку (загальна кількість цифр, одноіндексований) .

Ця функція відповідає умові виклику System V 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реєстр, XORвводячи його в себе (2 байти), а потім EDXочищає регістр шляхом розширення знака EAX до нього ( CDQ, 1 байт).

• Потім ми переходимо до циклу, який повторюється через усі цифри, передані в масиві. Він отримує цифру, перевіряє, чи є парним або непарним (випробувавши найменш значущий біт, який буде 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)