Driraftort là một cách đơn giản để "sắp xếp" một mảng. Nó hoạt động bằng cách "trượt" hoặc "xoay" các phần tử trong mảng cho đến khi mảng được sắp xếp hoặc cho đến khi mảng không được sắp xếp.

Hãy đi qua hai ví dụ. Đầu tiên, hãy xem xét các mảng [10, 2, 3, 4, 7]. Vì mảng không được sắp xếp, chúng tôi xoay nó một lần. (Điều này có thể xảy ra theo một trong hai hướng, miễn là nó vẫn giữ nguyên hướng.) Sau đó, mảng trở thành:

[7, 10, 2, 3, 4]

Điều này không được sắp xếp, vì vậy chúng tôi xoay một lần nữa.

[4, 7, 10, 2, 3]

Và một lần nữa:

[3, 4, 7, 10, 2]

Và lần cuối cùng:

[2, 3, 4, 7, 10]

Và nó đã được sắp xếp! Vì vậy, mảng [10, 2, 3, 4, 7]là driftraftortable. Dưới đây là tất cả các phép quay của mảng, cho rõ ràng:

[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]

Hãy xem xét các mảng [5, 3, 9, 2, 6, 7]. Nhìn vào góc quay của nó:

[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]

Không có mảng nào trong số này được sắp xếp, vì vậy mảng [5, 3, 9, 2, 6, 7]không bị trôi dạt.

Mục tiêu Đưa ra một mảng / danh sách các số nguyên làm đầu vào cho một chương trình / hàm, thực hiện các bản nháp trên đầu vào và đầu ra nó, hoặc xuất ra một giá trị falsey ( hoặc một mảng / danh sách trống) nếu nó không thể bị trôi. Các số nguyên được liên kết với ngôn ngữ của bạn tối đa / phút, nhưng điều này phải có ít nhất 255 cho tối đa và 0 cho tối thiểu.

Bạn có thể sử dụng các phương pháp sắp xếp tích hợp, nhưng không phải là phương pháp tích hợp sẵn để giải quyết thách thức.

Đây là một môn đánh gôn , vì vậy chương trình ngắn nhất tính bằng byte.

Các trường hợp thử nghiệm

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]

Thạch , 6 byte

ṙỤċṢȧṢ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

ṙỤċṢȧṢ  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.

Ruby, 33

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

a.any?kích hoạt tối đa một lần cho mỗi phần tử trong mảng, ngoại trừ nó dừng (và trả về true) ngay khi mảng bị biến đổi thành trạng thái được sắp xếp. Nếu điều này xảy ra, chúng tôi trả về mảng bị đột biến. Nếu không, chúng tôi trả lại giá trị sai mà any?trả về.

Python 2, 51 byte

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

Không thèm xoay. Thay vào đó, hãy sắp xếp danh sách, sau đó xem liệu bản gốc có thể sắp xếp trôi dạt hay không bằng cách kiểm tra xem có nhiều nhất một mức giảm trong số các phần tử liên tiếp của danh sách được luân chuyển hay không. Số lượng là <3bởi vì mapđệm danh sách ngắn hơn Noneở cuối, thêm một mức giảm giả.

Bình thường, 9 byte

*SQ}SQ.:+

Giải trình:

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

Hãy thử nó ở đây!

Hoặc sử dụng một bộ thử nghiệm!

Matlab, 61 47 41 byte

Cảm ơn @Suever cho -6 byte!

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

Nếu strfind([a,a],sort(a))cố gắng tìm vectơ đầu vào được sắp xếp dưới dạng một 'chuỗi con' của chưa được sắp xếp, thì nó đã được gắn vào chính nó. Nếu đúng, đầu vào là bản nháp và chúng ta có một vectơ có độ dài 2, nếu không chúng ta sẽ có một vectơ trống. minchỉ cần chuyển đổi nó thành một số / vector trống. Thêm vectơ đã sắp xếp vào 0 chỉ hiển thị nó, thêm vectơ vào một vectơ trống sẽ gây ra lỗi.

Julia, 71 66 52 byte

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

Đây là một hàm ẩn danh chấp nhận một mảng và trả về một mảng hoặc boolean. Để gọi nó, gán nó cho một biến.

Đối với mảng đầu vào x , chúng tôi xây dựng tập hợp tất cả các phép quay của x và kiểm tra xem phiên bản được sắp xếp x có phải là một thành phần của danh sách đó không. Nếu đúng, chúng ta trả về x được sắp xếp, nếu không chúng ta trả về false.

Đã lưu 19 byte nhờ Dennis!

Pip , 15 + 1 = 17 16 byte

Ugh, các ngôn ngữ chơi gôn khác đang thổi nó ra khỏi nước. Tuy nhiên, vì tôi đã viết nó ...

L#gI$<gPBPOgYgy

Lấy đầu vào làm đối số dòng lệnh được phân tách bằng dấu cách. Yêu cầu -phoặc một cờ định dạng mảng khác để hiển thị kết quả rõ ràng hơn là nối. Trường hợp sai xuất ra một chuỗi rỗng, có thể nhìn thấy nhờ vào dòng mới.

                 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

JavaScript (ES6), 72 70 65 byte

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

Trả 0về thất bại. Trước 85 83 phiên bản 80-byte tránh gọi 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)

Chỉnh sửa: Saved 2 byte bởi initialising cđể -1thay 0. Đã lưu 5 byte bằng cách chuyển từ reducesang map, thở dài ...

05AB1E , 12 byte

Mã số:

DgFÀÐ{Qi,}}0

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Người tuyết 1.0.2 , 27 byte

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

Đây là một chương trình con nhận đầu vào từ và đầu ra cho permavar hiện tại.

Hãy thử trực tuyến!

((                       ))  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

MATL, 13 12 10 9 byte

SGthyXfa*

Ý tưởng tương tự như câu trả lời của @ flawr trong đó chúng tôi chiếm quyền điều khiển strfind( Xf) để tìm phiên bản được sắp xếp của đầu vào trong phần nối của hai bản sao của đầu vào.

Hãy thử trực tuyến!

Giải trình

        % 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

Julia, 33 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Điều này kết hợp mảng x với chính nó và đếm số lượng các cặp không theo thứ tự, tức là số lượng các phân đoạn liền kề [a, b] trong đó b - a <0 . Nếu c là số cặp x không có thứ tự của chính nó và t là 1 nếu phần tử cuối cùng của x lớn hơn phần tử đầu tiên của nó, sumsẽ trả về 2c + t .

Mảng x là iftraftortable iff (c, t) = (1, 0) ( x phải được xoay thành giá trị nhỏ hơn của cặp không có thứ tự duy nhất), (c, t) = (0, 1) ( x được sắp xếp) hoặc (c, t) = (0, 0) ( x được sắp xếp và tất cả các phần tử của nó đều bằng nhau), điều này đúng iff 2c + t <3 .

Javascript ES6, 48 45 43 ký tự

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

Kiểm tra:

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)

Brachylog , 39 byte

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

Tôi thực sự cần thêm một đối số tùy chọn vào $( - circular permute left để hoán vị nhiều lần ... đây sẽ là 13 byte. Điều này sẽ đợi sau khi triển khai bộ chuyển mã mới ổn định trong Prolog.

Giải trình

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

Ruby, 47 byte

Hàm đệ quy. Trả về nilnếu mảng đầu vào không thể bị trôi.

f=->a,i=0{a.sort==a ?a:a[i+=1]?f[a.rotate,i]:p}

CJam, 17 13 byte

Cảm ơn Dennis vì đã tiết kiệm 4 byte.

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

Một khối không tên (hàm) sẽ nhận và trả về một danh sách.

Bộ thử nghiệm.

Giải trình

Điều này về cơ bản sử dụng quan sát của xnor rằng danh sách được sắp xếp xuất hiện trong hai lần danh sách ban đầu nếu sắp xếp trôi dạt:

_$   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.

C ++ 14, 242 ký tự

#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;}}

Nếu tôi không thể để trống đầu ra, hãy chọn 252 ký tự 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<<'-';}

Phiên bản đã được chỉnh sửa 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 << '-';
}

Tái bút: Dựa trên ý tưởng của @ MichelfrancisBustillos .

Java 7, 207 byte

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;}

Thử chi tiết tại đây

// 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;
}

Java 175

in ra đầu ra dưới dạng các giá trị được phân tách bằng dấu cách hoặc in fcho giá trị falsey.

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);}

trải qua tất cả các kết hợp của mảng số nguyên cho đến khi tìm thấy chuỗi hợp lệ hoặc hết các kết hợp. mảng không được sửa đổi, nhưng thay vào đó, chuỗi được sắp xếp lại được lưu trữ dưới dạng một chuỗi phân tách không gian.

dễ đọc hơn một chút:

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);
}

thử trực tuyến

C, 105 byte

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]);}

Điều này chấp nhận các số nguyên đầu vào dưới dạng các đối số dòng lệnh riêng biệt và in danh sách đầu ra dưới dạng một số nguyên trên mỗi dòng.

Nếu danh sách không thể chuyển đổi được, chương trình sẽ thoát sớm do ngoại lệ điểm nổi, do đó, đầu ra trống của nó đại diện cho một danh sách trống.

xác minh

$ 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

Ruby, 28

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

Trả về mảng được sắp xếp hoặc nil(là giá trị giả) nếu đầu vào không thể sắp xếp trôi.

Python, 53 byte

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

Nếu bạn muốn kiểm tra cái đầu này qua https://www.repl.it/lacular/python3 và sao chép dán này:

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

Làm thế nào nó hoạt động:

• slà một biến lưu trữ sortedhàm python sắp xếp danh sách
• N là chức năng chính
• Danh sách đầu vào được sắp xếp: s(x)được nhân với việc danh sách có bị trôi hay không str(s(x))[1:-1]in str(x+x)(nhờ @xnor)
  • Điều này hoạt động vì [1,2,3,4]*falsekết quả trong một danh sách trống[]
  • và [1,2,3,4]*truekết quả trong[1,2,3,4]

Python, 83 byte

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

Điều này đã gây bối rối bởi các câu trả lời của con trăn khác, nhưng dù sao tôi cũng có thể đăng nó. Tôi thực sự không thích

range(len(l)))

phần. Có cách nào nhanh hơn để lặp qua danh sách không?

MATLAB / Octave, 118 byte

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

PowerShell v2 +, 87 80 byte

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

Các bước thông qua danh sách đầu vào $a, kiểm tra từng yếu tố theo cặp (bao gồm cả cuối cùng và đầu tiên) để xem liệu có nhiều hơn một cặp giảm hay không. Nếu cặp cụ thể đang giảm, chúng tôi giảm $c. Xuất ra danh sách được sắp xếp hoặc phần tử đơn 0, dựa trên giá trị $cở cuối. Nếu có nhiều hơn một cặp "xấu", thì ++$cvẫn sẽ âm, nếu không thì ít nhất nó sẽ là 0yếu tố thứ hai của giả giả được chọn ( $a|sort).

Tôi thấy xnor đã làm một cái gì đó tương tự , nhưng tôi đã nghĩ ra điều này một cách độc lập.

Yếu tố, 47 byte

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

nối chuỗi vào chính nó, sau đó kiểm tra xem biểu hiện được sắp xếp của bản gốc có phải là một chuỗi không.

C ++, 313 359 370 byte

Hét to với @Qwertiy vì đã làm việc này và dạy tôi một số phương pháp chơi golf tuyệt vời!

Chơi gôn

#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";}

Ung dung:

#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";
}

Mathcad, TBD

Trong Mathcad, 0 (vô hướng) == false.

(Tương đương) số byte là TBD cho đến khi phương thức đếm đồng ý. Xấp xỉ 52 byte bằng cách sử dụng tương đương bàn phím byte = toán tử / ký hiệu.

Toán học 55 50 61 58 byte

Với 3 byte được lưu nhờ Martin Büttner.

Những nỗ lực trước đây của tôi đã không vượt qua tất cả các trường hợp thử nghiệm. Tôi cần phải thêm Unionđể tránh sự lặp lại trong danh sách được nhập theo thứ tự.

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

Xét nghiệm

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}}

Giải trình

Xoay phải danh sách đầu vào từ 1 đến nlần, trong đó nđộ dài của danh sách đầu vào. Nếu danh sách đầu vào được sắp xếp nằm trong số các danh sách xoay đầu ra, hãy trả về nó; mặt khác trả về một danh sách trống

PHP, 98 byte

Đầu ra 1nếu trôi dạt, không có gì khác

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