태스크

양의 정수 배열이 주어지면 각 요소를 다른 요소의 합계의 패리티로 바꿉니다. 배열 에는 최소 2 개의 요소 가 있어야 합니다.

정의

• 패리티 : 숫자가 홀수인지 짝수인지.

예

배열의 경우 [1,2,3,1]:

• 교체 1의 패리티 2+3+1즉, even.
• 교체 2의 패리티 1+3+1즉, odd.
• 교체 3의 패리티 1+2+1즉, even.
• 교체 1의 패리티 1+2+3즉, even.

산출: [even, odd, even, even]

입력

양의 정수로 구성된 배열입니다.

적절한 배열 또는 라인 피드로 구분 된 양의 정수 문자열로 사용할 수 있습니다.

배열과 내부의 값이 사용자 언어의 처리 능력 내에 있다고 가정 할 수 있습니다.

산출

두 개의 일관된 값 의 배열 . odd하나는 대표 , 다른 하나는 대표 even.

두 값의 줄 바꿈으로 구분 된 문자열로 출력 할 수 있습니다.

테스트 케이스

입력 :

[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]

참고 : odd및 이외의 다른 일관된 값을 선택할 수 있습니다 even.

채점

이것은 code-golf 입니다. 바이트 단위의 최단 답변이 이깁니다.

표준 허점이 적용됩니다.

젤리 , 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.

자바 스크립트 (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]))

하스켈, 20 바이트

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

True홀수 값과 짝수 값에 사용 False합니다.

온라인으로 사용해보십시오!

목록의 합계에서 각 요소를 빼고 홀수인지 테스트합니다.

fpointfree로 설정하면 20 바이트도 있습니다 map=<<(odd.).(-).sum.

MATL , 5 , 4 바이트

ts-o

온라인으로 사용해보십시오!

Dennis 덕분에 1 바이트가 절약되었습니다!

이것은 홀수에 '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

Alice , 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

@KZhang 덕분에 -1 바이트

홀수 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

파이썬 2 , 33 31 바이트

^{Leaky Nun 덕분에 -2 바이트}

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

온라인으로 사용해보십시오!

수학, 13 바이트

#+Tr@#&/*OddQ

또는

OddQ[#+Tr@#]&

클로저, 30 바이트

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

예를 들어 입력 [a b c d]으로 두 번째 계산 된 값이 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 바이트

@ Adám 덕분에 골프 12 바이트

2|+/-¨⊢

온라인으로 사용해보십시오!

Japt , 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

펄 5, 31 바이트

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

1홀수 및 짝수 출력 0.

클로저 (스크립트), 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을 출력합니다. 설명 : 처음 두 행은 입력의 각 숫자에 대해 입력을 한 번만 복사하지만 요소 자체는 없습니다. 빈 줄이 추가로 생성되어 삭제됩니다. 그런 다음 입력이 10 진수에서 단항으로 변환되고 공백이 삭제되고 패리티가 계산됩니다. 패리티조차도 0으로 변환되고 결과는 한 줄로 다시 합쳐집니다. 편집 : @FryAmTheEggman 덕분에 2 바이트가 절약되었습니다. 개념적으로 더 만족 스럽지만 표현하기에는 너무 많은 바이트가 필요한 다른 버전을 시도했습니다.

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

출력은 1for odd및 0짝수입니다. 온라인으로 사용해보십시오.

의사 코드로 변환하면 다음과 같습니다.

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

스칼라 , 19 바이트

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

온라인으로 사용해보십시오!

Brain-Flak , 94 68 66 바이트

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

온라인으로 사용해보십시오!

이 작업에는 약간 긴 것 같습니다. 더 편리한 방법이있을 수 있습니다.

설명

먼저 스택 합계를 다음과 같이 계산합니다.

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

우리는 전체 스택을 살펴보고 그 결과를 각 요소에 추가하고 쌍을 결정합니다.

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

이것은이 도전에 대해 생각 해낸 꽤 멋진 mod 2 알고리즘을 사용합니다.

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

이렇게하면 1-n이전에 배치 한 1을 수행 할 때마다 입력이 0에 도달 할 때까지 입력 감소 아래에서 1을 누른 다음 입력을 제거합니다.

와이즈 , 54 52 바이트

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

온라인으로 사용해보십시오!

설명

이 코드는 상위 두 요소를 교체하는 데 너무 많은 바이트가 걸리지 않으면 훨씬 짧습니다. 현재 레코드는

:?^:!^:?^!

불행히도 이것은 대부분의 코드를 구성합니다.

먼저 스택의 XOR 합을 가져옵니다

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

그런 다음 모든 요소와 마지막 비트가 0 인 요소와 XOR

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

자바 , 81 78 바이트

Kevin Cruissen 덕분에 3 바이트

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}

온라인으로 사용해보십시오!

개행으로 구분 된 짝수 합계 0와 1홀수 합계에 대해 a 를 출력합니다 . 약간의 독창적 인 사고는 print명령을for "증가"단계 . 몇 가지 "영리한"인쇄 방법을 시도했지만 바이트를 절약하지 못했습니다.

줄 바꿈을 원하지 않으면 낄낄 거립니다.

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

위와 동일한 바이트 수를 갖지만 약간 더 둔감합니다.

스위프트-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]]]

줄리아 1.0 , 17 바이트

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

온라인으로 사용해보십시오!