एक सकारात्मक पूर्णांक के सख्त विभाजन

Question

OEIS A000009 पूर्णांकों के सख्त विभाजन की संख्या की गणना करता है । एक nonnegative पूर्णांक का एक सख्त विभाजनn सकारात्मक पूर्णांकों का एक सेट है (इसलिए कोई पुनरावृत्ति की अनुमति नहीं है, और उस राशि के लिए आदेश कोई फर्क नहीं पड़ता) n।

उदाहरण के लिए, 5 तीन सख्त विभाजन है: 5, 4,1, और 3,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

चुनौती

एक nonnegative पूर्णांक n<1000 को देखते हुए , इसके पास सख्त विभाजन की संख्या को आउटपुट करता है।

परीक्षण के मामलों:

0 -> 1

42 -> 1426

यहाँ OEIS से 0 से 55 तक के सख्त विभाजन संख्याओं की सूची दी गई है:

[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]

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा समाधान जीतता है।

Answer 1

गणितज्ञ, 11 बाइट्स

PartitionsQ

---

परीक्षण का मामला

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

Answer 2

अजगर, 7 बाइट्स

l{I#./Q

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

• इनपुट ( Q) लें ।
• इसके विभाजन खोजें ( ./)।
• इसे फ़िल्टर करें ( #) uniquify पर ( {) नहीं बदल रहा है ( I) पार्टीशन। यह डुप्लिकेट के साथ विभाजन को हटाता है।
• परिणाम की लंबाई ( l) ज्ञात कीजिए ।

Answer 3

हास्केल, 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राशि के साथ ऐसी सूचियों के अनुरूप विभाजन n। ऐसे तत्वों को एक सूची समझ से गिना जाता है, जो इससे छोटा है length.filter।

Comments

प्रतिभाशाली! मैं अपने जवाब में खुद के लिए subsequences(+ import) प्रतिस्थापन की तलाश में था , लेकिन अब तक सफल नहीं हुआ।

— nimi

Answer 4

ईएस 6, 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खुद को घटा सकते हैं । (चूंकि यह पुनरावर्ती है इसलिए मुझे ध्यान रखना होगा कि मेरे सभी चर स्थानीय हैं।)

Answer 5

पायथन, 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को तर्क के रूप में पास करें ... और ब्रह्मांड के अंत की प्रतीक्षा करें।

Comments

इसे बनाओ n>0, आप एक बाइट को बचाते हैं और तेजी से

— आगे बढ़ते हैं

इसके अलावा, यह गति के इस प्रकार Memoizing

— st0le

कठबोली यदि आप अपने बयान को बदल सकते हैं:return sum(...)if n else 1

— andlrc

@randomra of, बेशक ...

— Bob

Answer 6

पायथन 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तय करने के लिए कि क्या यह शामिल किया जाना चाहिए। प्रत्येक शामिल सारांश को वांछित राशि से घटाया जाता है n, और अंत में, यदि n=0रहता है, तो वह पथ गिना जाता है।

Answer 7

हास्केल, 43 बाइट्स

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

बाइनरी फ़ंक्शन अधिकतम भाग के साथ भागों में n%kसख्त विभाजन की संख्या की गणना करता है , इसलिए वांछित फ़ंक्शन है । प्रत्येक मूल्य को शामिल किया जा सकता है, जो घटता है , या बाहर रखा गया है, और जिस तरह से नया अधिकतम एक कम है, पुनरावृत्ति दे रहा है ।nkf n=n%nknkkn%k=n%(k-1)+(n-k)%(k-1)

Comments

n%k|q<-k-1=n%q+(n-k)%qबाइट्स ऑफ लाइन 3.

— Izaak Weiss

Answer 8

जूलिया, 53 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

हम पूर्णांक विभाजन का उपयोग करते हैं partitions, filterकेवल उन लोगों के लिए जो अलग-अलग सारांशों के साथ collectएक सरणी में हैं, और अंतिम सूचकांक (लंबाई) का उपयोग कर पाते हैं endof।

Answer 9

हास्केल, 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]।

यह एक सरल जानवर-बल दृष्टिकोण है। के सभी बाद के योगों की जाँच करें 1..x। यह भी काम करता x == 0है, क्योंकि सभी के बाद के [1..0]हैं [[]]और का योग []है 0।

Answer 10

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

Answer 11

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