তিনটি আর এর: বিপরীত, পুনঃক্রম, পুনরাবৃত্তি

31

সংখ্যার সাথে ডুডল করার সময়, আমি একটি আকর্ষণীয় অনুমান পেয়েছি যা আপনি সংখ্যার একটি তালিকা থেকে তৈরি করতে পারেন। আপনি যদি এই একই ক্রিয়াকলাপটি পর্যাপ্ত সময় পুনরুক্ত করেন তবে আপনি সর্বদা আসল অ্যারেতে ফিরে আসবেন। আসুন নীচের তালিকাটি ব্যবহার করুন:

[1, 2, 3, 4, 5]

উদাহরণ হিসাবে

  1. অ্যারে বিপরীত । এখন আমাদের অ্যারে হয়

    [5, 4, 3, 2, 1]

  2. প্রতিটি জুড়াকে পুনরায় অর্ডার করুন (অদলবদল)। আমাদের তালিকায় 2 জোড়া রয়েছে: [5, 4]এবং [3, 2]। দুর্ভাগ্যক্রমে, আমরা 1একটি জোড়কে গ্রুপ করতে পারি না , তাই আমরা কেবল এটি নিজের হাতে ছেড়ে দেব। প্রতিটি জোড়া অদলবদল করার পরে, নতুন অ্যারেটি হ'ল:

    [4, 5, 2, 3, 1]

  3. আমরা মূল অ্যারে না ফেরা পর্যন্ত 1 এবং 2 পদক্ষেপ পুনরাবৃত্তি করুন । এখানে পরবর্তী 4 টি পদক্ষেপ রয়েছে:

    Step 2:
Start:          [4, 5, 2, 3, 1]
Reversed:       [1, 3, 2, 5, 4]
Pairs Swapped:  [3, 1, 5, 2, 4]

Step 3:
Start:          [3, 1, 5, 2, 4]
Reversed:       [4, 2, 5, 1, 3]
Pairs Swapped:  [2, 4, 1, 5, 3]

Step 4:
Start:          [2, 4, 1, 5, 3]
Reversed:       [3, 5, 1, 4, 2]
Pairs Swapped:  [5, 3, 4, 1, 2]

Step 5:
Start:          [5, 3, 4, 1, 2]
Reversed:       [2, 1, 4, 3, 5]
Pairs Swapped:  [1, 2, 3, 4, 5]

# No more steps needed because we are back to the original array

    তালিকার দৈর্ঘ্য, n বিজোড় হলে, এটি সর্বদা আসল n পদক্ষেপ গ্রহণ করবে মূল অ্যারেটিতে ফিরে আসতে। যদি এন সমান হয় তবে এটি সর্বদা 2 টি পদক্ষেপ গ্রহণ করে মূল অ্যারেটিতে ফিরে যেতে পারে, যদি না এন হয় 2, তবে এক্ষেত্রে এটি 1 পদক্ষেপ নেবে (কারণ বিপরীত হওয়া এবং অদলবদল একই জিনিস)।

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

  • STDOUT এ তালিকার প্রতিটি পদক্ষেপ আউটপুট করা

  • তালিকাগুলির একটি তালিকা ফিরিয়ে দেওয়া

  • প্রতিটি পদক্ষেপের স্ট্রিং উপস্থাপনার তালিকা ফিরিয়ে দেওয়া

  • একটি ম্যাট্রিক্স রিটার্নিং / আউটপুট আউট করা

গ্রহণযোগ্য হবে।

আপনার অবশ্যই মূল অ্যারে আউটপুট করতে হবে, তা শেষে আসে বা শুরুতে আপনার উপর নির্ভর করে। (প্রযুক্তিগতভাবে উভয়ই সঠিক)

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

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

পরীক্ষা IO

1: 
[1]


2: 
[1, 2]


3: 
[2, 3, 1]
[3, 1, 2]
[1, 2, 3]


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


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


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


9: 
[8, 9, 6, 7, 4, 5, 2, 3, 1]
[3, 1, 5, 2, 7, 4, 9, 6, 8]
[6, 8, 4, 9, 2, 7, 1, 5, 3]
[5, 3, 7, 1, 9, 2, 8, 4, 6]
[4, 6, 2, 8, 1, 9, 3, 7, 5]
[7, 5, 9, 3, 8, 1, 6, 2, 4]
[2, 4, 1, 6, 3, 8, 5, 9, 7]
[9, 7, 8, 5, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

এবং ভাল পরিমাপের জন্য, এখানে একটি বৃহত্তর পরীক্ষার কেস: 

27: 
[26, 27, 24, 25, 22, 23, 20, 21, 18, 19, 16, 17, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 1]
[3, 1, 5, 2, 7, 4, 9, 6, 11, 8, 13, 10, 15, 12, 17, 14, 19, 16, 21, 18, 23, 20, 25, 22, 27, 24, 26]
[24, 26, 22, 27, 20, 25, 18, 23, 16, 21, 14, 19, 12, 17, 10, 15, 8, 13, 6, 11, 4, 9, 2, 7, 1, 5, 3]
[5, 3, 7, 1, 9, 2, 11, 4, 13, 6, 15, 8, 17, 10, 19, 12, 21, 14, 23, 16, 25, 18, 27, 20, 26, 22, 24]
[22, 24, 20, 26, 18, 27, 16, 25, 14, 23, 12, 21, 10, 19, 8, 17, 6, 15, 4, 13, 2, 11, 1, 9, 3, 7, 5]
[7, 5, 9, 3, 11, 1, 13, 2, 15, 4, 17, 6, 19, 8, 21, 10, 23, 12, 25, 14, 27, 16, 26, 18, 24, 20, 22]
[20, 22, 18, 24, 16, 26, 14, 27, 12, 25, 10, 23, 8, 21, 6, 19, 4, 17, 2, 15, 1, 13, 3, 11, 5, 9, 7]
[9, 7, 11, 5, 13, 3, 15, 1, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 26, 14, 24, 16, 22, 18, 20]
[18, 20, 16, 22, 14, 24, 12, 26, 10, 27, 8, 25, 6, 23, 4, 21, 2, 19, 1, 17, 3, 15, 5, 13, 7, 11, 9]
[11, 9, 13, 7, 15, 5, 17, 3, 19, 1, 21, 2, 23, 4, 25, 6, 27, 8, 26, 10, 24, 12, 22, 14, 20, 16, 18]
[16, 18, 14, 20, 12, 22, 10, 24, 8, 26, 6, 27, 4, 25, 2, 23, 1, 21, 3, 19, 5, 17, 7, 15, 9, 13, 11]
[13, 11, 15, 9, 17, 7, 19, 5, 21, 3, 23, 1, 25, 2, 27, 4, 26, 6, 24, 8, 22, 10, 20, 12, 18, 14, 16]
[14, 16, 12, 18, 10, 20, 8, 22, 6, 24, 4, 26, 2, 27, 1, 25, 3, 23, 5, 21, 7, 19, 9, 17, 11, 15, 13]
[15, 13, 17, 11, 19, 9, 21, 7, 23, 5, 25, 3, 27, 1, 26, 2, 24, 4, 22, 6, 20, 8, 18, 10, 16, 12, 14]
[12, 14, 10, 16, 8, 18, 6, 20, 4, 22, 2, 24, 1, 26, 3, 27, 5, 25, 7, 23, 9, 21, 11, 19, 13, 17, 15]
[17, 15, 19, 13, 21, 11, 23, 9, 25, 7, 27, 5, 26, 3, 24, 1, 22, 2, 20, 4, 18, 6, 16, 8, 14, 10, 12]
[10, 12, 8, 14, 6, 16, 4, 18, 2, 20, 1, 22, 3, 24, 5, 26, 7, 27, 9, 25, 11, 23, 13, 21, 15, 19, 17]
[19, 17, 21, 15, 23, 13, 25, 11, 27, 9, 26, 7, 24, 5, 22, 3, 20, 1, 18, 2, 16, 4, 14, 6, 12, 8, 10]
[8, 10, 6, 12, 4, 14, 2, 16, 1, 18, 3, 20, 5, 22, 7, 24, 9, 26, 11, 27, 13, 25, 15, 23, 17, 21, 19]
[21, 19, 23, 17, 25, 15, 27, 13, 26, 11, 24, 9, 22, 7, 20, 5, 18, 3, 16, 1, 14, 2, 12, 4, 10, 6, 8]
[6, 8, 4, 10, 2, 12, 1, 14, 3, 16, 5, 18, 7, 20, 9, 22, 11, 24, 13, 26, 15, 27, 17, 25, 19, 23, 21]
[23, 21, 25, 19, 27, 17, 26, 15, 24, 13, 22, 11, 20, 9, 18, 7, 16, 5, 14, 3, 12, 1, 10, 2, 8, 4, 6]
[4, 6, 2, 8, 1, 10, 3, 12, 5, 14, 7, 16, 9, 18, 11, 20, 13, 22, 15, 24, 17, 26, 19, 27, 21, 25, 23]
[25, 23, 27, 21, 26, 19, 24, 17, 22, 15, 20, 13, 18, 11, 16, 9, 14, 7, 12, 5, 10, 3, 8, 1, 6, 2, 4]
[2, 4, 1, 6, 3, 8, 5, 10, 7, 12, 9, 14, 11, 16, 13, 18, 15, 20, 17, 22, 19, 24, 21, 26, 23, 27, 25]
[27, 25, 26, 23, 24, 21, 22, 19, 20, 17, 18, 15, 16, 13, 14, 11, 12, 9, 10, 7, 8, 5, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]

মজা গল্ফিং আছে!

code-golf  array-manipulation 
— ডিজেএমসিএমহেম
সূত্র
6
সামনের মূল আসলটি তৈরি করা কি ঠিক?
— হাইপারনিউটারিনো
1
আমি মনে করি উদাহরণের শেষ লাইনে একটি ত্রুটি আছে। এটা হওয়া উচিত 1 2 3 4 5, না 1 2 4 3 5।
— স্টিভি গ্রিফিন
2
প্রক্রিয়াটির শুরু এবং শেষের দিকে যে উপাদান 0 কেবল কখনও 1 হবে তা নিশ্চিত করতে পারেন?
— রবার্তো গ্রাহাম
1
@ রবার্তো গ্রাহাম আমার কাছে একটি অজগর স্ক্রিপ্ট রয়েছে যা যাচাই করে যা array[0]প্রক্রিয়াটির শুরু এবং শেষ পর্যন্ত কেবল ১ হবে n = 999। প্যাটার্ন দিকে তাকিয়ে থেকে, তা প্রত্যেক বিজোড় জন্য মত মনে হয় এন , প্রথম উপাদান যায় 1, n-1, 3, n - 3, 5, n - 5, 7...পর্যন্ত n - 2, 3, n, 1, যা সবসময় নিতে হবে এন ধাপ। বৃহত্তর এন দিয়ে এই প্যাটার্নটি পরিবর্তিত হবে এমন কোনও কারণ আমি দেখছি না ।
— ডিজেএমসিএমহেম
3
আমরা প্রমাণ করতে হবে যে সময়ের চান এন যখন এন বিজোড়, এটা সম্ভবত ট্র্যাক করা আরো সহজ যেখানে উপাদান 1 যায়: এটা পথ অনুসরণ করে 1, n, 2, n-2, 4, n-4, 6, n-6, 8, n-8, ...এবং এটি আনয়ন দ্বারা দেখানোর জন্য সহজ যে এমনকি অবস্থানে একটি উপাদান এক্স থেকে প্যাচসমূহ Nx এক ধাপ পরে , এবং বিজোড় অবস্থানের একটি উপাদান x -x + 2 এ চলে যায় । সুতরাং যদি এন = 2 কে + 1 হয় , তবে 2 কে- চতুর্থ পদক্ষেপের পরে 1 হবে 2 কে , এবং পরের ধাপে এন-2 কে = 1 এ হবে ।
— মিশা লাভরভ

উত্তর:

16

টিআই-বেসিক (83 সিরিজ), 58 57 54 বাইট (104 টি অক্ষর)

:seq(I,I,1,Ans→A
:Ans→B
:Repeat prod(Ans=ᶫB
:ᶫB→C
:int(⁻Ans/2→D
:SortD(ᶫC,ᶫA
:SortD(ᶫD,ᶫA
:Pause ᶫA
:End

ব্যাখ্যা

ইনপুট নেয় Ans(উদাহরণস্বরূপ, 5:prgmNAMEপাঁচ আকারের তালিকা ব্যবহার করতে লিখুন )।

প্রদত্ত আকারের তিনটি সহায়ক তালিকা তৈরি করে (যা ᶫBপ্রতিটি পদক্ষেপে পুনরায় তৈরি করা হয়): ᶫB = ᶫC = {1,2,3,4,5,...}এবং ᶫD = {-1,-1,-2,-2,-3,...}। প্রতিটি পদক্ষেপ, প্রকারের এ ᶫCএবং ᶫDযাতে সাজানো একই বিন্যাস প্রয়োগ করার ক্ষেত্রে ᶫA। এর ক্ষেত্রে ᶫC, এটি বিপরীত হয় ᶫAএবং এর ক্ষেত্রে ᶫD, এটি সংলগ্ন জোড়াগুলিকে অদলবদল করে কারণ টিআই-বেসিক সত্যিকার অর্থে মূ selectionSortD( ় নির্বাচনের সাজানোর প্রয়োগ ব্যবহার করে যার জন্য যতটা সম্ভব অভিন্ন উপাদানগুলি পুনরায় অর্ডার করে। আবার যখন ᶫAসমান ᶫBহয়, আমরা থামি।

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

-1 বাইট: Pauseএটি মুদ্রণ করা মানটি সংরক্ষণ করে Ansযা এর চেয়ে কম রেফারেন্স ᶫA।

-3 বাইট: ইনপুট নিন Ans

— মিশা লাভরভ
সূত্র
নির্বাচনের ধরণের সাথে দুর্দান্ত কৌশল!
— Riking
7

জেলি , 10 বাইট

RµUs2UFµÐĿ

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

ব্যাখ্যা

RµUs2UFµÐĿ  Main link
R           Generate the range
        ÐĿ  While the results are unique (collecting results)
 µUs2UFµ    Reverse and reorder
  U         Reverse
   s        Slice non-overlapping into length
    2       2
     U      Reverse (automatically vectorizes to depth 1)
      F     Flatten

বিঃদ্রঃ

মূল পরিসীমা তাহলে চাহিদা শেষে পরিশেষে যোগ করা ṙ112 বাইট কোড করতে।

— HyperNeutrino
সূত্র
— ডিজেএমসিএমহেম
@ ডিজেএমসিমেহেম দুর্দান্ত, দুর্দান্ত!
— হাইপারনিউট্রিনো
4

জাভাস্ক্রিপ্ট (ES6), 89 85

4 বাইট সম্পাদনা করুন THX @ জাস্টিনমারিনার সংরক্ষণ করা

যে কোনও উপাদান যখন সঠিক জায়গায় থাকে তখন সমস্ত উপাদান থাকে fact

n=>{for(l=[];n;l[n-1]=n--);while(alert(l=l.reverse().map((x,i)=>l[i^1]||x)),l[0]-1);}

কম গল্ফড

n => {
  for(l=[], i=0; i<n; l[i] = ++i);
  while( alert(l=l.reverse().map( (x,i) => l[i^1] || x)),
         l[0]-1);
}

পরীক্ষা

var F=
n=>{for(l=[];n;l[n-1]=n--);while(alert(l=l.reverse().map((x,i)=>l[i^1]||x)),l[0]-1);}

alert=x=>console.log(x+'') // to avoid popup stress

function update() {
  F(+I.value);
} 

update()
<input type=number id=I value=1 min=1 oninput='update()'>
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
আমি মনে করি আপনি নিজের পরিসীমা তৈরির লুপটি ছোট করতে পারেন for(l=[];n;l[n-1]=n--);, এটি অনলাইনে চেষ্টা করুন! ।
— জাস্টিন মেরিনার
@ জাস্টিনমারিনার বাহ পেছনের দিকে, দুর্দান্ত! ধন্যবাদ
— edc65
3

গণিত, 142 বাইট

(h=Range@#;W={};For[i=1,i<=#,i++,s=Reverse@h;AppendTo[W,h=Join[f=Flatten[Reverse/@Partition[s,{2}]],s~Complement~f]];s=h];DeleteDuplicates@W)&
— J42161217
সূত্র
3

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

f=(n,a=[...Array(n)],b=a.map((x,i)=>n-((x?x-1:i)^1)||1))=>b[0]>1?b+`
`+f(n,b):b

প্রতিটি পদক্ষেপের জন্য একটি তালিকা আউটপুট করে।

নোট করুন যে বলটি ঘূর্ণায়মান হওয়ার জন্য আমাদের অ্যারে শুরু করার দরকার নেই। যদি আনইনটিয়ালাইজড ( xঅপরিজ্ঞাত) হয় তবে আমরা অ্যারের সূচকগুলি (পরামিতি) ব্যবহার করতে পারিi প্রথম পদক্ষেপটি করতে ) ব্যবহার করতে পারি:

b=a.map((x,i)=>n-((x?x-1:i)^1)||1)

পরীক্ষার কেস:

কোড স্নিপেট দেখান

— রিক হিচকক
সূত্র
3

আর, 109 95 94 79 74 62 বাইট

কোডটি যদি আসল সমাধানের উপরে সতর্কতা ছুড়ে দেয় (যদি n1, 3 টি সতর্কতা যদি সমান হয় তবে nএবং nসতর্কতা যদি nবিজোড় হয়) কোনও সমস্যা না হয়, তবে নিম্নলিখিতটি পূর্ববর্তী সমাধানের মতোই কাজ করে, ভেক্টরকে ধন্যবাদ পুনর্ব্যবহার:

n=scan();m=1:n;w=0:n+2*1:0;while(print(m<-rev(m)[w[w<=n]])-1)n

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

জিউসেপ্পেকে আবারও ধন্যবাদঅতিরিক্ত 12 বাইট জন্য !

পূর্ববর্তী, 94 বাইটে সতর্কতা-কম সমাধান:

n=scan();m=s=1:n;while(any(print(m<-rev(m)[c(if(n>1)2:1+rep(seq(0,n-2,2),e=2),n[n%%2])])!=s))n

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

109 বাইটে আসল সমাধান :

n=scan();m=s=1:n;repeat{cat(m<-rev(m)[c(t(embed(s,min(n,2))[!!s[-n]%%2,]),n[n%%2])],"\n");if(all(m==s))break}

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

— plannapus
সূত্র
1
88 বাইট - printএর যুক্তিটি ফিরিয়ে দেয় যাতে আমরা এখানে এটির সুবিধা নিতে পারি। আমি encodeআগে কখনও দেখেছি বলে মনে করি না ; এটি সূচকের একটি ঝরঝরে উপায়!
— জিউসেপে
ধন্যবাদ! যদিও এখন পর্যন্ত n = 1 এ কাজ করে না বলে আমার এটি একটি ছোট্ট দীর্ঘতর করা দরকার make
— প্ল্যানাপাস
ওহ, আমি লক্ষ্য করিনি ... 2এর embedসাথে প্রতিস্থাপন করুন min(n,2)?
— জিউসেপে
1
আপনি শুধু লাগাতে পারেন nপরিবর্তে {}যখন লুপ জন্য যেহেতু nকিছু না। :)
— জিউসেপে
1
চিত্তাকর্ষক উন্নতি !!! -4 বাইট 0:n+2*1:0হিসাবে একই -1 বাইটের সমতুল্য । যদি আমরা প্রমাণ করতে পারি যে কেবলমাত্র অ্যালগরিদমের শেষে, তবে আমরা ড্রপ করতে পারি , তাই আমরা পেয়ে যাব এবং সরিয়ে ফেলতে পারি , সুতরাং আমরা পেয়েছি 62 বাইট,1+0:n+c(1,-1)any(print(...) != s)any(print(...)-s)m[1]==1anywhile(print(...)-1)sn=scan();m=1:n;w=0:n+2*1:0;while(print(m<-rev(m)[w[w<=n]])-1)n
— জিউসেপ্পে
3

জাপট , 20 18 15 12 বাইট

õ
£=ò2n)ÔcÃâ

এটি চেষ্টা করুন (-R ব্যবহার কেবলমাত্র দর্শনের উদ্দেশ্যে পতাকা)

ETH প্রোডাকশনগুলিতে 1 বাইট সংরক্ষণ করা হয়েছে।

               :Implicit input of integer U
õ              :Range [1,U]
\n             :Reassign to U
£              :Map
  ò            :  Partitions
   2           :    Of length 2
    n          :    Starting from the end
     )         :  End partition
      Ô        :  Reverse
       c       :  Flatten
 =             :  Reassign to U
        Ã      :End map
         â     :Deduplicate
— রোমশ
সূত্র
ঠিক এখন পর্যন্ত, আমি বিশ্বাস করি যে w ò mwহতে পারেò2n)w
— ইটিএইচ প্রডাকশনগুলি
ওও, সুন্দর একটি, ধন্যবাদ, @ পাঠ্যক্রমের। পাবটিতে হাঁটতে চলেছি তাই সকালে সেদিকে আমার সঠিক নজর থাকবে।
— শেগি
2

রুবি , 64 57 52 50 বাইট

->x{(s=*w=1..x).map{s=w.map{|y|s[-y^1]||s[0]}}|[]}

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

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

প্রথমে ব্যাপ্তি তৈরি করুন, তার পরে x বার পুনরাবৃত্তি করুন: negativeণাত্মক সূচক ব্যবহার করুন, তবে শেষ বিটটি ফ্লিপ করুন, সুতরাং আমরা ক্রমটি -2, -1, -4, -3 পেয়ে যাচ্ছি ... যদি x হয় তবে এটি শেষ হবে ভাল, না হলে আমরা শেষে অবশিষ্ট উপাদান যুক্ত করব। শেষ পদক্ষেপ: পুনরাবৃত্ত অ্যারে ফিল্টার আউট (সুতরাং আমরা সমস্ত কেস কভার করব: x = 1, x = 2, বিজোড় এবং এমনকি সংখ্যা)

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

হাস্কেল, 75 74 বাইট

g(a:b:c)=b:a:g c
g x=x
h=g.reverse
0!x|x<[2]=[x]|1<2=x:0!h x
p n=0!h[1..n]

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

gঅর্ডারটি পুনরুদ্ধার না হওয়া পর্যন্ত জোড়-ভিত্তিক অদলবদল, hএকটি একক পদক্ষেপ (বিপরীত + পুনঃক্রম) !পুনরায় প্রয়োগ করা হয় h(এবং মধ্যবর্তী ফলাফল সংগ্রহ করে) দ্রষ্টব্য: কেবলমাত্র ইনফিক্স অপারেটর তৈরি করতে !অতিরিক্ত কিন্তু অব্যবহৃত অতিরিক্ত প্যারামিটার লাগে 0। মূল ফাংশন pএটি শুরু হয়।

সম্পাদনা: একটি বাইটের জন্য @ অংগুলকে ধন্যবাদ।

— nimi
সূত্র
2
0!xf xএকটি বাইট সংরক্ষণ করার পরিবর্তে - এটি অনলাইনে চেষ্টা করুন!
— অ্যাঙ্গস
1

জাভা 8, 215 214 বাইট

import java.util.*;n->{Stack a=new Stack(),t;int i=0;for(;i<n;a.add(++i));t=(Stack)a.clone();Collections x=null;for(i=0;i<1|!a.equals(t);System.out.println(t))for(x.reverse(t),i=0;i<n;i++)if(i<n-1)x.swap(t,i,++i);}

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

ব্যাখ্যা:

এখানে চেষ্টা করুন।

import java.util.*;           // Required import for Stack and Collections

n->{                          // Method with integer parameter and no return-type
  Stack a=new Stack(),        //  Original List
        t;                    //  Copy-List
  int i=0;                    //  Index-integer, starting at 0
  for(;i<n;a.add(++i));       //  Fill the original list with the integers
  t=(Stack)a.clone();         //  Make a copy of the List
  Collections x=null;         //  Static `Collections` to reduce bytes
  for(i=0;                    //  Reset index `i` to 0
      i<1                     //  Loop (1) as long as `i` is 0 (the first iteration),
      |!a.equals(t);          //  or the input array is not equal to the copy
      System.out.println(t))  //    After every iteration: print the modified List
    for(x.reverse(t),         //   Reverse the copied List
        i=0;                  //   Reset `i` to 0
        i<n;                  //   Inner loop (2) over the List
        i++)                  //     After every iteration: increase `i` by 1 again
      if(i<n-1)               //    Unless it's the last item in the List:
        x.swap(t,i,++i);      //     Swap the items at indexes `i` and `i+1` 
                              //     (by increasing `i` by 1 first with `++i`)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
}                             // End of method
— কেভিন ক্রুইজসেন
সূত্র
1

জাভা (ওপেনজেডিকে 8) , 257 245 243 226 206 205 বাইট

n->{int i=0,k,t[]=new int[n];while(i<n)t[i]=++i;do{for(i=0;i<n/2;t[i]=t[n+~i],t[n+~i++]=k)k=t[i];for(k=1;k<n;t[k]=t[--k],t[k]=i,k+=3)i=t[k];System.out.println(java.util.Arrays.toString(t));}while(t[0]>1);}

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

— রবার্তো গ্রাহাম
সূত্র
1
n->{java.util.Arrays x=null;int i=0,k,f,a[]=new int[n],t[]=new int[n];for(;i<n;a[i]=t[i]=++i);do{for(f=0;f<n/2;k=t[f],t[f]=t[n+~f],t[n+~f++]=k);for(k=1;k<n;t[k]=t[--k],t[k]=f,k+=3)f=t[k];System.out.println(x.toString(t));}while(!x.equals(a,t));}( 245 বাইট ) পরিবর্তনের সারাংশ: java.util.Arrays x=null;; n-f-1to n+~f; লুপ সরানো বন্ধনী; 2x এ পরিবর্তন করা k-1হয়েছে --k(এবং এটি নিরপেক্ষ করতেও পরিবর্তিত k+=2হয়েছেk+=3
— কেভিন ক্রুইজসেন
এবং আপনি অপসারণ ,fএবং পুনরায় ব্যবহার করে আরও দুটি বাইট সংরক্ষণ করতে পারেন i।
— কেভিন ক্রুইজসেন
সুন্দর, আপনি এটিকে অনেক উন্নতি করেছেন! আপনি এখন আমার জাভা উত্তরের চেয়েও নীচে। :) আপনি এতে পরিবর্তন করে আরও একটি বাইট গলফ করতে for(i=0;i<n/2;k=t[i],t[i]=t[n+~i],t[n+~i++]=k);পারেনfor(i=0;i<n/2;t[i]=t[n+~i],t[n+~i++]=k)k=t[i];
— কেভিন ক্রুইজসেন
1

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

:`tP2ePXz!tG:-a]x

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

ব্যাখ্যা

:       % Implicit input: n. Push [1 2 ... n]
`       % Do...while
  t     %   Duplicate
  P     %   Reverse
  2e    %   Reshape into a 2-row matrix. A final 0 is added if needed
  P     %   Reverse each column
  Xz    %   Nonzero entries (i.e. remove final 0 if present). Gives a column vector
  !     %   Transpose into a row
  t     %   Duplicate
  G:    %   Push [1 2 ... n] again
  -     %   Subtract element-wise
  a     %   Any. Gives true if there is at least a nonzero value
]       % End. Go to next iteration if top of the stack is true.  So the loop ends
        % when [1 2 ... n] has been found again
x       % Delete top of the stack (which is [1 2  ... n]). Implicit display
— লুইস মেন্ডো
সূত্র
1

স্ট্যাক্স , 17 বাইট

âΩÄ─g╫B♥C╛♠ƒ?|πcD

এটি চালান এবং এটি ডিবাগ করুন

ব্যাখ্যা

RX~Wr2/{r+}Fc|uPcx=C      # Full program, unpacked, implicit input
RX~                       # Create range, save to X register, pop back to input stack
   W                      # Start while loop until truthy value
    r                     # reverse array
     2/                   # Split into groups of 2
      {r+}F               # Loop through each set and reverse each
           c              # Copy top value
            |u            # Convert to string representation of array
              P           # Pop top value off
               cx=        # Copy top value, get value of x register, compare to top value
                  C       # If top value is truthy, cancel block and end

সুপারিশ করা এটি যত দ্রুত কাজ করে ততক্ষণে, আমি আমার ব্রাউজারটিকে আর লম্পট করতে চাই না তার আগে 399 পর্যন্ত পরীক্ষা করে।

— মাল্টি
সূত্র
0

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

f=(n,a=[...Array(n)].map((_,i)=>i+1),r=[],b=a.map((_,i)=>a[n+~(i^1)]||a[0]))=>b.some((e,i)=>e>b[i+1],r.push(b))?f(n,b,r):r

r.push(a)r.push(b)মূল আদেশটি সামনে রাখার পরিবর্তে ব্যবহার করা যেতে পারে ।

— নিল
সূত্র
0

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

এটি কিছুটা দীর্ঘ অনুভব করে :(

f n|x<-[1..n]=x:takeWhile(/=x)(tail$iterate((r=<<).g.r)x)
r=reverse
g[]=[]
g x=take 2x:g(drop 2x)

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

ব্যাখ্যা / Ungolfed

-- starting with x, accumulate the results of repeatedly
-- applying the function permute
f n = x : takeWhile (/=x) (tail $ iterate permute x)
  where x = [1..n]
        -- reverse, cut2, reverse each pair & flatten
        permute = concatMap reverse . cut2 . reverse

-- recursively transform a list into groups of 2
cut2 [] = []
cut2 xs = take 2 xs : g (drop 2 xs)
— ბიმო
সূত্র
0

স্ট্যাকড , 42 বাইট

[~>[rev 2#<$revflatmap]periodsteps behead]

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

বিল্টিন ব্যবহার করে প্রদত্ত রূপান্তর periodstepsসম্পাদন করে। তবে এই বিল্টিনটি সমস্ত উপাদানকে ফেরত দেয়, যার মধ্যে ইনপুটটির ব্যাপ্তিটি তার প্রথম এবং শেষ উপাদান হিসাবে অন্তর্ভুক্ত। আমরা অতএব তালিকার শিরশ্ছেদ করছি, প্রথম উপাদানটি বাদে সমস্ত ফিরিয়ে দিচ্ছি।

— কনর ও ব্রায়ান
সূত্র
0

পাইথন 2 , 165 159 138 81 বাইট

x=input()+1
b=a=range(1,x)
while b:b=[b[x-min(x,i+1^1)]for i in a];print b;b*=a<b

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

-20 বাইটস @ চাসব্রাউনকে ধন্যবাদ । (দীর্ঘশ্বাস, আমি বর্ধিত স্লাইসিং সিনট্যাক্স সম্পর্কে পুরো চ্যালেঞ্জ করেছি)

ওহো! গল্ফস্টর্ম (-57 বাইট)! ইয়ান গডেল, টিশ এবং জনাথন ফ্রেচকে ধন্যবাদ জানাই।

— fireflame241
সূত্র
পরিবর্তে list(reversed(a))চেষ্টা করুন a[::-1]।
— চ্যাস ব্রাউন
' '*[2-(x<3),x][x%2]
— tsh
1
— tsh
1
@tsh [b,0][b==a]->b*(a!=b) ।
— জোনাথন ফ্রেচ
0

জাভাস্ক্রিপ্ট, 136 বাইট

(n)=>{for(a=[],i=0;i<n;a[i]=++i);for(j=0;j<(n&1?n:2);j++){a.reverse();for(i=0;i<a.length-1;i += 2)m=a[i],a[i]=a[i+1],a[i+1]=m;alert(a)}}
— tjespe
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.