quintopia在这里发布了计算多项式系数的挑战（此处的某些文本是从此处复制的）。有一个有趣的算法可以计算系数2的多项式。

给定数字列表k ₁，k ₂，...，k _m，输出多项式系数的余数：

降低模2.下列算法并此有效地：对于每个ķ _我，计算的二进制展开ķ _我，即，找到一个_IJ，使得每个一个_IJ是1或0和

如果存在j使r≠s 的_rj = a _sj = 1，则相关的mod 2多项式系数为0，否则mod 2多项式系数为1。

任务

编写一个程序或函数，该程序或函数采用m个数字k ₁，k ₂，...，k _m，并输出或返回相应的多项式系数。如果需要，您的程序可以选择将m作为附加参数。

• 这些数字可以按喜欢的任何格式输入，例如分组到列表中或以一元编码或其他方式输入，只要多项式系数的实际计算是由您的代码执行的，而不是由编码过程执行的。

• 如果多项式系数为奇数，则输出可以为任何真值，如果多项式系数为偶数，则输出可以为任何假值。

• 不允许设计用于计算多项式系数的内置函数。

• 有标准漏洞。

计分

这就是代码高尔夫：以字节为单位的最短解决方案获胜。

例子：

为了找到7、16和1000的多项式系数，我们对它们分别进行二进制扩展：

由于没有列具有不超过1的列，因此多项式系数是奇数，因此我们应该输出真实值。

为了找到7、16和76的多项式系数，我们对它们分别进行二进制扩展：

由于76和7的二进制扩展均为4，因此多项式系数为偶数，因此我们输出了falsey值。

测试用例：

Input: [2, 0, 1]
Output: Truthy

Input: [5,4,3,2,1]
Output: Falsey

Input: [1,2,4,8,16]
Output: Truthy

Input: [7,16,76]
Output: Falsey

Input: [7,16,1000]
Output: Truthy

Input: [545, 1044, 266, 2240]
Output: Truthy

Input: [1282, 2068, 137, 584]
Output: Falsey

Input: [274728976, 546308480, 67272744, 135004166, 16790592, 33636865]
Output: Truthy

Input: [134285315, 33849872, 553780288, 544928, 4202764, 345243648]
Output: Falsey

果冻，4字节

S=|/

在线尝试！

测试总和是否等于按位或总和（即a+b+c == a|b|c）。

蟒3 2，55个 43 42字节

lambda l:sum(l)==eval(`l`.replace(*',|'))

Xcoder先生提供的 -12个字节

Rod的 -1个字节

在线尝试！

说明：检查数字的总和是否等于数字的按位或。

Python 2，37个字节

lambda l:sum(l)==reduce(int.__or__,l)

在线尝试！

Pizzapant184算法的另一端口...

干净，38字节

import StdEnv
?l=sum l==foldr(bitor)0l

在线尝试！

另一个港口。

Japt，6个字节

Pizzapant184和Leaky Nun的解决方案的另一个移植。

x ¶Ur|

测试一下

JavaScript（ES6）， 37 35 34字节

@ Mr.Xcoder节省了2个字节@ETHproductions
节省了1个字节

将总和与按位OR进行比较（如pizzapant184和Leaky Nun所做的那样）为1 比我的初始方法短 3 4字节：

a=>(q=c=>eval(a.join(c)))`|`==q`+`

测试用例

let f =

a=>(q=c=>eval(a.join(c)))`|`==q`+`

console.log(f([2, 0, 1]))                                                       // Truthy
console.log(f([5,4,3,2,1]))                                                     // Falsey
console.log(f([1,2,4,8,16]))                                                    // Truthy
console.log(f([7,16,76]))                                                       // Falsey
console.log(f([7,16,1000]))                                                     // Truthy
console.log(f([545, 1044, 266, 2240]))                                          // Truthy
console.log(f([1282, 2068, 137, 584]))                                          // Falsey
console.log(f([274728976, 546308480, 67272744, 135004166, 16790592, 33636865])) // Truthy
console.log(f([134285315, 33849872, 553780288, 544928, 4202764, 345243648]))    // Falsey

Alt。版本，38字节

a=>!a.some((x,i)=>a.some(y=>i--&&x&y))

测试用例

let f =

a=>!a.some((x,i)=>a.some(y=>i--&&x&y))

console.log(f([2, 0, 1]))                                                       // Truthy
console.log(f([5,4,3,2,1]))                                                     // Falsey
console.log(f([1,2,4,8,16]))                                                    // Truthy
console.log(f([7,16,76]))                                                       // Falsey
console.log(f([7,16,1000]))                                                     // Truthy
console.log(f([545, 1044, 266, 2240]))                                          // Truthy
console.log(f([1282, 2068, 137, 584]))                                          // Falsey
console.log(f([274728976, 546308480, 67272744, 135004166, 16790592, 33636865])) // Truthy
console.log(f([134285315, 33849872, 553780288, 544928, 4202764, 345243648]))    // Falsey

Haskell，38个字节

(==).sum<*>foldl1 xor是返回的匿名函数Bool。用作((==).sum<*>foldl1 xor) [2,0,1]。

import Data.Bits
(==).sum<*>foldl1 xor

在线尝试！

• 每个人都使用Pizzapant184和Leaky Nun的技巧几乎相同，除了使用Haskell运算符名称外，它节省了一个字节以供使用（按位）xor而不是(.|.)（按位或）。

• (==).sum<*>foldl1 xor 是的无积分版本 \l->sum l==foldl1 xor l。

Java 8，53字节

a->{int i=0,j=0;for(int x:a){i+=x;j|=x;}return i==j;}

的港口 @LeakyNun的果冻答案。

说明：

在这里尝试。

a->{             // Method with integer-array parameter and boolean return-type
  int i=0,j=0;   //  Two integers, both starting at 0
  for(int x:a){  //  Loop over the array
    i+=x;        //   Add them to the first integer
    j|=x;}       //   And bitwise-OR it with the second integer
  return i==j;}  //  Return if both integers are the same after the loop

Pyth，6个字节

qsQ.|F

测试套件。

外壳，5个字节

§=ΣFv

在线尝试！

Perl 6、15个字节

{.sum==[+|] $_}

测试一下

展开：

{  # bare block lambda with implicit parameter ｢$_｣

    .sum  # the sum of ｢$_｣ (implicit method call)

  ==

    [+|]  # reduce using &infix:«+|» (numeric binary or)

      $_  # the input
}

红色，78字节

f: func[x][b: :to-binary t: 0 s: b 0 foreach n x[t: t + n s: s or b n]s = b t]

怎么运行的：

取消高尔夫：

Red []
f: func [x][         -  a function taking a block as an argument
    b: :to-binary    -  an alias for the to-binary function
    t: 0             -  set the sum of the numbers to 0
    s: b 0           -  set the "or" total to binary 0
    foreach n x[     -  for each number in the block
        t: t + n     -  add it to the sum
        s: s or b n  -  bitwise or of its binary representation with the total
    ]
    s = b t          - are the sum (binary) and the "or" total equal?
]

在线尝试！

Wolfram语言（Mathematica），15个字节

Tr@#==BitOr@@#&

在线尝试！

批处理，73个字节

@set/as=o=0
@for %%i in (%*)do @set/as+=%%i,o^|=%%i
@if %s%==%o% echo 1

输出1真实，虚假无益。Pizzapant184 / Leaky Nun算法的另一个明显端口。

J，10个字节

+/=+./&.#:

Pizzapant184和Leaky Nun的解决方案的另一个港口。

怎么运行的？

+/.&.#: -将数字转换为二进制，按位或应用2的幂，然后从二进制转换为十进制

+/ -通过添加减少输入

= -以上相等吗？

在线尝试！

简单的选择

J，12个字节

2>[:>./+/@#:

怎么运行的？

+/@#: -将每个数字转换为二进制并找到2的幂的和

>./ -找到最大值

2>-小于2吗？->真实

在线尝试！

三角形，31个字节

...)...
..IEu..
.)IE...
"|"JE=.

在线尝试！

替代解决方案，31字节

...)...
..IED..
.us"|".
JE=....

在线尝试！