Driftsortは、配列を「ソート」する簡単な方法です。配列が並べ替えられるまで、または配列の並べ替えに失敗するまで、配列内の要素を「スライド」または「回転」させることで機能します。

2つの例を見てみましょう。まず、配列を考え[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でなければなりません。

組み込みのソート方法を使用できますが、課題を解決する組み込みのソート方法は使用できません。

これはcode-golfなので、バイト単位の最短プログラムです。

テストケース

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を返す）ことを除いて、配列内の各要素に対して最大1回起動します。これが発生した場合、変更された配列を返します。それ以外の場合は、返されるfalse値をany?返します。

Python 2、51バイト

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

回転を気にしません。代わりに、リストを並べ替えてから、循環リストの連続する要素の間に最大で1つの減少があるかどうかを確認することで、元のファイルがドリフトソート可能かどうかを確認します。カウントがある<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バイト

-6バイトをありがとう@Suever！

@(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を返します。

デニスのおかげで19バイトを節約できました！

Pip、15 + 1 = 17 16バイト

うーん、他のゴルフ言語はこれを水から吹き飛ばしています。しかし、すでに書いているので...

L#gI$<gPBPOgYgy

スペースで区切られたコマンドライン引数として入力を受け取ります。-p結果を連結するのではなく読みやすく表示するために、または別の配列フォーマットフラグが必要です。falseの場合、空の文字列が出力されます。これは、末尾の改行によって表示されます。

                 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)

編集：の代わりに初期化cして2バイトを保存しました。からに切り替えて5バイト節約しました...-10reducemap

05AB1E、12バイト

コード：

DgFÀÐ{Qi,}}0

CP-1252エンコードを使用します。オンラインでお試しください！。

Snowman 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*

入力の2つのコピーの連結内で入力のソートされたバージョンを見つけるためにハイジャック（）する@flawrの答えと同じアイデア。strfindXf

オンラインでお試しください！

説明

        % 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をそれ自体とカウントを有する、すなわち隣接サブアレイの数順序外のペアの数、[B]そのため、B - <0 。場合cはの非順序対の数であり、X自体及びtがある1場合、Xの最後の要素は、その最初のより大きい、sum返され2C + Tを。

配列xは、（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 left2回以上追加する必要があります...これは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

ルビー、47バイト

再帰関数。nil入力配列をドリフトソートできない場合に返します。

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

CJam、17 13バイト

4バイトを節約してくれたDennisに感謝します。

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

リストを取得して返す名前のないブロック（関数）。

テストスイート。

説明

これは、ドリフトがソート可能な場合、ソートされたリストが元のリストの2倍に表示されるという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);}

有効なシーケンスが見つかるか、組み合わせがなくなるまで、整数の配列のすべての組み合わせを調べます。配列は変更されませんが、代わりにドリフトソートされたシーケンスはスペース区切りの文字列として保存されます。

もう少し読みやすい：

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

これは、入力整数を個別のコマンドライン引数として受け入れ、出力リストを1行に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]))

使い方：

• ssortedリストをソートするpython関数を格納する変数です
• 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]

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。そのため、擬似3項の2番目の要素が選択されます（$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、TBD

Mathcadでは、0（スカラー）== false。

（同等の）バイトカウントは、カウント方法が合意するまでは未定です。byte =演算子/シンボルキーボード等価を使用した約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バイト

1ifsortsortableを出力します。それ以外は何も出力しません

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