งาน

รับอาร์เรย์ของจำนวนเต็มบวกแทนที่แต่ละองค์ประกอบด้วยความเท่าเทียมกันของผลรวมขององค์ประกอบอื่น ๆ อาร์เรย์รับประกันว่ามีอย่างน้อย 2 องค์ประกอบ

คำนิยาม

• พาริตี: ไม่ว่าจะเป็นเลขคี่หรือคู่

ตัวอย่าง

สำหรับอาร์เรย์[1,2,3,1]:

• แทนที่1ด้วยความเท่าเทียมกันของคือ2+3+1even
• แทนที่2ด้วยความเท่าเทียมกันของคือ1+3+1odd
• แทนที่3ด้วยความเท่าเทียมกันของคือ1+2+1even
• แทนที่1ด้วยความเท่าเทียมกันของคือ1+2+3even

เอาท์พุท: [even, odd, even, even]

อินพุต

อาร์เรย์ของจำนวนเต็มบวก

คุณอาจคิดว่ามันเป็นอาร์เรย์ที่เหมาะสมหรือเป็นสตริงจำนวนเต็มบวก

คุณอาจคิดว่าอาเรย์และค่าภายในนั้นอยู่ในความสามารถในการจัดการภาษาของคุณ

เอาท์พุต

อาร์เรย์ของสองค่าที่สอดคล้องกันอย่างใดอย่างหนึ่งที่เป็นตัวแทนคนหนึ่งที่เป็นตัวแทนของoddeven

คุณสามารถส่งออกมันเป็นสตริงที่คั่นด้วยตัวป้อนบรรทัดของทั้งสองค่า

Testcases

ปัจจัยการผลิต:

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

ขาออก:

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

หมายเหตุ: คุณอาจจะเลือกค่าความสอดคล้องอื่น ๆ นอกเหนือจากและoddeven

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟ คำตอบที่สั้นที่สุดในการชนะไบต์

หนีมาตรฐานใช้

เยลลี่ 3 ไบต์

+SḂ

ลองออนไลน์!

มันทำงานอย่างไร

+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 ไบต์

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

ใช้0สำหรับคู่และ1คี่

ทดสอบ

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 ไบต์

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

ใช้Trueสำหรับค่าคี่และFalseค่าคู่

ลองออนไลน์!

ลบแต่ละองค์ประกอบจากผลรวมของรายการและทดสอบว่ามันแปลก

fหันไป pointfree ยังมี 20 map=<<(odd.).(-).sumไบต์:

MATL , 5 , 4 ไบต์

ts-o

ลองออนไลน์!

บันทึกหนึ่งไบต์ขอบคุณ Dennis!

สิ่งนี้จะให้ '1' สำหรับคี่และ '0' สำหรับคู่ คำอธิบาย:

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

อลิซ , 31 28 ไบต์

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

ลองออนไลน์!

รูปแบบการป้อนข้อมูลไม่สำคัญตราบใดที่มีการแยกจำนวนเต็ม รูปแบบผลลัพธ์ถูกคั่นด้วยการป้อนบรรทัด

เลย์เอาต์อาจยังไม่เหมาะสม แต่ฉันยังไม่พบวิธีที่จะย่อให้สั้นลงไปอีก

คำอธิบาย

/     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 ไบต์

mi2-sQ

-1 ไบต์ขอบคุณ @KZhang

เอาต์พุต 1 สำหรับคี่, 2 สำหรับคู่

ลองมัน!

คำอธิบาย

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 (ดั้งเดิม) , 4 3 ไบต์

O^È

ลองออนไลน์!

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

Python 2 , 33 31 ไบต์

^{-2 ไบต์ขอบคุณ Leaky Nun}

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

ลองออนไลน์!

R, 21 ไบต์

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

อ่านรายการจาก stdin และส่งกลับค่า 0 สำหรับคู่, 1 สำหรับคี่ ผูกอินพุตกับตัวแปรnภายในการเรียกไปที่sumแทนที่จะเรียกมันออกไปข้างนอกกล่าวคือn=scan();(sum(n)-n)%%2

ลองออนไลน์!

Mathematica ขนาด 13 ไบต์

#+Tr@#&/*OddQ

หรือ

OddQ[#+Tr@#]&

Clojure 30 ไบต์

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

Substracts ค่าทั้งหมดจากแต่ละค่าในการเปิดตัวอย่างเช่นมีการป้อนข้อมูล[a b c d]ค่าที่คำนวณเป็น 2 =b - a - b - c - d -(a + c + d)เอาท์พุทfalseสำหรับคู่และtrueคี่

แต่คุณอาจใช้+และคำนวณแต่ละคำที่ตามมาสองครั้งเพื่อไม่ให้กระทบกับความเท่าเทียมกัน

CJam , 10 ไบต์

{_:+f+1f&}

นี่คือบล็อกที่ไม่ระบุชื่อ (ฟังก์ชัน) ที่รับอินพุตจากสแต็กและแทนที่ด้วยเอาต์พุต

ลองออนไลน์!

คำอธิบาย

[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 ไบต์

2|]++/

ลองออนไลน์!

APL (Dyalog Unicode) , 19 7 ไบต์

มีขนาดถึง 12 ไบต์ที่ต้องขอบคุณ @ Adám

2|+/-¨⊢

ลองออนไลน์!

Japtap , 7 ไบต์

£x +X&1

ลองออนไลน์!

คำอธิบาย

 £   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 ไบต์

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

ขาออก1สำหรับแปลกและ0แม้แต่

Clojure (สคริปต์), 36 ไบต์

การส่งออกเป็นtrueเรื่องแปลกและfalseแม้กระทั่ง ทั้งเอาต์พุตและอินพุตเป็นลำดับ

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

PHP, 50 ไบต์

รุ่นออนไลน์

1 สำหรับคี่, 0 สำหรับคู่

เอาต์พุตเป็นสตริงคั่นด้วย _

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

PHP, 72 ไบต์

เอาต์พุตเมื่อใช้อาร์เรย์ array_map

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

C, 68 62 ไบต์

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

1 สำหรับคี่, 0 สำหรับคู่

ลองรายละเอียดออนไลน์

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

เรติน่า , 40 38 ไบต์

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶
 

ลองออนไลน์! เอาต์พุต 1 สำหรับคี่และ 0 สำหรับคู่ คำอธิบาย: สองบรรทัดแรกทำซ้ำอินพุตหนึ่งครั้งสำหรับแต่ละหมายเลขในอินพุต แต่ไม่มีองค์ประกอบนั้น สิ่งนี้สร้างบรรทัดว่างพิเศษซึ่งจะถูกลบไปแล้ว อินพุตจะถูกแปลงจากทศนิยมเป็น unary ช่องว่างจะถูกลบและคำนวณโดย parity แม้แต่พาริตี้จะถูกแปลงเป็นศูนย์และผลลัพธ์จะรวมกันเป็นหนึ่งบรรทัด แก้ไข: บันทึก 2 ไบต์ด้วย @FryAmTheEggman ฉันลองรุ่นอื่นที่มีแนวคิดที่น่าพอใจมากกว่านี้ แต่ใช้จำนวนไบต์มากเกินไปในการแสดง:

\d\B

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

เปลี่ยนอินพุตทั้งหมดเป็นพาริตีของพวกเขาจากนั้นพลิกพาริตี้ทั้งหมดหากยอดรวมมีพาริตี้คี่

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

11

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

ผลรวมที่ซ้ำกันของการป้อนข้อมูลจากนั้นนำความเท่าเทียมกันของทุกสิ่งจากนั้นกลับความเท่าเทียมกันถ้าผลรวมเป็นคี่แล้วลบผลรวมอีกครั้ง

โอห์ม 4 ไบต์

DΣ-é

ลองออนไลน์!

โดยทั่วไปพอร์ตโดยตรงของMATLและ05AB1Eตอบ ใช้trueสำหรับคู่และfalseคี่

k, 9 ไบต์

{2!x-+/x}

ผลลัพธ์คือ1สำหรับoddและ0สำหรับแม้ ลองออนไลน์

แปลงเป็นรหัสเทียมมันจะเป็น:

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

สกาลา , 19 ไบต์

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

ลองออนไลน์!

Brain-Flak , 94 68 66 ไบต์

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

ลองออนไลน์!

ดูเหมือนว่าจะใช้เวลานานสำหรับงานนี้ อาจมีวิธีที่สะดวกกว่าในการทำเช่นนี้

คำอธิบาย

ก่อนอื่นเราคำนวณผลรวมของสแต็กด้วย:

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

เราจะผ่านสแต็กทั้งหมดที่เพิ่มผลลัพธ์นั้นไปยังแต่ละองค์ประกอบและพิจารณาความเป็นคู่

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

นี่ใช้อัลกอริธึม mod cool สวย ๆ ที่ฉันคิดขึ้นมาสำหรับความท้าทายนี้

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

สิ่งนี้จะผลัก 1 ภายใต้การลดลงของอินพุตจนกระทั่งอินพุตถึงศูนย์ในแต่ละครั้งที่ดำเนินการ1-nกับ 1 ที่เราวางไว้ก่อนหน้านี้จากนั้นจะลบอินพุต

ปรีชาญาณ , 54 52 ไบต์

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

ลองออนไลน์!

คำอธิบาย

รหัสนี้จะสั้นกว่านี้มากหากไม่ได้ใช้หลายไบต์ในการสลับองค์ประกอบสองอันดับแรก ระเบียนปัจจุบันคือ

:?^:!^:?^!

สิ่งนี้ถือว่าเป็นรหัสส่วนใหญ่

ก่อนอื่นเราจะหาผลรวม XOR ของสแต็ก

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

จากนั้นเราก็แฮคเกอร์นี่กับทุก ๆ องค์ประกอบและองค์ประกอบที่มันจะกลายเป็นศูนย์

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

Java , 81 78 ไบต์

3 ไบต์ขอบคุณ 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);}

ลองออนไลน์!

ปรับเปลี่ยนอาร์เรย์ในสถานที่

AWK , 64 ไบต์

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

ลองออนไลน์!

เอาต์พุต a 0สำหรับผลรวม1สม่ำเสมอและหาผลรวมคี่คั่นด้วยการขึ้นบรรทัดใหม่ ความคิดนอกกรอบเพียงเล็กน้อยเท่านั้นคือการวางprintคำสั่งไว้ในforขั้นตอน "การเพิ่ม" ฉันลองใช้วิธีการพิมพ์ที่ "ฉลาด" สองสามอัน แต่พวกเขาไม่ได้ประหยัดไบต์

สำหรับหัวเราะคิกคักถ้าคุณไม่ต้องการขึ้นบรรทัดใหม่:

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

ซึ่งมีจำนวนไบต์เดียวกันกับข้างต้น แต่เป็นป้านอีกเล็กน้อย

Swift - 55 ไบต์

^{ในที่สุดก็เต้น C! นอกจากนี้ 0 สำหรับเสมอ 1 สำหรับคี่}

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

ฟังก์ชั่นที่มีการใช้งาน: g(a: [1,2,3,2,1] // => 0 1 0 1 0

ลองดูสิ!

ความจริง 45 ไบต์

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

ไม่มีการตรวจสอบประเภทอินพุตการคำนวณใหม่ที่เป็นไปได้ของผลรวม "a" แต่ละองค์ประกอบ ... การทดสอบ

(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 ไบต์

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

ลองออนไลน์!