넌 배열 주어진다 을 들 N 과 엄격히 양의 정수 , N ≥ 2 .

당신의 임무는 각 항목 A _i 를 다음 에 매핑 하는 것입니다.

• 한 경우 _J 개조 _난 각 홀수 J 되도록 1 ≤ N ≤ J 및 J ≠ 난
• 두 경우 _J 개조 _나 심지어 각이다 J 되도록 1 ≤ N ≤ J 및 J ≠ I
• 그렇지 않으면 0 (혼합 패리티)

예

옵션 A = [73, 50, 61] , 우리가있다 :

• 50 모드 73 = 50 , 61 모드 73 = 61 → 혼합
• 73 mod 50 = 23 , 61 mod 50 = 11 → 모두 홀수
• 73 모드 61 = 12 , 50 모드 61 = 50 → 모두 짝수

따라서 예상 출력은 [0, 1, 2] 입니다.

규칙

• 일관된 한 0 , 1 및 2 대신 3 가지 고유 한 값 (모든 유형)을 사용할 수 있습니다 . 챌린지에 설명 된 것을 사용하지 않는 경우 매핑을 지정하십시오 .
• 그것에 대해 의심이 있다면, 0도 짝수 입니다.
• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다!

테스트 사례

[ 1, 2 ] --> [ 2, 1 ]
[ 3, 4 ] --> [ 1, 1 ]
[ 1, 2, 3 ] --> [ 2, 1, 0 ]
[ 4, 4, 4 ] --> [ 2, 2, 2 ]
[ 73, 50, 61 ] --> [ 0, 1, 2 ]
[ 941, 459, 533 ] --> [ 1, 0, 0 ]
[ 817, 19, 928, 177 ] --> [ 1, 2, 1, 1 ]
[ 312, 463, 336, 729, 513 ] --> [ 0, 2, 0, 0, 0 ]
[ 53, 47, 33, 87, 81, 3, 17 ] --> [ 0, 0, 0, 1, 0, 2, 0 ]

파이썬 2 , 68 67 66 바이트

^{Xcoder
덕분에 -1 바이트 ovs 덕분에 -1 바이트}

x=input()
for j in x:k=sum(i%j%2for i in x);print(k<len(x)-1)+0**k

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

대신를 반환 1,0,2합니다 0,1,2.

젤리 , 9 바이트

%þœ-€0Ḃ‘Ṭ

0, 1, 2 대신 [1, 1], [0, 1], [1]을 반환합니다 . 합니다.

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

작동 원리

%þœ-€0Ḃ‘Ṭ  Main link. Argument: A (array)

%þ           Build the modulus table.
  œ-€0       Remove one 0 from each list of moduli.
      Ḃ      Take the last bit of each.
       ‘     Increment, mapping 0 and 1 to 1 and 2.
        Ṭ    Untruth; map each array to an aray of 1's at the specified indices.
             This yields:
                 [1] if the array contains only 1's (all even).
                 [0, 1] if the array contains only 2's (all odd).
                 [1, 1] if the array contains 1's and 2's.

MATL , 12 바이트

!G\o~tAws1=-

이 용도 0, -1, 1대신 0, 1, 2각각.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

!    % Implicit input: row vector. Transpose into a column
G    % Push input again
\    % Modulus, element-wise with broadcast. Gives a square matrix
o    % Parity: gives 1 for odd, 0 for even
~    % Logical negate: 0 for odd, 1 for even
t    % Duplicate
A    % All: gives 1 for columns that contain only 1
w    % Swap
s    % Sum of each column
1    % Push 1
=    % Is equal? Gives 1 if the column sum was 1, 0 otherwise
-    % Subtract, element-wise. Implicit display

C (GCC) , 118 (114) 97 92 91 바이트

• 버그 수정에 대한 Peter Cordes 에게 감사합니다 .
• 저장된 사 이십일이 덕분에 바이트 피터 코르을 ; 다른 출력값 매핑을 사용하도록 제안; [0 1 2] ~ [3 2 1].
• 5 바이트를 절약했습니다. 또 다른 매핑을 사용하는 것; [0 1 2] ~ [  ].
• 바이트를 저장했습니다. 에 골프 for(i=0;i<n;i++,putchar...를 쳤다 for(i=~0;++i<n;putchar....

i,j,r;f(A,n)int*A;{for(i=~0;++i<n;putchar(r)){for(j=r=0;j<n;j++)j-i&&(r|=1<<A[j]%A[i]%2);}}

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

매스 매 티카, 57 49 48 바이트

(s=#;And@@#.Or@@#&@OddQ@Rest@Sort[s~Mod~#]&)/@#&

이것은 다음을 반환합니다.

• False.True대 0 (혼합)
• True.True대 1 (홀수)를
• False.False에 대한 2 (모든 짝수)

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

약간 더 긴 대안 (49 바이트)이 있습니다.

Sign[(s=#;Tr@Mod[s~Mod~#,2]&)/@#/.Tr[1^#]-1->-1]&

이것은 다음을 반환합니다.

• 1대 0 (혼합)
• -1대 1 (홀수)를
• 0에 대한 2 (모든 짝수)

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

빨강 , 101 바이트

g: func[b][foreach n b[a: copy[]foreach m b[append a m % n % 2]sort a a: copy next a print unique a]]

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

반환 1 0혼합에, 1홀수 및 0도에 대한

g: func[b] [
    foreach n b [
        a: copy []
        foreach m b [
            append a m % n % 2
        ]
        sort a
        a: copy next a
        print unique a
    ]
]

자바 스크립트 (ES6), 46 바이트

a=>a.map(A=>a.map(B=>d+=B%A%2,d=0)|!a[d+1]-!d)

-1 (짝수), 1 (홀수) 및 0 (혼합)을 반환합니다.

작동 방식 :

d축적이 될 것입니다 :

1. 모두 모듈러스이면 0입니다. ( !a[d+1]== false, !d== 1, false - 1== -1 )
2. 하나 개 이하 ^* 홀수 계수 만약 어레이의 길이보다. ( ^* 누산기는 자체에 대해 변조 된 요소를 포함하므로 하나의 계수도 생성됩니다 .) ( !a[d+1]== true, !d== 0, true - 0== 1 )
3. 혼합 된 경우 배열의 길이보다 두 개 이상 짧습니다. ( !a[d+1]== false, !d== 0, false - 0== 0 )

테스트 사례 :

let f=

a=>a.map(A=>a.map(B=>d+=B%A%2,d=0)|!a[d+1]-!d)

console.log(f([ 1, 2 ] ) + ''); // [ -1, 1 ]
console.log(f([ 3, 4 ] ) + ''); // [ 1, 1 ]
console.log(f([ 1, 2, 3 ] ) + ''); // [ -1, 1, 0 ]
console.log(f([ 4, 4, 4 ] ) + ''); // [ -1, -1, -1 ]
console.log(f([ 73, 50, 61 ] ) + ''); // [ 0, 1, -1 ]
console.log(f([ 941, 459, 533 ] ) + ''); // [ 1, 0, 0 ]
console.log(f([ 817, 19, 928, 177 ] ) + ''); // [ 1, -1, 1, 1 ]
console.log(f([ 312, 463, 336, 729, 513 ] ) + ''); // [ 0, -1, 0, 0, 0 ]
console.log(f([ 53, 47, 33, 87, 81, 3, 17 ] ) + ''); // [ 0, 0, 0, 1, 0, -1, 0 ]

J , 27 20 바이트

[:<@~.@}:@\:"1~2||/~

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

0 1 2 대신 [1 0] [1] [0] 사용

설명:

|/~ -나머지가있는 테이블을 만듭니다.

  |/~ 73 50 61 
 0 50 61
23  0 11
12 50  0

2|홀수 또는 짝수? :

   2||/~ 73 50 61 
0 0 1
1 0 1
0 0 0

<@~.@}:@\:"1 -정렬하고 마지막 요소 (항상 0)를 삭제하고 ùnique 요소를 유지하고 각 행을 상자에 넣습니다.

   <@~.@}:@\:"1~2||/~ 73 50 61 
┌───┬─┬─┐
│1 0│1│0│
└───┴─┴─┘

루비 , 58 56 바이트

->r{r.map{m=r.shift;s=r.map{|e|e%m%2}.uniq.sort;r<<m;s}}

반환 [0, 1], [1], [0] 대신 0, 1, 2 (즉, [0] 모든 짝수를 들어, 홀수에 대해서는 [1] , 혼합에 대해서는 [0, 1] ).

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

펄, 38 바이트

포함 +3을 위해-p

#!/usr/bin/perl -p
s/\d+/$@|=$_%$&%2+1for<$`$'>;$@/gee

모든 짝수에 대해 출력 1, 모든 홀수에 대해 2, 혼합에 대해 3

클린 , 95 65 63 바이트

import StdEnv

\l=[sum(removeDup[-1^(j rem i)\\j<-l|j<>i])\\i<-l]

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

을 가져 와서 [Int]반환 하는 람다 [Int]:

• 0: 혼합
• 1: 모두 짝수
• -1: 모두 이상하다

펄 5 , 71 69 + 1 ( -a) = 70 바이트

map{//;$j=$s='';$j++-$i&&($s+=$_%$'&1)for@F;say$s?0|$s==$#F:2;$i++}@F

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

Pari / GP , 42 바이트

a->[[!s=vecsum([x%y%2|x<-a]),s>#a-2]|y<-a]

[0, 0], [0, 1], [1, 0]대신에를 반환 합니다 0, 1, 2.

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

자바 8, 91 89 바이트

a->{for(int z:a){int s=1;for(int y:a)s+=y%z%2;System.out.print(" "+(s<a.length)+(s<2));}}

• 사용 truetrue instead of 2 for even
• 사용 falsefalse instead of 1 for odd
• 사용 truefalse0혼합 대신

설명:

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

a->{                      // Method with integer-array parameter and no return-type
  for(int z:a){           //  Loop over the array
    int s=1;              //   Sum-integer, starting at 1
    for(int y:a)          //   Inner loop over the array again
      s+=y%z%2;           //    Increase the sum by `y` modulo-`z` modulo-2
    System.out.print(" "  //   Print a space
      +(s<a.length)       //    + "true" if the sum is smaller than the length of the array
                          //      (this means there is at least one even)
      +(s<2));}}          //    + "true" if the sum is still 1
                          //      (this means all are even)

클로저, 82 바이트

#(for[R[(range(count %))]i R](set(for[j R :when(not= i j)](odd?(mod(% j)(% i))))))

출력 변환에 대한 완전한 예 :

(def f #(for[R[(range(count %))]i R](set(for[j R :when(not= i j)](odd?(mod(% j)(% i)))))))
(->> [ 53, 47, 33, 87, 81, 3, 17] f
     (map {#{true} 1, #{false} 2, #{true false} 0}))
; (0 0 0 1 0 2 0)