รับจำนวนบวกnส่งออกพาร์ติชัน multiplicative ที่แตกต่างกันทั้งหมดของnในรูปแบบที่สะดวก

พาร์ติชันคูณของnเป็นชุดของจำนวนเต็มมากขึ้นทุกมากกว่าหนึ่งเช่นว่าผลิตภัณฑ์ของตนเป็นn ตัวอย่างเช่น 20 มีพาร์ติชัน multiplicative ที่แตกต่างกันดังต่อไปนี้:

2 * 2 * 5
2 * 10
4 * 5
20

การสั่งซื้อสินค้าไม่ได้เรื่องจึงเป็นพาร์ติชั่นเดียวกับ2 * 2 * 52 * 5 * 2

ตัวอย่าง:

1 -> {}
2 -> {2}
4 -> {2, 2}, {4}
20 -> {2, 2, 5}, {2, 10}, {4, 5}, {20}
84 -> {2, 2, 3, 7}, {2, 2, 21}, {2, 14, 3}, {2, 6, 7}, {2, 42}, {4, 3, 7}, {28, 3}, {4, 21}, {6, 14}, {12, 7}, {84}

Brachylogขนาด 16 ไบต์

>~l:{1<}a.*?,.=o

นี่คือฟังก์ชั่น (ไม่ใช่โปรแกรมเต็มรูปแบบ) ซึ่งใช้จำนวนบวกเป็นอินพุตและสร้างพาร์ติชัน multiplicative ทั้งหมดของมัน (ฉันยังหลีกเลี่ยงการใช้ตัวแยกตัวประกอบสำคัญในโซลูชันนี้ส่วนใหญ่เป็นเพราะฉันไม่แน่ใจว่าพวกเขาต้องการความช่วยเหลือหรือไม่ฉันอาจลองใช้ตัวแก้ไขที่หนักกว่ามากในบางจุด)

ลองออนไลน์! (มีการเพิ่มโค้ดพิเศษรอบฟังก์ชั่นที่นี่เพื่อทำให้เป็นโปรแกรมเต็มรูปแบบหากคุณให้ฟังก์ชั่นที่แสดงด้านบนกับ TIO โดยตรงมันจะเรียกใช้ฟังก์ชัน แต่ไม่พิมพ์ผลลัพธ์ที่ใดก็ได้ซึ่งไม่มีประโยชน์เหมือนกับการสาธิต .)

โปรแกรมนี้ทำให้ฉันผิดหวังจริงๆเพราะส่วนใหญ่ทำงานกับข้อบกพร่องในล่าม Brachylog และข้อบกพร่องในสเปคของมันแทนที่จะแก้ไขปัญหาจริง แต่ล่ามคือสิ่งที่มันเป็น (แม้จะมีโปรแกรมเช่นนี้ล่ามก็ใช้หน่วยความจำมากกว่าที่ควรจะมีเหตุผลและเกิดปัญหาเนื่องจากหน่วยความจำอ่อนเพลีย แต่โชคดีที่ปัญหาเล็ก ๆ มันจัดการเพื่อสร้างผลลัพธ์ที่ต้องการก่อน) ในสมมุติฐาน "Brachylog รุ่นสมบูรณ์" คุณสามารถเขียน~*.o.:{>1}a,ได้ซึ่งจะสั้นกว่า 4 ไบต์ แต่ฉันต้องการเพิ่มข้อ จำกัด พิเศษเพื่อช่วยให้ล่ามออกมาเล็กน้อย (ฉันไม่ชอบ Brachylog มากและค่อนข้างจะยึดติดกับ Prolog แต่มันต้องการคำแนะนำที่คล้ายกันเพื่อให้โปรแกรมทำงานได้และพวกเขาก็จะเขียนนานกว่านี้มากดังนั้น Brachylog จึงเป็น)

คำอธิบาย:

ตามปกติโปรแกรม Brachylog เป็นชุดของข้อ จำกัด โดยค่าเริ่มต้นข้อ จำกัด แรก จำกัด อินพุตกับที่ไม่รู้จัก (ซึ่งฉันจะเรียกว่าA ), ข้อ จำกัด ที่สองบังคับกับAที่ไม่รู้จักBที่สองและต่อ ๆ ไปจนกว่าเราจะถึงเอาต์พุต ตัวละครบางตัวเช่น{}สามารถเปลี่ยนการไหลทั่วไปนี้ได้ดังนั้นฉันจึงใช้ชุดตัวอักษรที่แตกต่างกัน (เช่นX / Y ) เพื่อแทนค่า unknowns ในเพรดิเคตที่ซ้อนกัน

>       A is smaller than the input
~l      B has length A
  1<    X is 1, Y is larger
:{1<}a  For each element X of B, it corresponds to an element Y of C
.       C, the output, and D are all identical
*       E is the product of D's elements
?       E, the input, and F are all identical
,       There's no constraint between F and G
.       G, the output, and H are all identical
=       H and I are identical, and need to be evaluated early
o       The output can be produced by sorting I

มันยังไม่ชัดเจนว่าโปรแกรมทำงานอย่างไรดังนั้นให้ลองลดข้อ จำกัด ลงเล็กน้อย C , D , G , Hและฉันเหมือนกันหมด (และเท่ากับเอาท์พุท) EและFก็เหมือนกัน (และเท่ากับอินพุต) ดังนั้นข้อ จำกัด ของเราจึงลดลงถึงสิ่งนี้:

• AคือความยาวของBและเอาต์พุตและมีขนาดเล็กกว่าอินพุต
• Bประกอบด้วย 1s ทั้งหมดและไม่มีประโยชน์อย่างยิ่ง (เป็นส่วนหนึ่งของโปรแกรมเพียงเพราะล่าม Brachylog ที่มีอยู่:{1<}aต้องการอาร์กิวเมนต์ด้านซ้ายของมันเพื่อให้มีความยาวที่ จำกัด
• ผลลัพธ์ประกอบด้วยตัวเลขทั้งหมดมากกว่า 1 (เช่นมากกว่าองค์ประกอบที่เกี่ยวข้องของB )
• ผลคูณขององค์ประกอบของเอาต์พุตเท่ากับอินพุต
• เอาท์พุทไม่เปลี่ยนแปลงโดยการจัดเรียงมัน

อนึ่งฉันไม่ได้ระบุอย่างชัดเจนว่าองค์ประกอบทั้งหมดของผลลัพธ์เป็นจำนวนเต็มซึ่งเป็นสิ่งที่อาจจำเป็นต้องใช้ อย่างไรก็ตามตัวแก้ไขข้อ จำกัด ของ Brachylog ไม่สามารถจัดการกับจำนวนที่ไม่ใช่จำนวนเต็มได้ดังนั้นมันจะผลิตเฉพาะโซลูชันที่เกี่ยวข้องกับจำนวนเต็มเท่านั้น

เห็นได้ชัดว่า "ความยาวของเอาต์พุตมีขนาดเล็กกว่าอินพุท" จะเป็นจริงเมื่อใดก็ตามที่เอาต์พุตเป็นพาร์ติชัน multiplicative ของอินพุต (เนื่องจาก 2 ^x > xสำหรับ nonnegative xทั้งหมดเช่นบวก 2 ^x ) ดังนั้นเราสามารถเพิกเฉยต่อข้อ จำกัด นั้น มีเพียงเพื่อให้ล่าม Brachylog เป็นกลยุทธ์การทำงานสำหรับการประเมินโปรแกรม ข้อ จำกัด อื่น ๆ (ที่ผลลัพธ์ถูกเรียงลำดับ, ผลิตภัณฑ์ของมันคืออินพุต, และองค์ประกอบทั้งหมดมากกว่า 1) คือคำจำกัดความของพาร์ติชันแบบหลายส่วนดังนั้นฟังก์ชันนี้จึงเป็นเพียงการนำคำถามไปปฏิบัติโดยตรง

Brachylog 1, 14 ไบต์

:{$pp~c:*ao}fd

ลองออนไลน์!

Brachylog 2, 11 10 ไบต์ภาษา postdates ท้าทาย

{ḋp~c×ᵐo}ᵘ

ลองออนไลน์!

Maltysen ตอบคำถามนี้ใน 17 bytes ของ Pyth ดังนั้นฉันจึงคิดวิธีแก้ปัญหา Brachylog ขนาด 16- ไบต์ที่ทำงานโดยการแปลข้อกำหนดของคำถามเป็น Brachylog ในขณะที่ฉันกำลังทำสิ่งนั้นเดนนิสเขียนโซลูชันวุ้นขนาด 15 ไบต์ ดังนั้นฉันต้องลงไปที่ 14 ไบต์ นี่คือฟังก์ชั่นที่รับอินพุตเป็นอาร์กิวเมนต์และส่งคืนรายการพาร์ติชันทั้งหมด (แทนที่จะเป็นตัวสร้างเช่นเดียวกับโซลูชันอื่น ๆ ของฉัน)

บางครั้งหลังจากที่ฉันเขียนคำตอบนี้เดนนิสและฉันพยายามร่วมมือกันให้ได้โซลูชันเจลลี่ลงไปที่ 11 ไบต์ ปรากฎว่ามี Brachylog รุ่นใหม่ออกมาพร้อมกับไวยากรณ์ terser; มันเป็นการโพสต์ความท้าทายดังนั้นจึงไม่นับ แต่มันสามารถจัดการผลรวม 11 ไบต์ได้ค่อนข้างเร็วพอ ๆ กับที่ปล่อยออกมา การแก้ไขในภายหลังของภาษา (โดยได้รับแรงบันดาลใจจากความท้าทายอื่น ๆ ) สามารถไปต่ำถึง 10 เท่าที่เห็นที่นี่ สองโปรแกรมเหมือนกันโดยมีความแตกต่างเพียงอย่างเดียวคือไวยากรณ์

แตกต่างจากโซลูชันอื่น ๆ ของฉันซึ่งไม่ได้ใช้ประโยชน์จาก "การตีกอล์ฟแบบดั้งเดิม" แต่ระบุปัญหาโดยตรง แต่สิ่งนี้ไม่สนใจพลังของข้อ จำกัด ของ Brachylog และแสดงผลเยลลี่ที่ดีที่สุดแทนการเขียนข้อ จำกัด ที่ อาร์กิวเมนต์ด้านซ้ายเป็นที่รู้จักกันแล้ว (และทำให้ข้อ จำกัด เพียงทำตัวเหมือน monads เยลลี่มากกว่าข้อ จำกัด แบบเต็มเป่า) ดังนั้นจึงใช้อัลกอริธึมแบบเดียวกับโซลูชัน Pyth ของ @ Maltysen ซึ่งอาจเป็นวิธีที่ง่ายที่สุดในการแก้ปัญหานี้โดยใช้วิธีตีกอล์ฟทั่วไป (น่าสนใจการแก้ปัญหา "เพียงระบุปัญหา" ในคำตอบอื่น ๆ ของฉันจะสั้นลงหากไม่ใช่ข้อบกพร่อง / ข้อบกพร่องในล่าม Brachylog แม้ว่าจะไม่มีการใช้งานการเล่นกอล์ฟแบบดั้งเดิมบางวันฉันต้องเขียน "ปรับปรุง Brachylog" เพื่อให้ได้ทางออกที่ดีสำหรับปัญหาประเภทนี้ เป็นภาษากอล์ฟไป Brachylog จริง verbose จริง ๆ )

โปรแกรมประกอบด้วยตัวกำเนิดและตัวล้อมรอบมัน ก่อนอื่นนี่คือคำอธิบายของเครื่องกำเนิดไฟฟ้า:

$pp~c:*ao  ḋp~c×ᵐo
$p         ḋ        Prime factor decomposition of the input
  p         p       Generate all permutations
   ~c        ~c     Generate all inverse concatenations (i.e. partitions)
     :*a       ×ᵐ   Take the product of each list element in each partition
        o        o  Sort each partition

สิ่งนี้เกือบจะแก้ปัญหาได้ แต่เราจบลงด้วยการสร้างพาร์ติชันจำนวนมากหลายต่อหลายครั้ง ดังนั้นเราจึงจำเป็นต้องใช้ wrapper ในการแก้ปัญหาซ้ำซ้อน:

:{…}fd
:{…}f     Convert generator to list
     d    Remove duplicate elements

{…}ᵘ      Convert generator to list of unique elements

Mathematica, 61 ไบต์

±1={{}}
±n_:=Union@@(Sort/@Append[n/#]/@±#&/@Most@Divisors@n)

กำหนดโอเปอเรเตอร์ unary (แบบเรียกซ้ำ) ±ซึ่งส่งคืนรายการของพาร์ติชัน

Pyth - 17 ไบต์

ใช้การเรียงสับเปลี่ยนทั้งหมดของการแยกตัวประกอบเฉพาะแล้วแบ่งพาร์ติชั่นแต่ละอันจากนั้นแยกพาร์ติชั่นทั้งหมดออกแล้วเก็บเฉพาะพาร์ติชั่นที่ต่างกันเท่านั้น

{mS-*Md1s./M.p+1P

Test Suite

Python 2, 70 ไบต์

f=lambda n,k=2,l=[]:n/k and(n%k<1)*f(n/k,k,l+[k])+f(n,k+1,l)or 1/n*[l]

แสดงรายการของรายการที่เรียงลำดับ ยกตัวอย่างคือf(20)[[2, 2, 5], [2, 10], [4, 5], [20]]

เยลลี่ , 14 13 11 ไบต์

Ḋx³ŒPQP=¥Ðf

ลองออนไลน์!

ฉันค่อนข้างมั่นใจว่า @ Jelly's Solution Jelly สามารถปรับปรุงได้ น่าเสียดายที่ฉันไม่สามารถเอาชนะสถิติ Brachylog ได้ แต่ฉันก็สามารถผูกมันได้ อัปเดต : ด้วยความช่วยเหลือของ @Dennis มันได้รับการปรับปรุงแล้ว ฉันเดาว่า Jelly จะกลับมงกุฎ

โปรแกรมนี้ไม่มีประสิทธิภาพอย่างไม่น่าเชื่อมีประสิทธิภาพ O (2 ^{n 2} ) (ซึ่งเป็นสาเหตุที่กรณีทดสอบด้านบนแสดงเป็นอินพุต 4) มันเสร็จสมบูรณ์อย่างรวดเร็วในวันที่ 4 ช้ามากในวันที่ 5 และอาจเป็นไปไม่ได้ที่จะเรียกใช้สำหรับตัวเลขขนาดใหญ่

ที่น่าสนใจ Brachylog ได้รับการปรับปรุงโดยไปจากโซลูชันที่อธิบายถึงปัญหา (ซึ่ง Brachylog นั้นดี) ไปยังโซลูชันที่ใช้อัลกอริทึมตามการแยกปัจจัยอินพุต (ซึ่งเป็นเยลลี่ที่ดี) ขณะที่การแก้ปัญหาเยลลี่ได้รับการปรับปรุงโดยการย้ายออกไปจากของจุดแข็งและจะกลับไปแก้ปัญหาที่เพิ่งอธิบายถึงปัญหา

คำอธิบาย:

Ḋx³ŒPQP=¥Ðf
Ḋ              List of integers from 2 to the input (apparently undocumented)
 x³            Make a number of copies of each that's equal to the input
   ŒP          Take all (possibly noncontiguous) subsequences of that list (!)
     Q         Remove duplicates
         Ðf    Filter, keeping elements where:
      P=         their product is equal to {the original input, by default}
        ¥      Parse preceding two links as a unit

เนื่องจากเอาต์พุตของḊxเรียงลำดับแล้วแต่ละลำดับจะต้องเรียงลำดับดังนั้นเราจึงไม่ต้องเรียงลำดับแยกกัน ดังนั้น "ผลลัพธ์เดียวกันในคำสั่งที่แตกต่างกันจึงเป็นส่วนที่ซ้ำกัน" ของปัญหาและ "ค่าทั้งหมดในผลลัพธ์เป็น> 1" ส่วนหนึ่งของปัญหาได้รับการแก้ไขโดยการสร้าง นอกเหนือจากนั้นสิ่งที่เรากำลังทำอยู่ที่นี่คือ "ค้นหารายการทั้งหมดที่P=³" ซึ่งเราทำ (ในวิธีที่ไม่มีประสิทธิภาพอย่างไม่น่าเชื่อ) โดยการสร้างรายการทั้งหมดที่เป็นปัญหาแล้วกรองรายการที่ไม่ถูกต้องออก

(เห็นได้ชัดว่าใครบางคนต้องคิดค้นลูกผสมระหว่าง Jelly และ Brachylog รวมถึงตัวแก้ไขข้อ จำกัดที่ดีมาก ๆ เพื่อที่เราจะได้เขียนอะไรบางอย่างตามบรรทัดของ{P=³}~รหัสบวกบางส่วนของการทำสำเนาซ้ำซ้อน อยู่ห่างออกไปเล็กน้อย)

JavaScript (ES6), 74 67 ไบต์

f=(n,m=2,a=[])=>n>1?m>n?[]:f(n,m+1,a).concat(f(n/m,m,[...a,m])):[a]

for (var i = 1; i < 31; i++) console.log(JSON.stringify(f(i)));

โดยตรงแก้ปัญหาซ้ำสำหรับแต่ละจำนวนเต็มม.จาก2ไปnเราใช้เวลาในแต่ละพาร์ติชันของn / mมีองค์ประกอบอย่างน้อยม. (เพื่อหลีกเลี่ยงพาร์ทิชันที่ซ้ำกัน) และผนวกเมตร (สำหรับmใด ๆที่ไม่หารnจะให้อาเรย์ว่างเนื่องจากไม่มีการจัดเรียงของจำนวนเต็มคูณกับทศนิยม) เรากำหนดกรณีฐานของอาเรย์ที่ว่างสำหรับ1เพื่อหลีกเลี่ยงการเรียกซ้ำแบบไม่สิ้นสุด

Python2, 198 191 172 180 ไบต์

from itertools import*
n=input()
for i in range(2,len(bin(n))):
 for P in combinations_with_replacement(range(2,n),i):
  if reduce(lambda a,b:a*b,P)==n:print(P)
print[(n,),()][n<2]

โปรแกรมเต็มรูปแบบ สิ่งนี้อาจได้รับการปรับปรุงให้ดีขึ้นมาก

• @FlipTackบันทึกแล้ว 9 ไบต์!
• @orlpบันทึกแล้ว 19 ไบต์!

เอาท์พุทจากช่วง 1 ถึง 31 (รวม):

(1,)
(2,)
(3,)
(2, 2), (4,)
(5,)
(2, 3), (6,)
(7,)
(2, 4), (2, 2, 2), (8,)
(3, 3), (9,)
(2, 5), (10,)
(11,)
(2, 6), (3, 4), (2, 2, 3), (12,)
(13,)
(2, 7), (14,)
(3, 5), (15,)
(2, 8), (4, 4), (2, 2, 4), (2, 2, 2, 2), (16,)
(17,)
(2, 9), (3, 6), (2, 3, 3), (18,)
(19,)
(2, 10), (4, 5), (2, 2, 5), (20,)
(3, 7), (21,)
(2, 11), (22,)
(23,)
(2, 12), (3, 8), (4, 6), (2, 2, 6), (2, 3, 4), (2, 2, 2, 3), (24,)
(5, 5), (25,)
(2, 13), (26,)
(3, 9), (3, 3, 3), (27,)
(2, 14), (4, 7), (2, 2, 7), (28,)
(29,)
(2, 15), (3, 10), (5, 6), (2, 3, 5), (30,)
(31,)

เยลลี่ 15 ไบต์

ÆfŒ!ŒṖ€;/P€€Ṣ€Q

ลองออนไลน์!

Clojure, 91 ไบต์

(defn f[n](conj(set(for[i(range 2 n):when(=(mod n i)0)j(f(/ n i))](sort(flatten[i j]))))n))

ตัวอย่างการทำงาน:

(map f [20 84])
(#{20 (2 2 5) (4 5) (2 10)} #{(7 12) (2 2 3 7) (2 3 14) (2 2 21) (2 6 7) (6 14) (3 4 7) (3 28) (4 21) (2 42) 84})

ค่าตัวเองจะถูกส่งกลับเป็นตัวเลขเดียว (ไม่ใช่กlist) คนอื่น ๆ ออกมาเป็นรายการ nในตอนท้ายจะถูกแทนที่ด้วย[n]ที่จะให้มันเป็นลำดับเช่นกันหรือ(list n)จะให้มันรายการ

ภาษา Wolfram (Mathematica) , 58 56 52 ไบต์

If[#>1,##&@@#0[#/i,##2,i]~Table~{i,2,Min@##},{##2}]&

ลองออนไลน์!

ดัดแปลงจากวิธีการแก้ปัญหาทางคณิตศาสตร์ของฉันไปสู่การหารตัวหารแบบแยกส่วน ส่งคืนSequenceพาร์ติชัน

J, 35 ไบต์

([:~.]<@/:~@(*//.)"$~#\#:i.@!@#)@q:

ขึ้นอยู่กับการแก้ปัญหาการแยกตัวประกอบเวลาที่ จำกัด

รุ่นนี้ไม่มีประสิทธิภาพมากขึ้นและทำงานในเวลาปัจจัยตามจำนวนของปัจจัยที่สำคัญ สร้างพาร์ติชันโดยสร้างหมายเลขตัวประกอบ

ลองออนไลน์!(อย่าลองใช้ค่าจำนวนมากออนไลน์!)

คำอธิบาย

([:~.]<@/:~@(*//.)"$~#\#:i.@!@#)@q:  Input: integer n
                                 q:  Prime factorization
(                              )@    Operate on them
                              #        Length
                            !@         Factorial
                         i.@           Range [0, i)
                     #\                Range [1, i]
                       #:              Mixed based conversion - Creates factoradic values
     ]                                 Get factors
            (    )"$~                  For each factoradic value
               /.                        Partition the factors based on equal
                                         digits in the factoradic value
             */                          Get the product of each block
        /:~@                             Sort it
      <@                                 Box it
 [:~.                                  Deduplicate

D, 95 ไบต์

void g(int n,int[]r){for(int i=r[0];i*i<=n;i++)(n%i)?0:g(n/i,i~r);r.back=n;r.writeln;}g(n,[2]);

เป็นเพียงวิธีแก้ปัญหาซ้ำ ในg(n,r), rเป็นพาร์ทิชันเพื่อให้ห่างไกลและnเป็นค่าที่เหลือยังคงที่จะบุกเข้าไปปัจจัย เพื่อให้ได้พาร์ติชั่นที่ไม่มีการเรียงลำดับเพียงครั้งเดียวเราจัดเรียงปัจจัยตามลำดับที่rไม่เพิ่มขึ้น องค์ประกอบสุดท้ายของการrเริ่มต้น2เป็นปัจจัยที่เป็นไปได้น้อยที่สุดและได้รับการเขียนทับโดยnในแต่ละสำเนาก่อนการดำเนินการส่งออกแต่ละ

สำหรับn = 60ผลลัพธ์จะเป็นดังนี้:

[3, 2, 2, 5]
[2, 2, 15]
[3, 2, 10]
[5, 2, 6]
[2, 30]
[4, 3, 5]
[3, 20]
[4, 15]
[5, 12]
[6, 10]
[60]

ลองออนไลน์!

D, 109 ไบต์

import std.stdio;void g(T)(T n,T[]r=[2]){if(n-1){for(T i=r[0];i*i<=n;i++)n%i?0:g(n/i,i~r);r[$-1]=n;r.write;}}

ลองออนไลน์!