Trong thử thách này, bạn sẽ được yêu cầu thực hiện bất kỳ chức năng (hoặc chương trình đầy đủ) nào đáp ứng hai thuộc tính. Những tính chất đó là:

• Hàm của bạn phải là hàm tiêm (có thể đảo ngược) từ đa thức với các hệ số nguyên không âm sang các số nguyên không âm. Điều này có nghĩa là không có hai đầu vào không bằng nhau có thể ánh xạ tới một đầu ra bằng nhau.

• Hàm của bạn phải bảo toàn tổng số "trên bit" từ đầu vào đến đầu ra của nó. Điều này có nghĩa là nếu bạn đếm 1 bit của mỗi hệ số của đa thức, tổng của chúng sẽ bằng với số lượng 1 bit trong biểu diễn nhị phân của đầu ra. Ví dụ 9là 1001ở dạng nhị phân nên nó có 2 1bit.

Tôi

Một đa thức số nguyên không âm giống như một danh sách vô hạn các số nguyên không âm sao cho sau một điểm nhất định tất cả các số nguyên đều bằng không. Do đó, đa thức có thể được biểu diễn bằng danh sách vô hạn (mặc dù điều này có thể là không mong muốn) hoặc bằng danh sách hữu hạn với các số 0 ẩn sau khi kết thúc danh sách.

Điểm khác biệt chính giữa đa thức và danh sách hữu hạn là việc thêm số 0 vào cuối danh sách sẽ thay đổi danh sách:

Trong khi việc thêm số 0 vào cuối đa thức không làm thay đổi giá trị của nó:

Do đó, nếu hàm của bạn lấy một danh sách hữu hạn đại diện cho đa thức làm đầu vào, việc thêm số 0 không được thay đổi kết quả của nó.

Khi biểu diễn đa thức dưới dạng danh sách, bạn có thể biểu thị chúng bằng mục nhập đầu tiên hoặc cuối cùng đại diện cho số hạng không đổi. Ví dụ: bạn có thể có một trong các khả năng sau:

Trong trường hợp đầu tiên, việc thêm số không vào cuối danh sách sẽ không thay đổi kết quả; trong trường hợp thứ hai, việc thêm số không vào phía trước danh sách sẽ không thay đổi kết quả.

Tất nhiên, nếu ngôn ngữ của bạn hỗ trợ đa thức, bạn có thể lấy chúng làm đầu vào.

Đầu ra phải là đầu ra số nguyên không âm thông qua bất kỳ phương thức tiêu chuẩn nào.

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte, với ít byte hơn sẽ tốt hơn.

Thạch , 8 byte

BFṢḄæ«ÆẸ

Hãy thử trực tuyến!

Trái ngược, 5 byte

Bċ0ÆE

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Ngôn ngữ Wolfram (Mathicala) , 36 20 byte

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

Hãy thử trực tuyến!

Lấy một đa thức f (x) làm đầu vào. Đánh giá y * f (y), trong đó y = 2 ^ (f (2)!). Đáng tiếc, điều này có nghĩa là các đầu ra nhận được khá lớn.

Đánh giá y * f (y) sẽ bảo toàn số lượng 1 bit bất cứ khi nào y có công suất lớn hơn 2 so với bất kỳ hệ số nào, điều này đúng với giá trị được chọn ở trên. Chúng tôi chọn y = 2 ^ (f (2)!) Để thực hiện kết quả tiêm truyền:

• Hai đầu vào khác nhau có cùng giá trị y sẽ cho các đầu ra khác nhau vì về cơ bản chúng ta đang đọc hai số khác nhau trong cơ sở y.
• Nếu chúng ta sửa k = f (2) và do đó y, giá trị nhỏ nhất của y * f (y) đạt được khi đầu vào là đa thức không đổi bằng k và giá trị lớn nhất đạt được khi đầu vào là đa thức cho cơ sở -2 mở rộng của k. Trong trường hợp đầu tiên, y * f (y) = 2 ^ (k!) * K và trong trường hợp thứ hai, y * f (y) <2 ^ (k! * Ceil (lg k)), ít hơn hơn 2 ^ ((k + 1)!) * (k + 1).
• Kết quả là, với hai đa thức f và g với f (2) <g (2), số nguyên chúng ta nhận được từ f sẽ nhỏ hơn số nguyên chúng ta nhận được từ g.

Ngôn ngữ Wolfram (Mathicala) , 61 byte

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

Hãy thử trực tuyến!

Hai số nguyên dương có thể được ánh xạ tới một số nguyên dương duy nhất. Hãy a, blà hai số nguyên dương. Sau đó a, b -> (2a - 1) 2^(b-1)là một mệnh đề từ NxN đến N.

Hàm này tìm vị trí của tất cả các 1bit trong đầu vào (từ vị trí 1s) và áp dụng một biến thể chỉ tiêm của bản đồ trên cho từng vị trí. Sau đó, mỗi số kết quả được nâng lên thành lũy thừa của hai và tất cả các số được cộng lại với nhau (điều này không sao vì chúng tôi đã áp dụng bản đồ NxN -> N tiêm).

Ví dụ:

{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 *)

Hàm nghịch đảo (124 byte)

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

Đây là một chức năng nghịch đảo để kiểm tra độ tiêm.

Hãy thử trực tuyến!

Python 2 , 118 117 114 103 100 byte

100 byte bởi Jonathan Frech:

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)

Hãy thử trực tuyến!

103 byte với khả năng chơi gôn ¹

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

Hãy thử trực tuyến!

-15 byte nhờ Jonathan Frech

Nó tạo ra một số đầu tiên chứa "trên bit" và sau đó biểu diễn đơn nhất của mảng được hiểu là một số thứ ba.

Số nhị phân được tạo bằng cách chuyển đổi các số thành chuỗi nhị phân ( 0bNNN), sau đó thay thế bbằng 2.

¹ Tôi có thể đã lưu 14 byte bằng cách chuyển đổi nó thành số cơ sở 12 thay vào đó, nhưng TIO hết bộ nhớ nên tôi quyết định sử dụng số này.

05AB1E , 14 byte

gÅpImPoIbS{2β*

Hãy thử trực tuyến!

Mang lại kết quả tương tự như giải pháp Dennis 'Jelly, tuy nhiên kỹ thuật hơi khác nhau.

Làm sao?

Hãy thử đầu vào [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 byte

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

Hãy thử trực tuyến!

JavaScript 6, 96 83 byte

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

đưa ra một biểu thức nhị phân

([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)