你给出的阵列甲的Ñ严格为正整数，Ñ≥2 。

您的任务是将每个条目A _i映射到：

• 1如果甲_Ĵ MOD甲_我是奇数每个Ĵ使得1≤Ĵ≤Ñ和Ĵ≠我
• 2，如果阿_Ĵ MOD甲_我是即使针对每个Ĵ使得1≤Ĵ≤Ñ和Ĵ≠我
• 否则为0（混合奇偶校验）

例

对于A = [73，50，61]，我们有：

• 50模73 = 50，61模73 = 61 →混
• 73模50 = 23，MOD 61 50 = 11 →所有奇数
• 73模61 = 12，50 MOD 61 = 50 →所有偶数

因此，预期输出为[0，1，2]。

规则

• 您可以使用任何三个不同的值（任何类型），而不是0，1和2，因为他们是一致的，只要。如果您未使用挑战中所述的映射，请指定映射。
• 如果对此有任何疑问，则零为偶数。
• 这是代码高尔夫球，因此最短答案以字节为单位！

测试用例

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

Python 2中，68个 67 66字节

^{-1字节归功于Xcoder先生
-1字节归功于ovs}

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Ḃ‘Ṭ

返回[1，1]，[0，1]，[1]，而不是0、1、2。

在线尝试！

怎么运行的

%þœ-€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的错误修复。
• 感谢Peter Cordes，节省了四个 21字节；建议使用不同的输出值映射；。[0 1 2] ~ [3 2 1]
• 保存了五个字节；使用另一个映射；[0 1 2] ~ [  ]。
• 保存一个字节；golfed 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);}}

在线尝试！

Mathematica，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
    ]
]

JavaScript（ES6），46个字节

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

返回-1（偶数），1（奇数）和0（混合）。

怎么运行的：

该d蓄电池将是：

1. 如果全部为偶数，则为零。（!a[d+1]==否，!d== 1，false - 1== -1）
2. 如果全为奇模，则比数组的长度小^*。（^*累加器包括一个针对自身模量的元素，导致一个偶数模量。）（!a[d+1]== true，!d== 0，true - 0== 1）
3. 如果混合，则比数组的长度少两个或更多。（!a[d+1]==否，!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||/~

在线尝试！

使用[1 0] [1] [0]代替0 1 2

说明：

|/~ -用余数做一张桌子：

  |/~ 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 -向下排序，删除最后一个元素（始终为零），保留ù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]对于混合的）。

在线尝试！

Perl，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]

在线尝试！

作为lambda，[Int]取回[Int]，映射到：

• 0：混合
• 1：全部
• -1：都很奇怪

Perl 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。

在线尝试！

Java 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代替2甚至
• 用falsefalse代替代替1奇数
• 使用truefalse代替0混合

说明：

在线尝试。

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)

Clojure，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)