değerini, toplamını gösteren farklı güç listesi olarak tanımlıyoruz . Örneğin, .2 x V ( 35 ) = [ 32 , 2 , 1 $V(x)$$2$$x$$V(35)=[32,2,1]$

Kural olarak, güçler burada en yüksekten en düşüğe doğru sıralanır. Ancak, meydan okuma mantığını veya beklenen çözümleri etkilemez.

Görev

Bir yarı-yarı verildiğinde , deki her terimi, bu terimi toplayan başka bir güç listesi ile değiştirin , böylece elde edilen tüm alt listelerin birleşimi aşağıdaki gibi tanımlanan matrisinin tam bir kapağı olacaktır :V ( N ) 2 $N$$V(N)$$2$$M$

burada ve , başlıca faktörleridir .Q $P$$Q$$N$

Bazı örneklerle bunu anlamak çok daha kolaydır.

Örnek 1

İçin , var:$N=21$

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

Açmak için bir tam kapağının içine , biz bölünmüş olabilir içine ve içine ise, değişmeden kalır. Yani olası bir çıktı:M 16 8 + 4 + 4 4 2 + 2 $V(N)$$M$$16$$8+4+4$$4$$2+2$$1$

Başka bir geçerli çıktı:

Örnek 2

İçin , var:$N=851$

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

Olası bir çıktı:

kurallar

• Faktoring , zorluğun ana parçası olmadığından, alternatif olarak ve girdi olarak alabilirsiniz .$N$$P$$Q$
• Birkaç olası çözüm olduğunda, bunlardan sadece birini veya tümünü geri verebilirsiniz.
• Alternatif olarak , yerine yetkilerin (örneğin, ).$[[3,2,2],[1,1],[0]]$$[[8,4,4],[2,2],[1]]$
• Alt listelerin sırası ve her alt listedeki terimlerin sırası önemli değildir.
• Bazı yarıiletkenler için herhangi bir terimi bölmeniz gerekmez, çünkü zaten mükemmel bir örtüsüdür (bkz. A235040 ). Ancak yine de için gibi (tekton) listelerin bir listesini döndürmeniz gerekir .M [ [ 8 ] , [ 4 ] , [ 2 ] , [ 1 ] ] N = $V(N)$$M$$[[8],[4],[2],[1]]$$N=15$
• Bu kod golfü !

Test senaryoları

 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 bayt

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

Çevrimiçi deneyin!

N yerine (P; Q) kabul eder

algoritması:

• A'yı V'nin kısmi toplamı olarak hesaplayın (P * Q)

• her V (P) 'yi her V (Q) ile çarpın, ürünleri azalan düzende sıralayın (buna R diyelim) ve kısmi toplamlarını B hesaplayın

• B'de A'da da bulunan bu elementlerin konumlarını bulmak; bu pozisyonlardan hemen sonra R'yi kes

Jöle , 24 bayt

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

Soruda [P, Q]açıklandığı gibi olası bir liste listesi veren iki tamsayının listesini kabul eden monadik bir bağlantı .

Çevrimiçi deneyin! (altbilgi, listeyi gerçekte olduğu gibi göstermek için bir dize temsili yazdırır)

Veya test takımına bakın (N'nin listesini alarak ve sonuçları sorudakiler gibi yeniden sıralamak)

Nasıl?

öğelerini her zaman en alttan, açgözlü bir şekilde dilimleyebiliriz (ya M'de 1 vardır)$M$$1$$M$ ya da bir giriş vardı olduğunda, K = [ [ 4 ] ] ) için bir çözüm bulmak için.$4$$M=[[4]]$

^{Not: kod bu tür tüm çözümleri bir listede toplar ve daha sonra kafa (sadece) sonucunu alır - yani bölümler olası tüm sıralamalar olmadığından son kafa gereklidir.}

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 bayt

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

Çevrimiçi deneyin!

Jo King'den 1 bayt ; ve Kevin Cruijssen'den dolayı 1 bayt daha .

Girdi olarak alır p,q. Açgözlü algoritmayı takip eder.

Jöle , 41 bayt

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

Çevrimiçi deneyin!

Muhtemelen çok daha kısa olmalı (bazı bölümler çok tekrarlı hissediyorum; özellikle ÇIP$Ƈ, ama nasıl golf yapacağımı bilmiyorum). Daha fazla golf sonrası gelecek açıklama. Birden çok var olması durumunda olası tüm çözümleri döndürür ve girişi şu şekilde alır:$[P, Q]$.

Jöle , 34 bayt

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

Çevrimiçi deneyin!

Giriş biçimi: [P, Q](yukarıdaki TIO bağlantısı bunu kabul etmez, ancak test senaryolarına yardımcı olmak için bunun yerine tek bir sayı).

Çıktı biçimi: Tüm çözümlerin listesi (3D listesinin TIO üzerinden ızgara temsili olarak gösterilir).

Hız: Kaplumbağa.

Pyth , 27 bayt

Jonathan Allan'ın Jelly çözümümü ezmesinden esinlenerek . Alır$N$ girdi olarak.

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

Burada deneyin!

Haskell, 281195 bayt

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