หมายเลขพาร์ติชันของเลขจำนวนเต็มบวกถูกกำหนดเป็นจำนวนวิธีที่สามารถแสดงเป็นผลรวมของจำนวนเต็มบวก กล่าวอีกนัยหนึ่งจำนวนพาร์ติชันจำนวนเต็มมี ตัวอย่างเช่นหมายเลข4มีพาร์ติชันต่อไปนี้:

[[1, 1, 1, 1], [1, 1, 2], [1, 3], [2, 2], [4]]

ดังนั้นจึงมี5พาร์ติชัน นี่คือOEIS A000041

งาน

รับจำนวนเต็มบวกNกำหนดหมายเลขพาร์ติชัน

• ใช้กฎมาตรฐานทั้งหมด

• อินพุตและเอาต์พุตอาจได้รับการจัดการผ่านค่าเฉลี่ยที่สมเหตุสมผล

• นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

อินพุต | เอาท์พุต

1 | 1
2 | 2
3 | 3
4 | 5
5 | 7
6 | 11
7 | 15
8 | 22
9 | 30
10 | 42

Pyth , 3 ไบต์

l./

ลองที่นี่! หรือลองใช้ชุดทดสอบ

คำตอบใช้เวลาในการฟอร์แมตนานกว่าการเขียนโค้ดเอง: P

อย่างไร?

Pyth เป็นเครื่องมือที่เหมาะสมสำหรับงาน

l. / โปรแกรมเต็มรูปแบบพร้อมอินพุตโดยนัย

 ./ พาร์ทิชันที่มีจำนวนเต็ม ส่งคืนรายการที่เรียงลำดับทั้งหมดของจำนวนเต็มบวกที่เพิ่มไปยังอินพุต
l ความยาว
      แสดงผลลัพธ์โดยปริยาย

Mathematica ขนาด 11 ไบต์

PartitionsP

คำอธิบาย

¯\_(ツ)_/¯

Python 2 , 85 83 ไบต์

-2 ไบต์ต้องขอบคุณ @notjagan

lambda n:n<1or sum(sum(i*((n-k)%i<1)for i in range(1,n+1))*p(k)for k in range(n))/n

ลองออนไลน์!

โดยใช้สูตรเวียนเกิดจากOEIS A000041

อิโมจิโคด 0.5, 204 201 ไบต์

🐋🚂🍇🐖🅰️➡🚂🍇🍊⬅🐕1🍇🍎1🍉🍮s 0🔂k⏩0🐕🍇🍦t➖🐕k🍮r t🔂i⏩1 t🍇🍊😛🚮t i 0🍇🍮➕r i🍉🍉🍮➕s✖r🅰️k🍉🍎➗s🐕🍉🍉

ลองออนไลน์!

-3 ไบต์โดยใช้ "น้อยกว่าหรือเท่ากับ 1" แทน "น้อยกว่า 2" เนื่องจากอิโมจิ "น้อยกว่า" มีการเข้ารหัส UTF-8 ที่ค่อนข้างยาว ทำให้tเป็นน้ำแข็งเพื่อปิดเสียงเตือนโดยไม่ส่งผลกระทบต่อจำนวนไบต์

ขยายคลาส integ (จำนวนเต็ม) ด้วยเมธอด🅰️ คุณสามารถเขียนโปรแกรมอย่างง่ายที่รับหมายเลขจากอินพุตโทร🅰️ที่หมายเลขแล้วพิมพ์ผลลัพธ์ดังนี้:

🏁🍇
 🍦str🔷🔡😯🔤Please enter a number🔤
 🍊🍦num🚂str 10🍇
  😀🔡🅰️num 10
 🍉🍓🍇
  😀🔤Learn what a number is, you moron!🔤
 🍉
🍉

ส่วนนี้สามารถเล่นกอล์ฟได้มากโดยการละเว้นข้อความและการจัดการข้อผิดพลาด แต่ไม่รวมอยู่ในคะแนนดังนั้นฉันชอบที่จะแสดงคุณลักษณะเพิ่มเติมของ Emojicode แทนในขณะที่ปรับปรุงการอ่านไปพร้อมกัน

Ungolfed

🐋🚂🍇
 🐖🅰️➡🚂🍇
  🍊◀️🐕2🍇
   🍎1
  🍉
  🍮sum 0
  🔂k⏩0🐕🍇
   🍦nmk➖🐕k
   🍮sig nmk
   🔂i⏩1 nmk🍇
    🍊😛🚮nmk i 0🍇
     🍮➕sig i
    🍉
   🍉
   🍮➕sum✖sig🅰️k
  🍉
  🍎➗sum🐕
 🍉
🍉

คำอธิบาย

หมายเหตุ:ตัวเลือกอีโมจิจำนวนมากไม่สมเหตุสมผลใน emojicode 0.5 มันคือ 0.x หลังจากทั้งหมด 0.6 จะแก้ไขสิ่งนี้

Emojicode เป็นภาษาการเขียนโปรแกรมเชิงวัตถุที่มี generics, โปรโตคอล, optionals และ closures แต่โปรแกรมนี้ไม่ได้ใช้การปิดและ generics และโปรโตคอลทั้งหมดสามารถพิจารณาได้โดยปริยาย

โปรแกรมดำเนินการเพียงไม่กี่ประเภท: 🚂เป็นประเภทจำนวนเต็ม, 🔡เป็นประเภทสตริงและ⏩เป็นประเภทช่วง บูลีนสองสามตัว (few) ก็ปรากฏเช่นกัน แต่พวกมันจะถูกใช้ในเงื่อนไขเท่านั้น บูลีนสามารถใช้ค่า👍หรือ👎ซึ่งสอดคล้องกับความจริงและเท็จตามลำดับ

ขณะนี้มีผู้ประกอบการในการ Emojicode ดังนั้นนอกจาก comparsions และการดำเนินงานอื่น ๆ ที่เป็นปกติผู้ประกอบการจะดำเนินการตามฟังก์ชั่นได้อย่างมีประสิทธิภาพทำให้การแสดงออกใช้คำนำหน้าสัญกรณ์ ผู้ประกอบการมีการวางแผนใน 0.6

ลองจัดการโปรแกรมทดสอบก่อน

🏁

นี่คือบล็อก, ซึ่งสามารถเปรียบเทียบกับหลักจากภาษาอื่น ๆ

🍇 ... 🍉

องุ่นและแตงโมประกาศบล็อกรหัสในอิโมจิโคด

🍦str🔷🔡😯🔤Please enter a number🔤

สิ่งนี้ประกาศชื่อ "แช่แข็ง" strและตั้งค่าเป็นสตริงใหม่ที่สร้างขึ้นโดยใช้ initializer (ตัวสร้าง) 😯ซึ่งรับพร้อมท์เป็นสตริงแล้วป้อนบรรทัดจากผู้ใช้ เหตุใดจึงใช้การแช่แข็งแทนตัวแปร? มันจะไม่เปลี่ยนแปลงดังนั้นตัวแปรจะส่งคำเตือน

🍊🍦num🚂str 10

มาทำลายมันกันเถอะ 🚂str 10เรียกใช้เมธอด frozen บนstrน้ำแข็งที่มีอาร์กิวเมนต์ 10 ตามระเบียบวิธีการตั้งชื่อด้วยชื่อประเภทแปลงวัตถุเป็นประเภทนั้น 10 คือฐานที่ใช้สำหรับการแปลงจำนวนเต็ม วิธีนี้จะคืนค่าเป็นทางเลือก, 🍬🚂. ตัวเลือกสามารถมีค่าของประเภทฐานหรือไม่มีอะไร⚡ เมื่อสตริงไม่มีตัวเลขระบบจะส่งคืน⚡ ในการใช้ค่าต้องทำการแกะตัวเลือกโดยใช้🍺ซึ่งทำให้เกิดข้อผิดพลาดขณะใช้งานหากค่าคือ⚡ ดังนั้นจึงเป็นวิธีปฏิบัติที่ดีในการตรวจสอบความว่างเปล่าก่อนที่จะยกเลิกการเลือกใช้ ในความเป็นจริงมันเป็นเรื่องธรรมดาที่ Emojicode มีการจดชวเลข โดยปกติ🍊คือ "ถ้า"🍊🍦 variable expressionหมายถึง: ประเมินการแสดงออก หากทางเลือกมีความว่างเปล่าเงื่อนไขจะประเมินเป็น👎 (false) มิฉะนั้นชื่อที่variableถูกตรึงจะถูกสร้างขึ้นด้วยค่าที่ยังไม่ได้ห่อของตัวเลือกและเงื่อนไขจะประเมินเป็น👍, (จริง) ดังนั้นในการใช้งานปกติ🍇 ... 🍉บล็อกตามเงื่อนไขจะถูกป้อน

😀🔡🅰️num 10

🅰️เป็นวิธีการที่รหัสหลักเพิ่มเข้ามาโดยใช้🐋ซึ่งคำนวณจำนวนพาร์ติชัน การเรียก🅰️บนnumน้ำแข็งที่เราประกาศในเงื่อนไขและแปลงผลลัพธ์เป็นสตริงโดยใช้ฐาน 10 โดยวิธี🔡 จากนั้น😀พิมพ์ผลลัพธ์

🍓🍇 ... 🍉

🍓หมายถึง "else" ดังนั้นบล็อกนี้จะถูกป้อนเมื่อผู้ใช้ไม่ได้ป้อนตัวเลขอย่างถูกต้อง

😀🔤Learn what a number is, you moron!🔤

พิมพ์สตริงตัวอักษร

ทีนี้มาดูโปรแกรมหลักกันดีกว่า ฉันจะอธิบายเวอร์ชันที่ไม่ดี เวอร์ชัน golfed เพิ่งลบช่องว่างออกและเปลี่ยนชื่อเป็นชื่อตัวอักษรเดียว

🐋🚂🍇 ... 🍉

ขยายคลาส🚂 นี่คือคุณสมบัติที่ไม่พบบ่อยในภาษาการเขียนโปรแกรม แทนที่จะสร้างคลาสใหม่ด้วย🚂เป็นซูเปอร์คลาส🐋จะปรับเปลี่ยน🚂โดยตรง

🐖🅰️➡🚂🍇 ... 🍉

สร้างวิธีการใหม่ที่ชื่อว่า🅰️ที่คืนค่า🚂 ส่งคืนจำนวนพาร์ติชันที่คำนวณโดยใช้สูตรa(n) = (1/n) * Sum_{k=0..n-1} sigma(n-k)*a(k)

🍊⬅🐕1🍇
 🍎1
🍉

🐕คล้ายกับthisหรือselfมาจากภาษาอื่นและอ้างอิงถึงวัตถุที่วิธีการนั้นถูกเรียกใช้ การใช้งานนี้ซ้ำซ้ำดังนั้นนี่คือเงื่อนไขการยกเลิก: ถ้าจำนวนวิธีการที่เรียกว่ามีค่าน้อยกว่าหรือเท่ากับ 1 กลับ 1

🍮sum 0

สร้างตัวแปรใหม่sumและตั้งเป็น 0 โดยปริยายถือว่าพิมพ์🚂

🔂k⏩0🐕

🔂วนซ้ำทุกสิ่งที่ใช้โปรโตคอล, ในขณะที่⏩เป็นช่วงตัวอักษรที่เกิดขึ้นเพื่อนำไปใช้🔂🐚🚂 ช่วงมีค่าเริ่มต้นค่าหยุดและค่าขั้นตอนซึ่งจะถือว่าเป็น 1 ถ้าstart < stopหรือ -1 เป็นอย่างอื่น หนึ่งยังสามารถระบุค่าขั้นตอนโดยใช้⏭เพื่อสร้างช่วงตัวอักษร ค่าเริ่มต้นรวมอยู่ด้วยในขณะที่ค่าหยุดเป็นพิเศษดังนั้นนี่จึงเท่ากับfor k in range(n)หรือSum_{k=0..n-1}ในสูตร

🍦nmk➖🐕k

เราจำเป็นต้องคำนวณ sigma (n - k) หรือผลรวมของตัวหารn - kในคำอื่น ๆ และอาร์กิวเมนต์ที่จำเป็นสองสามครั้งดังนั้นร้านนี้n - kในตัวแปรnmkเพื่อบันทึกไบต์บางส่วน

🍮sig nmk
🔂i⏩1 nmk

นี้กำหนดsigตัวแปรข้อโต้แย้งของซิกและ iterates มากกว่าตัวเลขทั้งหมดตั้งแต่ 1 nmk - 1ถึง ฉันสามารถเริ่มต้นตัวแปรเป็น 0 และวนซ้ำมากกว่า 1..nmk แต่การทำเช่นนี้จะสั้นกว่า

🍊😛🚮nmk i 0

🚮คำนวณส่วนที่เหลือหรือโมดูลัสและ😛การตรวจสอบเพื่อความเท่าเทียมกันเพื่อให้อยู่ในสภาพที่จะ👍ถ้าiเป็น divider nmkของ

🍮➕sig i

นี่คือการมอบหมายโดยการโทรซึ่งคล้ายกับ+= -= >>=ตระกูลโอเปอเรเตอร์ในภาษาที่ไม่มีภาษาอิโมจิที่ด้อยคุณภาพ 🍮 sig ➕ sig iบรรทัดนี้สามารถเขียนยังเป็น ดังนั้นหลังจากวนรอบด้านในเสร็จสิ้นsigจะมีผลรวมของตัวหารของn - kหรือsigma(n - k)

🍮➕sum✖sig🅰️k

การมอบหมายอื่นด้วยการโทรดังนั้นสิ่งนี้จะเพิ่มsigma(n - k) * A(k)ผลรวมเช่นเดียวกับในสูตร

🍎➗sum🐕

ในที่สุดยอดรวมจะถูกหารด้วย n และส่งกลับผลหาร คำอธิบายนี้อาจใช้เวลาสามครั้งในการเขียนโค้ดเอง ...

Pari / GP 8 ไบต์

numbpart

ลองออนไลน์!

อ็อกเทฟ, 18 ไบต์

partcnt(input(''))

ใช้ฟังก์ชันในตัว partcnt

ไม่สามารถทำให้ถูกต้องโดยใช้ฟังก์ชั่นที่ไม่ระบุชื่อโดยใช้ @ ความช่วยเหลือบางอย่างจะได้รับการชื่นชม

เรติน่า 34 ไบต์

.+
$*
+%1`\B
;$'¶$`,
,

%O`1+
@`.+

ลองออนไลน์!

คำอธิบาย

.+
$*

แปลงอินพุตเป็น unary

+%1`\B
;$'¶$`,

สิ่งนี้คำนวณพาร์ติชั่น2 ^{n-1 ทั้งหมด}ของรายการเลขหลัก เราทำสิ่งนี้โดยซ้ำ ( +) จับคู่กับ1ขอบเขตที่ไม่ใช่คำแรก ( ) \Bคือตำแหน่งระหว่างสอง1s ในแต่ละบรรทัด ( %) และแทนที่ด้วย;ทุกอย่างหลังจากนั้น ( $'), linefeed ( ¶) ทุกอย่างอยู่ข้างหน้า มัน ( $`) ,และ ตัวอย่าง:

1;1,111

กลายเป็น

      vv
1;1,1;11
1;1,1,11
^^^^^

ไหนvเครื่องหมายผลมาจาก$'และเครื่องหมายผล^ $`นี่เป็นสำนวนทั่วไปที่จะได้รับผลลัพธ์ของการแทนที่สองแบบพร้อมกัน (โดยทั่วไปเราแทรกทั้ง;และและการ,แทนที่รวมถึง "ครึ่ง" ที่ขาดหายไปของสตริงเพื่อเติมเต็มสองการแทนที่)

เราจะถือว่า;เป็นพาร์ติชันที่เกิดขึ้นจริงและ,เช่นเดียวกับตัวยึดที่ป้องกันไม่ให้\Bมีการจับคู่ในภายหลัง ดังนั้นต่อไป ...

,

... เราลบเครื่องหมายจุลภาคเหล่านั้น นั่นทำให้เรามีพาร์ติชั่นทั้งหมด ตัวอย่างเช่นการป้อนข้อมูลที่4เราได้รับ:

1;1;1;1
1;1;11
1;11;1
1;111
11;1;1
11;11
111;1
1111

เราไม่สนใจเกี่ยวกับการสั่งซื้อว่า:

%O`1+

นี่เป็นการเรียงลำดับการวิ่งของ1แต่ละบรรทัดดังนั้นเราจึงได้พาร์ติชันที่ไม่มีการเรียงลำดับ

@`.+

ในที่สุดเราจะนับการแข่งขันที่ไม่ซ้ำกัน@ของ.+นั่นคือจำนวนบรรทัด / พาร์ติชันที่เราได้รับ ฉันเพิ่ม@ตัวเลือกนี้ทุกเพศทุกวัยที่ผ่านมาแล้วลืมมันอย่างสมบูรณ์และเพิ่งค้นพบมันเมื่อเร็ว ๆ นี้ D`ในกรณีนี้มันจะช่วยประหยัดไบต์มากกว่าการขจัดข้อมูลซ้ำซ้อนแรกบรรทัดที่มี

Python 2 , 54 53 ไบต์

f=lambda n,k=1:1+sum(f(n-j,j)for j in range(k,n/2+1))

ลองออนไลน์!

มันทำงานอย่างไร

พาร์ทิชันของแต่ละnสามารถแสดงเป็นรายการx = [x ₁ , ⋯, x _เมตร ]เช่นว่าx ₁ + ⋯ + x _ม n = การเป็นตัวแทนนี้จะไม่ซ้ำกันหากเราต้องการx ₁ ≤⋯≤ x _mเมตร

เรากำหนดฟังก์ชั่นเสริมf (n, k)นับว่าพาร์ทิชันที่มีขีด จำกัด ล่างkคือรายการxเช่นว่าx ₁ + ⋯ + x _เมตร = nและk ≤ x ₁ ≤⋯≤ xเมตร สำหรับอินพุตnความท้าทายจึงถามเอาต์พุตของf (n, 1)1)

สำหรับจำนวนเต็มบวกnและkดังกล่าวว่าk ≤ nมีอย่างน้อยหนึ่งพาร์ทิชันที่มีขีด จำกัด ล่างk : รายการเดี่ยว[N] ถ้าn = k (โดยเฉพาะถ้าn = 1 ) นี่คือพาร์ติชันที่มีสิทธิ์เท่านั้น ในทางกลับกันถ้าk> nไม่มีวิธีแก้ปัญหาเลย

หากk <nเราสามารถนับพาร์ติชันที่เหลืออยู่ซ้ำโดยการสร้างพาร์ติชันจากซ้ายไปขวาดังนี้ สำหรับแต่ละญดังกล่าวว่าk ≤เจ≤ n / 2 , เราสามารถสร้างพาร์ทิชัน[x ₁ , ⋯, x _ม ] = [เจ, y ₁ , ⋯, y _M-1 ] เรามีที่x ₁ + ⋯ + x _ม n =ถ้าหากปี₁ + ⋯ + Y _M-1 n = - เจ นอกจากนี้x ₁ ≤⋯≤ x _mถ้าหากj ≤ y ₁ ≤⋯≤ y _m-1 M-1

ดังนั้นพาร์ติชันxของnที่ขึ้นต้นด้วยjสามารถคำนวณเป็นf (n - j, j)ซึ่งนับพาร์ทิชันที่ถูกต้องY โดยกำหนดว่าเจ≤ n / 2เรามั่นใจว่าเจ≤ n - เจจึงมีอย่างน้อยหนึ่งปี เราจึงสามารถนับทุกพาร์ทิชันของnจากข้อสรุปเขต1 (สำหรับ[N] ) และf (n - เจเจ)สำหรับค่าที่ถูกต้องทั้งหมดของเจ

รหัสการดำเนินการตรงไปตรงมาของฟังก์ชั่นทางคณิตศาสตร์ฉ นอกจากนี้ก็จะทำให้kเริ่มต้น1เพื่อf(n)คำนวณค่าของf (n, 1)สำหรับการป้อนข้อมูลn

J , 37 35 ไบต์

0{]1&((#.]*>:@#.~/.~&.q:@#\%#),])1:

ลองออนไลน์!

คำอธิบาย

0{]1&((#.]*>:@#.~/.~&.q:@#\%#),])1:  Input: n
                                 1:  Constant 1
  ]                                  Get n
   1&(                          )    Repeat n times on x = [1]
                          \            For each prefix
                         #               Length
                      q:@                Prime factors
                 /.~&                    Group equal factors
              #.~                        Compute p+p^2+...+p^k for each group
           >:@                           Increment
                    &.q:                 Product
                           %           Divide
                            #          Length
         ]                             Get x
          *                            Times
   1   #.                              Sum
                              ,        Joim
                               ]       Get x
                                       Set this as next value of x
0{                                   Select value at index 0

JavaScript, 125 121 ไบต์

n=>(z=(a,b)=>[...Array(a)].map(b))(++n**n,(_,a)=>z[F=z(n,_=>a%(a/=n,n)|0).sort().join`+`]=b+=eval(F)==n-1&!z[F],b=0)|b||1

ลองออนไลน์!

คำเตือน: ความซับซ้อนของเวลาและพื้นที่เป็นสิ่งที่อธิบาย ทำงานช้ามากสำหรับคนจำนวนมาก

Python 2 , 89 ไบต์

-9 ไบต์โดย Mr.Xcoder -1 ไบต์โดย notjagan

lambda n:len(p(n))
p=lambda n,I=1:{(n,)}|{y+(x,)for x in range(I,n/2+1)for y in p(n-x,x)}

ลองออนไลน์!

เยลลี่ 13 ไบต์

JÆsæ.:L;
1Ç¡Ḣ

ลองออนไลน์!

ใช้เวลา 5 วินาทีเพื่อแก้ปัญหา n = 1,000 ใน TIO

Java 8 (229 ไบต์)

import java.util.function.*;class A{static int j=0;static BiConsumer<Integer,Integer>f=(n,m)->{if(n==0)j++;else for(int i=Math.min(m,n);i>=1;i--)A.f.accept(n-i,i);};static Function<Integer,Integer>g=n->{f.accept(n,n);return j;};}

Ungolfed:

import java.util.function.*;

class A {
    static int j = 0;
    static BiConsumer<Integer, Integer> f = (n, m) -> {
        if (n == 0)
            j++;
        else
            for (int i = Math.min(m, n); i >= 1; i--)
                A.f.accept(n - i, i);
    };
    static Function<Integer, Integer> g = n -> {
        f.accept(n, n);
        return j;
    };
}

เยลลี่ 3 ไบต์

Œṗอะตอมเมื่อเร็ว ๆ นี้ได้รับการเพิ่มและมันหมายความว่า "พาร์ทิชันจำนวนเต็ม"

ŒṗL

ลองออนไลน์!

ŒṗL - โปรแกรมเต็มรูปแบบ

Œṗ - พาร์ทิชันที่มีจำนวนเต็ม
  L - ความยาว
      - ผลผลิตโดยปริยาย

Pyt , 2 ไบต์

←ᵱ

คำอธิบาย:

←          Get input
 ᵱ         Number of partitions

JavaScript ES7, 69 ไบต์

n=>(f=(i,s)=>i?[for(c of Array(1+n))f(i-1,s,s-=i)]:c+=!s)(n,n,c=0)&&c

JavaScript ES6, 71 ไบต์

n=>(f=(i,s)=>i?[...Array(1+n)].map(_=>f(i-1,s,s-=i)):c+=!s)(n,n,c=0)&&c

ความซับซ้อนของเวลา O (n ^ n) ดังนั้นควรระมัดระวัง (ความล่าช้าที่ชัดเจนปรากฏบนคอมพิวเตอร์ของฉันF(6))