Bài tập

Cho một mảng các số nguyên dương, thay thế từng phần tử bằng tính chẵn lẻ của tổng các phần tử khác. Mảng được đảm bảo có ít nhất 2 yếu tố.

Định nghĩa

• Chẵn lẻ: cho dù một số là số lẻ hay số chẵn.

Thí dụ

Đối với mảng [1,2,3,1]:

• Thay thế 1bằng tính chẵn lẻ của 2+3+1, tức là even.
• Thay thế 2bằng tính chẵn lẻ của 1+3+1, tức là odd.
• Thay thế 3bằng tính chẵn lẻ của 1+2+1, tức là even.
• Thay thế 1bằng tính chẵn lẻ của 1+2+3, tức là even.

Đầu ra: [even, odd, even, even]

Đầu vào

Một mảng số nguyên dương.

Bạn có thể lấy nó làm một mảng thích hợp hoặc là một chuỗi các số nguyên dương được phân tách bằng dòng.

Bạn có thể cho rằng mảng và các giá trị bên trong nằm trong khả năng xử lý ngôn ngữ của bạn.

Đầu ra

Một mảng gồm hai giá trị nhất quán , một đại diện odd, một đại diện even.

Bạn có thể xuất nó dưới dạng một chuỗi được phân tách bằng nguồn cấp của hai giá trị.

Tủ thử

Đầu vào:

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

Đầu ra:

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

Lưu ý: bạn có thể chọn các giá trị phù hợp khác ngoài oddvà even.

Chấm điểm

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng.

Lỗ hổng tiêu chuẩn áp dụng.

Thạch , 3 byte

+SḂ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Sử dụng 0cho chẵn và 1lẻ.

Kiểm tra

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

Sử dụng Truecho các giá trị lẻ và Falsecho các giá trị chẵn.

Hãy thử trực tuyến!

Trừ từng phần tử khỏi tổng của danh sách và kiểm tra xem nó có lẻ không.

fchuyển sang pointfree cũng có 20 byte : map=<<(odd.).(-).sum.

MATL , 5 , 4 byte

ts-o

Hãy thử trực tuyến!

Một byte được lưu nhờ Dennis!

Điều này mang lại '1' cho số lẻ và '0' cho số chẵn. Giải trình:

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%

Hãy thử trực tuyến!

Định dạng đầu vào không quan trọng miễn là các số nguyên được tách ra. Định dạng đầu ra được phân tách theo dòng.

Bố cục có thể vẫn chưa tối ưu nhưng tôi chưa tìm được cách rút ngắn điều này hơn nữa.

Giải trình

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

Bình thường, 7 6 byte

mi2-sQ

-1 Byte nhờ @KZhang

Đầu ra 1 cho lẻ, 2 cho chẵn.

Thử nó!

Giải trình

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 (di sản) , 4 3 byte

O^È

Hãy thử trực tuyến!

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

Python 2 , 33 31 byte

^{-2 byte nhờ Leaky Nun}

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

Hãy thử trực tuyến!

R, 21 byte

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

đọc danh sách từ stdin và trả về 0 cho chẵn, 1 cho số lẻ. liên kết đầu vào với biến nbên trong lệnh gọi sumthay vì gọi nó bên ngoài, nghĩa làn=scan();(sum(n)-n)%%2

Hãy thử trực tuyến!

Toán học, 13 byte

#+Tr@#&/*OddQ

hoặc là

OddQ[#+Tr@#]&

Clojure, 30 byte

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

Thay vào đó, tất cả các giá trị từ mỗi giá trị lần lượt, ví dụ với đầu vào [a b c d]giá trị được tính thứ 2 là b - a - b - c - d= -(a + c + d). Đầu ra là falsecho chẵn và truelẻ.

Nhưng bạn cũng có thể sử dụng +và tính toán mỗi thuật ngữ tiếp theo hai lần để nó không ảnh hưởng đến tính chẵn lẻ.

CJam , 10 byte

{_:+f+1f&}

Đây là một khối ẩn danh (chức năng) lấy đầu vào từ ngăn xếp và thay thế nó bằng đầu ra.

Hãy thử trực tuyến!

Giải trình

Xem xét đầu vào [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|]++/

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 19 7 byte

Đã chơi 12 byte nhờ @ Adám

2|+/-¨⊢

Hãy thử trực tuyến!

Japt , 7 byte

£x +X&1

Hãy thử trực tuyến!

Giải trình

 £   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,@_}

Đầu ra 1cho lẻ và 0cho chẵn.

Clojure (Script), 36 byte

Đầu ra là truecho lẻ và falsecho chẵn. Cả đầu ra và đầu vào là chuỗi.

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

PHP, 50 byte

Phiên bản trực tuyến

1 cho số lẻ, 0 cho số chẵn

Đầu ra dưới dạng chuỗi được phân tách bằng _

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

PHP, 72 byte

Đầu ra là sử dụng mảng 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 cho số lẻ, 0 cho số chẵn

Thử trực tuyến chi tiết

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

Võng mạc , 40 38 byte

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶
 

Hãy thử trực tuyến! Đầu ra 1 cho số lẻ và 0 cho số chẵn. Giải thích: Hai dòng đầu tiên nhân đôi đầu vào một lần cho mỗi số trong đầu vào, nhưng không có phần tử. Điều này tạo ra một dòng trống thêm mà sau đó sẽ bị xóa. Đầu vào sau đó được chuyển đổi từ thập phân sang đơn nguyên, các khoảng trắng bị xóa và tính chẵn lẻ được tính toán. Ngay cả chẵn lẻ sau đó được chuyển đổi thành 0 và kết quả được nối lại thành một dòng. Chỉnh sửa: Đã lưu 2 byte nhờ @FryAmTheEggman. Tôi đã thử một số phiên bản khác về mặt khái niệm dễ chịu hơn nhưng phải mất quá nhiều byte để thể hiện:

\d\B

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

Thay đổi tất cả các đầu vào thành chẵn lẻ của chúng, sau đó lật tất cả các chẵn lẻ của chúng nếu tổng số có chẵn lẻ.

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

11

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

Tính tổng một bản sao của đầu vào, sau đó lấy tính chẵn lẻ của mọi thứ, sau đó đảo ngược các tính chẵn lẻ nếu tổng là số lẻ, sau đó xóa tổng lại.

Ồ , 4 byte

DΣ-é

Hãy thử trực tuyến!

Về cơ bản là một cổng trực tiếp của câu trả lời MATL và 05AB1E . Sử dụng truecho chẵn và falselẻ.

k, 9 byte

{2!x-+/x}

Đầu ra là một 1for odd, và 0cho chẵn.Hãy thử trực tuyến.

Chuyển đổi thành mã giả, nó sẽ là:

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

Scala , 19 byte

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

Hãy thử trực tuyến!

Brain-Flak , 94 68 66 byte

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

Hãy thử trực tuyến!

Điều này có vẻ hơi dài cho nhiệm vụ. Có thể có một cách thuận tiện hơn để làm điều này.

Giải trình

Đầu tiên chúng ta tính tổng của ngăn xếp với:

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

Chúng tôi đi qua toàn bộ ngăn xếp thêm kết quả đó cho từng phần tử và xác định tính cặp

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

Điều này sử dụng thuật toán mod 2 khá thú vị mà tôi đã đưa ra cho thử thách này.

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

Thao tác này sẽ đẩy 1 dưới mức giảm đầu vào cho đến khi đầu vào bằng 0 mỗi lần thực hiện 1-nđến 1 mà chúng ta đã đặt trước đó, sau đó loại bỏ đầu vào.

Khôn ngoan , 54 52 byte

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

Hãy thử trực tuyến!

Giải trình

Mã này sẽ ngắn hơn rất nhiều nếu nó không mất quá nhiều byte để trao đổi hai phần tử hàng đầu. Kỷ lục hiện tại là

:?^:!^:?^!

Điều này không may cấu thành phần lớn của mã.

Đầu tiên chúng ta lấy tổng XOR của ngăn xếp

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

Sau đó, chúng tôi XOR điều này với mọi phần tử và phần tử với bit cuối cùng bằng 0

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

Java , 81 78 byte

3 byte nhờ 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);}

Hãy thử trực tuyến!

Sửa đổi các mảng tại chỗ.

AWK , 64 byte

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

Hãy thử trực tuyến!

Xuất ra một 0khoản tiền chẵn và 1cho các khoản tiền lẻ được phân tách bằng dòng mới. Suy nghĩ thậm chí hơi khác thường là đặt printlệnh bên trong bước for"gia tăng". Tôi đã thử một vài cách "thông minh" để in, nhưng chúng không lưu byte.

Chỉ để cười khúc khích, nếu bạn không muốn có dòng mới:

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

có cùng số byte như trên, nhưng khó hiểu hơn một chút.

Swift - 55 byte

^{Cuối cùng cũng đánh bại C! Ngoài ra, 0 cho chẵn, 1 cho lẻ}

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

Một chức năng, với cách sử dụng: g(a: [1,2,3,2,1] // => 0 1 0 1 0

Kiểm tra nó ra!

Tiên đề, 45 byte

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

không kiểm tra loại đầu vào, tính toán lại có thể của tổng "a" mỗi phần tử ... kiểm tra

(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

Hãy thử trực tuyến!