เรากำหนด$V(x)$เป็นรายการของอำนาจที่แตกต่างกันของ$2$ว่าผลรวมไปx$x$ยกตัวอย่างเช่น$V(35)=[32,2,1]$ ]

ตามแบบแผนอำนาจจะถูกจัดเรียงที่นี่จากมากไปหาน้อย แต่มันไม่ได้ส่งผลกระทบต่อตรรกะของความท้าทายหรือการแก้ปัญหาที่คาดหวัง

งาน

รับsemiprime $N$ , แทนที่แต่ละเทอมใน$V(N)$ด้วยรายชื่อของพลังของที่รวมกับเทอมนี้ในลักษณะที่การรวมกันของรายการย่อยที่เกิดขึ้นทั้งหมดเป็นหน้าปกที่แน่นอนของเมทริกซ์นิยามดังนี้$2$$M$

ที่และเป็นปัจจัยที่สำคัญของ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]]$
• ลำดับของรายการย่อยไม่สำคัญและไม่เรียงลำดับของเงื่อนไขในแต่ละรายการย่อย
• สำหรับ semiprimes คุณจะไม่ต้องแยกคำใด ๆ เนื่องจากเป็นปกที่สมบูรณ์แบบของ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 (ngn / 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Ḣ

ลิงค์ monadic ยอมรับรายการของจำนวนเต็มสองจำนวน[P, Q]ซึ่งให้รายการที่เป็นไปได้หนึ่งรายการตามที่อธิบายไว้ในคำถาม

ลองออนไลน์! (ส่วนท้ายพิมพ์การแสดงสตริงเพื่อแสดงรายการตามที่เป็นจริง)

หรือดูชุดทดสอบ (จดรายการ N และเรียงลำดับผลลัพธ์ใหม่เหมือนในคำถาม)

อย่างไร?

เราอาจแบ่งองค์ประกอบของจากต่ำสุดขึ้นไปอย่างตะกละตะกลาม (เช่นมี1ในMหรือเรามีอินพุต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 ไบต์จากJo King ; และอีก 1 ไบต์เนื่องจากเควิน Cruijssen

ใช้เวลาเป็น p,qinput ติดตามอัลกอริทึมโลภ

เยลลี่ , 41 ไบต์

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

ลองออนไลน์!

น่าจะสั้นกว่านี้มาก (บางส่วนรู้สึกซ้ำซากมากโดยเฉพาะอย่างยิ่งÇIP$Ƈแต่ฉันไม่รู้วิธีตีกอล์ฟ) คำอธิบายที่จะเกิดขึ้นหลังจากเล่นกอล์ฟต่อไป ส่งคืนโซลูชันที่เป็นไปได้ทั้งหมดในกรณีที่มีหลายรายการและรับอินพุตเป็น$[P, Q]$.

เยลลี่ 34 ไบต์

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

ลองออนไลน์!

รูปแบบการป้อนข้อมูล: [P, Q](ลิงก์ TIO ด้านบนไม่ยอมรับสิ่งนี้ แต่ใช้หมายเลขเดียวแทนเพื่อช่วยในกรณีทดสอบ)

รูปแบบผลลัพธ์: รายการโซลูชันทั้งหมด (แสดงเป็นตารางแสดงรายการ 3D ผ่าน 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))