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

По соглашению, полномочия сортируются здесь от наивысшего к низшему. Но это не влияет ни на логику задачи, ни на ожидаемые решения.

задача

При заданном полупростом замените каждый член в V ( N ) другим списком степеней 2 , суммирующим этот термин, таким образом, чтобы объединение всех результирующих подсписков было точным покрытием матрицы M, определенной как:$N$$V(N)$$2$$M$

где и Q являются главными факторами N .$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]$
• и 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}$

Возможный вывод:

правила

• Поскольку факторизация не является основной частью задачи, вы можете попеременно принимать P и Q в качестве входных данных.$N$$P$$Q$
• Если существует несколько возможных решений, вы можете вернуть только одно из них или все из них.
• Вы можете поочередно возвращать показатели степени (например, вместо [ [ 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 = 15 .$V(N)$$M$$[[8],[4],[2],[1]]$$N=15$
• Это код-гольф !

Контрольные примеры

 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 (нгн / к) , 66 63 байта

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

Попробуйте онлайн!

принимает (P; Q) вместо N

алгоритм:

• вычислить A как частичные суммы V (P * Q)

• умножить каждое V (P) на каждое V (Q), отсортировать произведения в порядке убывания (назовем это R) и вычислить их частичные суммы B

• найти позиции тех элементов в B, которые также встречаются в A; вырезать R сразу после этих позиций

Желе , 24 байта

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

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

Попробуйте онлайн! (нижний колонтитул выводит строковое представление, чтобы показать список таким, какой он есть на самом деле)

Или посмотрите набор тестов (взяв список N и переупорядочив результаты, чтобы они были такими же, как в вопросе)

Как?

Мы всегда можем жадно нарезать элементы снизу вверх (либо в M есть 1, либо у нас было 4 , когда M = [ [ 4 ] $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

Python 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 выше не принимает это, но вместо этого одно число, чтобы помочь с тестовыми случаями).

Выходной формат: список всех решений (отображается как сеточное представление трехмерного списка через TIO).

Скорость: черепаха.

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