23

চ্যালেঞ্জটি হ'ল প্রদত্ত ধনাত্মক পূর্ণসংখ্যার সমস্ত আদেশযুক্ত পার্টিশন (রচনা (সংমিশ্রণ)) তালিকাভুক্ত করা n। এই থেকে সংখ্যার তালিকা আছে 1করতে nযার সমষ্টি n। উদাহরণস্বরূপ, প্রদত্ত ইনপুট n = 4, ফলাফলটি হওয়া উচিত:

4
1, 3
3, 1
2, 2
2, 1, 1
1, 2, 1
1, 1, 2
1, 1, 1, 1

ফলাফল যে কোনও ক্রমে হতে পারে তবে প্রতিটি অর্ডার করা পার্টিশন একবারে অবশ্যই থাকতে হবে। এই উপায়ে যে n = 4, [1, 1, 2], [1, 2, 1]এবং [2, 1, 1]সব ফলাফলের এর অংশ হতে হবে।

এখানে আমার নিজস্ব জাভাস্ক্রিপ্ট কোড যা এটি অর্জন করে:

function range(n) {
    for (var range = [], i = 0; i < n; range.push(++i));
    return range;
}

function composition(n) {
    return n < 1 ? [[]] : range(n).map(function(i) {
        return composition(n - i).map(function(j) {
            return [i].concat(j);
        });
    }).reduce(function(a, b) {
        return a.concat(b);
    });
}

গল্ফড, ইএস 6 ( ~~169~~ ~~167~~ ~~119~~ ~~109~~ ~~105~~ 89 85 বাইট ):

n=>n?[].concat(...[...Array(n)].map((x,i)=>i+1).map(b=>m(n-b).map(a=>[b,...a]))):[[]]

— driima
সূত্র

3

সাইটে স্বাগতম! আপনাকে একটি বিজয়ী মানদণ্ড নির্দিষ্ট করতে হবে। কোড-গল্ফ হতে পারে? এছাড়াও, এটি কি সেই নির্দিষ্ট ক্রমে থাকতে হবে? যদি তা হয় তবে অর্ডারকে কীভাবে সাধারণভাবে সংজ্ঞায়িত করা হয়? আমি মনে করি অভিধানের ক্রমটি আরও অর্থবহ হবে; বা আরও ভাল, কোন আদেশ অনুমতি দিন। আপনি এখানে পোস্ট করার আগে ভবিষ্যতের চ্যালেঞ্জগুলির জন্য স্যান্ডবক্সটি ব্যবহার করতে চাইতে পারেন

— লুইস মেন্ডো

3

@ ফ্যাটালাইজ করুন এখানে [2 1 1] আলাদা নয়, [1 2 1] এর চেয়ে আলাদা। আমি সন্দেহ করি যে পদ্ধতিগুলি উল্লেখযোগ্যভাবে আলাদা হতে পারে

— লুইস মেন্ডো

3

যারা ডুপ হিসাবে বন্ধ হয়ে গেছে তাদের কাছে: আপনি কি মন্তব্যগুলিতে নির্দেশিত পার্থক্যটি প্রাসঙ্গিক না তা নিশ্চিত? আমি পুনরায় খুলতে ভোট দিচ্ছি না, কারণ আমি মনে করি

— লুইস মেন্ডো

3

আমি এখনও কোনও উত্তর গ্রহণ না করার পরামর্শ দিই (যদিও আপনি যে কোনও সময় এটি পরিবর্তন করতে পারেন) কারণ প্রথম পৃষ্ঠায় প্রশ্নটি গৃহীত হয়েছে দেখে লোকেরা ভাবতে পারে যে এটি শেষ হয়ে গেছে এবং অংশ নেবে না।

— xnor

5

এই আদেশযুক্ত পার্টিশনের জন্য সাধারণ শব্দটি হল " রচনাগুলি "।

— গ্রেগ মার্টিন

7

পাইথ, 7 6 বাইট

7 বাইট সমাধান:

পাইথের একটি পূর্ণসংখ্যা পার্টিশন অন্তর্নির্মিত রয়েছে ./, সুতরাং 7 বাইটের মধ্যে 5 টি অর্ডারিং পাচ্ছে।

{s.pM./

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

     ./  Integer partition (sorted by default)
  .pM    get all the orderings of each of the partitions as a nested list of lists of orderings
 s       Flatten by one layer
{        Remove duplicates

6 বাইট সমাধান:

আপনার যদি একটি তালিকা থাকে তবে ./অর্ডারগুলি দিয়ে গণনা করবেন; যে সমস্ত অবশিষ্ট রয়েছে তা আবার তালিকার সংখ্যা তৈরি করা।

lMM./m

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

     m  Get lists by gathering a list of [0, 1,...input] (I could use U as well)

   ./   Partition with orderings
 MM     Map an operation across each of the orderings lists of elements
l       where that operation is the length of the sublists

— স্টিভেন এইচ।
সূত্র

অ্যামেজিং। আমি এ পর্যন্ত দেখা সবচেয়ে ছোট এটি!

— ড্রিমা

11

হাস্কেল, 37 বাইট

f 0=[[]]
f n=[a:x|a<-[1..n],x<-f$n-a]

xnor দুটি বাইট সংরক্ষণ করেছে।

— লিন
সূত্র

1

দেখে মনে হচ্ছে আরও সোজা আরও f n=[a:x|a<-[1..n],x<-f$n-a]খাটো।

— xnor

আপনার শূন্য চেকের দরকার নেই ( given positive integer n ... numbers from 1 to n)

— nyro_0

2

f 0=[[]]শুধু চেয়ে খাটো বেস কেস হতে হবে f 1=[[1]]:)

— লিন

@xyLe_ এটি একটি পুনরাবৃত্ত বেস বেস ব্যবহার করা হয়।

— xnor

আহ নিশ্চিত, আপনি ঠিক বলেছেন, আমার খারাপ

— nyro_0

10

পাইথন, 56 বাইট

f=lambda n:[x+[n-i]for i in range(n)for x in f(i)]or[[]]

Recursive সমাধান: এর আদেশ পার্টিশন nকিছু ছোট একটি পার্টিশন হয় iসঙ্গে 0<=i<n, বাকি দ্বারা অনুসরণ n-iশেষ উপাদান হিসাবে। একটি বেস কেসের ক্ষেত্রে n=0কেবল খালি পার্টিশন থাকে।

— xnor
সূত্র

সহজ, ছোট এবং এখনও আশ্চর্যজনকভাবে পাঠযোগ্য। পাইথন সম্পর্কে আমি এটাই পছন্দ করি।

— ড্রিমা

10

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

f=lambda n,s='1,':1/n*[eval(s)]or f(n-1,'1+'+s)+f(n-1,'1,'+s)

এটি সবচেয়ে সংক্ষিপ্ত নয়, তবে পদ্ধতিটি আমি খুব পছন্দ করি কারণ এটি এত অদ্ভুত।

পুনরাবৃত্তভাবে 2**(n-1)স্ট্রিংগুলি তৈরি করে এবং মূল্যায়ন করে

1+1+1+1,
1,1+1+1,
1+1,1+1,
1,1,1+1,
1+1+1,1,
1,1+1,1,
1+1,1,1,
1,1,1,1,

জন্য n=4। এই স্ট্রিংগুলি সমস্ত পার্টিশনের প্রতিনিধিত্বকারী টিপলগুলিতে মূল্যায়ন করে। যে কোনও দুটি 1 এর মধ্যে হয় হয় a +, সেগুলিকে একক সংখ্যায় যোগ করা, বা একটি ,, বিভাজন সংলগ্ন অংশে।

— xnor
সূত্র

আমি করতে পারি সেরা নন-রিকারসিভ সংস্করণটি ছিলimport re lambda n:map(lambda n:map(len,re.finall('10*',bin(n))),range(1<<n-1,1<<n))

— নীল

1

কোড সহ একটি ব্যাখ্যা সত্যই এটি সুন্দর করে তুলবে।

— noman pouigt

8

জাভাস্ক্রিপ্ট (ফায়ারফক্স 30-57), 63 বাইট

f=n=>n?[for(i of Array(n).keys())for(a of f(i))[n-i,...a]]:[[]]

— নিল
সূত্র

12

ফায়ারফক্স 30+ ইন্টারনেটের আরও পরিপক্ক ব্যবহারকারীদের জন্য একটি বিশেষ ব্রাউজারের মতো শোনাচ্ছে।

— মার্টিন ইন্ডার

সম্ভবত এটির চেয়ে ছোট হয় না ...

— ETH প্রোডাকশনগুলি

অন্য ব্রাউজারগুলিতে কোনওভাবেই জাভাস্ক্রিপ্টের জন্য এটি রহস্যজনক করা যায়?

— ড্রিমা

@Eternity আমি করতে পারেন বন্দর @ xnor এর আপনার জন্য অন্যান্য উত্তর: f=n=>n<2?[[1]]:f(n-1).map(([n,...a])=>r.push([1+n,...a],[1,n,...a]),r=[])&&r।

— নিল

6

গণিত, 40 বাইট

Join@@Permutations/@IntegerPartitions@#&

ইন্টিজার পার্টিশনের জন্য গাণিতিকের অন্তর্নির্মিত সমস্ত অর্ডার করা পার্টিশন দেয় না , সুতরাং আমাদের তাদের প্রতিটি সম্ভাব্য ক্রম তৈরি করতে হবে এবং তারপরে ফলাফলটি সমতল করতে হবে।

— মার্টিন ইন্ডার
সূত্র

6

সিজেম , 17 14 বাইট

ri"X)"m*{~]p}/

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

আমি জানি আমি বলেছিলাম যে কার্টেসিয়ান পণ্যটি ব্যবহার করা আরও দীর্ঘ, তবে আমি এটিকে আরও দক্ষতার সাথে ব্যবহার করার উপায় খুঁজে পেয়েছি। আমি মনে করি যে উভয় পন্থা তাদের নিজস্ব আকর্ষণীয়, তাই আমি তাদের পৃথক পোস্টে রাখছি।

এটি এখনও এই ধারণার ভিত্তিতে রয়েছে যে, আমরা বর্তমান পার্টিশনে nএকটি সংযোজন 1বা বর্তমান পার্টিশনের শেষ উপাদানটিকে বাড়ানোর মধ্যে সময় বেছে নিতে পারি । এই সমাধানে, আমরা 2 ^{এন -1} বিভিন্ন প্রোগ্রাম তৈরি করে যা এটি বিভিন্ন পছন্দগুলির সাথে সামঞ্জস্য করে do

ri      e# Read input and convert to integer N.
        e# Decrement.
"X)"m*  e# Get all strings of length N which consist of 'X' and ')'. If
        e# we treat these strings as CJam code then 'X' pushes a 1 and ')'
        e# increments the top of the stack.
        e# Note that some of these strings will begin with an increment that
        e# doesn't have anything on the stack to work with. This will result in
        e# an error and terminate the program. Luckily, the programs are ordered
        e# such that all programs starting with 'X' are first in the list, so
        e# we get to print all the 2^(N-1) permutations before erroring out.
{       e# For each of these programs (well for the first half of them)...
  ~     e#   Evaluate the string as CJam code. This leaves the partition as
        e#   individual integers on the stack.
  ]p    e#   Wrap the stack in a list and pretty-print it.
}/

— মার্টিন ইন্ডার
সূত্র

আমি এই দিকে তাকিয়ে চিন্তা " যে হতে পারে না যখন এটি প্রথম স্ট্রিং যা দিয়ে শুরু হয় মূল্যায়ণ ঠিক আছে, এটি একটি ত্রুটির দিতে হবে) "। তাই আমি যুক্ত edএবং পরীক্ষিত। ত্রুটির সৃজনশীল অপব্যবহারের জন্য +1।

— পিটার টেলর

6

জেলি , 7 6 বাইট

-1 বাইট @ ডেনিসকে ধন্যবাদ ( ḅ1প্রত্যেকের জন্য প্রত্যেকের জন্য যোগফলের তুলনায় অ্যানারি থেকে রূপান্তর করুন S€€)

1ẋŒṖḅ1

TryItOnline

কিভাবে?

1ẋŒṖḅ1 - Main link: n          e.g. 4
1ẋ     - repeat 1 n times          [1,1,1,1]
  ŒṖ   - partitions of a list     [[[1],[1],[1],[1]], [[1],[1],[1,1]], [[1],[1,1],[1]],
                                   [[1],[1,1,1]],     [[1,1],[1],[1]], [[1,1],[1,1]],
                                   [[1,1,1],[1]],     [[1,1,1,1]]]
    ḅ1 - from base 1 (vectorises)  [[1,1,1,1],        [1,1,2],         [1,2,1],
                                   [1,3],             [2,1,1],         [2,2],
                                   [3,1],             [4]]

— জোনাথন অ্যালান
সূত্র

5

খাঁটি বাশ, 51

এটি পছন্দসই ফলাফল অর্জন করতে একাধিক স্তরের ব্যাশ বিস্তৃতি ব্যবহার করে @ xnor এর উজ্জ্বল উত্তরের একটি বন্দর :

a=$[10**($1-1)]
eval echo \$[${a//0/{+,']\ $[}1'}],

Ideone।

প্রথম লাইন কেবল একটি গাণিতিক সম্প্রসারণ একটি পরিবর্তনশীল তৈরি করা $aধারণকারী 1দ্বারা অনুসরণ n-1শূন্য।
প্রথম সম্প্রসারণ ${a//0/{+,']\ $[}1'}প্রতিটি প্রতিস্থাপন 0মধ্যে $aস্ট্রিং এর কপি {+,']\ $[}1'। এইভাবে এন = 4 আমরা স্ট্রিং পেতে1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1'
এই পূর্বে সমাধান সাথে আছেন $[এবং অ্যাপলিকেশনগুলি US English ব্যবহার সঙ্গে ],দিতে$[1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1]
এটি একটি বন্ধনী সম্প্রসারণ যা প্রসারিত হয় $[1+1+1+1], $[1+1+1] 1, $[1+1] $[1+1], $[1+1] 1 1,...
প্রয়োজনীয় ফলাফল দেওয়ার জন্য এটি শেষ পর্যন্ত গাণিতিকভাবে প্রসারিত।

উদ্ধৃতিগুলির যত্ন সহকারে ব্যবহার, ব্যাকস্ল্যাশ পলায়ন এবং evalএটি সঠিক ক্রমে প্রসার ঘটে তা নিশ্চিত করে।

— ডিজিটাল ট্রমা
সূত্র

4

রুবি, 61 বাইট

f=->n{n<1?[[]]:(1..n).map{|i|f[n-i].map{|x|x<<i}}.flatten(1)}

ungolfed

f=->n{
  n < 1 ?
    [[]]
  :
    (1..n).map { |i|
      f[n-i].map { |x|
        x << i
      }
    }.flatten(1)
}

ব্যবহার

p f[4]
# => [[1, 1, 1, 1], [1, 1, 2], [1, 2, 1], [1, 3], [2, 1, 1], [2, 2], [3, 1], [4]]

— cia_rana
সূত্র

2

ফোন করেই বলা যায়! আপনি কি রুবির সাথে পরিচিত নন এমন লোকদের (আমার মতো) জন্য কিছুটা ব্যাখ্যা যোগ করতে পারেন?

— অ্যাডমবর্কবার্ক

x<<iতুলনায় খাটো [i]+x।

— এম-ক্রিজান

@ টিমমিডি আমি একটি অবারিত কোড এবং ব্যবহার যুক্ত করেছি।

— cia_rana

@ এম-ক্রজ্জন আপনার পরামর্শের জন্য ধন্যবাদ! আমি এটি সম্পাদনা করেছি।

— cia_rana

কোন কারণ .flatten(1)নেই .flatten 1?

— সাইয়েস

3

ব্র্যাচল্যাগ , 20 বাইট

~lL#++?,L:=f:{:0x}ad

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

এটি এমন একটি পরিস্থিতি যেখানে আপনি ভাবেন যে ঘোষিত ভাষাগুলি ভাল করবে, তবে অতিরিক্ত +চাপের কারণে এবং সংকটকে যথাযথভাবে প্রচার করে এমন একটি সংক্ষিপ্ত শিকারী লিখতে অসুবিধাজনক কারণে, তারা তা করে না।

~lL                     L is a list of length Input
  L#+                   L is a list of non-negative integers
  L  +?,                The sum of the elements of L results in the Input
        L:=f            Find all values for the elements of L which satisfy those constraints
            :{:0x}a     Remove all 0s from each sublist of the result of Findall
                   d    Remove all duplicate sublists

— Fatalize
সূত্র

আমি মনে করি এটা আরো দ্রুত আপনি ফোকাস অনেক বংশ বিস্তার হবে ইতিবাচক পূর্ণসংখ্যার, এবং দৈর্ঘ্য দিন Lহতে মধ্যে 1 এবং ইনপুট।

— মাদুর

@ ম্যাট এটি আমি প্রথম যা করেছি তা কিন্তু এটি আরও দীর্ঘ । যেহেতু +এছাড়াও একটি একক পূর্ণসংখ্যার উপর কাজ করে, তাই আমাকে .তালিকা তৈরি করতে বাধ্য করা প্রয়োজন ##, এবং যেহেতু +তালিকাগুলির তালিকায়ও কাজ করে, তাই আমাকে আরোপ করা দরকার যেগুলির উপাদানগুলি .ইন্টিজারগুলির সাথে হয় :#$a।

— শে

সুতরাং মূল সমস্যাটি হ'ল ডেটা স্ট্রাকচারের ডিফল্টরতা: যখন কোনও ভেরিয়েবল ভেক্টরাইজ করা অপারেশনের আর্গুমেন্ট হিসাবে উপস্থিত হয়, আপনি ভেরিয়েবলটি একটি একক পূর্ণসংখ্যা বা একটি (সম্ভবত নেস্টেড) তালিকার জন্য দাঁড়িয়েছেন কিনা তা বলতে পারবেন না। এটি একটি শক্ত সমস্যা, এবং এটির সমাধানের জন্য আপনার মূল সংস্করণ থেকে শুরু করে উপযুক্ত ভাষা কাঠামোগুলি অনুসন্ধান করা যেতে পারে যা এটি সহজ করতে পারে an যে কোনও ক্ষেত্রে দুর্দান্ত কাজ!

— মাদুর

3

সিজেম , 19 বাইট

Lari{_1af.+1@f+|}*p

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

পূর্ণসংখ্যা পার্টিশনের জন্য সিজেএম-তে অন্তর্নির্মিত একটি দরকারী সংযুক্তি নেই। সুতরাং আমরা এটি ম্যানুয়ালি করব। সব জন্য আদেশ একটি পূর্ণসংখ্যা এর পার্টিশন n, আমরা একটি তালিকা তাকান পারেন nবেশী এবং বিভাজক সন্নিবেশ করতে সম্ভাব্য সব উপায় বিবেচনা করুন। তারপরে আমরা 1প্রতিটি বিভাগে গুলি যোগ করব । উদাহরণস্বরূপ n = 3:

1 1 1 => 3
1 1|1 => 2|1
1|1 1 => 1|2
1|1|1 => 1|1|1

আমি এই সমস্ত বিভাজক তৈরি করতে কার্টেসিয়ান পণ্য ব্যবহার করার চেষ্টা করেছি, তবে এটি 21 বাইটে শেষ হয়েছিল। পরিবর্তে আমি পাওয়ার সেট তৈরি করার জন্য এই পুরানো কৌশলটিতে ফিরে গিয়েছিলাম (এটি ডেনিসের পুরানো উত্তরের উপর ভিত্তি করে তবে এখনই এটি খুঁজে পাচ্ছি না)। ধারণাটি হ'ল: সমস্ত পার্টিশন তৈরি করতে আমরা খালি তালিকা থেকে শুরু করতে পারি। তারপরে nবার আমরা বাইনারি সিদ্ধান্ত নিতে পারি: হয় আমরা একটি সংযোজন করি 1(উপরের উদাহরণে একটি বিভাজকের সাথে মিলে যায়) অথবা আমরা তালিকার শেষের মানটি বৃদ্ধি করি (বিভাজক না হওয়ার সাথে মিল রেখে)। সমস্ত পার্টিশন জেনারেট করার জন্য, আমরা প্রতিটি পদক্ষেপে উভয়ই ক্রিয়া সম্পাদন করি এবং পরবর্তী পদক্ষেপের জন্য সমস্ত সম্ভাব্য আউটপুট রাখি। দেখা যাচ্ছে যে সিজেমে প্রথম উপাদানটির প্রেন্ডিং এবং ইনক্রিমেন্টিং খাটো হয় তবে নীতিটি একই থাকে:

La       e# Push [[]] onto the stack. The outer list will be the list of
         e# all possible partitions at the current iteration, and we initialise
         e# it to one empty partition (basically all partitions of 0).
ri       e# Read input and convert to integer N.
{        e# Repeat this N times...
  _      e#   Duplicate the list of partitions of i-1.
  1af.+  e#   Increment the first element in each of these. This is done
         e#   by performing a pairwise addition between the partition and [1].
         e#   There is the catch that in the first iteration this will turn
         e#   the empty array into [1], so it's equivalent to the next step.
  1@f+   e#   Pull up the other copy of the list of partitions of i-1 and
         e#   prepend a 1 to each of them.
  |      e#   Set union. This gets rid of the duplicate result from the first
         e#   iteration (in all other iterations this is equivalent to concatenating
         e#   the two lists).
         e#   Voilà, a list of all partitions of i.
}*
p        e# Pretty-print the result.

— মার্টিন ইন্ডার
সূত্র

3

টি-এসকিউএল, 203 বাইট

Golfed:

USE master
DECLARE @ INT=12

;WITH z as( SELECT top(@)cast(number+1as varchar(max))a FROM spt_values WHERE'P'=type),c as(SELECT a*1a,a b FROM z UNION ALL SELECT c.a+z.a,b+','+z.a FROM c,z WHERE c.a+z.a*1<=@)SELECT b FROM c WHERE a=@

Ungolfed:

USE master --needed to make sure it is executed from the correct database
DECLARE @ INT=12

;WITH z as
(
  SELECT top(@)cast(number+1as varchar(max))a
  FROM spt_values
  WHERE'P'=type
),c as
(
  SELECT a*1a,a b
  FROM z
  UNION ALL
  SELECT c.a+z.a,b+','+z.a
  FROM c,z
  WHERE c.a+z.a*1<=@
)
SELECT b 
FROM c
WHERE a=@

বেহালা

— t-clausen.dk
সূত্র

3

গণিত 10.0, 44 বাইট tes

পার্টিশন সম্পর্কিত বিল্টিন ব্যবহার না করে একটি প্রচেষ্টা An সাইজের কে- এর প্রতিটি অর্ডার করা পার্টিশন থেকে , কে + 1 এর দুটি উত্তরোত্তর পার্টিশন তৈরি করা হয়: একটি 1 প্রিপেন্ডিং দিয়ে এবং অন্যটি প্রথম মান বাড়িয়ে।

Nest[##&[{1,##},{#+1,##2}]&@@@#&,{{1}},#-1]&

একটি মজাদার, তবে দু: খজনকভাবে একই ধারণাটি বাস্তবায়নের আরও 2 টি দীর্ঘ উপায়:

#@{1}&/@Tuples[Prepend[1]@*MapAt[#+1&,1],#-1]&

— feersum
সূত্র

@ এলফাল্ফা না, ততটা সাহায্য করবে না কারণ আমাকে MapAtসূচকটি -১ এ পরিবর্তন করতে হবে ।

— feersum

3

05 এ বি 1 ই , 14 12 বাইট

আদনানকে ধন্যবাদ 2 বাইট সংরক্ষণ করা

>G¹LNãvyO¹Q—

ব্যাখ্যা

>G              # for N in range(1..input)
  ¹L            # range(1, input)
    Nã          # cartesian product with N (all combinations of length N)
      v         # for each resulting list
       yO¹Q—    # if it's sum equals the input print it

এটি অনলাইন চেষ্টা করুন!

সংশ্লিষ্ট সমাধানটি 2sable মধ্যে 2 বাইট সংক্ষিপ্ত ।

2sable , 10 বাইট

>GLNãvyOQ—

এটি অনলাইন চেষ্টা করুন!

— Emigna
সূত্র

আপনি এর —পরিবর্তে ব্যবহার করতে পারেন iy,:)।

— আদনান

@ আদনান: ধন্যবাদ! এক সম্পর্কে ভুলে গেছি।

— Emigna

3

হাস্কেল, 41 বাইট

f 1=[[1]]
f n=do a:b<-f$n-1;[1:a:b,a+1:b]

সংক্ষিপ্ততম হাস্কেল সমাধান নয়, তবে আমি পছন্দ করি যে এটি [..]ব্যাপ্তি ব্যবহার করে না । পরিবর্তে, এটি পুনরায় বিভাজন nহিসাবে পার্টিশন হিসাবে n-1নতুন 1 বা প্রথম মান একতর উচ্চতর হিসাবে পার্টিশন হিসাবে গণনা করে । এটি 2^(n-1)তাদের মধ্যে কেন রয়েছে তা স্পষ্ট করে দেয়।

— xnor
সূত্র

3

গণিত, 53 বাইট

মার্টিন ইন্ডারের জবাবটি হারাবে না, যা বিল্ট-ইন IntegerPartitionsফাংশন ব্যবহার করে (এবং বিল্ট-ইনগুলি আমার দ্বারা সম্পূর্ণ সূক্ষ্ম)। (এমনকি এটি ফেয়ারসামের উত্তরকেও হারাতে পারে না, যা আমি খুব দেরি পর্যন্ত দেখিনি)) তবে আমি গল্ফযুক্ত পুনরাবৃত্ত ফাংশনটি অনুশীলন করতে চেয়েছিলাম।

If[#<1,{{}},Join@@Table[#~Append~j&/@#0[#-j],{j,#}]]&

সমস্ত সম্ভাব্য চূড়ান্ত নম্বর উত্পন্ন করে jএবং তারপরে ইনপুটটি #-jকোথায় #রয়েছে তা কল করে পুনরাবৃত্তভাবে সমস্ত রচনা তৈরি করে ।

— গ্রেগ মার্টিন
সূত্র

Arrayপরিবর্তে অপারেটরটি সংজ্ঞায়িত করে Tableএবং Appendএকটি তালিকা ব্যবহার করে এবং এড়ানো থেকে আপনি কয়েকটি বাইট সংরক্ষণ করতে পারেন Apply:±0={{}};±n_:=Join@@Array[{##,n-+##}&@@@±#&,n,0]

— মার্টিন ইন্ডার

কি করে @@?

— সাইয়েস

এটি একটি অভিব্যক্তির "মাথা" প্রতিস্থাপন করে। উদাহরণস্বরূপ, f@@g[a,b]মূল্যায়ন f[a,b]। এখানে আমরা এই তথ্যটি ব্যবহার করছি যে { { {1,1,1}, {2,1} } , { {1,2} }, { {3} } }অদৃশ্যভাবে একটি তালিকার মাথা রয়েছে List; তাই Join@@{ { {1,1,1}, {2,1} } , { {1,2} }, { {3} } }মূল্যায়ণ Join@@List[ { {1,1,1}, {2,1} } , { {1,2} }, { {3} } ]মূল্যায়ণ Join[ { {1,1,1}, {2,1} } , { {1,2} }, { {3} } ]মূল্যায়ণ { {1,1,1}, {2,1}, {1,2}, {3} }।

— গ্রেগ মার্টিন

3

রেটিনা , 32 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে।

.+
$*
+%1`1
!$'¶$`,!
!+
$.&
A`^,

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

এটি আমার সিজেএম উত্তরের মতো কাজ করে । আমরা একটি তালিকাভুক্ত Nব্যক্তিদের মধ্য দিয়ে যাই এবং প্রতিটি পজিশনে আমরা বাইনারি সিদ্ধান্তের উভয় শাখা নিয়ে থাকি) ক) শেষ মান বা খ) নতুন মান 1 এ শুরু করি।

ধাপ 1

.+
$*

ইনপুটটি আনারিতে রূপান্তর করুন।

ধাপ ২

+%1`1
!$'¶$`,!

+রেটিনা বলে একটি লুপ এই পর্যায়ে চালানো পর্যন্ত আউটপুট পরিবর্তন বন্ধ করে দেয়। %ইনপুট লাইন মধ্যে পর্যায় প্রয়োগ করার আগে ফিরে একসঙ্গে পরে বিভক্ত এবং তাদের যোগদান করতে বলা হয়েছে। %পরে রাখার পরে +রেটিনা বিভক্ত হয় এবং প্রতিটি পুনরাবৃত্তির পরে পুনরায় যোগদান করে। পর্যায়টির একটি পুনরাবৃত্তি সেই সিদ্ধান্তগুলির মধ্যে একটি করে আমি উল্লেখ করেছি এবং এর ফলে পার্টিশনের বর্তমান সেটকে দ্বিখণ্ডিত করে।

কিভাবে এটা আসলে কাজ করে যে এটি একটি ম্যাচ হয় 1(কিন্তু শুধুমাত্র প্রথম এক হিসাবে দ্বারা নির্দেশিত 1ব্যাকটিক সামনে), এবং এটি প্রতিস্থাপন সঙ্গে !(যা আমরা আমাদের আউটপুট ইউনারী অঙ্ক হিসাবে ব্যবহার করব), অবশিষ্ট দ্বারা অনুসরণ 1গুলি এই সারিতে (এটি শেষ মান বাড়ায়)। তারপরে অন্য একটি লাইনে ( ¶) এটি বর্তমান লাইনের উপসর্গটি মুদ্রণ করে, তারপরে ,!, যা একটি বিভাজক সন্নিবেশ করে এবং তারপরে পরবর্তী মানটি শুরু করে 1।

পর্যায় 3

!+
$.&

এটি !দৈর্ঘ্যের সাথে প্রতিস্থাপন করে রানকে দশমিক পূর্ণসংখ্যায় রূপান্তর করে ।

মঞ্চ 4

A`^,

এবং পরিশেষে, আমরা লক্ষ্য করেছি যে আমরা আমাদের চেয়ে দ্বিগুণ রেখা তৈরি করেছি এবং এর অর্ধেকটি একটি দিয়ে শুরু হয় ,(আমরা যেখানে প্রাথমিকভাবে বিভক্তির সিদ্ধান্ত নিয়েছিলাম, যদিও এখনও বিভাজনের কিছু ছিল না)। অতএব, আমরা সমস্ত লাইন এ দিয়ে শুরু করি যা বাতিল করে দেয় ,।

— মার্টিন ইন্ডার
সূত্র

3

পার্ল, 44 বাইট

এর জন্য +3 -n(কোড ব্যবহার করে $'এবং $0তাই এটি একটি -eকমান্ডলাইন হিসাবে চালানো যায় না ) অন্তর্ভুক্ত করে

এসটিডিনে পার্টিশনের জন্য নম্বর দিন:

partitions.pl <<< 4

partitions.pl

#!/usr/bin/perl -n
$_=$&-$_.",$_$'",do$0for/\d+/..$&-1;print

আপনি যদি কোনও লাইনের শেষে অতিরিক্ত স্থান এবং অতিরিক্ত নিউলাইন মনে না করেন তবে এই 42 বাইট সমাধানটি খুব কার্যকর (এটি হিসাবে চালান perl -M5.010 partitions.pl):

#!/usr/bin/perl -n
$_=$`-$_." $_ $'",do$0for/\s/..$_-1;say

— টন হসপেল
সূত্র

3

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

f(N)=unique(reduce(vcat,(map(x->[permutations(x)...],[vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N]))))

অ-পুনরাবৃত্ত সমাধান

ব্যাখ্যা:

[vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N] N এর সমষ্টি তালিকার একটি সেট তৈরি করুন, যার অনুমতিগুলি সমাধানের সাথে সাদৃশ্যযুক্ত হবে (যেমন এন = 4 এর জন্য: [[1,1,1,1], [1,1,2], [1,3], [4 ]])
map(x->[permutations(x)...],) সমস্ত অনুমতি গণনা করুন
reduce(vcat,) তালিকার তালিকায় তাদের একত্রিত করুন
unique() ফিল্টার সদৃশ

— nyro_0
সূত্র

আমাদের পূর্ণ প্রোগ্রাম বা ফাংশন হতে সাবমিশনের প্রয়োজন, সুতরাং এই ক্ষেত্রে আপনাকে Nইনপুট হিসাবে গ্রহণ করতে হবে । আপনি N->3 বাইট ব্যয়ে প্রিপেন্ড করে ল্যাম্বডা ফাংশনটি তৈরি করতে পারেন ।

— অ্যালেক্স এ

@AlexA। আহ, দুঃখিত f(N)=অনুলিপিটি হারিয়ে গেছে, বাইটগুলি গণনা করার সময় আমি তা পেয়েছিলাম

— nyro_0

2

এমএটিএল , 15 বাইট

:"G:@Z^t!XsG=Y)

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

ইনপুট দেওয়া n, এই বহিঃপ্রকাশ বেড়ে কার্টিজিয়ান ক্ষমতা নির্ণয় kথেকে 1থেকে n; এবং প্রতিটি kঅভ্যাসকারীর জন্য ইনপুটের সমান পরিমাণযুক্ত টিউপলগুলি নির্বাচন করে।

:       % Take input n implicitly and push range [1 2 ... n]
"       % For each k in that range
  G:    %   Push [1 2 ... n] again
  @     %   Push k
  Z^    %   Cartesian power. Gives 2D array, say A, with each k-tuple in a row.
  t     %   Duplicate
  !     %   Transpose
  Xs    %   Sum of each column. Gives a row vector
  G=    %   True for entries that equal the input
  Y)    %   Use as logical vector into the rows of array A
        % End implicitly
        % Display stack implicitly

— লুইস মেন্ডো
সূত্র

1

লুয়া 214 203 182 বাইট

function g(m, l, n,c)for i=1,m do if i+n < m then l[#l+1]=i;g(m,l,n+i,c+1)elseif i+n == m then l[#l+1]=i;print(unpack(l))end end for k=c,#l do l[k]=nil end end g(io.read()*1,{},0,0)

অমীমাংসিত সংস্করণ।

function g(m, l, n,c)
    for i=1,m do 
        if i+n < m then 
            l[#l+1]=i
            g(m,l,n+i,c+1)
        elseif i+n == m then 
            l[#l+1]=i
            print(unpack(l))
        end 
    end 
    for k=c,#l do 
        l[k]=nil 
    end 
end 
g(io.read()*1,{},0,0)

একটি বিপথগামী হোয়াইটস্পেস পেয়েছে এবং 11 বাইট নিরাপদে অনাবশ্যক ভেরিয়েবল সরিয়েছে। দেখা যাচ্ছে, টেবিল.িনেট্রেট () বাইট অদক্ষ

— lenscas
সূত্র

1

পিএইচপি, 125 বাইট

for($i=$n=$argv[1];$i<=str_repeat(1,$n);$i++)if(array_sum($a=str_split($i))==$n&!strpos($i,"0"))$r[]=$a;echo json_encode($r);

-4 আউটপুট print_r($r);পরিবর্তে জন্য বাইটecho json_encode($r);

250 বাইট সহ একটি পুনরাবৃত্ত সমাধান

function f($n){global$a;foreach($a as$x)foreach(range(1,$n)as$y)$a[]=array_merge((array)$x,[$y]);if(--$n)f($n);}$a=range(1,$w=$argv[1]);f($w-1);foreach($a as$z)if(array_sum((array)$z)==$w)$c[join("-",(array)$z)]=$z;echo json_encode(array_values($c));

— জার্গ হালসারম্যান
সূত্র

1

প্রোলগ, কল করতে 81 বাইট + 6 বাইট

L*L.
[H|T]*L:-H>1,M is H-1,[M,1|T]*L.
[H,K|T]*L:-H>1,M is H-1,N is K+1,[M,N|T]*L.

এটি অনলাইন চেষ্টা করুন!
সাথে কল করুন [4]*L., ;সমস্ত সমাধান উপস্থাপন না করা পর্যন্ত পুনরাবৃত্তি করুন ।

বিকল্পভাবে, যদি বারবার টিপতে ;ঠিক না হয় (বা বাইট গণনায় যোগ করা উচিত), কল করুন bagof(L,[4]*L,M).যার সাথে কলটির জন্য 17 বাইট যুক্ত করা হবে।

— SQB
সূত্র

1

জে , 30 26 বাইট

#&1<@(+/;.1)~2#:@(+i.)@^<:

বিভাজন করে কাজ করে ইউনারী তালিকা এন 2 বাইনারি মান ব্যবহার করে ^এন ।

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

#&1<@(+/;.1)~2#:@(+i.)@^<:  Input: n
                        <:  Decrement n
             2         ^    Compute 2^(n-1)
                 (   )@     Operate on that
                   i.         Make the range [0, 1, ..., 2^(n-1)-1]
                  +           Add 2^(n-1) to each in that range
              #:@           Convert each in that range to binary
#&1                         Make n copies of 1 (n in unary)
     (     )~               Operate over each row on RHS and unary n on LHS
        ;.1                   Chop unary n starting at each 1
      +/                        Reduce by addition on each chop
   <@                           Box the sums of each chop

— মাইল
সূত্র

0

আসলে, 17 16 বাইট

এই উত্তরটি আংশিকভাবে লুই মেন্ডোর এমএটিএল উত্তরের উপর ভিত্তি করে । গল্ফিং পরামর্শ স্বাগত জানাই। এটি অনলাইন চেষ্টা করুন!

;╗R`╜R∙i`M`Σ╜=`░

Ungolfing

         Implicit input n.
;╗       Duplicate n and save a copy of n to register 0.
R        Take the range of [1..n].
`...`M   Map the following function over the range. Variable k.
  ╛R       Push n from register 0 and take the range [1..n] again.
  ∙        Take the k-th Cartesian power of the range.
  i        Flatten that product.
`...`░   Push values of the previous map where the following function returns a truthy value.
          Variable L.
  Σ        Push sum(L).
  ╜        Push n from register 0.
  =        Check if sum(L) == n.
         Implicit return.

— Sherlock9
সূত্র

0

আসলে, 17 16 15 বাইট

এটি মার্টিন ইন্ডারের সিজেএম উত্তরের একটি আকর্ষণীয় কাঁটাচামচ ( কারটিশিয়ান পণ্যটির সাথে একটি), বাস্তবায়নের একটি পার্থক্য যা আমি ভেবেছিলাম আকর্ষণীয়। মার্টিনের একটি স্ট্রিং যখন ইনক্রিমেন্টের সাথে শুরু হয়, ত্রুটিগুলি সেই স্ট্রিংকে মূল্যায়ন করা থেকে বিরত করে। আসলে, ত্রুটিটি দমন করা হয় এবং স্ট্রিংটি যাইহোক মূল্যায়ন করা হয়। এটি kপরিসীমাটির প্রত্যেকটির রচনা দেয় [1..n]।

অতিরিক্ত রচনাগুলি মুছে ফেলার চেষ্টা করার পরিবর্তে, আমি প্রতিটি স্ট্রিংয়ের শুরুতে সংযোজনীয় n-1কার্টেসিয়ান শক্তি নিয়েছিলাম । এই কৌশলটি কেবল রচনাগুলি দেয় । দুর্ভাগ্যক্রমে এটি মার্টিনের উত্তরের চেয়ে দীর্ঘতর।"1u""1"n

গল্ফিং পরামর্শ স্বাগত জানাই। এটি অনলাইন চেষ্টা করুন!

D"1u"∙`1@Σ£ƒk`M

Ungolfing

         Implicit input n.
D        Decrement n.
"1u"∙    Take the (n-1)th Cartesian power of the string "1u".
          In Actually, 1 pushes 1 to the stack and u is increment.
`...`M   Map the following function over the Cartesian power. Variable s.
  1@       Push a 1 to be used later.
  Σ        Summing a list of chars joins the chars into one string.
  £ƒ       Turn s into a function and call it immediately on the 1 in the stack.
  k        Take the whole stack and wrap in a list. This is a composition of n.
         Implicit return.

— Sherlock9
সূত্র

এন এর অর্ডার করা সমস্ত পার্টিশন তালিকাভুক্ত করুন

পাইথ, 7 6 বাইট

হাস্কেল, 37 বাইট

পাইথন, 56 বাইট

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

জাভাস্ক্রিপ্ট (ফায়ারফক্স 30-57), 63 বাইট

গণিত, 40 বাইট

সিজেম , 17 14 বাইট

ব্যাখ্যা

জেলি , 7 6 বাইট

খাঁটি বাশ, 51

রুবি, 61 বাইট

ungolfed

ব্যবহার

ব্র্যাচল্যাগ , 20 বাইট

ব্যাখ্যা

সিজেম , 19 বাইট

ব্যাখ্যা

টি-এসকিউএল, 203 বাইট

গণিত 10.0, 44 বাইট tes

05 এ বি 1 ই , 14 12 বাইট

2sable , 10 বাইট

হাস্কেল, 41 বাইট

গণিত, 53 বাইট

রেটিনা , 32 বাইট

ব্যাখ্যা

পার্ল, 44 বাইট

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

এমএটিএল , 15 বাইট

ব্যাখ্যা

লুয়া 214 203 182 বাইট

পিএইচপি, 125 বাইট

প্রোলগ, কল করতে 81 বাইট + 6 বাইট

জে , 30 26 বাইট

ব্যাখ্যা

আসলে, 17 16 বাইট

আসলে, 17 16 15 বাইট