কোনও বিল্ট-ইন বাছাই পদ্ধতি ব্যবহার না করে স্ট্রিংগুলির তালিকা বাছাই করা

Question

এই কোড গল্ফের লক্ষ্য হ'ল এমন একটি প্রোগ্রাম তৈরি করা যা কোনও বিল্ট-ইন বাছাইয়ের পদ্ধতি ব্যবহার না করে স্ট্রিংগুলির একটি তালিকা (আরোহী ক্রমে) বাছাই করে (যেমন পিএইচপি Array.Sort()তে। নেট sort(), ...)। নোট করুন যে এই বিধিনিষেধটি বিল্ট-ইন পদ্ধতি ব্যবহার করে বাদ দেয় যা একটি অ্যারে অবতরণ করে এবং তারপরে অ্যারেটিকে বিপরীত করে।

কিছু বিশদ:

• আপনার প্রোগ্রামটি ইনপুটটির জন্য প্রম্পট করবে এবং এই ইনপুটটি কেবলমাত্র ASCII লোয়ার-কেস বর্ণমালার অক্ষরযুক্ত স্ট্রিংগুলির তালিকা a-z, ফাঁকা জায়গা ছাড়াই কমা দ্বারা পৃথক। উদাহরণ স্বরূপ:

  code,sorting,hello,golf
  

• আউটপুটটি স্ট্রিংগুলির প্রদত্ত তালিকা হওয়া উচিত, তবে আরোহী ক্রমে সাজানো, ফাঁকা স্থান ছাড়াই কমা দ্বারা পৃথক separated উদাহরণ স্বরূপ:

  code,golf,hello,sorting
  

Answer 1

গল্ফস্ক্রিপ্ট, 26 25 বাইট

","/.,{{.2$<{\}*}*]}*","*

বুদ্বুদ বাছাইয়ের সোজাসুজি বাস্তবায়ন

ওয়েব গল্ফস্ক্রিপ্ট এ এটি অনলাইন চেষ্টা করুন ।

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

","/     # Split the input string at commas.
.,       # Get the number of chunks.
{        # Do that many times:
  {      #   Reduce; for each element but the first:
    .2$< #     Push 1 if the last two strings are in descending order, 0 if not.
    {\}* #     Swap these strings that many times.
  }*]    #   Collect the strings dumped by reduce in an array.
}*       #
","*     # Join, separating by commas.

Comments

নিস! এটিকে উত্তর হিসাবে গ্রহণ করা কারণ এটি বর্তমানে গৃহীত প্রশ্নের চেয়ে কম।

— প্রোগ্রামফক্স

Answer 2

রুবি 76 54 51 চর

x=gets.scan /\w+/;$><<x.dup.map{x.delete(x.min)}*?,

Comments

খুব সুন্দর, বোগোসর্ট : ডি

— ডোরকনব

বাহ, এখন এটি আরও আকর্ষণীয়! কী হচ্ছে তা বুঝতে পেরে আমাকে কিছুক্ষণ এটি দেখতে হয়েছিল। আমি মনে করি এখন এটি নির্বাচনের ধরণের সামান্যতম প্রকরণ: পি

— ডোরকনব

যেহেতু আইটেমগুলি আলফা অক্ষর হওয়ার গ্যারান্টিযুক্ত:x=gets.scan /\w+/

— স্টিভেন রাম্বালস্কি

Answer 3

কে (১rs টি অক্ষর)

সম্ভবত সমস্যার চেতনা অবলম্বন করে না। কে-তে, বাছাই করা অপারেটর নেই। <xসাজানো ক্রমে x এর আইটেমের সূচকের একটি তালিকা প্রদান করে।

{x@<x}[","\:0:0]

Comments

ভাল, এটি এক ধরণের অন্তর্নির্মিত বাছাই, সুতরাং দুর্ভাগ্যক্রমে, আমি এটিকে উত্তর হিসাবে চিহ্নিত করতে পারি না। আমি যদিও ধারণাটি পছন্দ করি তাই +1!

— ProgramFOX

Answer 4

এসইডি, 135

s/.*/,&,!,abcdefghijklmnopqrstuvwxyz/;:;s/\(,\([^,]*\)\(.\)[^,]*\)\(.*\)\(,\2\(.\)[^,]*\)\(.*!.*\6.*\3\)/\5\1\4\7/;t;s/^,\(.*\),!.*/\1/

আমার পূর্ববর্তী বাছাই প্রবেশের উপর ভিত্তি করে

Answer 5

রুবি, ৯৯ টি চর ( জিনোম সাজান )

a=gets.scan /\w+/
p=1
while a[p]
a[p]>a[p-1]?p+=2:(a[p],a[p-1]=a[p-1],a[p])
p-=1if p>1
end
$><<a*?,

এটি সবেমাত্র আমার বুদ্বুদ সাজানোর প্রয়োগকে মারধর করে:

রুবি, 110 104 101 অক্ষর ( বুদ্বুদ সাজান )

s=gets.scan /\w+/
(z=s.size).times{(0..(z-2)).map{|i|s[i],s[i+1]=s[i+1],s[i]if s[i]>s[i+1]}}
$><<s*?,

এটি list.lengthপুনরাবৃত্তি করে, কারণ সবচেয়ে খারাপ ক্ষেত্রে দৃশ্যের list.length - 1পুনরাবৃত্তি হয় এবং আরও একটিতে সত্যিকার অর্থে কিছু আসে যায় না এবং 2 টি অক্ষর সংরক্ষণ করে।

কেবল মজাদার জন্য, একটি কুইকোর্টের সংস্করণ:

রুবি, ১১৩ টি চর ( কুইকোর্ট )

q=->a{if a[1]
p=a.shift
l=[]
g=[]
a.map{|x|(x>p ?g:l).push x}
q[l]+[p]+q[g]
else
a
end}
$><<q[gets.scan /\w+/]*?,

Comments

আমি দেখেছি যে ইনপুট আইটেমগুলি সমস্ত অনন্য নয়, যেমন জিনোম সাজানোর এই প্রয়োগটি অসীমভাবে লুপ করে।

— স্কট লিডলি

Answer 6

হাস্কেল, 141

import Data.List
m=minimum
s[]=[]
s l=m l:s(l\\[m l])
t[]=[]
t s=let(a,b)=span(/=',')s in a:t(drop 1 b)
main=interact$intercalate",".s.t.init

কমপক্ষে এটি ... দক্ষ সাজানোর ।

Comments

আপনি বাছাই বাছাই করে 11 টি অক্ষর সংরক্ষণ করতে পারেন: m=minimum s[]=[] s l=m l:(s$l\\[m l])(এই লাইনগুলির সাথে আপনার লাইনগুলিকে 2–4 প্রতিস্থাপন করুন)।

— ব্যবহারকারী 3389669

initসেখানে তন্ন তন্ন একটি trailing নিমিত্ত আবশ্যক বলে মনে হচ্ছে না ,, কিংবা একটি trailing সম্পর্কে newline। t s=let(a,b)=span(/=',')s in a:t(drop 1 b), একটি প্যাটার্ন পাহারা ব্যবহার ব্যবহার করে সংক্ষিপ্ত করা যেতে পারে (>',')এবং তাদের মধ্যে স্থান ড্রপ 1 b: t s|(a,b)<-span(>',')s=a:t(drop 1b)।

— লাইকনি

সন্নিবেশ ফাংশন সহ সন্নিবেশ ব্যবহার x#(y:r)|y<x=y:x#r;x#r=x:rকরা সংক্ষিপ্ত। এটি সরাসরি ব্যবহার করা যেতে পারে tএবং এটি ব্যবহার না করে (\\)এবং intercalate","প্রতিস্থাপন করা যেতে পারে tail.((',':)=<<), আমদানি বাদ দেওয়া যেতে পারে। সব মিলিয়ে 101 বাইট: এটি অনলাইনে চেষ্টা করুন!

— লাইকনি

Answer 7

ভিবিএ, 165

Sub q()
c=","
s=InputBox("?")
Z=Split(s, c)
t=UBound(Z)
For i=1 To t-1
For j=i To t
If Z(i)>Z(j) Then a=Z(i):Z(i)=Z(j):Z(j)=a
Next
Next
Debug.Print Join(Z,c)
End Sub

Comments

আমি 165 টি অক্ষর গণনা করছি ...

— ডুরকনব

@ ডুরকনব, স্থির গণনা ... গ্রীস্মোনকি স্ক্রিপ্ট স্পষ্টতই আমাকে কোডটি টাইপ করার সময় আমাকে ভুল গণনা দিয়েছিল।

— শনক

আপনি যে কোনও জায়গা থেকে মুক্তি পেতে পারেন Split।

— রাই-

দুবার ব্যবহার c=","এবং কল cকরা আসলে এই ক্ষেত্রে বাইট কাউন্টে যুক্ত হয়, বাইট গণনায় 7 বাইট অবদান রাখে, যেখানে কেবল "," দুবার ব্যবহার করলে 6 বাইট অবদান থাকবে। উপ কল ( sub q(s)) থেকে সরাসরি ইনপুট নিয়ে এবং বাম ধরণের ভেরিয়েন্ট \ স্ট্রিং ধরে ধরে ধরে আপনি আপনার বাইট কোডটি হ্রাস করতে পারেন । এতে পরিবর্তন করে For i=1 toআপনি আরও একটি বাইট হারাতে পারেন for i=1To। আপনি পরিবর্তন করে 5 বাইট হারাতে পারেন Debug.Print Join...করতেDebug.?Join...

— টেলর স্কট

Answer 8

স্কালা, 122 বাইট

ওয়ান-লাইনার হিসাবে (88 বাইট):

.permutations.filter(_.sliding(2).map(w=>w(0)<w.last).fold(true)((a,b)=>a&&b)).toSeq(0)

(এটি কেবল করে একটি তালিকা বাছাই করবে list.permutations.fil...)

প্রোগ্রাম হিসাবে (122 বাইট):

println(readLine.split(",").toSeq.permutations.filter(_.sliding(2).map(w=>w(0)<w.last).fold(true)((a,b)=>a&&b)).toSeq(0))

আপনি যদি এটি স্টিন থেকে পড়তে চান তবে একটি দীর্ঘ সংস্করণ।

প্রদত্ত তালিকার সমস্ত ক্রিয়াকলাপের উপরে এটি পুনরাবৃত্তি করে যতক্ষণ না এটি সাজানো কোনওর উপর হোঁচট খায় না। এটি 10 ​​টি উপাদান তালিকার বাছাই করতে প্রায় 12 সেকেন্ড সময় লাগে এবং 11 উপাদানগুলির জন্য এক মিনিটেরও বেশি সময় লাগে না fast

[সম্পাদনা] আইটেমগুলি অনন্য <হতে হবে বা এটি দ্বারা প্রতিস্থাপন করা যেতে পারে <=। এছাড়াও, নেক্রো জন্য দুঃখিত।

Answer 9

জাভাস্ক্রিপ্ট 128

a=prompt().split(',');b=[];for(i in a){b.push(a[i]);k=0;for(j in b){j=k;b[j]>a[i]?[c=b[j],b.splice(j,1),b.push(c)]:k++}}alert(b)

ডেমো ভাজা ।

আমি একটি উপায় নির্মূল করার জন্য খোঁজ করছি b।

Comments

2 টি চর সংরক্ষণ করার []পরে অংশটির চারপাশে সরিয়ে ফেলুন?

— ডুরকনব

@ ডুরকনব আমি পাওয়ার আগেই এটি চেষ্টা করেছি SyntaxError: missing : in conditional expressionকারণ ?:;(শর্টহ্যান্ড if/else) ব্যবহার করার জন্য কেবল দুটি পিসি কোড নেওয়ার কথা (যেমন true?b++:b--;) ব্যবহার করা হচ্ছে [, ]এটি একটি হ্যাক, কেন এখনও এটি নিশ্চিতভাবে নিশ্চিত না যে এটি কেন কাজ করে, আমি মনে করি এটি খালি অ্যারে হিসাবে বোঝে ঘোষণা, একটি স্ট্যান্ড-অ্যালোন কমান্ড হিসাবে একটি এলোমেলো স্ট্রিং বা সংখ্যা স্থাপন মত। তবে আপনি এখনও নির্দ্বিধায় মুক্ত মনে করতে পারেন।

— ম্যাথ চিলার

হুম, আমি মনে করি আমার ভুল হয়েছে। কমা অপারেটর একবারে একাধিক কোডের টুকরোগুলি কার্যকর করতে পারে। প্রথম বন্ধনী ব্যবহার করে কাজ করে, তাই আমি মনে করি ?:অপারেটরের প্রাধান্য কম,

— ডোরকনব

না, আপনি চেষ্টা করেছেন? পেরেনথেসিস এখনও কাজ করে ...

— ডোরকনব

@ ডোরকনব আপনার অধিকার , যদিও আমি চেষ্টা করেছিলাম {, }এবং এটি কার্যকর হয়নি - আমি পেয়েছি SyntaxError: missing : after property id। অগ্রাধিকার প্রথম বন্ধনী হিসাবে সর্বদা প্রথম। আমি এখনও একটি উত্সাহ চাই ...

— ম্যাথ চিলার

Answer 10

পিএইচপি 83 বাইট

<?for($x=fgetcsv(STDIN);$x;)${$x[0]>min($x)?x:a}[]=array_shift($x)?><?=join(~Ó,$a);

একটি হে (ঢ ³ ) একটি নির্বাচন সাজানোর বাস্তবায়ন। Óচরিত্র 211 হয়; বিট-ইনভার্টেড কমা।

নমুনা ব্যবহার:

$ more in.dat
code,sorting,hello,golf

$ php list-sort.php < in.dat
code,golf,hello,sorting

Answer 11

পাইথন 3 (80 টি চর)

l=input().split(',')
m=[]
while l:m+=[l.pop(l.index(min(l)))]
print(','.join(m))

সমতুল্য দৈর্ঘ্যের সময়-বিবৃতিটির এখানে একটি পরিবর্তন রয়েছে:

while l:x=min(l);m+=[x];l.remove(x)

Answer 12

ম্যাথামেটিকাল 66 56

Row[#[[Ordering@#]]&[InputString[]~StringSplit~","],","]

বিল্ট-ইন প্রতীক ছাড়া অন্য কিছু সমাধান Ordering:

বোগোসর্ট: 84 74

NestWhile[RandomSample,InputString[]~StringSplit~",",!OrderedQ@#&]~Row~","

বুদ্বুদ বাছাই করুন: 93 83

Row[InputString[]~StringSplit~","//.{x___,i_,j_,y___}/;j~Order~i==1:>{x,j,i,y},","]

বোগোসর্টের মতো অদক্ষতার মতো আর একটি সমাধান: 82 72

#~Row~","&/@Permutations[InputString[]~StringSplit~","]~Select~OrderedQ;

Answer 13

পাইথন 3.5+, 73 বাইট

এটি স্টিভেন রাম্বালস্কির উত্তর থেকে অনুপ্রেরণা গ্রহণ করে তবে কিছু সময়ের জন্য লুপের পরিবর্তে তালিকা বোঝার ব্যবহার করে; পুনরাবৃত্তির সংখ্যা অনুলিপি করা তালিকা থেকে আসে lযার জন্য এটি অতিরিক্ত আনপ্যাকিং সাধারণীকরণ এবং পাইথন 3.5 এর প্রয়োজন হয়

l=input().split(',');print(*[l.pop(l.index(min(l)))for _ in[*l]],sep=',')

Answer 14

আর

বুদ্বুদ বাছাই করুন: 122 118 টি অক্ষর

a=scan(,"",sep=",");h=T;while(h){h=F;for(i in 1:(length(a)-1)){j=i+1;if(a[i]>a[j]){a[j:i]=a[i:j];h=T}}};cat(a,sep=",")

বোগোসর্ট: 100 টি অক্ষর

a=scan(,"",sep=",");while(any(apply(embed(a,2),1,function(x)x[1]<x[2]))){a=sample(a)};cat(a,sep=",")

Answer 15

পার্ল, 159

perl -F"," -lape "$m=$m<length()?length():$m for@F;$_{10**(2*$m)*sprintf'0.'.'%02d'x$m,map-96+ord,split//}=$_ for@F;$_=join',',map$_{$_+0},grep exists$_{$_+0},'0'.1..'0'.10**100"

এটি কখনও জয়ের সুযোগ দাঁড়ায়নি, তবে এটিকে ভাগ করে নেওয়ার সিদ্ধান্ত নিয়েছে কারণ আমি যুক্তিটি পছন্দ করলেও এটি গোলমাল করলেও :) এর পেছনের ধারণাটি হ'ল প্রতিটি শব্দকে একটি পূর্ণসংখ্যায় রূপান্তর করা ( অর্ড ফাংশনটি ব্যবহার করে ), আমরা সংখ্যাটি সংরক্ষণ করি একটি হ্যাশটির মূল কী এবং মান হিসাবে স্ট্রিং, এবং তারপরে আমরা সমস্ত সংখ্যার মাধ্যমে ক্রমবর্ধমান পুনরাবৃত্তি করি (এই ক্ষেত্রে 1..10 ** 100) এবং সেইভাবে আমরা আমাদের স্ট্রিংগুলি বাছাই করি।

সতর্কতা : আপনার কম্পিউটারে এই কোডটি চালাবেন না, যেহেতু এটি ট্রিলিয়ন + ইন্টিজারের মধ্য দিয়ে যায়। আপনি যদি এটি পরীক্ষা করতে চান তবে আপনি উপরের সীমার সীমাটি এবং ইনপুট দীর্ঘ-দৈর্ঘ্যের স্ট্রিংগুলি কম করতে পারেন। যদি কোনও কারণে এটি নিয়মের বিরুদ্ধে থাকে তবে দয়া করে আমাকে জানান এবং আমি প্রবেশটি মুছব!

Answer 16

জেএস: 107 অক্ষর - বুদ্বুদ বাছাই করুন

a=prompt().split(/,/);for(i=a.length;i--;)for(j=0;j<i;)a[j]>a[j+1]?[b=a[j],a[j]=a[++j],a[j]=b]:j++;alert(a)

আমি @ ট্রাইজিটপ্রোগ্রামিংসট্রাইটের উত্তরের দিকে চেয়েছি এবং এটি উন্নত করার চেষ্টা করেছি, তবে কিছুটা ভিন্নভাবে এটি প্রয়োগ করে শেষ করেছি।

Answer 17

জাভা, 134 বাইট

জিনোম বাছাই কার্যকর করে এমন একটি পদ্ধতি।

void s(String[]a){int m=a.length-1,i=0;while(i<m){while(i>=0&&a[i].compareTo(a[i+1])>0){String t=a[i];a[i]=a[i+1];a[i+1]=t;i--;}i++;}}

Answer 18

সুইফট, 101 বাইট

func s(a:[String])->[String]{return a.count<2 ? a:(s(a.filter{$0<a[0]})+[a[0]]+s(a.filter{$0>a[0]}))}

Ungolfed:

//quicksort
func sort(a:[String]) -> [String]
{
    //return the array if its length is less than or equal to 1
    if a.count <= 1
    {
        return a
    }
    //choose the first element as pivot
    let pivot = a[0]
    //retrieve all elements less than the pivot
    let left = a.filter{ $0 < pivot }
    //retrieve all elements greater than the pivot
    let right = a.filter{ $0 > pivot }
    //sort the left partition, append a new array containing the pivot,
    //append the sorted right partition
    return sort(left) + Array<String>(arrayLiteral: pivot) + sort(right)
}

Comments

এটি প্রদত্ত কমা-বিচ্ছিন্ন বিন্যাসে স্ট্রিংগুলি গ্রহণ করে না এবং ফেরত দেয় না।

— লাইকনি

Answer 19

𝔼𝕊𝕄𝕚𝕟, 24 টি অক্ষর / 30 বাইট (অযৌক্তিক)

ï⇔Ĕ⍪;↻ïꝈ)ΞÿѨŗ ï,⇀$≔МƵï;Ξ

Try it here (Firefox only).

নির্বাচনের ধরণের ব্যবহার!

ব্যাখ্যা

ï⇔Ĕ⍪;↻ïꝈ)ΞÿѨŗ ï,⇀$≔МƵï;Ξ // implicit: ï=input, Ξ=[]
ï⇔Ĕ⍪;                    // split ï along commas and set it to ï
     ↻ïꝈ)                // while ï's length > 0
         Ξÿ              // push to Ξ:
           Ѩŗ ï,⇀$≔МƵï;  // removed minimum item(s) from ï using builtin
                       Ξ // get sorted array

মূলত পুনরাবৃত্তির সাথে ইনপুট থেকে অন্য অ্যারেতে সর্বনিম্ন সরানো হয় এবং পুশ করে।

Answer 20

সিলোন (বোগোসর্ট), 119

String s(String i)=>",".join([*i.split(','.equals)].permutations.select((p)=>!any{for([x,y]in p.paired)y<x})[0]else[]);

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

আমি permutationsপদ্ধতিটি পেয়েছি এবং এভাবে বোগোসর্ট (একটি নন-র্যান্ডম ভেরিয়েন্ট) দিয়ে শেষ হয়েছিল।

ফর্ম্যাট এবং মন্তব্য:

// a function `s` mapping a String `i` to a String
String s(String i) =>
    // the end result is created by joining the iterable in (...).
    ",".join(
        // take the input, split it on commas, make the result a sequence.
        [*
            i.split(','.equals)   // → {String+}
           ]                      // → [String+]
        // get the iterable of all permutations of this sequence.
        // Yes, this is an iterable of O(n!) sequences (though likely
        // lazily computed, we don't need all in memory at once).
        .permutations              // → {[String+]*}
        // filter this iterable for ordered sequences.
        // Using select instead of filter makes this
        // eager instead of lazy, so we are actually iterating
        // through all n! sequences, and storing the ordered
        // ones. (All of those are equal.)
        .select(
            // this is our function to check whether this sequence
            // is ordered in ascending order.
            (p)=>
               // return if none of the following iterable of booleans is true.
                !any {
                   // This is a for-comprehension. Inside an named argument list
                   // (what we have here, although there is no name) for a
                   // function which wants an iterable, this becomes an iterable,
                   // lazily built from the existing iterable p.paired,
                   // which is just an iterable with all pairs of subsequent
                   // elements.
                      for([x,y] in p.paired)
                        // for each such pair, we evaluate this expression, which
                        // is true when the sequence is not ordered correctly.
                           y < x         // → Boolean
                        // → {Boolean*}
                    }  //   → Boolean
                 //  → Boolean([String+])
               ) // → [[String+]*]
         // we now have a sequence of (correctly sorted) sequences.
         // just take the first one.
         // If we had used `.filter` before, this would have to be `.first`.
               [0]    // → [String+]|Null
         // in case this is null, which can only happen if the original array was
         // empty, so there were no permutations, just use the empty sequence
         //  again. (Actually, split never returns an empty array, so this can't
         //  happen, but the type checker can't know that.)
               else []    // → [String*]
    // so that is what we pass to the join method.
        )   // → String
    ;

বিন্যাস এবং পার্সিং ব্যতীত এটি মাত্র 90 বাইট হয়ে যায়:

String[]s(String[]i)=>i.permutations.select((p)=>!any{for([x,y]in p.paired)y<x})[0]else[];

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

Answer 21

পার্ল 5 , 77 বাইট

map{$F[$_]gt$F[$_+1]&&(@F[$_,$_+1]=@F[$_+1,$_])for 0..@F-2}@F;$_=join',',"@F"

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

সাধারণ বুদ্বুদ সাজান।

Answer 22

ruby -plaF, , 70 বাইট

o=[]
$F.map{|s|i=o;s.bytes{|b|i=i[b]=[*i[b]]};i[0]=s<<?,}
$_=o*''
chop

ও (এন), আপনি যদি ভান করেন যে কোনও অ্যারেরকে পুনরায় আকার এবং সংশ্লেষ করা বিনামূল্যে (এটি খুব বেশি বিনামূল্যে নয়)।

ও ₁ [b ₁ ] [b ₂ ] ... [b _n ] এ অ্যারেতে oবাইট বি ₁ , বি ₂ ... বি _এন দিয়ে স্ট্রিং রেখে আমরা গভীর এবং অসমভাবে নেস্টেড অ্যারে তৈরি করি । ফলাফল দেখে মনে হচ্ছে[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,["a,",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ["abc,"], ["abd,"], ["abe,"]], ["ac,"], ["ad,"]],, ["c,"]]

তারপরে আমরা সমতল এবং আউটপুট।

Answer 23

পুনঃব্যবহার আমার নিজের উত্তর উপর সাজান একটি পূর্ণসংখ্যা তালিকা

টিসিএল , 211 বাইট

set L [split [gets stdin] ,]
set i 0
time {incr j;set x 0;while \$x<$i {if \"[lindex $L $i]"<"[lindex $L $x]" {set L [lreplace [linsert $L $x [lindex $L $i]] $j $j]};incr x};incr i} [llength $L]
puts [join $L ,]

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