11

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

সুতরাং তালিকার [1, 2, 3, 4]জন্য ফলাফল:

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

আউটপুটে তালিকাগুলির ক্রমের বিষয়টি বিবেচনা করে না, তাই [[1, 2, 3, 4]]প্রথম, শেষ বা অন্য যে কোনও জায়গায় হতে পারে। উপাদানগুলির ক্রম অবশ্যই সংরক্ষণ করা উচিত।

এটি কোড-গল্ফ, তাই সংক্ষিপ্ত উত্তর জেতে।

সম্পর্কিত: একটি তালিকা বিভাগ!

— mbomb007
সূত্র

2

আমরা কি [...]আউটপুট ফর্ম্যাটে আশেপাশেরটি বাদ দিতে পারি ? (যতক্ষণ পার্টিশনগুলি স্পষ্টভাবে পৃথক করা হয়, যেমন লাইনফিডগুলি দ্বারা।)

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

ইনপুট এবং আউটপুট ফর্ম্যাটগুলি নমনীয়, তবে সেগুলি একই হওয়া উচিত। সুতরাং যদি ইনপুট তালিকার এক লাইনে এর উপাদান থাকে তবে আউটপুট তালিকাগুলিও হওয়া উচিত।

— mbomb007

আমি যা বলতে চাইছি তা নয়। বাশ উত্তরটি একবার দেখুন। এটি :তালিকার বিভাজক হিসাবে ব্যবহার করে তবে আউটপুটে পার্টিশনগুলি নিজের অতিরিক্ত জোড়ায় আবৃত হয় না [...]।

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

অথবা, আলাদাভাবে জিজ্ঞাসা করলেন: চ্যালেঞ্জে আপনার উদাহরণ ফর্ম্যাটে, আমি কি প্রতিটি লাইন থেকে প্রথম [এবং শেষ বাদ দিতে পারি ]?

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

1

টিপস হিসাবে একই প্রশ্ন

— xnor

2

জেলি , 2 বাইট

ŒṖ

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

— ডেনিস
সূত্র

13

রেটিনা , 27 19 বাইট

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

+1%`,
;$'¶$`];[
;
,

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

ব্যাখ্যা

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

ইনপুটটি বেস কেস হিসাবে কাজ করে: পার্টিশন যেখানে সমস্ত উপাদান এখনও একক তালিকায় থাকে।

+1%`,
;$'¶$`];[

এখন আমরা বারে বারে ( +) প্রথম ( 1) কমা ( ,) সাথে প্রতিটি লাইনে মেলে ( %) (সেই লাইনটিকে পৃথক স্ট্রিং হিসাবে বিবেচনা করি, যা প্রাসঙ্গিক ক্ষেত্রে $'এবং `` $ 1। প্রাসঙ্গিক )।

সেই কমাটি প্রতিস্থাপন করে:

;   A semicolon. This is just a stand-in for the comma, so we know we've already
    processed it and it won't be substituted again by the next iteration.
$'  Everything after the match. This completes the first (unchanged) version of
    the current line.
¶   A linefeed. Since the next iteration will scan for all lines again, this doubles
    the number of strings we're working with.
$`  Everything before the match. This completes the second (split) version of
    the current line.
];[ A semicolon around which we split the list.

মনে রাখবেন ম্যাচের সামনের এবং ম্যাচের পরে সমস্ত কিছুই যেভাবেই স্ট্রিংয়ে থেকে যায়, তাই পুরো ফলাফলটি আসলে $`;$'¶$`];[$'এটি ব্যাখ্যা করে যা আমরা কেন সেই ক্রমে প্রত্যয় এবং উপসর্গ সন্নিবেশ করিয়েছি।

সমস্ত কমা শেষ হয়ে গেলে এই লুপটি বন্ধ হয়ে যায়।

;
,

অবশেষে, ইনপুট ফর্ম্যাটটির সাথে মিল রেখে সেমিকোলনগুলিকে আবার কমা দিয়ে প্রতিস্থাপন করুন।

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

10

খাঁটি বাশ, 28

eval echo [${1//:/{:,]:[\}}]

এখানে তালিকাগুলি কোলন দ্বারা পৃথক করা হয়েছে এবং বর্গাকার বন্ধনীতে রয়েছে। প্রশ্নে উদাহরণস্বরূপ, ইনপুট তালিকাটি হবে 1:2:3:4এবং আউটপুটটি হ'ল:

[1:2:3:4] [1:2:3]:[4] [1:2]:[3:4] [1:2]:[3]:[4] [1]:[2:3:4] [1]:[2:3]:[4] [1]:[2]:[3:4] [1]:[2]:[3]:[4]

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

${1//:/REPLACEMENT}$1সাথে কলোনগুলি প্রতিস্থাপন করে{:,]:[\}
এটি একটি ধনুর্বন্ধনী সম্প্রসারণ এর মতো উত্পন্ন করে [1{:,]:[}2{:,]:[}3{:,]:[}4]
ইওল (এবং সাবধানে \পালিয়ে যাওয়া) ব্রেস সম্প্রসারণটি সর্বশেষে ঘটে এবং কাঙ্ক্ষিত ফলাফল দেয়।

যদি প্রদত্ত [[ , , ...]]ফর্ম্যাটটি হুবহু মিলে যায় তবে আমরা পরিবর্তে এটি করতে পারি:

খাঁটি বাশ, 47

eval printf '%s\\n' ${1//, /{\\,\\ ,]\\,\\ [\}}

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

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

6

পাইথ , 2 বাইট

./

ইনপুট সহ [1, 2, 3, 4](উদাহরণস্বরূপ)।

ব্যাখ্যা : ./পার্টিশন অপারেটর। এটি ইনপুট তালিকার সমস্ত বিভাগকে উপ-তালিকায় বিচ্ছিন্ন করে দেয়। ইনপুটটি স্পষ্টভাবে প্রোগ্রামটিতে খাওয়ানো হয়।

এটি অনলাইন পরীক্ষা!

— জিম
সূত্র

6

05 এ বি 1 ই , 5 বাইট

Œæʒ˜Q

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

Œæʒ˜Q  Main link. Argument l
Œ      Get all sublists of l
 æ     Powerset of those lists
  ʒ˜Q  Filter: Keep the lists that when flattened equal the input

— kalsowerus
সূত্র

1

বাহ, এটা খুব ঝরঝরে উত্তর!

— আদনান

1

@ আদনান ধন্যবাদ, আমি এতেও বেশ খুশি। যদিও এটি সবকিছুই দক্ষ তবে :)

— কলসওয়ারাস 18'17

এখনও কোনও বিল্টিন না থাকলে ভাল উত্তর, আমার কাছ থেকে +1! শুধু অন্য কেউ ভবিষ্যতে এখানে আসার জন্য এই ত্যাগ, কিন্তু 05AB1E এখন একটি 2-বাইট সমস্ত পার্টিশন পেতে builtin: .œ: অনলাইনে চেষ্টা করুন।

— কেভিন ক্রুইজসেন

4

পাইথন 3 , 82 72 66 বাইট

f=lambda l:[k+[l[i:]]for i in range(len(l))for k in f(l[:i])]or[l]

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

-5 বাইটস @ জোনাথান অ্যালানকে ধন্যবাদ

— ovs
সূত্র

ওহ আমার, আমি আবার ^ v করতে পারি না :( আমি আসলে এরকম কিছু চেষ্টা করেছি এবং এটি কাজ করে না, আমি অবশ্যই কোথাও ভুল হয়ে গিয়েছি

— জনাথন অ্যালান

1

... যে ক্ষেত্রে আরও 5

— জোনাথন অ্যালান

1

@ জোনাথন অ্যালান অনেক ধন্যবাদ! আমি পুনঃব্যবহার দ্বারা অন্য বাইট বাঁচাতে পারে lশেষ

— ovs

এই সমাধানটি এখানে ইতিমধ্যে বিদ্যমান । প্রশ্ন পোস্ট করার পরে আমি টিএনবিতে @ ফার্সামকে বার্তা দিয়েছি, যাতে তিনি এটি পোস্ট করার সুযোগ পান।

— mbomb007

আমি আপনাকে বোঝাতে চাইনি যে আপনি এটি পূর্বাবস্থায় ফেরা উচিত, আমি কেবল বোঝাতে চাইছিলাম যে আপনি তাকে এটির কাছে পিটিয়েছেন। অবশ্যই এটি আপনার পছন্দ

— mbomb007

4

হাস্কেল , 59 55 49 বাইট

p[x]=[[[x]]]
p(x:r)=do a:b<-p r;[(x:a):b,[x]:a:b]

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

পুনরাবৃত্তির সমাধান। ব্যবহারের উদাহরণ: p [1,2,3]আয় [[[1,2,3]],[[1,2],[3]],[[1],[2,3]],[[1],[2],[3]]]।

-6 বাইটস xnor ধন্যবাদ !

— Laikoni
সূত্র

1

আপনি স্বরলিপি দিয়ে দ্বিতীয় লাইনটি সংক্ষিপ্ত লিখতে পারেন: do a:b<-p r;[(x:a):b,[x]:a:b](এটি তালিকার ক্রম পরিবর্তন করে)।

— xnor

1

এছাড়াও, <*>আপনি যা চান ঠিক তা করেন না [\(a:b)->(x:a):b,([x]:)]<*>p r, যদিও এটির চেয়ে বেশি দীর্ঘ doকারণ প্রথম ল্যাম্বডায় একটি প্যাটার্ন ম্যাচের প্রয়োজন বলে মনে হয়।

— xnor

3

জে , 42 বাইট

<@(</."1)~<:@#_&(][:;<@(,~"{~0 1+>./)"1)0:

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

উদাহরণস্বরূপ, দৈর্ঘ্য 4 তালিকার জন্য কীগুলি তৈরি করার প্রক্রিয়াটি এখানে।

উদাহরণ

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

— মাইল
সূত্র

3

জে , 26 24 বাইট

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

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

— মাইল
সূত্র

2

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

~c

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

জেনারেটর হিসাবে অভিনয়ের মাধ্যমে আউটপুট উত্পাদন করে এমন ফাংশন জমা দেওয়া। (টিআইও লিঙ্কটিতে পরীক্ষার প্রয়োজনে এটি একটি পূর্ণ প্রোগ্রামে পরিণত করার জন্য অতিরিক্ত কোড রয়েছে))

ঘটনাক্রমে, যদিও প্রযুক্তিগতভাবে কোনও বিল্টিন না হলেও এটি ব্র্যাক্ল্যাগে এতই সাধারণভাবে ব্যবহৃত হয় যে ক) এটি সম্ভবত একটি একক বাইট উপস্থাপনা প্রাপ্য, এবং খ) বিল্টিন cতার ইনপুট সম্পর্কে দৃser়তা জানাতে একটি পরামিতি নিতে পারে (যেখানে বেশিরভাগ বিল্টিনের সাথে একটি পরামিতি রয়েছে) কিভাবে আউটপুট উত্পাদন করতে হয় )

ব্যাখ্যা

~c
~     Find a value with the following properties:
 c      concatenating its elements produces {the input}

2

এপিএল, 26 বাইট

{⊂∘⍵¨1,¨↓⍉(X⍴2)⊤⍳2*X←⍴1↓⍵}

টেস্ট:

      {⊂∘⍵¨1,¨↓⍉(X⍴2)⊤⍳2*X←⍴1↓⍵} 1 2 3 4
┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
│┌─────┬─┐│┌───┬───┐│┌───┬─┬─┐│┌─┬─────┐│┌─┬───┬─┐│┌─┬─┬───┐│┌─┬─┬─┬─┐│┌───────┐│
││1 2 3│4│││1 2│3 4│││1 2│3│4│││1│2 3 4│││1│2 3│4│││1│2│3 4│││1│2│3│4│││1 2 3 4││
│└─────┴─┘│└───┴───┘│└───┴─┴─┘│└─┴─────┘│└─┴───┴─┘│└─┴─┴───┘│└─┴─┴─┴─┘│└───────┘│
└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘

ব্যাখ্যা:

X←⍴1↓⍵: এর প্রথম উপাদানটি বাদ দেওয়া (ইনপুট তালিকা) এর Xদৈর্ঘ্য কি⍵
⍳2*X: সংখ্যাগুলি [1.২ ^ এক্স]
(X⍴2)⊤: Xঅবস্থানগুলি সহ এই সংখ্যাগুলির বেস -২ উপস্থাপনা (অর্থাত্ এগুলি Xনিজেই প্রায় গুটিয়ে দেবে 0)।
↓⍉: ম্যাট্রিক্সটি ঘোরান এবং লাইনগুলি দিয়ে বিভক্ত করুন ( ⊤ফলস্বরূপ কলামগুলির সাথে সংখ্যার সাথে একটি ম্যাট্রিক্স দেয়), বিট ভেক্টরগুলির একটি অ্যারে প্রদান করে
1,¨: প্রতিটি বিট ভেক্টর থেকে একটি 1 প্রেন্ডেন্ড করুন।
⊂∘⍵¨: প্রতিটি বিট ভেক্টরের জন্য, ⍵প্রতিটি 1 এ বিভক্ত করুন ।

— সামুদ্রিক
সূত্র

2

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

foldr(\h t->map([h]:)t++[(h:y):z|y:z<-t])[[]]

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

আমি হাস্কেল টিপ সম্পর্কে চিন্তা করে কিছুক্ষণ আগে এই সমাধানটি পেয়েছি ।

— xnor
সূত্র

1

পাইথন , 90 বাইট

ovs দ্বারা আউটগল্ফড (এমন কিছু তৈরি করা যা আমি ভেবেছিলাম আমি কাজ করার চেষ্টা করব: পি)

def f(a):r=[[a]];i=len(a)-1;exec("for s in f(a[:i]):s+=[a[i:]];r+=[s]\ni-=1\n"*i);return r

একটি পুনরাবৃত্ত ফাংশন যা টুকরাগুলির দৈর্ঘ্য 1 এর পূর্বে পৌঁছে যাওয়া লেজের সাথে ইনপুটটির টুকরোগুলি থেকে পার্টিশনের তালিকা তৈরি করে।

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

execএকটি ওভার 4 বাইট সংরক্ষণ whileএকটি ওভার বা 3 for(নীচে) লুপ যেহেতু এটি মাত্র দুটি অর্থ \nখাঁজ দুই মাত্রা বদলে গুলি, সমগ্র ফাংশন এক লাইনে হতে (যখন slicing ক্রম ব্যাপার না) অনুমতি দেয়।

def f(a):
 r=[[a]]
 for i in range(1,len(a)):
  for s in f(a[:i]):s+=[a[i:]];r+=[s]
 return r

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

1

পাইথন 3 , 67 বাইট

f=lambda x,n=1:x[n:]and[y+[x[n:]]for y in f(x[:n])]+f(x,n+1)or[[x]]

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

— ডেনিস
সূত্র

1

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

x#[]=[[[x]]]
x#(a:b)=[(x:a):b,[x]:a:b]
foldr((=<<).(#))[[]]

— alephalpha
সূত্র

1

রুবি , 62 57 বাইট

->l{(0..2**l.size).map{|x|l.chunk{1&x/=2}.map &:last}|[]}

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

কিভাবে এটা কাজ করে:

পার্টিশনের সংখ্যা 2 ^ (n-1): আমি সেই পরিসরে বাইনারি সংখ্যায় পুনরাবৃত্তি করি, শূন্য এবং গোষ্ঠীগুলির গোষ্ঠী গ্রহণ করি এবং তাদের প্রাথমিক তালিকার উপগ্রহ হিসাবে মানচিত্র করি।
পরিসীমাটির সাথে ঝাঁকুনির পরিবর্তে, আমি এটিকে ডাবল এবং শেষে ডুপ্লিকেট বাতিল করি। এখন আমি প্রথম বাইনারি অঙ্কটিও বাতিল করতে পারি এবং খণ্ডের ক্রিয়াকে আরও খাটো করে তুলতে পারি।

— গিগাবাইট
সূত্র

0

জাভাস্ক্রিপ্ট (ES6), 87 বাইট

([e,...a],b=[],c=[e],d=[...b,c])=>1/a[0]?[...f(a,b,[...c,a[0]]),...f(a,d,[a[0]])]:[d]

ব্যাখ্যা: bপূর্ববর্তী সাবলিস্টগুলির তালিকা হ'ল cবর্তমান সাবলিস্ট, (যা অ্যারের প্রথম উপাদান হিসাবে শুরু হয়, যেহেতু এটি অবশ্যই প্রথম সাবলিস্টে থাকা আবশ্যক) যখন dসমস্ত সাবলিস্টের তালিকা থাকে। অ্যারের উপাদানগুলির বাকি অংশগুলি পুনরাবৃত্তভাবে প্রক্রিয়া করা হয়। প্রতিটি ক্ষেত্রে দুটি বিকল্প রয়েছে: হয় পরের উপাদানটি বর্তমান সাবলিস্টে যুক্ত হয়, বা বর্তমান সাবলিস্টটি সম্পূর্ণ হয়ে যায় এবং পরবর্তী উপাদানটি একটি নতুন সাবলিস্ট শুরু করে। পুনরাবৃত্তির ফলাফলগুলি একসাথে একত্রিত হয়। অ্যারেটি ক্লান্ত হয়ে গেলে সমস্ত সাবলিস্টের তালিকার তালিকাটি ফলাফল হয়।

— নিল
সূত্র

0

এপিএল (এনএআরএস) 38 চর, 76 বাইট

{k←↑⍴⍵⋄x←11 1‼k k⋄y←⍵⋄∪{x[⍵;]⊂y}¨⍳↑⍴x}

এটি Nars ফাংশন 11 1‼ kk ব্যবহার করে তবে এটি খুব ধীর, ইতিমধ্যে 9 টি উপাদানের আরগ অ্যারের জন্য অযোগ্য ...

  P3←{k←↑⍴⍵⋄x←11 1‼k k⋄y←⍵⋄∪{x[⍵;]⊂y}¨⍳↑⍴x}

  ⍴∘P3¨{1..⍵}¨⍳8
1  2  4  8  16  32  64  128 
  P3 'abcd'
abcd    abc d    ab cd    a bcd    ab c d    a bc d    a b cd    a b c d

এটি নীচে এমন ফাংশন যা অন্তর্নির্মিতটি ব্যবহার করে না:

r←h w;k;i
   r←⊂,⊂w⋄k←↑⍴w⋄i←1⋄→B
A: r←r,(⊂⊂,i↑w),¨h i↓w⋄i+←1
B: →A×⍳i<k

  h 'abcd'
abcd    a bcd    a b cd    a b c d    a bc d    ab cd    ab c d    abc d
  ⍴∘h¨{1..⍵}¨⍳8
2  4  8  16  32  64  128

আমরা প্রতিটি ফলাফল টাইপ se:

  o h ,1
┌──────┐
│┌1───┐│
││┌1─┐││
│││ 1│││
││└~─┘2│
│└∊───┘3
└∊─────┘
  o h 1 2
┌2───────────────────┐
│┌1─────┐ ┌2────────┐│
││┌2───┐│ │┌1─┐ ┌1─┐││
│││ 1 2││ ││ 1│ │ 2│││
││└~───┘2 │└~─┘ └~─┘2│
│└∊─────┘ └∊────────┘3
└∊───────────────────┘

আমি জানি না এটি কীভাবে কাজ করে, এটি কেবলমাত্র ধর্মীয় চেষ্টা ...

সম্ভব আমি কিছু ত্রুটি করি; উভয় ফাংশন তালিকার পার্টিশনগুলি যা কিছু ইনপুট দেয় এবং কেবল 1 2 ... এন নয়।

— RosLuP
সূত্র

0

অ্যাক্সিয়াম, 251 বাইট

C==>concat;A==>List Any;px(a:A):A==(k:=#a;r:=copy[a];k<=1=>r;i:=1;repeat(i>=k=>break;x:=a.(1..i);y:=a.((i+1)..k);z:=px(y);t:=[x,z.1];for j in 2..#z repeat(w:=(z.j)::A;m:=#w;v:=[x];for q in 1..m repeat v:=C(v,w.q);t:=C(t,[v]));r:=C(r,copy t);i:=i+1);r)

যদি কেউ আরও ভাল কিছু আবিষ্কার করে ... অধম এবং পরীক্ষা:

pp(a:List Any):List Any==
  k:=#a;r:=copy[a];k<=1=>r;i:=1
  repeat
    i>=k=>break
    x:=a.(1..i);y:=a.((i+1)..k);z:=pp(y);
    t:=[x,z.1]
    for j in 2..#z repeat
           w:=(z.j)::List Any
           m:=#w; v:=[x]
           for q in 1..m repeat 
                       v:=concat(v,w.q);
           t:=concat(t,[v])
    r:=concat(r,copy t);
    i:=i+1
  r

(7) -> px []
 (7)  [[]]
                                                           Type: List Any
(8) -> px [1]
 (8)  [[1]]
                                                           Type: List Any
(9) -> px [1,2]
 (9)  [[1,2],[[1],[2]]]
                                                           Type: List Any
(10) -> px [1,2,3]
 (10)  [[1,2,3],[[1],[2,3]],[[1],[2],[3]],[[1,2],[3]]]
                                                           Type: List Any
(11) -> px [1,2,3,4,5,6]
 (11)
[[1,2,3,4,5,6], [[1],[2,3,4,5,6]], [[1],[2],[3,4,5,6]],
 [[1],[2],[3],[4,5,6]], [[1],[2],[3],[4],[5,6]], [[1],[2],[3],[4],[5],[6]],
 [[1],[2],[3],[4,5],[6]], [[1],[2],[3,4],[5,6]], [[1],[2],[3,4],[5],[6]],
 [[1],[2],[3,4,5],[6]], [[1],[2,3],[4,5,6]], [[1],[2,3],[4],[5,6]],
 [[1],[2,3],[4],[5],[6]], [[1],[2,3],[4,5],[6]], [[1],[2,3,4],[5,6]],
 [[1],[2,3,4],[5],[6]], [[1],[2,3,4,5],[6]], [[1,2],[3,4,5,6]],
 [[1,2],[3],[4,5,6]], [[1,2],[3],[4],[5,6]], [[1,2],[3],[4],[5],[6]],
 [[1,2],[3],[4,5],[6]], [[1,2],[3,4],[5,6]], [[1,2],[3,4],[5],[6]],
 [[1,2],[3,4,5],[6]], [[1,2,3],[4,5,6]], [[1,2,3],[4],[5,6]],
 [[1,2,3],[4],[5],[6]], [[1,2,3],[4,5],[6]], [[1,2,3,4],[5,6]],
 [[1,2,3,4],[5],[6]], [[1,2,3,4,5],[6]]]
                                                           Type: List Any
(12) -> [[i,#px i] for i in [[],[1],[1,2],[1,2,3],[1,2,3,4],[1,2,3,4,5,6]] ]
 (12)
[[[],1],[[1],1],[[1,2],2],[[1,2,3],4],[[1,2,3,4],8],[[1,2,3,4,5,6],32]]
                                                      Type: List List Any
(13) -> [#px(i) for i in [[],[1],[1,2],[1,2,3],[1,2,3,4],[1,2,3,4,5,6]] ]
 (13)  [1,1,2,4,8,32]
                                            Type: List NonNegativeInteger

যদি এটি খুব বেশি স্থান হয় তবে এটি বলুন এবং আমি উদাহরণগুলি সরিয়ে দিই ...

— RosLuP
সূত্র

সমস্ত সাবলিস্ট পার্টিশন তৈরি করুন

জেলি , 2 বাইট

রেটিনা , 27 19 বাইট

ব্যাখ্যা

খাঁটি বাশ, 28

খাঁটি বাশ, 47

পাইথ , 2 বাইট

05 এ বি 1 ই , 5 বাইট

পাইথন 3 , 82 72 66 বাইট

হাস্কেল , 59 55 49 বাইট

জে , 42 বাইট

জে , 26 24 বাইট

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

ব্যাখ্যা

এপিএল, 26 বাইট

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

পাইথন , 90 বাইট

পাইথন 3 , 67 বাইট

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

রুবি , 62 57 বাইট

কিভাবে এটা কাজ করে:

জাভাস্ক্রিপ্ট (ES6), 87 বাইট

এপিএল (এনএআরএস) 38 চর, 76 বাইট

অ্যাক্সিয়াম, 251 বাইট