Driftsort는 배열을 "정렬"하는 간단한 방법입니다. 배열이 정렬 될 때까지 또는 배열이 정렬되지 않을 때까지 배열에서 요소를 "슬라이딩"또는 "회전"하여 작동합니다.

두 가지 예를 살펴 보겠습니다. 먼저 배열을 고려하십시오 [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?반환합니다.

파이썬 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 바이트

-6 바이트를위한 @Suever에게 감사합니다!

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

경우 strfind([a,a],sort(a))시도 자체에 추가 된 분류되지 않은의 '문자열'로 정렬 된 입력 벡터를 찾을 수 있습니다. 참이면 입력이 드리프트 가능하고 길이가 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

자바 스크립트 (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 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

눈사람 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 를 자체와 연결하고 순서가 잘못된 쌍의 수, 즉 b-a <0 인 연속 서브 어레이의 수 [a, b] 를 계산 합니다. 만약 c 가 x 와 t 의 비 순서 쌍의 수 라면 있다 한 경우 X 의 마지막 요소는 먼저보다 큰 경우, sum반환 + t를 2C .

배열 x 는 표류 가능 iff (c, t) = (1, 0) ( x 는 순서가없는 유일한 쌍의 더 작은 값으로 회전해야 함), (c, t) = (0, 1) ( x 는 정렬 됨) 또는 (c, t) = (0, 0) ( x 가 정렬되고 모든 요소가 동일 함), 이는 iff 2c + t <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)

Brachylog , 39 바이트

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

나는 $( - circular permute left두 번 이상 permute 하기 위해 선택적 인수를 추가해야합니다 ... 이것은 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

루비, 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*}

리스트를 가져오고 리턴하는 명명되지 않은 블록 (함수).

테스트 스위트.

설명

이것은 기본적으로 정렬 된 목록이 드리프트가 정렬 가능한 경우 원래 목록의 두 배로 나타나는 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<<'-';}

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의 아이디어를 기반으로 합니다.

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

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

이것은 입력 정수를 별도의 명령 행 인수로 승인하고 출력 목록을 행당 하나의 정수로 인쇄합니다.

목록을 표류 할 수없는 경우 부동 소수점 예외로 인해 프로그램이 조기 종료되므로 빈 출력은 빈 목록을 나타냅니다.

확인

$ 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입력이 표류 정렬 가능하지 않은 경우 (가짜 값)를 반환합니다.

파이썬, 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)( @xnor 덕분에)
  • [1,2,3,4]*false결과는 빈 목록 이되기 때문에 작동 합니다[]
  • 그리고 [1,2,3,4]*true결과[1,2,3,4]

파이썬, 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)))

부품. 목록을 반복하는 더 빠른 방법이 있습니까?

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

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, TBD

Mathcad에서는 0 (스칼라) == false입니다.

(등가) 바이트 수는 계산 방법이 동의 될 때까지 TBD입니다. 바이트 = 연산자 / 기호 키보드 동등성을 사용하는 약 52 바이트.

매스 매 티카 55 50 61 58 bytes

Martin Büttner 덕분에 3 바이트가 절약되었습니다.

이전의 시도는 모든 테스트 사례를 통과하지 못했습니다. Union순서대로 입력 된 목록에서 반복을 피하기 위해 추가해야했습니다 .

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

Tests

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

Explanation

Right rotate the input list from 1 to n times, where n is the length of the input list. If the sorted input list is among the output rotated lists, return it; otherwise return an empty list.

PHP, 98 bytes

Outputs a 1 if driftsortable, else nothing

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