Negatif olmayan bir tam sayı verildiğinde, çift basamaklarının toplamı ile tek basamaklarının toplamı arasındaki mutlak farkı döndürün.

Varsayılan Kurallar

• Standart Loopholes uygulanır.

• Herhangi bir standart Giriş / Çıkış yöntemiyle girdi alabilir ve çıktı sağlayabilirsiniz.

• Girdiyi Dize, Tamsayı veya rakam listesi olarak alabilirsiniz.

• Bu kod golf , bu yüzden her dilde bayt en kısa kod kazanır!

Test Durumları

Giriş ~> Çıkış

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)

Jöle , 6 bayt

-*æ.¹A

Çevrimiçi deneyin!

Nasıl çalışır

-*æ.¹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 komut dosyaları, 197 (126 + 71) bayt

Çip 1 (MC6000):

• x0: Liste olarak giriş
• x2: Çip 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

Çip 2 (MC4000):

• p0: Çıkış
• x0: MC4010
• x1: Çip 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 bayt

Tamsayı liste olarak alır. Çevrimiçi deneyin

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

@ Mr.Xcoder sayesinde -3 bayt @ovs
sayesinde -1 bayt

TI-Basic, 18 9 bayt

abs(sum((-1)^AnsAns

açıklama

Listedeki her bir basamağı -1 ile çarparak, her bir tek basamağı toplamadan önce yok eder.

C (gcc) , 59 58 57 bayt

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

Çevrimiçi deneyin!

R, 30 29 bayt

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

d = scan() giriş numarasını arka arkaya bir basamak alır.

@Giuseppe sayesinde -1 bayt!

C #, 57 bayt

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

Girdi olarak alır ive olasılıkları negatife çevirerek tam sayıları toplar.

Mathematica, 20 bayt

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

girdi olarak bir basamak listesi alır

"yeni kurallar" hakkında bilgi verdiğiniz için @LLlAMnYP'ye özel teşekkürler

Japt , 8 bayt

x_*JpZÃa

Çevrimiçi test edin!

açıklama

 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 bayt

ΓDᛃΞ𝐍}𝐬

Açıklama:

Γ        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 bayt

|⊢+.ׯ1*⊢

Çevrimiçi deneyin!

Nasıl?

¯1*⊢- -1 ^{, n} için nde⍵

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

⊢+.×- ile verctorized çarpma oardından toplamı

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

| - mutlak değer

JavaScript (ES6), 43 38 bayt

Girdi dizgisini bir dizi basamak alır.

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

Test senaryoları

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: Daha golf merkezli bir yaklaşım:

EXCEL, 42 36 29 bayt

Magic Octopus Urn sayesinde 6 bayt kaydedildi Dennis '-1 ^ yaklaşımını kullanarak 7 bayt kaydetti (az önce öğrendim, Excel'deki diziler üzerinde çalışıyor)

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

Giriş için A sütunundaki tam sayıların bir listesini alır. Muhtemelen daha fazla golf oynayabilir veya giriş için A1'de bir dize alarak dize sürümü kullanılarak.

EXCEL, 256 bayt

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

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

Çevrimiçi deneyin!

Kabuk , 7 bayt

≠0ṁṠ!¡_

Çevrimiçi deneyin!

Rakamların bir listesini girdi olarak alır.

Hala bir "abs" yerleşik eksik, ama aynı iyi bir sonuç :)

açıklama

Ṡ!¡_bir sayı alan nve sonra n-1da işlevin _(olumsuzlama) zamanını uygulayan bir işlevdir n. Bu sonuçlar ntek için nya -nda için n.

ṁ listenin her öğesine bir işlev uygular ve sonuçları toplar.

≠0 bir sayı ile 0 arasındaki mutlak farkı döndürür.

05AB1E , 6 bayt

-1 güç numarası için Dennis'e teşekkürler . Girdileri rakam listesi olarak alır

®sm*OÄ

Çevrimiçi deneyin!

açıklama

®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 bayt

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

tekse sayı ekler $s, çift ise çıkarır. İle boru olarak çalıştırın -nR.

veya

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

Dennis´ -1güç hilesi kullanarak .

Mathematica, 67 bayt

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

PHP , 54 bayt

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

Çevrimiçi deneyin!

PHP , 57 bayt

çift ​​ve tek toplamları bir dizide saklar

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

Çevrimiçi deneyin!

PHP , 57 bayt

çift ​​ve tek toplamları iki değişkende saklamak

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

Çevrimiçi deneyin!

Haskell , 47 42 39 38 26 25 bayt

-1 sayesinde nimi

-12 Bruce sayesinde

Xnor sayesinde -1

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

Çevrimiçi deneyin!

Perl 6 , 28 bayt

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

Çevrimiçi deneyin!

Rakamların bir listesini girdi olarak alır.

• $_ girdi bağımsız değişkenidir.
• .map(* % 2 * 2 - 1)ya da her bir basamak haritalar 1veya -1basamaklı tek ya da hatta, sırasıyla bağlı olarak.
• Z* çarpma kullanarak orijinal basamak listesini çift / tek listesiyle sıkıştırır.

Braingolf , 18 bayt

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

Çevrimiçi deneyin!

Girdileri rakam listesi olarak alır

açıklama

{.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 bayt

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

İlk olarak, d = scan()numarayı girdi olarak alır, bir rakam birbiri ardına (@Giuseppe yorumu sayesinde!)
Ardından, rakamların paritesine bağlı olarak her bir dizindeki bir veya değerle b = d %% 2 <1ilişkilendirilir . Bu nedenle, değerler çift sayı için, ve olan tek değerler için.bTRUEFALSEbTRUE!bTRUE

Son olarak, abs(sum(d[b]) - sum(d[!b]))iş yapar.

Bash 141 139 99 Bayt

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

Çevrimiçi deneyin!

Java (OpenJDK 8) , 55 bayt

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

Çevrimiçi deneyin!

Saf uygulama.

C #, 67 bayt

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

05AB1E , 7 bayt

È2*<*OÄ

Çevrimiçi deneyin!

        # 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 Makine Kodu, 30 bayt

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

Yukarıdaki kod, bir tamsayı hane listesini / dizisini kabul eden ve çift hane toplamı ile tek hane toplamı arasındaki mutlak farkı döndüren bir işlevi tanımlar.

C'deki gibi dilinde , montaj dili listeleri veya dizileri birinci sınıf türleri olarak uygulamaz, aksine bunları bir işaretçi ve uzunluk kombinasyonu olarak temsil eder. Bu nedenle, bu işlevin iki parametreyi kabul etmesi için ayarladım: birincisi basamak listesinin başlangıcına bir işaretçi ve ikincisi listenin toplam uzunluğunu belirten bir tamsayıdır (toplam basamak sayısı, tek dizinli) .

İşlev , Gnu / UNIX sistemlerinde standart olan System V AMD64 çağrı kuralına uygundur . Özellikle, ilk parametre (listenin başına işaretçi) geçirilir RDI(64 bit kod olduğu için 64 bitlik bir işaretçi) ve ikinci parametre (listenin uzunluğu) iletilir ESI( bu sadece 32 bitlik bir değerdir, çünkü bu, oynamak için yeterli basamaktan fazladır ve doğal olarak sıfır olmadığı varsayılır). Sonuç EAXkayıt defterine döndürülür .

Daha açıksa, bu C prototipi olacaktır (ve işlevi C'den çağırmak için bunu kullanabilirsiniz):

int OddsAndEvens(int *ptrDigits, int length);

Ungolfed montaj anımsatıcıları:

; 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

İşte kodun kısa bir özeti:

• İlk olarak, çift ​​ve tek rakamların toplamını tutmak için kullanılacak EAXve EDXkayıtlarını sıfırlarız . EAXYazmaç ile temizlenir XORbaşına (2 byte) ile ing ve EDXyazmaç işareti uzanan içine EAX ile (temizlenir CDQ, 1 bayt).

• Ardından, dizide geçirilen tüm basamakları yineleyen döngüye giriyoruz. Bir rakam alır, çift veya tek olup olmadığını test eder (en küçük anlamlı biti test ederek, değer çiftse 0 veya tek ise 1 olur) ve ardından buna göre atlar veya düşer uygun akümülatöre Döngünün altında, basamak sayacını ( ESI) azaltır ve sıfır olmadığı sürece (yani, alınacak listede daha fazla basamak kaldığı sürece) döngüye devam ederiz .

  Burada zor olan tek şey, x86'da mümkün olan en karmaşık adresleme modunu kullanan ilk MOV talimatıdır. ^* Bu alan RDItaban kaydının (listenin başına işaretçi), terazi olarak RSI(bayt, bir tamsayı büyüklüğü) 4 ile (indir olarak uzunluğu sayacı) ve ekler tabanına ve daha sonra toplamdan 4 çıkarır (çünkü uzunluk sayacı tek tabanlıdır ve ofsetin sıfır tabanlı olması gerekir). Bu, daha sonra ECXkayıt defterine yüklenen dizideki basamağın adresini verir .

• Döngü bittikten sonra, oranların eşitlerden ( EAX -= EDX) çıkarılmasını sağlıyoruz.

• Son olarak, mutlak değeri ortak bir hile kullanarak hesaplıyoruz - absfonksiyon için çoğu C derleyicisi tarafından kullanılanla aynı . Bu hilenin burada nasıl çalıştığı hakkında ayrıntılara girmeyeceğim; ipuçları için kod yorumlarına bakın veya bir web araması yapın.

__
_{* Kod, daha basit adresleme modlarını kullanmak için yeniden yazılabilir, ancak bu kodu kısaltmaz. RDIDöngü boyunca her seferinde 8 tarafından referansı kaldırılan ve arttıran alternatif bir uygulama geliştirebildim , ancak yine de sayacı azaltmanız gerektiğinden ESI, bu aynı 30 bayt olduğu ortaya çıktı. Başlangıçta bana umut veren add eax, DWORD PTR [rdi]şey, sadece 2 bayt, iki kayıtlı değer eklemekle aynı. İşte bana, biraz çaba sarf etmeye çalışan herkes kurtarmak için bu uygulama :-)}

                    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 bayt

abs(sum(Anscos(πAns

Girişi liste olarak alır. parantezlere ihtiyacımız olmadığından i²^Ansiki bayt tasarruf sağlar (-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 bayt

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

Çevrimiçi deneyin!

açıklama

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