ধনাত্মক পূর্ণসংখ্যার কঠোর পার্টিশন


14

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]

এটি , তাই বাইটগুলির মধ্যে সংক্ষিপ্ততম সমাধানটি জিতে।

উত্তর:


4

গণিত, 11 বাইট

PartitionsQ

পরীক্ষা ক্ষেত্রে

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

3

পাইথ, 7 বাইট

l{I#./Q

এটি অনলাইনে চেষ্টা করুন। পরীক্ষা স্যুট.

  • ইনপুট নিন (Q )।
  • এর পার্টিশনগুলি সন্ধান করুন (./ ) সন্ধান করুন।
  • এটি পরিবর্তন করুন () পরিবর্তন না করে ( #) এ ফিল্টার করুন ( ){I ) পার্টিশন । এটি সদৃশগুলি সহ পার্টিশনগুলি সরিয়ে দেয়।
  • ফলাফলের দৈর্ঘ্য ( l) নির্ধারণ করুন।

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


উজ্জ্বল! আমি আমার নিজের উত্তরটিতে subsequences(+ import) এর জন্য প্রতিস্থাপনের সন্ধান করছিলাম, তবে এতদিন সফল হইনি।
নিমি

2

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নিজেকে বিয়োগ করতে পারেন । (এছাড়াও এটি যেহেতু পুনরাবৃত্তিযোগ্য তাই আমার খেয়াল রাখতে হবে যে আমার সমস্ত ভেরিয়েবলগুলি স্থানীয়)


2

পাইথন, 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আর্গুমেন্ট হিসাবে কল করুন ... এবং মহাবিশ্বের শেষের জন্য অপেক্ষা করুন।


এটি তৈরি করুন n>0, আপনি একটি বাইট সংরক্ষণ করুন এবং দ্রুত যান (আমি বিশ্বাস করি আপনি নেতিবাচক সংখ্যায়
পুনরাবৃত্তি করছেন

এছাড়াও, এই ধরণের গতিবেগ
স্মরণে রাখুন

আপনি যদি নিজের বিবৃতিটি এতে পরিবর্তন করতে পারেন তবে:return sum(...)if n else 1
andlrc

@ আরন্দোমরা অবশ্যই, অবশ্যই ...
বব

1

পাইথন 2, 49 বাইট

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

প্রত্যেক সম্ভাব্য summand এ পুনরাবৃত্তির শাখা kথেকে 1থেকে nসিদ্ধান্ত নিতে তা অন্তর্ভুক্ত করা উচিত। প্রতিটি অন্তর্ভুক্ত যোগফলকে পছন্দসই যোগফল থেকে বিয়োগ করা হয় n, এবং শেষে, যদি n=0অবশিষ্ট থাকে, তবে সেই পথটি গণনা করা হয়।


1

হাস্কেল, 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)


n%k|q<-k-1=n%q+(n-k)%qলাইন 3 এর বাইট বন্ধ করে দেয়
Izaak ওয়েইস

0

জুলিয়া, 53 বাইট

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

এটি একটি বেনামে ফাংশন যা কোনও পূর্ণসংখ্যা গ্রহণ করে এবং পূর্ণসংখ্যা ফেরত দেয়। এটি কল করতে, এটি একটি ভেরিয়েবলের জন্য বরাদ্দ করুন।

আমরা ব্যবহার পূর্ণসংখ্যা পার্টিশন পেতে partitions, filterশুধুমাত্র স্বতন্ত্র summands যাদের, এর collectএকটি অ্যারের মধ্যে, এবং শেষ সূচক (অর্থাত দৈর্ঘ্য) ব্যবহার করে এটি endof


0

হাস্কেল, 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]

এটি একটি সাধারণ উদ্দীপনা পদ্ধতির approach এর সমস্ত অনুচ্ছেদের যোগফলগুলি পরীক্ষা করে দেখুন 1..x। এই জন্য কাজ করে x == 0, খুব, কারণ সব subsequences [1..0]হয় [[]]এবং এর সমষ্টি []হল 0


0

05 এ বি 1 ই , 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

0

05 এ বি 1 ই , 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
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.