Chúng tôi định nghĩa là danh sách các quyền hạn riêng biệt của 2 tổng bằng x . Chẳng hạn, V ( 35 ) = [ 32 , 2 , 1 ] .$V(x)$$2$$x$$V(35)=[32,2,1]$

Theo quy ước, quyền hạn được sắp xếp ở đây từ cao nhất đến thấp nhất. Nhưng nó không ảnh hưởng đến logic của thách thức, cũng như các giải pháp dự kiến.

Bài tập

Đưa ra một bán kết , thay thế mỗi thuật ngữ trong V ( N ) bằng một danh sách quyền hạn khác bằng 2 với thuật ngữ này, theo cách mà sự kết hợp của tất cả các danh sách phụ kết quả là một vỏ bọc chính xác của ma trận M được định nghĩa là:$N$$V(N)$$2$$M$

nơi và Q là những yếu tố chính của N .$P$$Q$$N$

Điều này dễ hiểu hơn nhiều với một số ví dụ.

Ví dụ 1

Với , chúng ta có:$N=21$

• $V(N)=[16,4,1]$
• và V ( P ) = [ 4 , 2 , 1 $P=7$$V(P)=[4,2,1]$
• và V ( Q ) = [ 2 , 1 $Q=3$$V(Q)=[2,1]$
• $M=\pmatrix{8&4&2\\4&2&1}$

Để biến thành bìa chính xác của M , chúng ta có thể chia 16 thành 8 + 4 + 4 và 4 thành 2 + 2 , trong khi 1 không thay đổi. Vì vậy, một đầu ra có thể là:$V(N)$$M$$16$$8+4+4$$4$$2+2$$1$

Một đầu ra hợp lệ khác là:

Ví dụ # 2

Với , chúng ta có:$N=851$

• $V(N)=[512,256,64,16,2,1]$
• và V ( P ) = [ 32 , 4 , 1 $P=37$$V(P)=[32,4,1]$
• và V ( Q ) = [ 16 , 4 , 2 , 1 $Q=23$$V(Q)=[16,4,2,1]$
• $M=\pmatrix{512&64&16\\128&16&4\\64&8&2\\32&4&1}$

Một đầu ra có thể là:

Quy tắc

• Vì nhân tố không phải là phần chính của thử thách, bạn có thể luân phiên lấy P và Q làm đầu vào.$N$$P$$Q$
• Khi một số giải pháp khả thi tồn tại, bạn có thể trả về chỉ một trong số chúng hoặc tất cả chúng.
• Bạn có thể luân phiên trả lại số mũ của các lũy thừa (ví dụ: thay vì [ [ 8 , 4 , 4 ] , [ 2 , 2 ] , [ 1 ] ] ).$[[3,2,2],[1,1],[0]]$$[[8,4,4],[2,2],[1]]$
• Thứ tự của các danh sách phụ không thành vấn đề, cũng như thứ tự của các điều khoản trong mỗi danh sách phụ.
• Đối với một số bán kết, bạn sẽ không phải chia bất kỳ thuật ngữ nào vì đã là một vỏ bọc hoàn hảo của M (xem A235040 ). Nhưng bạn vẫn phải trả về một danh sách các danh sách (singleton), chẳng hạn như [ [ 8 ] , [ 4 ] , [ 2 ] , [ 1 ] ] cho N = 15 .$V(N)$$M$$[[8],[4],[2],[1]]$$N=15$
• Đây là môn đánh gôn !

Các trường hợp thử nghiệm

 Input | Possible output
-------+-----------------------------------------------------------------------------
 9     | [ [ 4, 2, 2 ], [ 1 ] ]
 15    | [ [ 8 ], [ 4 ], [ 2 ], [ 1 ] ]
 21    | [ [ 8, 4, 4 ], [ 2, 2 ], [ 1 ] ]
 51    | [ [ 32 ], [ 16 ], [ 2 ], [ 1 ] ]
 129   | [ [ 64, 32, 16, 8, 4, 2, 2 ], [ 1 ] ]
 159   | [ [ 64, 32, 32 ], [ 16 ], [ 8 ], [ 4 ], [ 2 ], [ 1 ] ]
 161   | [ [ 64, 32, 16, 16 ], [ 8, 8, 4, 4, 4, 2, 2 ], [ 1 ] ]
 201   | [ [ 128 ], [ 64 ], [ 4, 2, 2 ], [ 1 ] ]
 403   | [ [ 128, 64, 64 ], [ 32, 32, 16, 16, 16, 8, 8 ], [ 8, 4, 4 ], [ 2 ], [ 1 ] ]
 851   | [ [ 512 ], [ 128, 64, 64 ], [ 32, 16, 16 ], [ 8, 4, 4 ], [ 2 ], [ 1 ] ]
 2307  | [ [ 1024, 512, 512 ], [ 256 ], [ 2 ], [ 1 ] ]

K (ngn / k) , 66 63 byte

{(&1,-1_~^(+\*|a)?+\b)_b:b@>b:,/*/:/2#a:{|*/'(&|2\x)#'2}'x,*/x}

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

chấp nhận (P; Q) thay vì N

thuật toán:

• tính A là tổng một phần của V (P * Q)

• nhân mỗi V (P) với mỗi V (Q), sắp xếp các sản phẩm theo thứ tự giảm dần (hãy gọi R đó) và tính tổng của chúng một phần B

• tìm vị trí của các phần tử đó trong B cũng xảy ra trong A; cắt R ngay sau những vị trí đó

Thạch , 24 byte

BṚT’2*
Ç€×þ/FṢŒṖ§⁼Ç}ɗƇPḢ

Một liên kết đơn âm chấp nhận danh sách hai số nguyên [P, Q]mang lại một danh sách có thể có của danh sách như được mô tả trong câu hỏi.

Hãy thử trực tuyến! (chân trang in một chuỗi đại diện để hiển thị danh sách như thực tế)

Hoặc xem bộ thử nghiệm (lấy danh sách N và sắp xếp lại kết quả giống như trong câu hỏi)

Làm sao?

Chúng tôi luôn có thể cắt các phần tử của từ thấp nhất, tham lam (có 1 trong M hoặc chúng tôi có đầu vào là 4 , khi M = [ [ 4 ] ] ) để tìm giải pháp.$M$$1$$M$$4$$M=[[4]]$

^{Lưu ý: mã thu thập tất cả (một!) Các giải pháp như vậy trong một danh sách và sau đó lấy kết quả đầu (chỉ) - tức là đầu cuối là cần thiết vì các phân vùng không phải là tất cả các thứ tự có thể.}

BṚT’2* - Link 1, powers of 2 that sum to N: integer, N    e.g. 105
B      - binary                                                [1,1,0,1,0,0,1]
 Ṛ     - reverse                                               [1,0,0,1,0,1,1]
  T    - truthy indices                                        [1,4,6,7]
   ’   - decrement                                             [0,3,5,6]
    2  - literal two                                           2
     * - exponentiate                                          [1,8,32,64]

Ç€×þ/FṢŒṖ§⁼Ç}ɗƇPḢ - Main Link: list of two integers, [P,Q]
Ç€                - call last Link (1) as a monad for €ach
    /             - reduce with:
   þ              -   table with:
  ×               -     multiplication
     F            - flatten
      Ṣ           - sort
       ŒṖ         - all partitions
              Ƈ   - filter keep if:
             ɗ    -   last three links as a dyad:
         §        -     sum each
            }     -     use right...
               P  -       ...value: product (i.e. P×Q)
           Ç      -       ...do: call last Link (1) as a monad
          ⁼       -     equal? (non-vectorising so "all equal?")
                Ḣ - head

Python 2 , 261 233 232 231 byte

g=lambda n,r=[],i=1:n and g(n/2,[i]*(n&1)+r,i*2)or r
def f(p,q):
 V=[[v]for v in g(p*q)];i=j=0
 for m in sorted(-a*b for a in g(p)for b in g(q)):
	v=V[i]
	while-m<v[j]:v[j:j+1]=[v[j]/2]*2
	i,j=[i+1,i,0,j+1][j+1<len(v)::2]
 return V

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

1 byte từ Jo King ; và thêm 1 byte do Kevin Cruijssen .

Lấy làm đầu vào p,q. Theo đuổi thuật toán tham lam.

Thạch , 41 byte

Œṗl2ĊƑ$Ƈ
PÇIP$ƇṪÇ€Œpµ³ÇIP$ƇṪƊ€ŒpZPṢ⁼FṢ$µƇ

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

Có lẽ nên ngắn hơn nhiều (một số phần cảm thấy rất lặp đi lặp lại; đặc biệt ÇIP$Ƈ, nhưng tôi không biết chơi golf). Giải thích để đến sau khi chơi golf. Trả về tất cả các giải pháp có thể trong trường hợp nhiều tồn tại và lấy đầu vào là$[P, Q]$.

Thạch , 34 byte

BṚT’2*
PÇŒṗæḟ2⁼ƊƇ€ŒpẎṢ⁼Ṣ}ʋƇÇ€×þ/ẎƊ

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

Định dạng đầu vào: [P, Q](liên kết TIO ở trên không chấp nhận điều này, nhưng thay vào đó là một số duy nhất để hỗ trợ cho các trường hợp thử nghiệm).

Định dạng đầu ra: Danh sách tất cả các giải pháp (được hiển thị dưới dạng biểu diễn lưới của danh sách 3D qua TIO).

Tốc độ: Rùa.

Bình , 27 byte

Lấy cảm hứng từ việc Jonathan Allan nghiền nát dung dịch Jelly của tôi . Nhận$N$ làm đầu vào.

L^2x1jb2;hfqyQsMT./S*M*FyMP

Hãy thử nó ở đây!

Haskell, 281 195 byte

import Data.List
r=reverse.sort
n#0=[]
n#x=[id,(n:)]!!mod x 2$(n*2)#div x 2
m!0=[]
m!x=m!!0:tail m!(x-m!!0)
m%[]=[]
m%n=m!head n:drop(length$m!head n)m%tail n
p&q=r[x*y|x<-1#p,y<-1#q]%r(1#(p*q))