একটি অ্যারে চালিত করুন

25

ড্রিফ্টসর্ট একটি অ্যারে "বাছাই" করার একটি সহজ উপায়। এটি অ্যারেতে উপাদানগুলি "স্লাইডিং" বা "আবর্তিত" দ্বারা কাজ করে যতক্ষণ না অ্যারে বাছাই করা হয় বা অ্যারে বাছাই করা যায় না।

আসুন দুটি উদাহরণ দিয়ে চলুন। প্রথমে অ্যারে বিবেচনা করুন [10, 2, 3, 4, 7]। অ্যারে বাছাই না করা হয়, আমরা এটি একবার ঘোরান। (এটি উভয় দিকেই ঘটতে পারে, যতক্ষণ না এটি একই দিক থেকে যায়)) তারপরে, অ্যারেটি হয়ে যায়:

[7, 10, 2, 3, 4]

এটি বাছাই করা হয়নি, তাই আমরা আবার ঘোরান।

[4, 7, 10, 2, 3]

এবং আবার:

[3, 4, 7, 10, 2]

এবং একটি চূড়ান্ত সময়:

[2, 3, 4, 7, 10]

এবং এটি সাজানো! সুতরাং অ্যারে [10, 2, 3, 4, 7]ড্রিফোর্টেবল। এখানে স্পষ্টতার জন্য অ্যারের সমস্ত ঘূর্ণন রয়েছে:

[10, 2, 3, 4, 7]
[7, 10, 2, 3, 4]
[4, 7, 10, 2, 3]
[3, 4, 7, 10, 2]
[2, 3, 4, 7, 10]

অ্যারে বিবেচনা করুন [5, 3, 9, 2, 6, 7]। এর আবর্তনগুলি দেখুন:

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

এই অ্যারেগুলির [5, 3, 9, 2, 6, 7]কোনওটিই বাছাই করা হয় না , তাই অ্যারেটি ড্রিফোর্টযোগ্য নয়।

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

আপনি বিল্ট-ইন বাছাই পদ্ধতিগুলি ব্যবহার করতে পারেন, তবে এমন বিল্ট-ইন নয় যা চ্যালেঞ্জ সমাধান করে।

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

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

input => output
[1] => [1]
[5, 0, 5] => [0, 5, 5]
[3, 2, 1] => false
[0, 9, 3] => false
[1, 2, 3, 4] => [1, 2, 3, 4]
[4, 1, 2, 3] => [1, 2, 3, 4]
[0, 2, 0, 2] => false
[5, 3, 9, 2, 6, 7] => false
[0, 0, 0, 0, 0, 0, 0] => [0, 0, 0, 0, 0, 0, 0]
[75, 230, 30, 42, 50] => [30, 42, 50, 75, 230]
[255, 255, 200, 200, 203] => [200, 200, 203, 255, 255]
code-golf  sorting 
— কনর ও ব্রায়ান
সূত্র
5
তালিকাটি ড্রিফসোর্টেবল কিনা তা যাচাই করার একটি সহজ উপায় হ'ল এটির sorted(l)একটি সংক্ষিপ্ত সাবলিস্ট l+l।
— xnor
কেবল স্পষ্ট করে বলতে: আমাদের ভাষা যদি নেতিবাচক পূর্ণসংখ্যার সমর্থন করে তবে সেগুলি ইনপুটটিতে আসতে পারে, হ্যাঁ?
— ডেনিস
@ ডেনিস যেটি সঠিক।
— কনর ও'ব্রায়ান
এই বলা উচিত নয় shiftsort?
— ফিলিপ হাগলুন্ড
@ ফিলিপ হাগলুন্ড আমি এটিকে কল করার বিষয়ে ভেবেছিলাম তবে এটি shiftঅপারেশনের সাথে বিভ্রান্তি সৃষ্টি করতে পারে যা অ্যারের প্রথম উপাদানটিকে সরিয়ে দেয়।
— কনর ও'ব্রায়ান

উত্তর:

9

জেলি , 6 বাইট

ṙỤċṢȧṢ

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

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

ṙỤċṢȧṢ  Main link. Argument: A (list)

 Ụ      Grade up; return the indices of A, sorted by their corresponding values.
ṛ       Rotate A by each index, yielding the list of all rotations.
   Ṣ    Yield A, sorted.
  ċ     Count the number of times sorted(A) appears in the rotations.
        This gives 0 if the list isn't driftsortable.
    ȧṢ  Logical AND with sorted(A); replaces a positive count with the sorted list.
— ডেনিস
সূত্র
1
আহেম, ইউটিএফ 8 এর 19 বাইট।
— আরএসএক্সভিসি
11
জেলির একটি কাস্টম কোড পৃষ্ঠা রয়েছে যা এটি 256 টি অক্ষরের প্রতিটি এনকোড করে এটি একক বাইট হিসাবে বোঝে। (UTF-8 দিয়ে 16 বাইট BTW আছে।)
— ডেনিস
3
@ ডেনিস: আমাদের (যেমন, যারা আগে এটি জানত না) একই মন্তব্য করতে বাধা দেওয়ার জন্য আপনার সমস্ত জেলি সাবমিশনে এটি অনুলিপি / পেস্ট করা উচিত? ;)
— অলিভিয়ার দুলাক
18

রুবি, ৩৩

->a{a.any?{a.sort==a.rotate!}&&a}

a.any?অ্যারেতে প্রতিটি উপাদানের জন্য একবারে আগুন জ্বলে ওঠে তবে এটি বন্ধ হয়ে যায় (এবং সত্যটি প্রত্যাবর্তন হয়) যত তাড়াতাড়ি অ্যারেটিকে সাজানো অবস্থায় রূপান্তরিত করা হয়। যদি এটি ঘটে থাকে তবে আমরা পরিবর্তিত অ্যারেটি ফিরিয়ে দেব। অন্যথায় আমরা যে মিথ্যা মানটি any?ফিরিয়ে দেই return

— histocrat
সূত্র
1
এটি অত্যন্ত চালাক, বিশেষত স্থানের আবর্তন। চমৎকার কাজ!
— অ্যালেক্স এ।
হায়, আমার নিজের রুবির উত্তরটি ভাল লেগেছে। +1
— মান কালি
3
হ্যাঁ হ্যাঁ, পুরাতনটি "কৌশলটি বাছাই করতে সক্ষম কিনা" আপনি যতক্ষণ না বলতে পারবেন ততক্ষণ তা সাজান।
— corsiKa
14

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

lambda l:sorted(l)*(map(cmp,l[-1:]+l,l).count(1)<3)

ঘোরাঘুরি করে না। পরিবর্তে, তালিকাটি বাছাই করুন, তারপরে চক্রাকারে তালিকার টানা উপাদানগুলির মধ্যে একটিরও কমতি আছে কিনা তা খতিয়ে দেখে আসলটি প্রবাহিত বাছাইযোগ্য কিনা তা দেখুন। গণনা করা হয় <3কারণ mapপ্যাড সঙ্গে খাটো তালিকা Noneশেষে একটি জাল হ্রাস যোগ।

— xnor
সূত্র
2
[1, 3, 2, 4]টানা উপাদানগুলির মধ্যে কেবল একটি হ্রাস পেয়েছে তবে এটি ড্রিফ্ট-বাছাইযোগ্য নয়।
— নীল
1
@ নীল ওহ শুট
— xnor
@ নীল আমি মনে করি এটি এটি ঠিক করে দেয়। আপনি কি দয়া করে একবার দেখতে পারেন?
— xnor
10
ওহ আমরা <3আপনাকে
— মনিকার লসুইট
আমি বলতে পারি না আমি পাইথনের বিশেষজ্ঞ, তবে এটি <3সঠিকভাবে তালিকাটি ঘোরানো থেকে বিরত থাকার বিষয়টি ধরে নেওয়া যুক্তিযুক্ত বলে মনে হয়।
— নীল
10

পাইথ, 9 বাইট

*SQ}SQ.:+

ব্যাখ্যা:

           - Q = eval(input())
         + -    Q+Q
       .:  -   sublists(^)
   }       -  V in ^
    SQ     -   sorted(Q)
*SQ        - ^ * sorted(Q) (return sorted(Q) if ^ True)

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

বা একটি পরীক্ষা স্যুট ব্যবহার করুন!

— নীল
সূত্র
1
আমি মনে করি আপনি এর জন্য সাবস্ট্রিং (সাবলিস্ট) বোঝাতে চাইছেন .:। সংমিশ্রণে অ-তাত্পর্যপূর্ণ উপাদান অন্তর্ভুক্ত থাকবে।
— xnor
6

মতলব, 61 47 41 বাইট

ধন্যবাদ -সুইভার -6 বাইটের জন্য!

@(a)sort(a)+0*min(strfind([a,a],sort(a)))

যদি strfind([a,a],sort(a))বাছাই করা ইনপুট ভেক্টরটিকে অরসোর্টডের একটি 'সাবস্ট্রিং' হিসাবে সন্ধান করার চেষ্টা করে, এটি নিজেই সংযোজন করা হয়েছিল। যদি সত্য হয় তবে ইনপুটটি ড্রিফোর্টযোগ্য এবং আমরা খালি ভেক্টর না পেলে আমরা দৈর্ঘ্য 2 এর একটি ভেক্টর পাই। minএটি কেবল একটি নম্বর / খালি ভেক্টরে রূপান্তর করে। বাছাই করা ভেক্টরকে 0-এ যুক্ত করা কেবল এটি প্রদর্শিত হয়, এটি একটি খালি ভেক্টরে যুক্ত করে একটি ত্রুটি ছুঁড়ে দেয়।

— flawr
সূত্র
সাবস্ট্রিং চেক হ্যান্ডেল কি [2, 3]সাব-লিস্ট হচ্ছে না [12, 34]?
— xnor
হ্যাঁ, প্রতিটি পূর্ণসংখ্যার অ্যারেটি স্ট্রিং হিসাবেও ব্যাখ্যা করা যায়, যেখানে প্রতিটি সংখ্যাকেই একটি সংখ্যা হিসাবে বিবেচনা করা হয়, সংখ্যা যতই বড় হোক না কেন।
— flawr
@ ফ্লোয়ার আমার ব্যাখ্যাটি হ'ল strfindসংখ্যার সাথে সরাসরি কাজ করতে পারে, কেবল অক্ষরের সাথে নয় (যদিও এটি দলিল নয়)। যদি সংখ্যাগুলি চর হিসাবে ব্যাখ্যা করা হত তবে তারা সীমাবদ্ধ থাকবে 65535(উদাহরণস্বরূপ চেষ্টা করুন +char(1e5))
— লুইস মেন্ডো
@ লুইস মেন্ডো আপনি ঠিক বলেছেন, এটি এমনকি ভাসমান পয়েন্ট সংখ্যাগুলির সাথেও কাজ করে। নোট করুন যে 65535 এর উপরে সংখ্যাগুলি কেবল একটি স্ট্রিংয়ের অংশ হিসাবে বিবেচনা করার সময় একটি স্থান হিসাবে প্রদর্শিত হবে।
— flawr
5

জুলিয়া, 71 66 52 বাইট

x->(y=sort(x))∈[circshift(x,i)for i=1:endof(x)]&&y

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

জন্য একটি ইনপুট অ্যারের এক্স , আমরা সব ঘুর্ণন সেট গঠন করা এক্স এবং চেক সাজানো সংস্করণ কিনা এক্স সেই তালিকাটি একজন উপাদান। যদি তা হয়, আমরা এক্স সাজানো ফিরে আসি, অন্যথায় আমরা মিথ্যা ফিরে আসি।

ডেনিসকে ধন্যবাদ 19 বাইট সংরক্ষণ!

— অ্যালেক্স এ।
সূত্র
4

পিপ , 15 + 1 = 17 16 বাইট

ওহ, অন্যান্য গল্ফ ভাষা এই জল থেকে প্রবাহিত হয়। তবে, যেহেতু আমি ইতিমধ্যে এটি লিখেছি ...

L#gI$<gPBPOgYgy

স্থান দ্বারা পৃথক কমান্ড-লাইন আর্গুমেন্ট হিসাবে ইনপুট নেয় akes -pফলাফলটি গাaten় হওয়ার পরিবর্তে সুস্পষ্টভাবে প্রদর্শন করতে অন্য বা অ্যারে-ফর্ম্যাটিং পতাকা প্রয়োজন । মিথ্যা মামলাটি একটি খালি স্ট্রিং আউটপুট দেয়, যা পিছনে থাকা নতুন লাইনের গুণাবলী দ্বারা দৃশ্যমান।

                 Implicit: g is array of cmdline args; y is empty string
L#g              Loop len(g) times:
         POg       Pop the first item from g
      gPB          Push it onto the back of g
    $<             Fold on < (true if g is now sorted)
   I        Yg     If true, yank g into y
              y  Autoprint y
— DLosc
সূত্র
4

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

a=>a.map(y=>{c+=x>y;x=y},x=a.slice(c=-1))|c<1&&a.sort((a,b)=>a-b)

রিটার্নস 0ব্যর্থতা উপর। পূর্ববর্তী 85 83 80-বাইট সংস্করণ কল করা এড়ানো হয়েছে sort:

a=>a.map((y,i)=>{x>y&&(c++,j=i);x=y},x=a.slice(c=-1))|c<1&&a.splice(j).concat(a)

সম্পাদনা: সংরক্ষিত 2 initialising দ্বারা বাইট cথেকে -1পরিবর্তে 0। থেকে সুইচিং 5 বাইট সংরক্ষিত reduceকরার mapদীর্ঘশ্বাস ...

— নিল
সূত্র
সম্পাদনা দেখুন;)
— কনর ও'ব্রায়ান
সংখ্যার জন্য বাছাই করার কলটি ভুল। নমুনা পরীক্ষা করুন [10, 2, 3, 4, 7]।
— কিউয়ের্তি
এই কোড 3 পরীক্ষার failes: [1], [0, 0, 0, 0, 0, 0, 0]এবং [75, 230, 30, 42, 50]।
— কিওয়ারটি
@ কিওয়ার্টি sortতদারকি সম্পর্কে দুঃখিত , যা তৃতীয় পরীক্ষায় ব্যর্থতার কারণ হয়েছিল। অন্য দুটি পরীক্ষায় ব্যর্থতা আমার ওভার-গল্ফিংয়ের কারণে হয়েছিল; আমি আগের সংস্করণে ফিরে এসেছি।
— নীল
3

স্নোম্যান 1.0.2 , 27 বাইট

((}#AsO|##aC,as|aLNdE`aR*))

এটি একটি সাবরুটাইন যা বর্তমান পেরামভার থেকে ইনপুট নেয় এবং আউটপুট দেয়।

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

((                       ))  subroutine
  }                          set our active variables b, e, and g:
                              .[a] *[b] .[c]
                              .[d]      *[e]    (* represents an active variable)
                              .[f] *[g] .[h]
   #                         store the input in variable b
    AsO                      sort in-place
       |                     swap b with g; now sorted input is in g
        ##                   store the input again in b and e
          aC                 concat; now the input doubled is in b and e is empty
            ,                swap e/g; now b has 2*input and e has sorted input
             as              split 2*input on sort(input) and store result in g
               |             bring the result up to b (we no longer care about g)
                aLNdE        take length and decrement; now we have 0 in b if the
                               array is not driftsortable and 1 if it is
                     `aR     repeat e (the sorted array) b times:
                               if b is 0 (nondriftsortable), returns [] (falsy)
                               otherwise (b=1), returns sorted array unchanged
                        *    put this back into the permavar
— ডোরকনব
সূত্র
3

এমএটিএল, 13 12 10 9 বাইট

SGthyXfa*

যেমন একই ধারণা @ flawr এর উত্তর যেখানে আমরা হাইজ্যাক strfind( Xf) ইনপুট দুই কপি সংযুক্তকরণের মধ্যে ইনপুটের সাজানো সংস্করণ খুঁজে।

অনলাইনে চেষ্টা করে দেখুন!

ব্যাখ্যা

        % Implicitly get input
S       % Sort the input
Gth     % Explicitly grab the input again and concatenate with itself
y       % Copy the sorted version from the bottom of the stack
Xf      % Look for the sorted version as a subset
a       % Gives a 1 if there were matches and 0 otherwise
*       % Multiply by the sorted array. Yields all zeros for no match and the
        % sorted array when a match was found
        % Implicitly display the stack contents
— Suever
সূত্র
1
আপনি কি সরাতে পারবেন না g? বা এর ngদ্বারা প্রতিস্থাপন করুনa
— লুইস মেন্ডো
@ লুইস মেন্ডো কেবলমাত্র একটি nকারণে প্রতিস্থাপন করতে পারবেন না n> 1. তবে a অবশ্যই কাজ করে। আমি আরও ভাল উপায় ছিল অনুভূত। ধন্যবাদ!
— সুয়েভার
3

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

x->sum(diff([x;x]).<0)<3&&sort(x)

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

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

এই যোগসূত্র অ্যারের এক্স নিজেই এবং গন্য সঙ্গে যাতে বাইরে জোড়া সংখ্যা, অর্থাত সংলগ্ন subarrays সংখ্যা [A, B] , যার জন্য খ - একটি <0 । যদি গ এর x টি নিজেই বিন্যাসিত জোড়গুলির সংখ্যা হয় এবং টি এর 1 টি যদি x এর শেষ উপাদানটি তার প্রথমটির চেয়ে বড় হয় তবে 2c + tsum ফিরে আসবে ।

অ্যারে এক্স driftsortable iff হয় (গ, টি) = (1, 0) ( এক্স , শুধুমাত্র unordered যুগল ছোট মান আবর্তিত হবে) (গ, টি) = (0, 1) ( এক্স অনুসারে বাছাই করা হয়) বা (গ, টি) = (0, 0) ( এক্স অনুসারে বাছাই করা হয় এবং তার উপাদানের সবাই সমান), যা সত্য iff হয় 2C + T <3 ।

— ডেনিস
সূত্র
3

জাভাস্ক্রিপ্ট ES6, 48 45 43 অক্ষর

x=>~(x+[,x]).indexOf(x.sort((a,b)=>a-b))&&x

টেস্ট:

f=x=>~(x+[,x]).indexOf(x.sort((a,b)=>a-b))&&x
;`[1] => [1]
[5, 0, 5] => [0, 5, 5]
[3, 2, 1] => false
[0, 9, 3] => false
[1, 2, 3, 4] => [1, 2, 3, 4]
[4, 1, 2, 3] => [1, 2, 3, 4]
[0, 2, 0, 2] => false
[5, 3, 9, 2, 6, 7] => false
[0, 0, 0, 0, 0, 0, 0] => [0, 0, 0, 0, 0, 0, 0]
[75, 230, 30, 42, 50] => [30, 42, 50, 75, 230]
[255, 255, 200, 200, 203] => [200, 200, 203, 255, 255]`
.split`
`.map(t => t.replace(/^(.*) => (.*)$/, "f($1)+'' == $2")).every(eval)
— Qwertiy
সূত্র
আমি মনে করি আপনি নিজের অবস্থার পরিবর্তে দুটি বাইট ব্যবহার করে (x+[,x])এবং আরও একটি বাইট ব্যবহার করে সঞ্চয় করতে পারেন । ~1+
— নীল
@ ব্যবহারকারী 6188402, হ্যাঁ, আপনাকে ধন্যবাদ
— কিওয়ারটি
2

Brachylog , 39 বাইট

l:0re:?{[0:L],!L.|rh$(L,?h-1=:L:1&.}.o.

আমার $( - circular permute leftএকবারে একাধিকবার অনুমতি দেওয়ার জন্য একটি alচ্ছিক যুক্তি যুক্ত করতে হবে ... এটি 13 বাইট হত। প্রোলোগে স্থিতিশীল নতুন ট্রান্সপোর্টার প্রয়োগের পরে এটি অপেক্ষা করবে।

ব্যাখ্যা

l:0re                                     I = a number between 0 and the length of Input
     :?{[0:L],!L.|rh$(L,?h-1=:L:1&.}      All this mess is simply circular permutating the
                                          input I times
                                    .o.   Unify the Output with that circular permutation
                                          if it is sorted, else try another value of I
— Fatalize
সূত্র
2

রুবি, 47 বাইট

পুনরাবৃত্তি ফাংশন। রিটার্নস nilইনপুট অ্যারের driftsorted করা যাবে না পারেন।

f=->a,i=0{a.sort==a ?a:a[i+=1]?f[a.rotate,i]:p}
— মান কালি
সূত্র
2

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

4 বাইট সঞ্চয় করার জন্য ডেনিসকে ধন্যবাদ।

{_$\_+1$#)g*}

একটি নামবিহীন ব্লক (ফাংশন) যা একটি তালিকা গ্রহণ করে এবং প্রদান করে।

পরীক্ষা স্যুট.

ব্যাখ্যা

এটি মূলত xnor এর পর্যবেক্ষণ ব্যবহার করে যে বাছাই করা তালিকাটি মূল তালিকায় দ্বিগুণ হয়ে গেলে যদি তার বাছাইযোগ্য সাজানো যায়:

_$   e# Duplicate input and sort.
\_+  e# Get other copy and append to itself.
1$   e# Copy sorted list.
#    e# Find first position of sorted list in twice the original,
     e# of -1 if it's not found.
)g   e# Increment and take signum to map to 0 or 1.
*    e# Repeat sorted array that many times to turn it into an empty
     e# array if the input was not drift sortable.
— মার্টিন ইন্ডার
সূত্র
@ ডেনিস ওহ, দেখে মনে হচ্ছে আমরা স্বাধীনভাবে এটি নিয়ে এসেছি। ধন্যবাদ যদিও. :)
— মার্টিন এন্ডার
2

সি ++ 14, 242 অক্ষর

#include<iostream>
#include<vector>
#include<algorithm>
#define b v.begin()
using namespace std;int main(){vector<int>v;int x,n=0;for(;cin>>x;++n)v.push_back(x);for(x=n;x--;rotate(b,b+1,b+n))if(is_sorted(b,b+n)){for(x:v)cout<<x<<' ';return 0;}}

যদি আমি আউটপুট খালি ছেড়ে না রাখতে পারি, 252 টি http://ideone.com/HAzJ5V লিখুন

#include<iostream>
#include<vector>
#include<algorithm>
#define b v.begin()
using namespace std;int main(){vector<int>v;int x,n=0;for(;cin>>x;++n)v.push_back(x);for(x=n;x--;rotate(b,b+1,b+n))if(is_sorted(b,b+n)){for(x:v)cout<<x<<' ';return 0;}cout<<'-';}

অবহেলিত সংস্করণ http://ideone.com/Dsbs8W

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

#define b v.begin()

int main()
{
  vector <int> v;
  int x, n=0;

  for(;cin>>x;++n)
    v.push_back(x);

  for(x=n;x--;rotate(b,b+1,b+n))
    if(is_sorted(b,b+n))
    {
      for(x:v) cout<<x<<' ';
      return 0;
    }

  cout << '-';
}

পিএস: @ মাইচেলফ্রান্সিস বুস্টিলোসের ধারণার ভিত্তিতে ।

— কিওয়ার্তি
সূত্র
2

জাভা 7, 207 বাইট

int[]D(int[]i){int x,z;z=x=-1;int[]d=new int[i.length];while(++x<i.length)if(i[x]>i[(x+1)%i.length])if(z<0)z=(x+1)%i.length;else return null;if(z<0)z=0;x=-1;while(++x<d.length)d[x]=i[z++%i.length];return d;}

বিস্তারিত চেষ্টা এখানে

// driftsort in ascending-order
int[] D(int[]i)
{
    int x = -1,z = -1;
    int[] d = new int[i.length];

    while ((++x) < i.length)
    {
        if (i[x] > i[(x+1)%i.length])
        {
            if(z < 0) z = (x+1)%i.length;
            else return null; // not driftsortable
        }
    }

    if(z < 0) z = 0;
    x = -1;
    while ((++x) < d.length)
    {
        d[x] = i[(z++)%i.length];
    }

    return d;
}
— Khaled.K
সূত্র
2

জাভা 175

স্থান পৃথক মান হিসাবে আউটপুট মুদ্রণ করে, বা fএকটি মিথ্যা মান জন্য প্রিন্ট ।

void d(int[]a){String s;for(int v,w,x=-1,y,z=a.length;++x<z;){v=a[x];s=""+v;for(y=0;++y<z;v=w){w=a[(x+y)%z];if(v>w){s="f";break;}s+=" "+w;}if(y==z)break;}System.out.print(s);}

পূর্ণসংখ্যার অ্যারের সমস্ত সংমিশ্রণের মধ্য দিয়ে যায় যতক্ষণ না এটি বৈধ ক্রম খুঁজে পায় বা সংমিশ্রণগুলি শেষ না হয়। অ্যারেটি সংশোধন করা হয়নি, তবে পরিবর্তে ড্রিফোর্ট করা ক্রমটি স্থান সীমাবদ্ধ স্ট্রিং হিসাবে সংরক্ষণ করা হয়।

কিছুটা বেশি পঠনযোগ্য:

void driftsort(int[]array){
    String str;
    for(int previous,current,x=-1,y,len=array.length;++x<len;){
        previous=array[x];
        s=""+previous;
        for(y=0;++y<len;previous=current){
            current=array[(y+x)%len];
            if(previous>current){
                str="false";
                break;
            }
            str+=" "+current;
        }
        if(y==len)break;
    }
    System.out.print(str);
}

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

— জ্যাক আম্মো
সূত্র
2

সি, 105 বাইট

i,s;main(c,v)char**v;{c--;while(i++<c)if(atoi(v[i])>atoi(v[i%c+1]))c*=!s,s=i;while(--i)puts(v[s++%c+1]);}

এটি ইনপুট পূর্ণসংখ্যা পৃথক কমান্ড-লাইন আর্গুমেন্ট হিসাবে গ্রহণ করে এবং প্রতি লাইনে একক পূর্ণসংখ্যা হিসাবে আউটপুট তালিকা মুদ্রণ করে।

যদি তালিকাটি ড্রিফোর্টেবল না হয় তবে একটি ভাসমান পয়েন্ট ব্যতিক্রমের কারণে প্রোগ্রামটি অকালেই প্রস্থান করে, তাই এর খালি আউটপুট একটি খালি তালিকা উপস্থাপন করে।

প্রতিপাদন

$ gcc -o driftsort driftsort.c 2>&-
$ ./driftsort 1 | cat
1
$ ./driftsort 5 0 5 | cat
0
5
5
$ ./driftsort 3 2 1 | cat
$ ./driftsort 0 9 3 | cat
$ ./driftsort 1 2 3 4 | cat
1
2
3
4
$ ./driftsort 4 1 2 3 | cat
1
2
3
4
$ ./driftsort 0 2 0 2 | cat
$ ./driftsort 5 3 9 2 6 7 | cat
$ ./driftsort 0 0 0 0 0 0 0 | cat
0
0
0
0
0
0
0
$ ./driftsort 75 230 30 42 50 | cat
30
42
50
75
230
$ ./driftsort 255 255 200 200 203 | cat
200
200
203
255
255
— ডেনিস
সূত্র
2

রুবি, 28

->a{(a*2*?,)[a.sort!*?,]&&a}

বাছাই করা অ্যারে, বা nil(যা একটি মিথ্যা মান) ফেরত দেয় যদি ইনপুটটি ড্রিফ্ট-বাছাইযোগ্য না হয়।

— Ventero
সূত্র
2

পাইথন, 53 বাইট

s,N=sorted,lambda x:s(x)*(str(s(x))[1:-1]in str(x+x))

আপনি যদি এই মাথাটি https://www.repl.it/languages/python3 এ পরীক্ষা করতে চান এবং এটি অনুলিপি করুন:

s,N=sorted,lambda x:s(x)*(str(s(x))[1:-1]in str(x+x))
print(N([1,2,3,4,5,0]))

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

  • ssortedপাইথন ফাংশন সংরক্ষণ করে একটি পরিবর্তনশীল যা তালিকাগুলি বাছাই করে
  • N প্রধান কাজ
  • সাজানো ইনপুট তালিকা: s(x)তালিকাটি ড্রিফোর্টযোগ্য কিনা তা দ্বারা গুণিত হয় str(s(x))[1:-1]in str(x+x)( @ এক্সনোরকে ধন্যবাদ)
    • এটি কাজ করে কারণ [1,2,3,4]*falseখালি তালিকার ফলাফল[]
    • এবং [1,2,3,4]*trueফলাফল[1,2,3,4]
— স্যামি বেঞ্চিরিফ
সূত্র
1
পাইথন 2 এ, আপনি এটি lambda x,s=sorted:(`s(x)`[1:-1]in`x+x`)*s(x)44 বাইটে সংক্ষিপ্ত করতে পারেন ।
— ডেনিস
1

পাইথন, 83 বাইট

def f(l):g=sorted(l);return g if any(l[x:]+l[:x]==g for x in range(len(l)))else 1>2

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

range(len(l)))

অংশ। তালিকার মাধ্যমে পুনরাবৃত্তি করার কোন দ্রুত উপায় আছে?

— ডিজেএমসিএমহেম
সূত্র
1
এটি খুব বেশি নয়, তবে l.append(l.pop(0))or g==l for _ in lপরিসর-লেন পদ্ধতির উপর একটি বাইট সংরক্ষণ করে। একটি ব্যবহার lambdaকরে 14 টি অতিরিক্ত বাইট সাশ্রয় হবে।
— ডেনিস
1

ম্যাটল্যাব / অক্টোবায়, 118 বাইট

function r(a)
i=0
while (~issorted(a) && i<length(a))
    a=a([2:end 1]),i=i+1
end
if issorted(a)
    a
else
    0
end
— costrom
সূত্র
2
আমি মনে করি আপনি ইতিমধ্যে কিছু লাইনে একটি লাইনে লিখে ব্যবহার করে কিছু বাইট সংরক্ষণ করতে পারেন input('')। অপ্রয়োজনীয় স্থান এবং প্রথম বন্ধনী এড়ানোও! এবং আপনি প্রথমে সংজ্ঞা দিয়ে কিছু বাইট ছড়িয়ে দিতে পারেন f=@issorted।
— flawr
1

পাওয়ারশেল ভি 2 +, 87 80 বাইট

param($a)0..($a.length-1)|%{if($a[$_-1]-gt$a[$_]){$c--}};(0,($a|sort))[++$c-ge0]

ইনপুট তালিকার মধ্য দিয়ে পদক্ষেপগুলি $a, প্রতিটি জোড়াযুক্ত উপাদান (সর্বশেষ এবং প্রথম সহ) চেক করে একাধিক হ্রাসমান জোড় আছে কিনা তা পরীক্ষা করে দেখুন। নির্দিষ্ট জুটি যদি হ্রাস পাচ্ছে তবে আমরা হ্রাস পাচ্ছি $c। শেষে 0থাকা মানটির ভিত্তিতে বাছাই করা তালিকা বা একক উপাদানকে আউটপুট দেয় $c। যদি একাধিক "খারাপ" জুটি উপস্থিত থাকে, তবে ++$cএখনও তা নেতিবাচক থাকবে, অন্যথায় এটি কমপক্ষে হবে 0, সুতরাং সিউডো-টের্নারি দ্বিতীয় উপাদানটি বেছে নেওয়া হয়েছে ( $a|sort)।

আমি xnor দেখতে অনুরূপ কিছু করেছে , কিন্তু আমি স্বাধীনভাবে এটি নিয়ে এসেছি।

— AdmBorkBork
সূত্র
1

ফ্যাক্টর, 47 বাইট

[ dup dup append [ natural-sort ] dip subseq? ]

ক্রমটি নিজেই যোগ করুন, তারপরে পরীক্ষা করুন যে মূলটির বাছাই করা উপস্থাপনাটি একটি অনুবর্তন কিনা is

— বিড়াল
সূত্র
1
এটি দার্শনিক হাইকুর মতো শোনাচ্ছে: dup dup append \\ natural sort \\ dip subseq?এমনকি 4-4-3 প্যাটার্নেও ফিট করে :)
— আকিইইনো
@ আকিইনো: ডি পয়েন্ট-মুক্ত ভাষাগুলি এত কাব্যিক।
— বিড়াল
1

সি ++, 313 359 370 বাইট

এই কাজটি করার জন্য এবং আমাকে কিছু দুর্দান্ত গল্ফিং পদ্ধতি শেখানোর জন্য @ কিওয়ার্তির কাছে বিশাল চিৎকার!

Golfed:

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){vector<int> v;int x,c=0,s=0,y;while(cin>>x)v.push_back(x);do if(rotate(v.begin(),v.begin()+1,v.end()),c++,is_sorted(v.begin(),v.end()))s=1;while(!s&c<=v.size());if(s)for(y=0;y<v.size();y++)cout<<v[y]<<" ";else cout<<"False";}

Ungolfed:

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int main(){
  vector <int> v;
  int x, c=0, s=0, y;

  while(cin>>x)
    v.push_back(x);

  do 
    if (
      rotate(v.begin(),v.begin()+1,v.end()),
      c++,
      is_sorted(v.begin(),v.end())
    ) s = 1;
  while(!s & c <= v.size());

  if (s)
    for(y=0; y<v.size(); y++)
      cout<<v[y]<<" ";
  else
    cout<<"False";
}
— মিশেলফ্রান্সিস বুস্টিলোস
সূত্র
1
গল্ফিং কেবল স্থানগুলি সরিয়ে দিচ্ছে না। 6 বার 30 হয় using namespace std;যখন 20 অক্ষর std::হয় bool s = False;- কেন না =0? আপনি ড্রপ করতে পারেন return 0;। এখানে বন্ধনী কেন !s&&(c<=v.size())? চিত্রের ধনুর্বন্ধনী এবং কোনও কমা নেই ...
— Qwertiy
ওহ ধন্যবাদ! প্রোগ্রামিং ক্লাস থেকে প্রচুর স্টাফ (যেমন std::এবং return 0;) অভ্যাস হয়ে গেছে। আমার প্রোগ্রামগুলি আরও ভাল করে পরীক্ষা করা শুরু করা দরকার।
— মিশেলফ্রান্সিস বুস্টিলোস
1
এছাড়াও বাগের একটি সেট রয়েছে। আপনি কেন শূন্য পর্যন্ত পড়েন এবং সেই শূন্যটিকে ডেটাতে রাখেন? আপনি কেন সমেত আকারে আউটপুট করবেন? কেন Trueএবং Falseপরিবর্তে trueএবং false। ideone.com/kVTI25 - আপনার সংস্করণ, আদর্শ one.com/y8s44A - স্থির এবং গল্ফ সংস্করণের জন্য প্রস্তুত।
— কিওয়ারটি
আবার আপনাকে ধন্যবাদ! ক্যাপিং Trueএবং Falseপাইথনের থেকে। আমিও জানতাম না যে আপনি ifএর মতো লিখতে পারেন!
— মাইকেলফ্রান্সিস বুস্টিলোস
1
এবং আরও অনেকগুলি সংক্ষিপ্ত করা হয়েছে: ideone.com/Dsbs8W এবং গল্ফড আইডিয়োনে / এএএচজেজে 5 ভি (<s> 255 </s> 252 অক্ষর)। ফোরচ লুপের জন্য সি ++ 14 ব্যবহার করা হয়েছে।
— কিওয়ারটি
1

ম্যাথক্যাড, টিবিডি

এখানে চিত্র বর্ণনা লিখুন

ম্যাথক্যাডে, 0 (স্কেলার) == মিথ্যা।

(সমতুল্য) বাইট গণনা টিবিডি হয় যতক্ষণ না গণনা পদ্ধতিটি সম্মত হয়। বাইট = অপারেটর / প্রতীক কীবোর্ড সমতুল্যতা ব্যবহার করে প্রায় 52 বাইট।

— স্টুয়ার্ট ব্রুফ
সূত্র
1

গণিত 55 55 61 58 বাইট

3 টি বাইট সংরক্ষণ করে মার্টিন বাটনারকে ধন্যবাদ জানায়।

আমার আগের প্রচেষ্টাগুলি পরীক্ষার সমস্ত ক্ষেত্রে পাস করেনি। Unionতালিকায় পুনরাবৃত্তিগুলি এড়ানোর জন্য আমাকে যুক্ত করা দরকার যা ক্রম অনুসারে ইনপুট ছিল। 

Join@Union@Cases[NestList[RotateRight,#,Length@#],Sort@#]&

টেস্ট

Join@Union@Cases[NestList[RotateRight,#,Length@#],Sort@#]&/@
{{1},{5,0,5},{3,2,1},{0,9,3},{1,2,3,4},{4,1,2,3},{0,2,0,2},{5,3,9,2,6,7},
{0,0,0,0,0,0,0},{75,230,30,42,50},{255,255,200,200,203}}

{{1}, {0, 5, 5}, {}, {}, {1, 2, 3, 4}, {1, 2, 3, 4}, {}, {}, {0, 0, 0, 0, 0, 0, 0}, {30, 42, 50, 75, 230}, 200, 200, 203, 255, 255}

ব্যাখ্যা

ইনপুট তালিকাটি 1 থেকে nবারে ডানদিকে ঘোরান , যেখানে nইনপুট তালিকার দৈর্ঘ্য। যদি সাজানো ইনপুট তালিকাটি আউটপুট ঘোরানো তালিকার মধ্যে থাকে তবে এটি ফিরিয়ে দিন; অন্যথায় একটি খালি তালিকা ফেরত দিন।

— DavidC
সূত্র
@ মার্টিনবাটনার, আপনার পরামর্শটি পরীক্ষার কয়েকটি ক্ষেত্রে ব্যর্থ হয়েছে, বিশেষত, ৩,৪,,,7,৮।
— ডেভিডসি
@ ডেভিডসি আহ, অভিশাপ, ঠিক বলেছেন, আমি ফাঁকা তালিকার আচরণ @@এবং মিশ্রণটি মিশ্রিত করেছি /@। Join@@তবুও কম হওয়া উচিত Flatten@।
— মার্টিন এন্ডার
1

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

1ড্রিফোর্টেবল হলে আউটপুট দেয়, অন্য কিছুই না

$a=$argv[1];$b=$a;sort($a);foreach($a as $v){echo($a===$b?1:'');array_unshift($b, array_pop($b));}
— MonkeyZeus
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.