Paritas jumlah elemen lainnya

23

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.

code-golf  array-manipulation 
— Biarawati Bocor
sumber

Jawaban:

16

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.
— Dennis
sumber
Itu pendekatan yang cerdas.
— Leaky Nun
1
@ LeakyNun Ini adalah pendekatan yang sama yang digunakan orang lain, hanya lebih pendek: P
— ETHproduk
@ ETHproduksi Cukup banyak, ya. Hanya ada begitu banyak cara untuk menghitung paritas ...
— Dennis
@ ETHproductions ini menggunakan penambahan bukan pengurangan ...
— Leaky Nun
@ LeakyNun Benar, jawaban Japt saya juga. Dalam Jelly itu hanya menjadi_SḂ
— ETHproduksi
8

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]))
Luaskan cuplikan

— Luke
sumber
2 byte off: c-b&1alih-alih(c-b)%2
— Leaky Nun
Bah! Anda mengalahkan saya untuk itu!
— Shaggy
1
Aku harus ingat untuk menggunakan eval(a.join`+`)lebih a.reduce((x,y)=>x+y). Itu pintar
— Cyoce
8

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.

— nimi
sumber
6

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
— DJMcMayhem
sumber
6

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.
— Martin Ender
sumber
6

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
— KarlKastor
sumber
Dengan mengubah modulo %_2ke GCD i2_, Anda bahkan dapat membuat dimplisit mengubah kode mi2-sQ, menghemat satu byte. Output diubah menjadi 2 untuk genap, dan 1 untuk ganjil.
— K Zhang
4

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!

— Giuseppe
sumber
3

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.

— NikoNyrh
sumber
3

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
— Luis Mendo
sumber
2

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
— Produksi ETH
sumber
2

Perl 5, 31 byte

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

Output 1untuk ganjil dan 0genap.

— Chris
sumber
+1, bagus. Saya pikir ini adalah 28 byte, meskipun: perldoc perlsubmengatakan, "Tanda tangan adalah bagian dari tubuh subrutin. Biasanya tubuh subrutin hanyalah blok kode yang diperkuat.".
— msh210
@ msh210 Terima kasih! Saya tidak berpikir itu cara kerjanya, meskipun- tentu saja tubuh subrutin hanya 28 byte, tetapi Anda tidak dapat meninggalkan subtanpa melanggar itu.
— Chris
Tetapi kadang-kadang subrutin bekerja tanpa sub, misalnya setelah sortatau grepatau sebagai argumen untuk subrutin lain. Ini mungkin patut ditanyakan tentang Code Golf Meta .
— msh210
@ msh210 Subrutin berfungsi tanpa subhanya jika digunakan dalam fungsi prototipe ( sortdan greplebih atau kurang prototipe). Tetapi sebaliknya, subitu diperlukan. Apapun, golf 3 byte dengan menghilangkan subtidak terlalu menarik.
— Dada
2

Clojure (Script), 36 byte

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

(fn[l](map #(odd?(-(apply + l)%))l))
— madstap
sumber
2

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));
— Jörg Hülsermann
sumber
1
Anda dapat menjatuhkannya ?:0tidak melakukan apa-apa. foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;
— Christoph
2

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;
    }
}
— Khaled.K
sumber
2

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.

— Neil
sumber
Saya mencoba apa yang datang ke pikiran bagi saya, dan mendapat sedikit lebih pendek solusi , meskipun saya masih berpikir itu tidak optimal. Khususnya saya tidak suka bagaimana saya menangani nol ekstra yang saya dapatkan di akhir.
— FryAmTheEggman
@FryAmTheEggman Penghematan Anda berasal dari cara yang kurang terlihat untuk mengubah ;kembali ke spasi. Jika Anda meletakkan ;di awal maka Anda dapat menyimpan byte dengan menghapusnya segera alih-alih setelah itu dikonversi menjadi 0.
— Neil
Sebenarnya, melihat lagi, mengapa tahap terakhir Anda tidak hanya mengganti baris baru dengan spasi? Bukankah itu menghemat 2 byte?
— FryAmTheEggman
@FryAmTheEggman Ya; Saya pikir saya awalnya memiliki lebih dari satu pengganti untuk dibuat dalam iterasi sebelumnya.
— Neil
1

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
— zgrep
sumber
1

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.

— Wisaya Gandum
sumber
Anda dapat mod 2 pada akhirnya. Anda tidak perlu mengubah 2 jumlahnya.
— Leaky Nun
@ LeakyNun Terima kasih! Saya baru menyadari itu dan melakukan perbaikan.
— Wheat Wizard
1

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

::^??[!:?^:><^!:?^:!^:?^?]!&|
— Wisaya Gandum
sumber
1

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.

— Biarawati Bocor
sumber
Anda dapat bermain golf dengan 3 byte seperti ini: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);}
— Kevin Cruijssen
67 byte jika Anda menggunakan lambda: Coba online!
— Brian McCutchon
Terima kasih, tapi saya tidak suka menggunakan lambda.
— Leaky Nun
1

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.

— Robert Benson
sumber
1

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!

— Tuan Xcoder
sumber
Tidak terbiasa dengan Swift, tetapi dalam banyak bahasa Anda dapat menggantinya (x-y)%2denganx-y&1
— Cyoce
@Cyoce Bagi saya, setelah pengujian, itu tidak berhasil. Operasi bitwise bukan keahlian Swift
— Tn. Xcoder
1

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]]]
— RosLuP
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.