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?

— फिलिप हगलुंड

@FilipHaglund मैंने इसे कॉल करने के बारे में सोचा था, लेकिन यह 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

अहम, UTF8 के 19 बाइट्स।

— rsaxvc

11

जेली में एक कस्टम कोड पेज होता है, जो एक ही बाइट को 256 अक्षरों में से प्रत्येक को समझता है। (यह UTF-8 btw के साथ 16 बाइट्स है।)

— डेनिस

3

@ डेनिस: आपको एक ही टिप्पणी करने से रोकने के लिए, हमें रोकने के लिए (यानी, जो लोग पहले से यह नहीं जानते थे) उसे अपने सभी जेली सबमिशन में कॉपी / पेस्ट करना चाहिए? ;)

— ओलिवियर दुलैक

18

रूबी, ३३

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

a.any?सरणी में प्रत्येक तत्व के लिए एक बार आग लग जाती है, इसके अलावा यह बंद हो जाता है (और सच लौटाता है) जैसे ही सरणी को सॉर्ट की गई अवस्था में बदल दिया जाता है। यदि ऐसा होता है, तो हम उत्परिवर्तित सरणी लौटाते हैं। अन्यथा हम उस झूठे मूल्य को any?वापस करते हैं जो रिटर्न करता है।

— 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]?

— 19

हां, प्रत्येक पूर्णांक सरणी को स्ट्रिंग के रूप में भी समझा जा सकता है, जहां प्रत्येक संख्या को एक वर्ण माना जाता है, चाहे संख्या कितनी भी बड़ी हो।

— flawr

@flawr मेरी व्याख्या यह है कि strfindसंख्याओं के साथ सीधे काम कर सकते हैं, न केवल चार्ट के साथ (भले ही वह दस्तावेज न हो)। यदि संख्या को वर्णों के रूप में व्याख्या किया जा रहा था, तो वे 65535(उदाहरण के लिए प्रयास करें +char(1e5)) तक सीमित होंगे

— लुइस मेंडो

@LuisMendo आप सही हैं, यह फ्लोटिंग पॉइंट नंबरों के साथ भी काम करता है। ध्यान दें कि 65535 से ऊपर के अंक बस एक स्ट्रिंग के हिस्से के रूप में माने जाने वाले स्थान के रूप में प्रदर्शित होंगे।

— flawr

5

जूलिया, 71 66 52 बाइट्स

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

यह एक अनाम फ़ंक्शन है जो किसी सरणी को स्वीकार करता है और एक सरणी या बूलियन देता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

के लिए एक इनपुट सरणी एक्स , हम सभी को रोटेशन के सेट का निर्माण एक्स और जाँच क्रमबद्ध संस्करण है कि क्या एक्स उस सूची का एक तत्व है। यदि ऐसा है, तो हम x सॉर्ट किए गए रिटर्न देते हैं , अन्यथा हम झूठे लौटते हैं।

डेनिस की बदौलत 19 बाइट बच गईं!

— एलेक्स ए।
स्रोत

4

पिप , 15 + 1 = 17 16 बाइट्स

उह, अन्य गोल्फिंग भाषाएं इसे पानी से बाहर निकाल रही हैं। हालाँकि, जब से मैंने इसे लिखा है ...

L#gI$<gPBPOgYgy

अंतरिक्ष-पृथक कमांड-लाइन तर्कों के रूप में इनपुट लेता है। आवश्यक है -pया किसी अन्य सरणी-स्वरूपण झंडा परिणाम प्रदर्शित करने के लिए स्पष्ट रूप से नहीं बल्कि concatenated से। झूठा मामला एक खाली स्ट्रिंग को आउटपुट करता है, जो अनुगामी न्यूलाइन के गुण से दिखाई देता है।

                 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

जावास्क्रिप्ट (ईएस 6), 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]।

— क्वर्टी

@Qwertiy ओवरसाइट के बारे में क्षमा करें sort, जिसके कारण तीसरा परीक्षण विफल हो गया। अन्य दो परीक्षण विफलताओं के कारण मुझे ओवर-गोल्फिंग किया गया; मैं पिछले संस्करण में वापस आ गया हूं।

— नील

3

05AB1E , 12 बाइट्स

कोड:

DgFÀÐ{Qi,}}0

CP-1252 का उपयोग करता है एन्कोडिंग का । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

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

— Doorknob
स्रोत

3

MATL, 13 12 10 9 बाइट्स

SGthyXfa*

@ दोष के उत्तर के समान विचार जहां हम अपहरण करते हैं 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

— लुइस मेंडो

@LuisMendo सिर्फ एक nकारण से प्रतिस्थापित नहीं nकिया जा सकता है> 1. हालांकि a निश्चित रूप से काम करता है। मुझे लगा कि एक बेहतर तरीका है। धन्यवाद!

— स्वेअर

3

जूलिया, 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

यह अपने साथ एरे एक्स को समेटता है और क्रम से बाहर होने वाले जोड़े की संख्या को गिनता है, अर्थात सन्निहित उप-संख्या [a, b] जिसके लिए b - a <0 । यदि ग की अव्यवस्थित जोड़े की संख्या है एक्स ही है और टी है 1 यदि एक्स के अंतिम तत्व अपनी पहली से बड़ा है, sumवापस आ जाएगी + टी 2c ।

सरणी x driftsortable iff (c, t) = (1, 0) है ( x को केवल अनियंत्रित युग्म के छोटे मान में घुमाया जाना है), (c, t) = (0, 1) ( x को सॉर्ट किया गया है या (सी, टी) = (0, 0) ( एक्स को सॉर्ट किया गया है और इसके सभी तत्व समान हैं), जो कि सही iff 2c + t <3 है ।

— डेनिस
स्रोत

3

जावास्क्रिप्ट ईएस 6, 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+

— नील

@ user6188402, हां, धन्यवाद।

— क्वर्टी 20

2

ब्रेकीलॉग , 39 बाइट्स

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

मुझे वास्तव में एक वैकल्पिक तर्क जोड़ने की आवश्यकता है $( - circular permute left से अधिक बार अनुमति लिए ... यह 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

CJam, 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 chars 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<<'-';}

Ungolfed संस्करण 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 << '-';
}

पुनश्च: @ MichelfrancisBustillos के विचार पर आधारित ।

— Qwertiy
स्रोत

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

रूबी, २,

->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)( @xnor के लिए धन्यवाद)
- यह काम करता है क्योंकि [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)))

अंश। क्या सूची के माध्यम से पुनरावृति का एक तेज़ तरीका है?

— DJMcMayhem
स्रोत

1

यह ज्यादा नहीं है, लेकिन l.append(l.pop(0))or g==l for _ in lरेंज-लेन दृष्टिकोण पर एक बाइट बचाता है। एक का उपयोग करने से lambda14 अतिरिक्त बाइट्स बचेंगे।

— डेनिस

1

MATLAB / ऑक्टेव, 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।

— दोष

1

PowerShell v2 +, 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? ]

अनुक्रम को स्वयं से मिलाएं, फिर जांचें कि क्या मूल का क्रमबद्ध प्रतिपादन एक अनुवर्ती है।

— बिल्ली
स्रोत

1

यह एक दार्शनिक हाइकु जैसा लगता है: dup dup append \\ natural sort \\ dip subseq?यहां तक कि 4-4-3 पैटर्न भी फिट बैठता है :)

— अकिइनो

@ अकिइनो: डी बिंदु मुक्त भाषा इतनी काव्यात्मक हैं।

— बिल्ली

1

सी ++, 313 359 370 बाइट्स

इस काम को पाने और मुझे कुछ बेहतरीन गोल्फ बनाने के तरीके सिखाने के लिए @Qwertiy को बहुत बड़ा झटका!

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

गोल्फ केवल रिक्त स्थान नहीं निकाल रहा है। using namespace std;जब 20 std::बार 6 बार 30 है। bool s = False;- क्यों नहीं =0? तुम गिरा सकते हो return 0;। कोष्ठक यहाँ क्यों हैं !s&&(c<=v.size())? फिगर ब्रेसेस और नो कॉमा ...

— क्वर्टी २१'१६

वाह धन्यवाद! प्रोग्रामिंग कक्षाओं से बहुत सारे सामान (जैसे std::और return 0;) आदत बन गए हैं। मुझे वास्तव में अपने कार्यक्रमों को बेहतर तरीके से जांचना शुरू करना होगा।

— मिशेलफ्रांसिस बस्टिलोस

1

इसके अलावा कीड़े का एक सेट है। आप शून्य तक क्यों पढ़ते हैं और उस शून्य को डेटा में डालते हैं? आप समावेशी आकार देने के लिए आउटपुट क्यों देते हैं? क्यों Trueऔर Falseके बजाय trueऔर false। ideone.com/kVTI25 - आपका संस्करण, ideone.com/y8s44A - फिक्स्ड और गोल्फिंग संस्करण के लिए तैयार है।

— क्वर्टी

फिर से धन्यवाद! क्षमता Trueऔर Falseपायथन से है। मुझे यह भी नहीं पता था कि आप ऐसा लिख सकते हैं if!

— मिशेलफ्रांसिस बस्टिलोस

1

और बहुत छोटा: ideone.com/Dsbs8W और golfed ideone.com/HAzJ5V (<s> 255 </ s> 252 वर्ण)। फोर्क लूप के लिए C ++ 14 का उपयोग किया।

— क्वर्टी

1

मठकाद, टीबीडी

मथकड में, 0 (स्केलर) == असत्य।

(समतुल्य) बाइट काउंट टीबीडी है जब तक कि मतगणना विधि सहमत नहीं हो जाती। एक बाइट = ऑपरेटर / प्रतीक कीबोर्ड समतुल्यता का उपयोग करके 52 बाइट्स को अनुमानित करें।

— स्टुअर्ट ब्रुफ़
स्रोत

1

गणितज्ञ 55 50 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
स्रोत

@ मार्टिनबटनर, आपके सुझाव कुछ परीक्षण मामलों में विफल रहे, विशेष रूप से, # 3,4,7,8।

— डेविड

@DavidC आह, धिक्कार है, तुम सही हो, मैं खाली सूची के व्यवहार पर @@और मिलाया /@। हालांकि Join@@अभी भी कम होना चाहिए Flatten@।

— मार्टिन एंडर

1

PHP, 98 बाइट्स

आउटपुट 1अगर एक driftsortable, और कुछ नहीं

$a=$argv[1];$b=$a;sort($a);foreach($a as $v){echo($a===$b?1:'');array_unshift($b, array_pop($b));}

— MonkeyZeus
स्रोत

एक सरणी बहती है

परीक्षण के मामलों

जेली , 6 बाइट्स

यह काम किस प्रकार करता है

रूबी, ३३

पायथन 2, 51 बाइट्स

अजगर, 9 बाइट्स

मतलाब, 61 47 41 बाइट्स

जूलिया, 71 66 52 बाइट्स

पिप , 15 + 1 = 17 16 बाइट्स

जावास्क्रिप्ट (ईएस 6), 72 70 65 बाइट्स

05AB1E , 12 बाइट्स

स्नोमैन 1.0.2 , 27 बाइट्स

MATL, 13 12 10 9 बाइट्स

जूलिया, 33 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट ईएस 6, 48 45 43 चार्ट

ब्रेकीलॉग , 39 बाइट्स

व्याख्या

रूबी, 47 बाइट्स

CJam, 17 13 बाइट्स

व्याख्या

सी ++ 14, 242 वर्ण

जावा 7, 207 बाइट्स

जावा 175

सी, 105 बाइट्स

सत्यापन

रूबी, २,

पायथन, 53 बाइट्स

पायथन, 83 बाइट्स

MATLAB / ऑक्टेव, 118 बाइट्स

PowerShell v2 +, 87 80 बाइट्स

फैक्टर, 47 बाइट्स

सी ++, 313 359 370 बाइट्स

golfed:

Ungolfed:

मठकाद, टीबीडी

गणितज्ञ 55 50 61 58 बाइट्स

PHP, 98 बाइट्स