Ми визначаємо як перелік відмінних потужностей 2, які дорівнюють x . Наприклад, V ( 35 ) = [ 32 , 2 , $V(x)$$2$$x$ .$V(35)=[32,2,1]$

За умовами повноваження тут сортуються від найвищої до найнижчої. Але це не впливає на логіку виклику, ні на очікувані рішення.

Завдання

З огляду на напівпримір , замініть кожен додаток у V ( N ) іншим переліком потужностей 2, які дорівнюють цьому терміну, таким чином, що об'єднання всіх підсумків, що виникають, є точним покриттям матриці M, визначеної як:$N$$V(N)$$2$$M$

де і Q є основними факторами $P$$Q$$N$ .

Це набагато простіше зрозуміти на деяких прикладах.

Приклад №1

Для маємо:$N=21$

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

Щоб перетворити в точне покриття M , ми можемо розділити 16 на 8 + 4 + 4 і 4 на 2 + 2 , а 1 залишити без змін. Таким чином можливий вихід:$V(N)$$M$$16$$8+4+4$$4$$2+2$$1$

Інший дійсний вихід:

Приклад №2

Для маємо:$N=851$

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

A possible output is:

Rules

• Because factorizing $N$ is not the main part of the challenge, you may alternately take $P$ and $Q$ as input.
• When several possible solutions exist, you may either return just one of them or all of them.
• Ви можете по черзі повертати експоненти потужностей (наприклад, замість [ [ 8 , 4 , 4 ] , [ 2 , 2 ] , [ 1 $[[3,2,2],[1,1],[0]]$ ).$[[8,4,4],[2,2],[1]]$
• Порядок підсписів не має значення, а також порядок термінів у кожному підсписку.
• Для деяких напівперіодів вам не доведеться розділяти жоден термін, оскільки вже є ідеальною обкладинкою M (див. A235040 ). Але вам все одно потрібно повернути список (одиночні) списки, такі як [ [ 8 ] , [ 4 ] , [ 2 ] , [ 1 ] ] для N = $V(N)$$M$$[[8],[4],[2],[1]]$$N=15$.
• Це code-golf!

Тестові справи

 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 bytes

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

Try it online!

accepts (P;Q) instead of N

algorithm:

• compute A as the partial sums of V(P*Q)

• multiply each V(P) with each V(Q), sort the products in descending order (let's call that R), and compute their partial sums B

• find the positions of those elements in B that also occur in A; cut R right after those positions

Желе , 24 байти

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

Монадична посилання, що приймає список з двох цілих чисел, [P, Q]що дає один можливий список списків, як описано в питанні.

Спробуйте в Інтернеті! (footer prints a string representation to show the list as it really is)

Або подивіться набір тестів (взявши список N та упорядкувавши результати, щоб вони були такими, як у запитанні)

Як?

Ми завжди можемо нарізати елементи $M$ знизу вгору, жадібно (або є $1$ в $M$ або у нас був внесок $4$, коли $M=[[4]]$) для того, щоб знайти рішення.

^{Примітка: код збирає всі (одне!) Подібні рішення у списку, а потім отримує головний (лише) результат - тобто остаточний заголовок необхідний, оскільки розділи не в усіх можливих порядках.}

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

Пітон 2 , 261 233 232 231 байт

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

Спробуйте в Інтернеті!

1 байт від Джо Кінга ; і ще 1 байт завдяки Кевіну Крейсейну .

Приймає як вхід p,q. Створює жадібний алгоритм.

Желе , 41 байт

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

Спробуйте в Інтернеті!

Напевно, він повинен бути набагато коротшим (деякі частини відчувають себе дуже повторюваними; особливо ÇIP$Ƈ, але я не знаю, як у нього грати в гольф). Пояснення, щоб прийти після подальшого гольфу. Повертає всі можливі рішення у випадку наявності декількох і приймає введення як$[P, Q]$.

Желе , 34 байти

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

Спробуйте в Інтернеті!

Формат введення: [P, Q](посилання TIO, наведене вище, не приймає це, а замість нього одне число, щоб допомогти з тестовими випадками).

Формат виводу: Список усіх рішень (показаний у вигляді сітки 3D-списку в TIO).

Швидкість: Черепаха.

Піт , 27 байт

Натхненний розчавленням Джонатана Аллана мого розчину Джелі . Бере$N$ як вхід.

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

Спробуйте тут!

Haskell, 281 195 байт

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