মার্জ বাছাই একটি বাছাই করা অ্যালগরিদম যা প্রদত্ত তালিকাকে অর্ধেক ভাগে বিভক্ত করে পুনরাবৃত্তভাবে ছোট দুটি তালিকা বাছাই করে এবং সেগুলি একসাথে সাজানো তালিকায় আবার একত্রিত করে কাজ করে। পুনরাবৃত্তির বেস কেসটি একটি একক তালিকায় উপস্থিত হয়, যা আরও বিভক্ত হতে পারে না তবে ইতোমধ্যে সাজানো সংজ্ঞা অনুসারে।

তালিকার অ্যালগরিদমের কার্য সম্পাদন [1,7,6,3,3,2,5]নিম্নলিখিত পদ্ধতিতে দৃশ্যমান হতে পারে:

       [1,7,6,3,3,2,5]
       /             \      split
   [1,7,6,3]       [3,2,5]
    /     \        /    \   split
 [1,7]   [6,3]   [3,2]  [5]
 /   \   /   \   /   \   |  split
[1] [7] [6] [3] [3] [2] [5]
 \   /   \   /   \   /   |  merge
 [1,7]   [3,6]   [2,3]  [5]
    \     /         \   /   merge
   [1,3,6,7]       [2,3,5]
       \             /      merge
       [1,2,3,3,5,6,7]

কাজটি

একটি প্রোগ্রাম বা ফাংশন লিখুন যা ইনপুট হিসাবে কোনও যুক্তিসঙ্গত উপায়ে পূর্ণসংখ্যার একটি তালিকা গ্রহণ করে এবং এই তালিকার বিভিন্ন পার্টিশনটি মার্জ্ট সাজানোর অ্যালগরিদমের দ্বারা বাছাই করার সময় ভিজ্যুয়ালাইজ করে। এর অর্থ আপনাকে উপরের মতো কোনও গ্রাফ আউটপুট করতে হবে না , তবে কেবল তালিকাগুলি ঠিক আছে:

[1,7,6,3,3,2,5]
[1,7,6,3][3,2,5]
[1,7][6,3][3,2][5]
[1][7][6][3][3][2][5]
[1,7][3,6][2,3][5]
[1,3,6,7][2,3,5]
[1,2,3,3,5,6,7]

তদতিরিক্ত, যে কোনও যুক্তিসঙ্গত তালিকার স্বরলিপি ঠিক আছে, সুতরাং নিম্নলিখিতটিও একটি বৈধ আউটপুট হবে:

1 7 6 3 3 2 5
1 7 6 3|3 2 5
1 7|6 3|3 2|5
1|7|6|3|3|2|5
1 7|3 6|2 3|5
1 3 6 7|2 3 5
1 2 3 3 5 6 7

অবশেষে, দুটি ছোট তালিকায় একটি তালিকা বিভক্ত করার উপায় আপনার পক্ষে যতক্ষণ না উভয় ফলাফলের তালিকার দৈর্ঘ্য একের পর এক পৃথক হয়। এর অর্থ হল এর মধ্যে বিভক্ত [3,2,4,3,7]হওয়ার পরিবর্তে [3,2,4]এবং [3,7]আপনি সমান এবং বিজোড় সূচকগুলিতে ( [3,4,7]এবং [2,3]) উপাদানগুলি নিয়েও বিভক্ত করতে পারেন বা প্রতিবার বিভাজনটিকে এলোমেলো করেও দিতে পারেন।

এটি কোড-গল্ফ , তাই কোনও ভাষার সংক্ষিপ্ততম কোডটি বাইট জিতায় পরিমাপ করা।

পরীক্ষার মামলা

উপরে উল্লিখিত হিসাবে, আসল ফর্ম্যাট এবং তালিকা অর্ধেক বিভক্ত করার উপায় আপনার উপর নির্ভর করে।

[10,2]
[10][2]
[2,10]

[4,17,1,32]
[4,17][1,32]
[4][17][1][32]
[4,17][1,32]
[1,4,17,32]

[6,5,4,3,2,1]
[6,5,4][3,2,1]
[6,5][4][3,2][1]
[6][5][4][3][2][1]
[5,6][4][2,3][1] <- Important: This step cannot be [5,6][3,4][1,2], because 3 and 4 are on different branches in the the tree
[4,5,6][1,2,3]
[1,2,3,4,5,6]

code-golf array-manipulation sorting

— Laikoni
সূত্র

5

@ অল্লানান আপনি বাছাই করতে অন্য বাছাই করা অ্যালগরিদম বা বিল্ট ইন সাজানো ফাংশন ব্যবহার করতে পারেন ...

— flawr

5

কিছু গল্ফিং ধারণা: ফলাফলের নীচের অর্ধেকটি প্রতিটি উপ-তালিকাটি প্রথম অর্ধে বাছাই করে এবং ক্রমটিকে বিপরীত করে উত্পন্ন করা যায়।

— জংহওয়ান মিন

2

@ আরনাউল্ড [[1,2],[3],[4,5],[6]]পর্যায়টি আসলে সঠিক সমাধান, কারণ মার্জ সাজ্ট পুনরাবৃত্তভাবে কাজ করছে। এটি হ'ল যদি আমরা [1,2,3,4,5,6]এটির সাথে শুরু করি এবং এর মধ্যে বিভক্ত হয়ে যাই [1,2,3]এবং [4,5,6]তখন সেই তালিকাগুলি চূড়ান্ত পদক্ষেপে মার্জ না হওয়া অবধি স্বাধীনভাবে প্রক্রিয়া করা হবে।

— লাইকনি

2

@ l4m2 ঠিক আছে, উত্তরের জন্য চূড়ান্ত চেষ্টা করুন: 1. আপনার ডিলিমিটারগুলি প্রয়োজন কারণ এছাড়াও পূর্ণসংখ্যার> 9 সমর্থন করা উচিত। ২. উপরের আমার মন্তব্যে যেমন দেওয়া হয়েছে একই কারণে এটি বৈধ নয়। আমরা যদি বিভক্ত [3]এবং [2,1]তারপর, ঐ, বিভিন্ন শাখা রয়েছে তাই আমরা মার্জ করতে পারবেন না [3]এবং [2]পরে [2,1]বিভক্ত করা [2]এবং [1]।

— লাইকনি

1

আসলে তার পরে বাক্যটি আমার প্রশ্নের সঠিক উত্তর দেয়। মিস করার জন্য দুঃখিত। : পি

— জাগারব

8

হাস্কেল , 137 128 127 125 121 109 106 বাইট

^{(-2) + (- 4) = (- 6) বামি নিমিকে ধন্যবাদ ! তালিকার সমস্ত পদক্ষেপ সংগ্রহ করার জন্য এটি পরিবর্তন করা (নিমির কারণে আবার) আরও 12 টি বাইট সংরক্ষণ করে।}

^{লাইকোনির কারণে আরও 3 বাইট , প্যাটার্ন গার্ড বাঁধাই এবং গার্ডকে এনকোড করার জন্য তালিকা বোধগম্যতার একটি চতুর ব্যবহার সহ।}

import Data.List
g x|y<-x>>=h=x:[z|x/=y,z<-g y++[sort<$>x]]
h[a]=[[a]]
h x=foldr(\x[b,a]->[x:a,b])[[],[]]x

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

বিজোড় এবং এমনকি অবস্থানিক উপাদানগুলির মধ্যে তালিকাগুলি বিভক্ত করা দুটি ক্রমবর্ধমান অংশের তুলনায় একটি সংক্ষিপ্ত কোড, কারণ আমরা lengthতখন পরিমাপ করতে ছাড়ছি ।

তালিকাগুলি "মুদ্রণ" করে কাজ করে, তারপরে বিভক্ত তালিকার সাথে পুনরাবৃত্তি করে ( x >>= h) যদি সেখানে কোনও বিভাজন ঘটেছিল এবং সাজানো তালিকাগুলি "মুদ্রণ" করে; এক ইনপুট তালিকা দিয়ে শুরু; খালি খালি ইনপুট ধরে নিচ্ছি। এবং প্রকৃত মুদ্রণের পরিবর্তে কেবল তাদের একটি তালিকাতে সংগ্রহ করুন।

g[[6,5..1]]লাইন-বাই লাইন প্রিন্ট করা তালিকাটি হ'ল:

[[6,5,4,3,2,1]]
[[6,4,2],[5,3,1]]
[[6,2],[4],[5,1],[3]]
[[6],[2],[4],[5],[1],[3]]
[[2,6],[4],[1,5],[3]]
[[2,4,6],[1,3,5]]
[[1,2,3,4,5,6]]

— উইল নেস
সূত্র

1

... p=printএবং তিনবার p। এটি অনলাইন চেষ্টা করুন!

— নিমি

@ নিমিমি আবারও, এবং অনেক ধন্যবাদ! এখন এটি সত্যিই গল্ফ লাগছে । :)

— নেস

ফাংশনটির মধ্যে মুদ্রণের পরিবর্তে gআপনি একটি তালিকার সমস্ত পদক্ষেপ সংগ্রহ করে তা ফিরিয়ে দিতে পারেন। এটি অনলাইন চেষ্টা করুন!

— নিমি

3

আমি মনে করি না যে আমাদের "ভিজ্যুয়ালাইজিং" এর সঠিক সংজ্ঞা রয়েছে। আরও সাধারণ চ্যালেঞ্জগুলি তালিকাগুলিকে "আউটপুট" করার জন্য জিজ্ঞাসা করে এবং আমাদের ডিফল্ট অনুসারে এটি কোনও ফাংশনের রিটার্ন মান দ্বারা করা যেতে পারে । অন্যান্য উত্তর, উদাহরণস্বরূপ, 1 , 2 এটিও এইভাবে করুন। - আমি মনে করি না যে আমার পরামর্শটি এর চেয়ে অনেক আলাদা, এটি কেবলমাত্র মধ্যবর্তী তালিকাগুলি মুদ্রণের পরিবর্তে সংগ্রহ করে। এটি সম্পাদনা করতে নির্দ্বিধায়।

— নিমিম

3

g x|y<-x>>=h=x:[z|x/=y,z<-g y++[sort<$>x]]আরও কিছু বাইট সাশ্রয় করে।

— লাইকনি

7

ওল্ফ্রাম ভাষা (গণিত) , 146 127 111 102 বাইট

Join[u=Most[#/.a:{_,b=__Integer}:>TakeDrop[a,;;;;2]&~FixedPointList~#],Reverse@Most@u/.a:{b}:>Sort@a]&

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

Listপদক্ষেপগুলি ধারণ করে এমন একটি ফেরত দেয় ।

ব্যাখ্যা

#/.a:{_,b=__Integer}:>TakeDrop[a,;;;;2]&

একটি ইনপুটে, List2 বা ততোধিক পূর্ণসংখ্যাসহ সমস্ত গুলিকে অর্ধেকভাগে ভাগ করুন । প্রথম সাবলিস্টে বিজোড়-সূচকযুক্ত উপাদান রয়েছে (1-সূচকযুক্ত) এবং দ্বিতীয়টিতে সম-সূচকযুক্ত উপাদান রয়েছে।

u=Most[... &~FixedPointList~#]

কিছুই পরিবর্তন না হওয়া পর্যন্ত পুনরাবৃত্তি করুন (অর্থাত্ সমস্ত সাবলিস্ট দৈর্ঘ্য -1)। সমস্ত মধ্যবর্তী ফলাফল রাখুন। এটিকে ( Listসমস্ত পদক্ষেপের মধ্যে) সংরক্ষণ করুন u।

Reverse@Most@u

এর শেষ উপাদানটি ফেলে দিন uএবং বিপরীত করুন।

... /.a:{b}:>Sort@a

উপরের ফলাফল থেকে, পূর্ণসংখ্যার তালিকার সমস্ত উপস্থিতি বাছাই করুন।

— জংহওয়ান মিন
সূত্র

6

পরিষ্কার , 228 206 168 157 140 121 104 বাইট

প্রান্ত থেকে ভিতরের দিকে পর্যায়গুলির তালিকা তৈরি করে, প্রান্তটি nথেকে- nথিম উপাদানটি শুরু থেকেই-তম উপাদানটির বাছাই করা সংস্করণটি ব্যবহার করে ।

জংহওয়ান মিনের মন্তব্য থেকে আইডিয়া

import StdEnv
@u#(a,b)=splitAt(length u/2)u
=if(a>[])[[u]:[x++y\\y<- @b&x<- @a++ @a++ @a]][]++[[sort u]]

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

— Οurous
সূত্র

4

কাঠকয়লা , 145 133 123 122 বাইট

≔⟦⪪Ｓ ⟧θＷ⊖Ｌ§θ⁰«⟦⪫Ｅθ⪫κ ¦|⟧≔ＥＥ⊗Ｌθ§θ÷λ²✂κ﹪λ²Ｌκ²θ»⟦⪫ΦＥθ⪫ι ι|⟧Ｗ⊖Ｌθ«≔⮌θη≔⟦⟧θＷη«≔⊟ηε≔⟦⟧ζＦ⊟η«≔εδ≔⟦⟧εＦδ⊞⎇‹ＩμＩλζεμ⊞ζλ»⊞θ⁺ζε»⟦⪫Ｅθ⪫κ ¦|

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ~~চারকোল বাগের চারপাশে এখনও কাজ করতে হচ্ছে ...~~ সম্পাদনা: Mapদরিদ্র ব্যক্তির অ্যারে বোধগম্যতা হিসাবে ডাবল ব্যবহার করে 5 বাইট সংরক্ষণ করা হয়েছে । Popএকটি অ্যারের উপর দ্বিগুণ পুনরাবৃত্তি করতে ব্যবহার করে 4 বাইট সংরক্ষণ করা হয়েছে। পরিবর্তে কনকনেটেশন ব্যবহার করে 3 বাইট সংরক্ষণ করা হয়েছে Push। একটি গল্ফিয়ার whileশর্ত নিয়ে এসে 10 বাইট সংরক্ষণ করা হয়েছে যা চারকোল বাগটিও এড়িয়ে চলে। চারকোলের প্রকৃতপক্ষে একটি ফিল্টার অপারেটর রয়েছে তা আবিষ্কার করে 1 বাইট সংরক্ষণ করা হয়েছে। ব্যাখ্যা:

≔⟦⪪Ｓ ⟧θ

স্পেসগুলিতে ইনপুটটি বিভক্ত করুন এবং তারপরে ফলাফলটি একটি বাহ্যিক অ্যারেতে মোড়ানো করুন q।

Ｗ⊖Ｌ§θ⁰«

প্রথম উপাদানের qএকাধিক উপাদান থাকা অবস্থায় পুনরাবৃত্তি করুন । ( qতালিকাগুলিকে যেভাবে দুটি ভাগে ভাগ করা হয়েছে তার কারণে সর্বদা প্রথম উপাদানটির সর্বাধিক উপাদান থাকে))

⟦⪫Ｅθ⪫κ ¦|⟧

qফাঁকা স্থান এবং উল্লম্ব লাইনগুলির সাথে যোগদানের উপাদানগুলি মুদ্রণ করুন । (অ্যারে ফলাফলটি তার নিজস্ব লাইনে মুদ্রণ করে তোলে same একই বাইট গণনার জন্য এটি অর্জনের অন্যান্য উপায় রয়েছে))

≔ＥＥ⊗Ｌθ§θ÷λ²✂κ﹪λ²Ｌκ²θ»

প্রতিটি উপাদানের নকল করে একটি তালিকা তৈরি করুন q, তারপরে সেই তালিকাটিতে ম্যাপ করুন এবং ফলাফলটি আবার সংরক্ষণ করে প্রতিটি তালিকার অর্ধেক (বিকল্প উপাদান পদ্ধতির ব্যবহার করে) নিন q।

⟦⪫ΦＥθ⪫ι ι|⟧

qফাঁকা স্থান এবং উল্লম্ব লাইনগুলির সাথে যোগদানের উপাদানগুলি মুদ্রণ করুন । প্রকৃতপক্ষে, এই মুহুর্তে উপাদানগুলি qহয় ফাঁকা বা একক উপাদানগুলির তালিকা হয়, সুতরাং এগুলিতে যোগদান করা কেবল খালি স্ট্রিং বা তাদের উপাদানগুলিতে রূপান্তর করে। খালি স্ট্রিংগুলি অপ্রয়োজনীয় ট্রেইলিং লাইন যুক্ত করবে যাতে সেগুলি ফিল্টার আউট হয়। একটি সমতল অপারেটর যদিও (যেমন কিছু ⟦⪫Σθ|⟧) গল্ফিয়ার হত ।

Ｗ⊖Ｌθ«

qএকাধিক উপাদান থাকা অবস্থায় পুনরাবৃত্তি করুন । (নিম্নলিখিত কোডের জন্য সংখ্যক উপাদানগুলির প্রয়োজন))

≔⮌θη≔⟦⟧θ

অনুলিপি qকরুন h, তবে বিপরীত হয়েছে (নীচে দেখুন) এবং qখালি তালিকায় পুনরায় সেট করুন ।

Ｗη«

hখালি না হওয়া পর্যন্ত পুনরাবৃত্তি করুন ।

≔⊟ηε

পরবর্তী উপাদান এক্সট্র্যাক্ট hমধ্যে e। ( Popশেষ থেকে নিষ্কাশন, এজন্য আমাকে বিপরীত করতে হবে q))

≔⟦⟧ζ

ইনিশিয়ালাইজ zএকটি খালি লিস্টে।

Ｆ⊟η«

এর পরবর্তী উপাদানের উপাদানগুলির উপর লুপ করুন h।

≔εδ≔⟦⟧ε

অনুলিপি eকরুন dএবং eখালি তালিকায় পুনরায় সেট করুন ।

Ｆδ

এর উপাদানগুলির উপর লুপ করুন d।

⊞⎇‹ＩμＩλζεμ

তাদের পরবর্তী ধরণের বর্তমান উপাদানের তুলনায় ছোট কিনা তার উপর নির্ভর করে zবা তাদের eউপর চাপ দিন h।

⊞ζλ»

পরবর্তী উপাদান বর্তমান উপাদান পুশ hকরার z।

⊞θ⁺ζε»

CONCATENATE zকোনো অবশিষ্ট উপাদানের সঙ্গে eএবং ধাক্কা যে q। এটি দুটি উপাদানের একত্রীকরণ সম্পূর্ণ করে h।

⟦⪫Ｅθ⪫κ ¦|

qফাঁকা স্থান এবং উল্লম্ব লাইনগুলির সাথে যোগদানের উপাদানগুলি মুদ্রণ করুন ।

— নিল
সূত্র

লেগে থাকা. আর একটি বাগ আছে? : /

— ASCII- কেবল

@ এএসসিআইআই-না, এটি while (...Map(...)...)আমি আপনাকে ইতিমধ্যে জানিয়েছি যে বাগটি।

— নিল

3

পাইথন 2 , 145 144 বাইট

^{জংহওয়ান মিনের মন্তব্য}^{-১ বাইট জোনাথন}^{ফ্রেচের}^{পক্ষ থেকে}
^{ধন্যবাদ}

p=input()
l=[[p]]
i=0
while 2**i<len(p):l[i+1:i+1]=[sum([[x[1::2],x[::2]][len(x)<2:]for x in l[i]],[]),map(sorted,l[i])];i+=1
for s in l:print s

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

— যষ্টি
সূত্র

আমি সম্পূর্ণরূপে নিশ্চিত নই, যদিও আপনি তার <2পরিবর্তে ব্যবহার করতে সক্ষম হতে পারেন==1 ।

— জোনাথন ফ্রেচ

2

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

f=a=>a.join`|`+(a[0][1]?`
${f([].concat(...a.map(b=>b[1]?[b.slice(0,c=-b.length/2),b.slice(c)]:[b])))}
`+a.map(b=>b.sort((x,y)=>x-y)).join`|`:``)

একটি অ্যারের মধ্যে অ্যারের হিসাবে ইনপুট নেয়, অর্থাত্‍ f([[6,5,4,3,2,1]])। প্রতিটি উপ-অ্যারের দৈর্ঘ্য না হওয়া পর্যন্ত আউটপুটটির প্রথম এবং শেষ লাইনগুলি তৈরি করে, তারপরে বিভাজন এবং নিজেকে আবার কল করে কাজ করে Works

f([[6,5,4,3,2,1]]):
  6,5,4,3,2,1
  f([[6,5,4],[3,2,1]]):
    6,5,4|3,2,1
    f([[6,5],[4],[3,2],[1]]):
      6,5|4|3,2|1
      f([[6],[5],[4],[3],[2],[1]]):
        6|5|4|3|2|1
      end f
      5,6|4|2,3|1
    end f
    4,5,6|1,2,3
  end f
  1,2,3,4,5,6
end f

— ETHproductions
সূত্র

2

সুতরাং, সেখানে এমন একটি বিন্দু ছিল যেখানে 145 বাইটে তিনটি উত্তর বাঁধা ছিল?

— নীল

2

কাস্তে , 14 বাইট

S+ȯ†O↔hUmfL¡ṁ½

একটি একক অ্যারে সমন্বিত একটি অ্যারে নেয়। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

S+ȯ†O↔hUmfL¡ṁ½  Implicit input, say A = [[4,17,32,1]].
           ¡    Iterate this function on A:
            ṁ½   Split each array in two, concatenate results: [[4,17],[32,1]]
                Result is [[[4,17,32,1]],
                           [[4,17],[32,1]],
                           [[4],[17],[32],[1]],
                           [[4],[],[17],[],[32],[],[1],[]],
                           ...
        mfL     Map filter by length, removing empty arrays.
                Result is [[[4,17,32,1]],
                           [[4,17],[32,1]],
                           [[4],[17],[32],[1]],
                           [[4],[17],[32],[1]],
                           ...
       U        Longest prefix of unique elements:
                       P = [[[4,17,32,1]],[[4,17],[32,1]],[[4],[17],[32],[1]]]
      h         Remove last element: [[[4,17,32,1]],[[4,17],[32,1]]]
     ↔          Reverse: [[[4,17],[32,1]],[[4,17,32,1]]]
   †O           Sort each inner array: [[[4,17],[1,32]],[[1,4,17,32]]]
S+ȯ             Concatenate to P:
                           [[[4,17,32,1]],
                            [[4,17],[32,1]],
                            [[4],[17],[32],[1]],
                            [[4,17],[1,32]],
                            [[1,4,17,32]]]
                Implicitly print.

অন্তর্নির্মিত ½একটি অ্যারে নেয় এবং এটি মাঝখানে বিভক্ত হয়। যদি এর দৈর্ঘ্য বিজোড় হয় তবে প্রথম অংশটি একটি উপাদান দ্বারা দীর্ঘ হয়। একটি সিঙ্গলটন অ্যারে [a]ফলাফল [[a],[]]এবং একটি খালি অ্যারে []দেয় [[],[]], তাই প্রয়োগ করার আগে খালি অ্যারেগুলি সরানো প্রয়োজন U।

— Zgarb
সূত্র

1

স্ট্যাক্স , 116 (÷ 3>) 38 29 বাইট ^{সিপি 437}

@ রিচার্জ দ্বারা মন্তব্য -9 বাইট। এখন ইনপুটটি সিঙ্গেলটন হিসাবে দেওয়া হয়েছে যার একমাত্র উপাদান বাছাই করা সংখ্যার একটি অ্যারে।

ƒ3s}óºE/ßB╢↕êb∩áαπüµrL╞¶è,te+

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

35 বাইট সহ আনপ্যাক করা সংস্করণ:

{c{Jm'|*Pc{2Mm:f{fc{Dm$wW{{eoJm'|*P

ব্যাখ্যা

কোডটি দুটি ভাগে ভাগ করা যায়। প্রথম অংশটি বিভাজনের দৃশ্য এবং দ্বিতীয়টি সংশ্লেষের কল্পনা করে।

বিভাজক কল্পনা করার কোড:

{                      w    Do the following while the block generates a true value
 c                          Copy current nested array for printing
  {Jm                       Use spaces to join elements in each part
     '|*                    And join different parts with vertical bar 
        P                   Pop and print

         c                  Copy current nested array for splitting
          {2Mm              Separate each element of the array to two smaller parts with almost the same size
                                That is, if the number of elements is even, partition it evenly.
                                Otherwise, the first part will have one more element than the second.
              :f            Flatten the array once
                {f          Remove elements that are empty arrays

                  c         Copy the result for checking 
                   {Dm$     Is the array solely composed of singletons?
                            If yes, ends the loop.

মার্জ করার জন্য ভিজ্যুয়ালাইজ করার কোড:

W              Execute the rest of the program until the stack is empty
 {{eoJm        For each part, sort by numeric value, then join with space
       '|*     Join the parts with vertical bar
          P    Pop and print the result

পুরানো সংস্করণ, আসলে নেস্টেড তালিকার কাঠামো তৈরি করছে।

{{cc0+=!{x!}Mm',*:}}Xd;%v:2^^{;s~{c^;<~sc%v,*{2M{s^y!svsm}M}YZ!x!Q,dmU@e;%v:2^{;%v:2^-N~0{c;={scc0+=Cc%v!C:f{o}{scc0+=C{s^y!svsm}?}Y!cx!P,dcm

cc0+= স্ট্যাকের শীর্ষটি কোনও স্কেলার বা অ্যারে কিনা তা যাচাই করতে কোডটিতে তিনবার ব্যবহার করা হয়।

{{cc0+=!{x!}Mm',*:}}Xএমন একটি ব্লক তৈরি করে যা পুনরাবৃত্তভাবে নিজেকে সংখ্যার নেস্টেড অ্যারে আউটপুট করতে ডাকে। (স্টেক্সে ডিফল্ট আউটপুট প্রিন্টিংয়ের আগে নেস্টেড অ্যারেটিকে ভেক্টরাইজ করে)।

{                  }X    Store the code block in X
 {           m           Map each element in the list with block
  cc                     Make two copies of the element
    0+                   + 0. If the element is a scalar, nothing will change
                              If the element is an array, the element 0 will be appended
      =!{  }M            If the element has changed after the `0+` operation
                             Which means it is an array
         x!              Recursively execute the whole code block on the element

              ',*        Join the mapped elements with comma
                 :}      Bracerizes the final result

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

— ওয়েইজুন ঝো
সূত্র

খুব সুন্দর উন্নতি। আমি এখনও এটি পুরোপুরি বুঝতে পারি না, তবে আমি মনে করি cH!এর জায়গায় ব্যবহার করা যেতে পারে cH%!।

— পুনরাবৃত্তি

{Nd}Mদ্বারা প্রতিস্থাপন করা যেতে পারে T।

— পুনরাবৃত্তি

আমি আরও কিছু অভিযোজন করেছি। staxlang.xyz/… হুশ উত্তর একটি অ্যারে হিসাবে অ্যারে হিসাবে ইনপুট নেয়, তাই আমি অনুমান করি যে এটি আইনী।

— পুনরাবৃত্তি

আমি একটি সমাধান পেয়েছি যা 2 টি এসকিআই অক্ষর কম হওয়া উচিত, তবে আমি অ্যারে ট্রান্সপোজে একটি বাগ আবিষ্কার করেছি। বিশেষত, এটি অ্যারে সারিগুলিকে পরিবর্তিত করে। আমি এটি 1.0.4

— 25:38

ঠিক আছে. আমি আপডেটের অপেক্ষায় আছি

— ওয়েইজুন চিউ

মার্জ বাছাইয়ের ভিজ্যুয়ালাইজ করুন

কাজটি

পরীক্ষার মামলা

হাস্কেল , 137 128 127 125 121 109 106 বাইট

ওল্ফ্রাম ভাষা (গণিত) , 146 127 111 102 বাইট

ব্যাখ্যা

পরিষ্কার , 228 206 168 157 140 121 104 বাইট

কাঠকয়লা , 145 133 123 122 বাইট

পাইথন 2 , 145 144 বাইট

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

কাস্তে , 14 বাইট

ব্যাখ্যা

স্ট্যাক্স , 116 (÷ 3>) 38 29 বাইট সিপি 437

ব্যাখ্যা

পুরানো সংস্করণ, আসলে নেস্টেড তালিকার কাঠামো তৈরি করছে।

স্ট্যাক্স , 116 (÷ 3>) 38 29 বাইট ^{সিপি 437}