Tugas

Diberikan array bilangan bulat positif, ganti setiap elemen dengan paritas dari jumlah elemen lainnya. Array dijamin memiliki setidaknya 2 elemen.

Definisi

• Paritas: apakah suatu angka ganjil atau genap.

Contoh

Untuk array [1,2,3,1]:

• Ganti 1dengan paritas 2+3+1, yaitu even.
• Ganti 2dengan paritas 1+3+1, yaitu odd.
• Ganti 3dengan paritas 1+2+1, yaitu even.
• Ganti 1dengan paritas 1+2+3, yaitu even.

Keluaran: [even, odd, even, even]

Memasukkan

Array integer positif.

Anda dapat menganggapnya sebagai array yang tepat, atau sebagai string bilangan bulat positif yang dipisahkan oleh linefeed.

Anda dapat mengasumsikan bahwa array dan nilai-nilai di dalamnya berada dalam kemampuan penanganan bahasa Anda.

Keluaran

Array dua nilai yang konsisten , satu mewakili odd, satu mewakili even.

Anda dapat menampilkannya sebagai string yang dipisahkan oleh umpan baris dari kedua nilai.

Testcases

Input:

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

Output:

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

Catatan: Anda dapat memilih nilai konsisten lainnya selain odddan even.

Mencetak gol

Ini adalah kode-golf . Jawaban terpendek dalam byte menang.

Celah standar berlaku.

Jelly , 3 byte

+SḂ

Cobalah online!

Bagaimana itu bekerja

+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 byte

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

Penggunaan 0untuk genap dan 1ganjil.

Uji

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 byte

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

Menggunakan Truenilai ganjil dan Falsenilai genap.

Cobalah online!

Kurangi setiap elemen dari jumlah daftar dan uji apakah itu aneh.

fberpaling ke pointfree juga memiliki 20 byte: map=<<(odd.).(-).sum.

MATL , 5 , 4 byte

ts-o

Cobalah online!

Satu byte disimpan berkat Dennis!

Ini memberi '1' untuk ganjil dan '0' untuk genap. Penjelasan:

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 byte

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

Cobalah online!

Format input tidak masalah selama bilangan bulat dipisahkan. Format output dipisahkan dengan linefeed.

Tata letaknya mungkin masih belum optimal tetapi saya belum menemukan cara untuk mempersingkat ini lebih lanjut.

Penjelasan

/     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 byte

mi2-sQ

-1 Byte berkat @KZhang

Output 1 untuk ganjil, 2 untuk genap.

Cobalah!

Penjelasan

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 (legacy) , 4 3 byte

O^È

Cobalah online!

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

Python 2 , 33 31 byte

^{-2 byte terima kasih untuk Leaky Nun}

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

Cobalah online!

R, 21 byte

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

membaca daftar dari stdin dan mengembalikan 0 untuk genap, 1 untuk ganjil. mengikat input ke variabel ndi dalam panggilan sumalih-alih memanggilnya di luar, yaitu,n=scan();(sum(n)-n)%%2

Cobalah online!

Mathematica, 13 byte

#+Tr@#&/*OddQ

atau

OddQ[#+Tr@#]&

Clojure, 30 byte

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

Kurangi semua nilai dari setiap nilai secara bergantian, misalnya dengan input [a b c d], nilai yang dihitung ke-2 adalah b - a - b - c - d= -(a + c + d). Output adalah falseuntuk genap dan trueganjil.

Tetapi Anda sebaiknya menggunakan +dan menghitung setiap istilah berikutnya dua kali sehingga tidak mempengaruhi paritas.

CJam , 10 byte

{_:+f+1f&}

Ini adalah blok anonim (fungsi) yang mengambil input dari tumpukan dan menggantinya dengan output.

Cobalah online!

Penjelasan

Pertimbangkan input [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 byte

2|]++/

Cobalah online!

APL (Dyalog Unicode) , 19 7 byte

Golf 12 byte berkat @ Adám

2|+/-¨⊢

Cobalah online!

Japt , 7 byte

£x +X&1

Cobalah online!

Penjelasan

 £   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 byte

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

Output 1untuk ganjil dan 0genap.

Clojure (Script), 36 byte

Output trueuntuk ganjil dan falsegenap. Output dan input keduanya adalah urutan.

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

PHP, 50 Bytes

Versi Online

1 untuk ganjil, 0 untuk genap

Output sebagai string dipisahkan dengan _

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

PHP, 72 Bytes

Output sebagai penggunaan array array_map

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

C, 68 62 byte

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

1 untuk ganjil, 0 untuk genap

Detail Coba Online

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 byte

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶
 

Cobalah online! Output 1 untuk odd dan 0 untuk even. Penjelasan: Dua baris pertama menduplikasi input sekali untuk setiap angka dalam input, tetapi tanpa elemen itu sendiri. Ini menciptakan baris kosong tambahan yang kemudian dihapus. Input kemudian dikonversi dari desimal ke unary, spasi dihapus dan paritas dihitung. Bahkan paritas kemudian dikonversi menjadi nol dan hasilnya bergabung kembali ke satu baris. Sunting: Disimpan 2 byte berkat @FryAmTheEggman. Saya mencoba beberapa versi lain yang secara konseptual lebih menyenangkan tetapi terlalu banyak byte untuk diekspresikan:

\d\B

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

Ubah semua input ke paritasnya, lalu membalik semua paritasnya jika totalnya memiliki paritas ganjil.

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

11

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

Menjumlahkan duplikat dari input, kemudian mengambil paritas dari segalanya, lalu membalikkan paritas jika jumlahnya ganjil, lalu menghapus jumlahnya lagi.

Ohm , 4 byte

DΣ-é

Cobalah online!

Pada dasarnya port langsung dari MATL dan 05AB1E jawaban. Penggunaan trueuntuk genap dan falseganjil.

k, 9 byte

{2!x-+/x}

Outputnya adalah 1untuk odd, dan 0bahkan untuk. Cobalah online.

Dikonversi menjadi pseudocode, itu akan menjadi:

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

Scala , 19 byte

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

Cobalah online!

Brain-Flak , 94 68 66 byte

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

Cobalah online!

Ini sepertinya agak lama untuk tugas itu. Mungkin ada cara yang lebih nyaman untuk melakukan ini.

Penjelasan

Pertama kita menghitung jumlah tumpukan dengan:

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

Kami pergi melalui seluruh tumpukan menambahkan hasil itu untuk setiap elemen dan menentukan pasangan

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

Ini menggunakan algoritma mod 2 yang cukup keren yang saya buat untuk tantangan ini.

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

Ini mendorong 1 di bawah pengurangan input sampai input mencapai nol setiap kali melakukan 1-nke 1 yang kita tempatkan sebelumnya, itu kemudian menghapus input.

Wise , 54 52 byte

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

Cobalah online!

Penjelasan

Kode ini akan jauh lebih pendek jika tidak memerlukan banyak byte untuk menukar dua elemen teratas. Catatan saat ini adalah

:?^:!^:?^!

Sayangnya ini merupakan mayoritas kode.

Pertama kita ambil jumlah XOR dari stack

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

Kami kemudian XOR ini dengan setiap elemen dan elemen dengan bit terakhir memusatkan perhatian

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

Jawa , 81 78 byte

3 byte, terima kasih kepada Kevin Cruissen

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

Cobalah online!

Memodifikasi array di tempat.

AWK , 64 byte

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

Cobalah online!

Output a 0untuk jumlah genap dan 1untuk jumlah ganjil dipisahkan oleh baris baru. Satu-satunya pemikiran yang sedikit di luar kebiasaan adalah menempatkan printperintah di dalam langkah for"kenaikan". Saya mencoba beberapa cara "pintar" untuk mencetak, tetapi mereka tidak menyimpan byte.

Hanya untuk cekikikan, jika Anda tidak ingin baris baru:

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

yang memiliki byte-count yang sama seperti di atas, tetapi sedikit lebih tumpul.

Swift - 55 byte

^{Akhirnya ketukan C! Juga, 0 untuk genap, 1 untuk ganjil}

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

Fungsi, dengan penggunaan: g(a: [1,2,3,2,1] // => 0 1 0 1 0

Saksikan berikut ini!

Aksioma, 45 byte

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

tidak memeriksa jenis input, perhitungan ulang kemungkinan jumlah "a" setiap elemen ... tes

(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 byte

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

Cobalah online!