Driftsort是“排序”数组的一种简单方法。它通过“滑动”或“旋转”数组中的元素来工作，直到对数组进行排序或对数组进行排序失败为止。

让我们来看两个例子。首先，考虑array [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]

果冻，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.

红宝石，33岁

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

a.any?对数组中的每个元素最多触发一次，除了一旦数组突变为已排序状态即停止（并返回true）。如果发生这种情况，我们将返回变异数组。否则，我们返回返回的假值any?。

Python 2，51字节

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

不必打扰旋转。取而代之的是，对列表进行排序，然后通过检查环化列表的连续元素中最多是否有一个减数来查看原始文档是否可以进行漂移排序。计数是<3因为在末尾map填充了较短的列表None，从而增加了虚假的减少。

Pyth，9个字节

*SQ}SQ.:+

说明：

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

在这里尝试！

或使用测试套件！

Matlab，61 47 41字节

感谢@Suever -6个字节！

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

如果strfind([a,a],sort(a))尝试查找已排序的输入向量作为未排序的“子字符串”，则会附加到其自身。如果为true，则输入是可漂移排序的，并且我们得到一个长度为2的向量，否则，我们得到一个空向量。min只是将其转换为数字/空向量。将排序后的向量添加到0只会显示它，将其添加到空向量会抛出错误。

朱莉娅71 66 52字节

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

这是一个匿名函数，它接受一个数组并返回一个数组或一个布尔值。要调用它，请将其分配给变量。

对于输入数组x，我们构造x的所有旋转的集合，并检查排序后的版本x是否为该列表的元素。如果是，则返回已排序的x，否则返回false。

感谢Dennis，节省了19个字节！

点，15 +1 = 17 16字节

嗯，其他高尔夫语言正在把它吹出水面。但是，由于我已经写过了...

L#gI$<gPBPOgYgy

将输入作为以空格分隔的命令行参数。需要-p或另一个数组格式标志来清晰显示结果，而不是串联显示。错误的情况将输出一个空字符串，该字符串可通过结尾的换行符看到。

                 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字节

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个字节的初始化c，以-1代替0。从切换reduce到map，节省了5个字节。

05AB1E，12个字节

码：

DgFÀÐ{Qi,}}0

使用CP-1252编码。在线尝试！。

雪人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

MATL，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

朱莉娅，33个字节

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

在线尝试！

怎么运行的

这样可以将阵列X与自身和计数对属于的顺序出的数量，即连续的子阵列的数目[A，B]为其中b - a <0时。如果c是x本身的无序对的数量，并且如果x的最后一个元素大于第一个元素，则t为1，则将返回2c + t。sum

数组x是可漂移排序的iff （c，t）=（1，0）（x必须旋转到唯一的无序对中的较小值），（c，t）=（0，1）（x已排序）或（c，t）=（0，0）（x已排序且所有元素均相等），当2c + t <3时为真。

的Javascript 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)

Brachylog，39个字节

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

我真的需要添加一个可选参数来$( - circular permute left进行多次置换……这将是13个字节。在Prolog中实施稳定的新编译器后，将等待。

说明

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个字节

递归函数。返回nil输入数组是否不能进行漂移排序。

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

CJam，17 13字节

感谢Dennis节省了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.

C ++ 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 << '-';
}

PS：基于@MichelfrancisBustillos的想法。

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

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

遍历整数数组的所有组合，直到找到有效序列或组合用完。不会修改数组，而是将driftsorted序列存储为以空格分隔的字符串。

更具可读性：

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

在线尝试

C，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

红宝石，28岁

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

返回排序后的数组，或者返回nil（输入值是伪造的）如果输入不是可漂移排序的。

Python，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]))

怎么运行的：

• s是存储对sorted列表进行排序的python函数的变量
• 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]

Python，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

这让其他python答案感到羞耻，但无论如何我还是应该发布它。我真的不喜欢

range(len(l)))

部分。有没有更快的方法来遍历列表？

MATLAB / Octave，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

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做过类似的事情，但是我是独立提出的。

因子，47字节

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

将序列连接到自身上，然后检查原始序列的排序表示形式是否为子序列。

C ++，313个359 370字节

@Qwertiy对此大声喊叫，以使其正常工作并教我一些出色的高尔夫方法！

打高尔夫球：

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

取消高尔夫：

#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

在Mathcad中，0（标量）== false。

（等效）字节计数为TBD，直到同意计数方法为止。使用一个字节=运算符/符号键盘等效项，大约52个字节。

Mathematica 55 50 61 58字节

感谢MartinBüttner，节省了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是输入列表的长度。如果排序后的输入列表在输出循环列表中，则将其返回；否则，返回它。否则返回一个空列表。

PHP，98字节

输出一个1if如果可漂移排序，否则不输出

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