Görev

Bir pozitif tamsayı dizisi göz önüne alındığında, her bir öğeyi diğer öğelerin toplamının paritesi ile değiştirin. Dizinin en az 2 elemana sahip olması garanti edilir .

Tanım

• Eşlik: bir sayının tek mi, çift mi olduğu.

Örnek

Dizi için [1,2,3,1]:

• Örneğin 1paritesiyle değiştirin .2+3+1even
• Örneğin 2paritesiyle değiştirin .1+3+1odd
• Örneğin 3paritesiyle değiştirin .1+2+1even
• Örneğin 1paritesiyle değiştirin .1+2+3even

Çıktı: [even, odd, even, even]

Giriş

Bir pozitif tamsayı dizisi.

Uygun bir dizi olarak veya satır besleme ayrılmış pozitif tamsayılar dizisi olarak alabilirsiniz.

Dizinin ve içindeki değerlerin, dilinizin kullanım kapasitesi içinde olduğunu varsayabilirsiniz.

Çıktı

Biri temsil eden , biri temsil eden iki tutarlı değer dizisi .oddeven

İki değerin satır besleme ayrılmış bir dizesi olarak çıktı alabilirsiniz.

testcases

girişler:

[1, 2, 3, 1]
[1, 2, 3, 2, 1]
[2, 2]
[100, 1001]

Çıktılar:

[even, odd, even, even]
[even, odd, even, odd, even]
[even, even]
[odd, even]

Not: oddve dışındaki diğer tutarlı değerleri seçebilirsiniz even.

puanlama

Bu kod golfü . Bayt cinsinden en kısa cevap kazanır.

Standart boşluklar geçerlidir.

Jöle , 3 bayt

+SḂ

Çevrimiçi deneyin!

Nasıl çalışır

+SḂ  Main link. Argument: A (array)

 S   Compute the sum of A.
+    Add the sum to each element of A.
     Using _ (subtraction) or ^ (bitwise XOR) would also work.
  Ḃ  Bit; compute the parity of each resulting integer.

JavaScript (ES6), 38 36 32 bayt

a=>a.map(b=>eval(a.join`+`)-b&1)

Tek 0ve 1tuhaf kullanım için .

Ölçek

f=
a=>a.map(b=>eval(a.join`+`)-b&1)
console.log(f([1, 2, 3, 1]))
console.log(f([1, 2, 3, 2, 1]))
console.log(f([100, 1001]))

Haskell, 20 bayt

f x=odd.(sum x-)<$>x

Kullanımları Truegarip değerleri için ve Falsehatta değerler için.

Çevrimiçi deneyin!

Her bir öğeyi listenin toplamından çıkarın ve tek olup olmadığını test edin.

fpointfree döndü da 20 bayt vardır: map=<<(odd.).(-).sum.

MATL , 5 , 4 bayt

ts-o

Çevrimiçi deneyin!

Dennis sayesinde bir bayt kurtarıldı!

Bu, tek için '1' ve hatta '0' verir. Açıklama:

t       % Duplicate the input
 s      % Get the sum of the input
  -     % Subtract it from the original input
   o    % Get the parity of each element

Alice , 31 28 bayt

/O.HQ\d$K@
\i#\ /d2-&+!w?+2%

Çevrimiçi deneyin!

Giriş biçimi, tamsayılar ayrıldığı sürece önemli değildir. Çıkış formatı satır besleme ile ayrılmıştır.

Düzen muhtemelen hala en uygun değil, ancak bunu daha da kısaltmanın bir yolunu bulamadım.

açıklama

/     Reflect to SE. Switch to Ordinal.
i     Read all input as a string.
      Reflect off bottom boundary. Move to NE.
.     Duplicate the input string.
      Reflect off top boundary. Move to SE.
\     Reflect to N. Switch to Cardinal.
H     Implicitly convert the top copy of the input to the integers it
      contains and take the absolute value of the top-most one. (Taking
      the absolute value doesn't do anything, but we need the implicit
      conversion to integers.)
      The IP wraps back to the second line.
\     Reflect to SE. Switch to Ordinal.
      Immediately reflect off bottom boundary. Move to NE.
Q     Reverse the stack (this converts the integers back to strings but
      that's irrelevant). After this, we end up with all the individual
      integers on the bottom of the stack in reverse order and the other
      copy of the input string with all integers on top.
      Reflect off top boundary. Move to SE.
/     Reflect to E. Switch to Cardinal.
d     Push the stack depth, which is one more than the number of list
      elements (due to the other input string on the stack).
2-    Subtract 2.
&+    Run + that many times, which implicitly converts the second string
      to the integers it contains and then adds up all the list elements.
!     Store the sum on the tape.
w     Push the current IP position to the return address stack. This
      lets us return here repeatedly to implement a loop.

  ?+    Retrieve the input sum from the tape and add it to the current
        element.
  2%    Compute its parity. Other ways to do this are 1A and 0x. 2F would
        also work but it gives 0/2 instead of 0/1.
        The IP wraps the first column of the grid.
  \     Reflect to NE. Switch to Ordinal. The IP bounces diaginally up
        and down until it hits the next \.
  O     Implicitly convert the current parity to a string and print it
        with a trailing linefeed.
  #     Skip the next command (the H).
  \     Reflect to E. Switch to Cardinal.
  d     Push the stack depth. This is zero when we're done.
  $     Skip the next command if the stack depth is indeed zero, which
        exits the loop.

K     Jump to the return address on top of the return address stack without
      popping it (so that the next K will jump there again).

@     Terminate the program.

Pyth, 7 6 bayt

mi2-sQ

@KZhang sayesinde -1 Bayt

Tek için 1, çift için 2 çıkışı.

Dene!

açıklama

m%-sQd2
m      Q    # For each element in the (implicit) input list
   sQ       # Take the sum of all the elements
  -  d      # subtract that element, so that we now have the sum of the other elements
 %    2     # modulo 2; 1=off, 0=even

05AB1E (eski) , 4 3 bayt

O^È

Çevrimiçi deneyin!

O   # Sum
 ^  # XOR with (implicit) input
  È # Print 1 for even / 0 for odd

Python 2 , 33 31 bayt

^{Leaky Nun sayesinde -2 bayt}

lambda x:[sum(x)-z&1for z in x]

Çevrimiçi deneyin!

R, 21 bayt

(sum(n<-scan())-n)%%2

stdin'den listeyi okur ve çift için 0, tek için 1 döndürür. girişi dışardan çağırmak yerine nçağrının içindeki değişkene bağlar;sumn=scan();(sum(n)-n)%%2

Çevrimiçi deneyin!

Mathematica, 13 bayt

#+Tr@#&/*OddQ

veya

OddQ[#+Tr@#]&

Clojure, 30 bayt

#(for[i %](odd?(apply - i %)))

Sırasıyla her bir değerden tüm değerleri çıkarır, örneğin girişle [a b c d]hesaplanan 2. değer b - a - b - c - d= -(a + c + d). Çıktı falsedüzgün ve truetek içindir.

Ancak +sonraki her terimi iki kez de kullanabilir ve hesaplayabilirsiniz, böylece pariteyi etkilemez.

CJam , 10 bayt

{_:+f+1f&}

Bu, girdiyi yığından alan ve çıktı ile değiştiren adsız bir bloktur (fonksiyon).

Çevrimiçi deneyin!

açıklama

Girişi düşünün [1 2 3 1].

{         e# Begin block
          e#   STACK: [1 2 3 1]
  _       e#   Duplicate
          e#   STACK: [1 2 3 1], [1 2 3 1]
  :+      e#   Fold addition over the array: compute its sum
          e#   STACK: [1 2 3 1], 7 
  f+      e#   Map addition over the array with extra parameter
          e#   STACK: [8 10 11 8]
  1       e#   Push 1
          e#   STACK: [8 10 11 8], 1
  f&      e#   Map bit-wise "and" over the array with extra parameter
          e#   STACK: [0 0 1 0]
}         e# End block

J , 6 bayt

2|]++/

Çevrimiçi deneyin!

APL (Dyalog Unicode) , 19 7 bayt

@ Adám sayesinde 12 bayt golf oynadı

2|+/-¨⊢

Çevrimiçi deneyin!

Japt , 7 bayt

£x +X&1

Çevrimiçi deneyin!

açıklama

 £   x +X&1
 mX{ x +X&1}  // Ungolfed
UmX{Ux +X&1}  // Variable introduction

UmX{       }  // Replace each item in the input array with
         &1   //   the parity of
    Ux        //   the sum of the input array
       +X     //   plus X.
              // Implicit: output result of last expression

Perl 5, 31 bayt

sub{map$x+=$_,@_;map$x-$_&1,@_}

1Tek ve çiftler için çıkışlar 0.

Clojure (Betik), 36 bayt

Çıktı truetek ve falseçift ​​içindir. Hem çıkış hem giriş dizilerdir.

(fn[l](map #(odd?(-(apply + l)%))l))

PHP, 50 Bayt

Çevrimiçi Sürümler

Tek için 1, çift için 0

Ayrılmış dize olarak çıktı _

<?foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;

PHP, 72 Bayt

Dizi kullanımı olarak çıktı array_map

<?print_r(array_map(function($v){return array_sum($_GET)-$v&1;},$_GET));

C, 68 62 bayt

i;s;f(c,l)int*l;{while(i<c)s+=l[i++];while(i)l[--i]=s-l[i]&1;}

Tek için 1, çift için 0

Detaylı Deneyin Çevrimiçi

f(int c, int * l)
{
    int i = 0, s = 0;

    while(i < c)
    {
        s = s + l[i];
        i = i + 1;
    }

    // assert(i == c)

    while(i > 0)
    {
        i = i - 1;
        l[i] = s - l[i]&1;
    }
}

Retina , 40 38 bayt

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶
 

Çevrimiçi deneyin! Tek için 1, çift için 0 çıkışı. Açıklama: İlk iki satır, girdideki her numara için girişi bir kez çoğaltır, ancak öğenin kendisi olmadan. Bu daha sonra silinen fazladan bir boş satır oluşturur. Girdi daha sonra onluktan tek birime dönüştürülür, boşluklar silinir ve parite hesaplanır. Daha sonra parite bile sıfıra dönüştürülür ve sonuçlar bir satırda tekrar birleştirilir. Düzenleme: @ FryAmTheEggman sayesinde 2 bayt kaydedildi. Kavramsal olarak daha sevindirici olan ancak ifade etmesi çok fazla bayt alan başka sürümleri de denedim:

\d\B

T`2468O`00001
T`d`10`^([^1]*1[^1]*1)*[^1]*1[^1]*$

Tüm girişleri parite olarak değiştirir, daha sonra eğer toplam tuhaf bir parite varsa tüm pariteleri çevirir.

\d+
$*
^.*
$&¶$&
 (?=.*$)

11

\B
0
T`d`10`.*¶1
¶0

Girişin bir kopyasını toplar, sonra her şeyin paritesini alır, sonra toplam tuhafsa pariteleri tersine çevirir, sonra toplamı tekrar siler.

Ohm , 4 bayt

DΣ-é

Çevrimiçi deneyin!

Temel olarak MATL ve 05AB1E'nin doğrudan bir limanı cevaplar. Tek trueve falsetuhaf kullanım için .

k, 9 bayt

{2!x-+/x}

Çıktı bir 1for oddve 0hatta bir for içindir. Çevrimiçi deneyin.

Sözde koduna dönüştürülür, şöyle olurdu:

for number in x:
    yield (number - sum(x)) % 2

Scala , 19 bayt

x=>x.map(x.sum-_&1)

Çevrimiçi deneyin!

Brain-Flak , 94 68 66 bayt

({({}<>)<>})<>{<>(({})<({}<>{}<>(())){({}[()]<([{}])>)}{}>)<>}<>{}

Çevrimiçi deneyin!

Bu görev için biraz uzun görünüyor. Bunu yapmanın daha uygun bir yolu olabilir.

açıklama

İlk önce yığının toplamını şu şekilde hesaplarız:

({({}<>)<>})

Her öğeye bu sonucu ekleyerek tüm yığını gözden geçiririz ve çiftliği belirleriz

<>{<>(({})<({}<>{}<>(())){({}[()]<([{}])>)}{}>)<>}<>{}

Bu, bu meydan okuma için bulduğum oldukça serin bir mod 2 algoritması kullanır.

({}(())){({}[()]<([{}]())>)}{}

Bu 1-n, daha önce koyduğumuz 1'e göre her defasında giriş sıfıra ulaşana kadar giriş düşüşlerinin altına 1 basar , ardından girişi kaldırır.

Bilge , 54 52 bayt

::^:??[:!^:?^:!^:?^?]|!::^??[!:?^:><^!:?^:!^:?^?]!&|

Çevrimiçi deneyin!

açıklama

İlk iki öğeyi değiştirmek için çok fazla bayt almadıysanız bu kod daha kısa olacaktır. Mevcut kayıt

:?^:!^:?^!

Bu ne yazık ki kodun çoğunluğunu oluşturur.

İlk önce yığının XOR toplamını alırız

::^:??[:!^:?^:!^:?^?]|!

Daha sonra bunu XOR ile her elementle ve onunla birlikte geçen bit sıfırla

::^??[!:?^:><^!:?^:!^:?^?]!&|

Java , 81 78 bayt

Kevin Cruissen sayesinde 3 bayt

void f(int[]a){int s=0,i=a.length;for(int x:a)s+=x;for(;i-->0;a[i]=s-a[i]&1);}

Çevrimiçi deneyin!

Diziyi yerinde değiştirir.

AWK , 64 bayt

{for(i=0;++i<=NF;print s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}

Çevrimiçi deneyin!

Yeni satırlarla ayrılmış 0eşit toplamlar ve 1tekli toplamlar için a değerini verir. Kutudan çıkmayan tek düşünce bile, printkomutu for"artış" adımının içine yerleştirmekti . Yazdırmanın birkaç "akıllı" yolunu denedim, ancak bayt kaydetmediler.

Sadece kıkırdamak için, eğer yeni satır istemiyorsanız:

{for(i=0;++i<=NF;m=m,s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}1

yukarıdaki gibi aynı bayt sayısına sahip olan, ancak biraz daha geniş.

Swift - 55 bayt

^{Sonunda C yener! Ayrıca, çift için 0, tek için 1}

func g(a:[Int]){for i in a{print((a.reduce(0,+)-i)%2)}}

Kullanım ile bir işlev: g(a: [1,2,3,2,1] // => 0 1 0 1 0

Bunu kontrol et!

Aksiyom, 45 bayt

f(a)==[(reduce(+,a)-a.j)rem 2 for j in 1..#a]

giriş tipi için kontrol yok, "a" toplamının yeniden hesaplanması, her bir eleman ... testler

(27) -> [[a,f(a)] for a in [[1,2,3,1], [1,2,3,2,1], [2,2], [100, 1001] ]]
   (27)
   [[[1,2,3,1],[0,1,0,0]], [[1,2,3,2,1],[0,1,0,1,0]], [[2,2],[0,0]],
    [[100,1001],[1,0]]]

Julia 1.0 , 17 bayt

x->(sum(x).-x).%2

Çevrimiçi deneyin!