在此挑战中，系统将要求您实现具有两个属性的任何功能（或完整程序）。这些属性是：

• 您的函数必须是从具有非负整数系数的多项式到非负整数的内射（可逆）函数。这意味着没有两个不相等的输入可以映射到相等的输出。

• 您的函数必须保留从输入到输出的“按位”总数。这意味着，如果您计算多项式每个系数的1位，则它们的总和应与输出的二进制表示形式中1位的数目相同。例如，它9是1001二进制的，所以它有2 1位。

IO

非负整数多项式与非负整数的无限列表相同，因此在某个点之后所有整数均为零。因此，多项式可以由无限列表表示（尽管这可能是不希望的），也可以由列表末尾带有隐式零的有限列表表示。

多项式与有限列表之间的主要区别在于，在列表的末尾添加零将更改列表：

在多项式的末尾添加零不会更改其值：

因此，如果您的函数采用表示多项式的有限列表作为输入，则添加零不得更改其结果。

当将多项式表示为列表时，可以用代表常数项的第一个或最后一个条目来表示它们。例如，您可能具有以下两种可能性之一：

在第一种情况下，将零添加到列表的末尾不应更改结果。在第二种情况下，加零到前方列表的不应该改变的结果。

当然，如果您的语言支持多项式，则可以将其作为输入。

通过任何标准方法，输出应为非负整数输出。

这是代码高尔夫球，因此答案将以字节计分，而字节越少越好。

果冻，8字节

BFṢḄæ«ÆẸ

在线尝试！

左逆，5个字节

Bċ0ÆE

在线尝试！

怎么运行的

BFṢḄæ«ÆẸ  Main link. Argument: A (array)

B         Binary; convert each integer in A to base 2.
 F        Flatten; concatenate the resulting binary arrays.
  Ṣ       Sort the resulting bit array.
   Ḅ      Convert from base 2 to integer, yielding an integer x with as much set
          bits as there are set bits in A.
      ÆẸ  Unexponents; convert A = [a1, a2, ...] to y = (p1**a1 + p2**a2 + ...),
          where pn is the n-th prime number.
          By the fundamental theorem of arithmetic, the resulting integer is unique
          for each array A without trailing zeroes.
    æ«    Bitshift left; compute x * 2**y.

Wolfram语言（Mathematica），36 20字节

x#/.x->2^(#/.x->2)!&

在线尝试！

将多项式f（x）作为输入。计算y * ​​f（y），其中y = 2 ^（f（2）！）。遗憾的是，这意味着输出变得很大。

每当y比任何系数大2的幂时，评估y * f（y）将保留1位的数量，这对于上面选择的值是正确的。我们选择y = 2 ^（f（2）！）使结果具有内射性：

• y值相同的两个不同输入将给出不同的输出，因为我们实际上是在以y为底的两个不同的数字上进行读取。
• 如果我们固定k = f（2）并因此确定y，则当输入为等于k的常数多项式时，获得y * f（y）的最小值，而当输入为给定底数的多项式时，获得y * f（y）的最小值-2扩展k。在第一种情况下，y * f（y）= 2 ^（k！）* k，在第二种情况下，y * f（y）<2 ^（k！* ceil（lg k）），该值较小大于2 ^（（k + 1）！）*（k + 1）。
• 结果，对于f（2）<g（2）的两个多项式f和g，我们从f得到的整数将小于我们从g得到的整数。

Wolfram语言（Mathematica），61字节

Tr[2^((2#2-1)2^#)&@@@Position[Reverse/@#~IntegerDigits~2,1]]&

在线尝试！

两个正整数可以映射到单个正整数。设a, b两个正整数。然后a, b -> (2a - 1) 2^(b-1)是从NxN到N的双射。

此函数查找1输入中所有位的位置（从1s位置开始），并将上述映射的仅用于注入的变体应用于每个位置。然后，将每个结果数字提高为2的幂，然后将所有数字加在一起（这很好，因为我们应用了内射式NxN-> N映射）。

例如：

{1, 2, 3}
{{1}, {1, 0}, {1, 1}}             (* Convert to binary *)
{{1}, {0, 1}, {1, 1}}             (* Reverse each *)
{{1, 1}, {2, 2}, {3, 1}, {3, 2}}  (* Position of 1s *)
{2, 12, 8, 24}                    (* Inject to N *)
{4, 4096, 256, 16777216}          (* Raise to the power of 2 *)
16781572                          (* Add *)

反函数（124字节）

##+#&~Fold~#&@*Reverse/@Normal@SparseArray[{Log2[j=#~BitAnd~-#],(#/j+1)/2}->1&@@@(Reverse[#~IntegerDigits~2]~Position~1-1)]&

这是一个测试内射性的逆函数。

在线尝试！

Python 2中，118个 117 114 103 100字节

Jonathan Frech的100个字节：

a=input()
while a[0]<1:a.pop(0)
y="".join("2"+bin(v)[2:]for v in a)
print~-2**y.count("1")<<int(y,3)

在线尝试！

103字节，可打高尔夫球¹

a=input()
while a[0]<1:a.pop(0)
x="".join(map(bin,a))
print~-(1<<x.count("1"))<<int(x.replace(*"b2"),3)

在线尝试！

-15字节归功于Jonathan Frech

它创建一个数字，该数字首先包含“按位”，然后包含数组的一元表示形式，将其解释为三进制数。

三进制数是通过将数字为二进制字符串（创建0bNNN），然后替换b用2。

¹我本可以通过将其转换为以12为基数的数字来节省14个字节，但是TIO内存不足，所以我决定使用它。

05AB1E，14个字节

gÅpImPoIbS{2β*

在线尝试！

产生的结果与Dennis的Jelly解决方案相同，但是技术略有不同。

怎么样？

让我们尝试输入 [1, 2, 3]：

gÅpImPoIbS{2β* | Full program.
               | STACK: [[1, 2, 3]]
               |
g              | Push the length.
               | STACK: [3]
 Åp            | Generate the first N primes.
               | STACK: [[2, 3, 5]]
   Im          | Push the input, and apply pairwise exponentiation.
               | STACK: [2, 9, 125]
     P         | Push the product.
               | STACK: 2250
      o        | Push 2 ** N.
               | STACK: 2 ** 2250 (way too large)
       Ib      | Push the input and convert to binary.
               | STACK: [2 ** 2250, ['1', '10', '11']].
         S{    | Sort all the characters.
               | STACK: [2 ** 2250, ['0', '1', '1', '1', '1']]
           2β  | Convert from binary.
               | STACK: [2 ** 2250, 15]
             * | Multiplication.
               | STACK: [2 ** 2250 * 15]
               | Implicitly print the top of the stack (2 ** 2250 * 15).

Python 2，74个字节

r='print 0';s='<<'
for n in input():r+=oct(n)[:0:-1];s+='0'+'1'*n
exec r+s

在线尝试！

JavaScript 6，96 83字节

x=>(t=x.map(k=>(x[0]+=k)&&2+k.toString(2)).join``).replace(/0|2/g,'')+'0'.repeat(t)

输出一个二进制表达式

([1,2]) => 3*2^21210(Decimal)
([0,1,2]) => 3*2^21210
([1,2,0]) => 3*2^2121020
([1,2,3,4]) => 31*2^212102112100(Threotically)