OEIS A000009นับจำนวนพาร์ติชันที่เข้มงวดของจำนวนเต็ม พาร์ทิชันที่เข้มงวดของติดลบnเป็นชุดของจำนวนเต็มบวก (จึงไม่มีการทำซ้ำที่ได้รับอนุญาตและการสั่งซื้อไม่ได้เรื่อง) nรวมว่า

ยกตัวอย่างเช่น 5 มีสามพาร์ทิชันที่เข้มงวด: 5, และ4,13,2

10 มีสิบพาร์ติชัน:

10
9,1
8,2
7,3
6,4
7,2,1
6,3,1
5,4,1
5,3,2
4,3,2,1

ท้าทาย

รับจำนวนเต็มไม่ใช่ลบn<1,000 ส่งออกจำนวนพาร์ทิชันที่เข้มงวดมันมี

กรณีทดสอบ:

0 -> 1

42 -> 1426

นี่คือรายการของหมายเลขพาร์ติชันเข้มงวดจาก 0 ถึง 55 จาก OEIS:

[1,1,1,2,2,3,4,5,6,8,10,12,15,18,22,27,32,38,46,54,64,76,89,104,122,142,165,192,222,256,296,340,390,448,512,585,668,760,864,982,1113,1260,1426,1610,1816,2048,2304,2590,2910,3264,3658,4097,4582,5120,5718,6378]

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

Mathematica ขนาด 11 ไบต์

PartitionsQ

กรณีทดสอบ

PartitionsQ@Range[10]
(* {1,1,2,2,3,4,5,6,8,10} *)

Pyth, 7 ไบต์

l{I#./Q

ลองออนไลน์ ชุดทดสอบ

• รับอินพุต ( Q)
• ค้นหาพาร์ติชัน ( ./)
• กรอง ( #) บน uniquify ( {) ไม่เปลี่ยน ( I) พาร์ติชัน สิ่งนี้จะลบพาร์ติชันที่มีรายการซ้ำ
• ค้นหาความยาวของผลลัพธ์ ( l)

Haskell, 39 ไบต์

f n=sum[1|x<-mapM(:[0])[1..n],sum x==n]

ฟังก์ชั่น(:[0])แปลงตัวเลขในรายการk [k,0]ดังนั้น,

mapM(:[0])[1..n]

คำนวณผลิตภัณฑ์คาร์ทีเซียน[1,0],[2,0],...,[n,0]ซึ่งให้ชุดย่อยทั้งหมดที่[1..n]มีสถานะเป็น 0 สำหรับองค์ประกอบที่ละเว้น พาร์ทิชันที่เข้มงวดของตรงกับรายการดังกล่าวมีผลรวมn องค์ประกอบดังกล่าวจะนับความเข้าใจรายการซึ่งจะสั้นกว่าnlength.filter

ES6, 64 ไบต์

f=(n,k=0)=>[...Array(n)].reduce((t,_,i)=>n-i>i&i>k?t+f(n-i,i):t,1)

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

Python ขนาด 68 ไบต์

p=lambda n,d=0:sum(p(n-k,n-2*k+1)for k in range(1,n-d+1))if n else 1

เพียงแค่เรียกใช้ฟังก์ชันที่ไม่ระบุตัวตนผ่านจำนวนเต็มไม่ใช่ค่าลบnเป็นอาร์กิวเมนต์ ... และรอจุดสิ้นสุดของจักรวาล

Python 2, 49 ไบต์

f=lambda n,k=1:n/k and f(n-k,k+1)+f(n,k+1)or n==0

สาขาการสอบถามซ้ำในทุก ๆ การสรุปที่มีศักยภาพkจาก1ถึงnเพื่อตัดสินใจว่าควรรวมไว้หรือไม่ แต่ละ Summand ที่รวมจะถูกลบออกจากผลรวมที่ต้องการnและในตอนท้ายถ้าn=0ยังเหลืออยู่เส้นทางนั้นจะถูกนับ

Haskell, 43 ไบต์

0%0=1
_%0=0
n%k=n%(k-1)+(n-k)%(k-1)
f n=n%n

ฟังก์ชั่นไบนารีn%kนับจำนวนของพาร์ทิชันที่เข้มงวดของnเป็นส่วนที่มีส่วนร่วมสูงสุดเพื่อให้ฟังก์ชั่นที่ต้องการคือk f n=n%nแต่ละค่าkสามารถรวมซึ่งลดลงnจากkหรือได้รับการยกเว้นและวิธีการอย่างใดอย่างหนึ่งสูงสุดใหม่เป็นหนึ่งในที่ต่ำกว่าให้เรียกซ้ำkn%k=n%(k-1)+(n-k)%(k-1)

จูเลีย 53 ไบต์

n->endof(collect(filter(p->p==∪(p),partitions(n))))

นี่เป็นฟังก์ชั่นนิรนามที่รับจำนวนเต็มและคืนค่าจำนวนเต็ม หากต้องการเรียกใช้กำหนดค่าให้กับตัวแปร

เราได้รับพาร์ทิชันจำนวนเต็มโดยใช้partitions, filterการเฉพาะผู้ที่มี summands ที่แตกต่างกันcollectเป็นอาร์เรย์และหาดัชนีที่ผ่านมา (เช่นความยาว) endofโดยใช้

Haskell, 58 ไบต์

import Data.List
h x=sum[1|i<-subsequences[1..x],sum i==x]

ตัวอย่างการใช้งาน: map h [0..10] ->[1,1,1,2,2,3,4,5,6,8,10] ->

มันเป็นวิธีการที่ดุร้ายอย่างง่าย ตรวจสอบผลรวมของ subsequences 1..xทั้งหมดของ งานนี้สำหรับx == 0เกินไปเพราะ subsequences ทั้งหมดของ[1..0]มี[[]]และผลรวมของการมี[]0

05AB1E , 8 ไบต์

ÅœʒDÙQ}g

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

Ŝ          # Get all integer partitions of the (implicit) input
            #  i.e. 5 → [[1,1,1,1,1],[1,1,1,2],[1,1,3],[1,2,2],[1,4],[2,3],[5]]
  ʒ   }     # Filter by:
   D        #  Duplicate the current partition
    Ù       #  Uniquify (removing any duplicated values from) this copied partition
            #   i.e. [1,1,1,1,1] → [1]
            #   i.e. [1,4] → [1,4]
     Q      #  Check if it's still the same
            #   i.e. [1,1,1,1,1] and [1] → 0 (falsey)
            #   i.e. [1,4] and [1,4] → 1 (truthy)
       g    # Then take the length of the filtered list (and implicitly output it)
            #  i.e. [[1,4],[2,5],[5]] → 3

05AB1E , 5 ไบต์

LæOQO

ลองออนไลน์!

หมายเหตุ: นี่ช้ามากและจะหมดเวลาสำหรับอินพุตที่มากกว่าประมาณ 20

คำอธิบาย:

L         # range 1..input
 æ        # list of subsets
  O       # sum each subset
   Q      # equal? (1 for each sum that equals the input, 0 otherwise)
    O     # sum the booleans