Driftsort, bir diziyi "sıralamak" için basit bir yoldur. Dizi sıralanıncaya veya dizi sıralanamayana kadar dizideki elemanları "kaydırarak" veya "döndürerek" çalışır.

İki örnek üzerinden geçelim. İlk önce diziyi düşünün [10, 2, 3, 4, 7]. Dizi sıralanmadığından, bir kere döndürürüz. (Bu, aynı yönde kaldığı sürece her iki yönde de olabilir.) Sonra dizi:

[7, 10, 2, 3, 4]

Bu sıralanmamıştır, bu yüzden tekrar döndürürüz.

[4, 7, 10, 2, 3]

Ve yeniden:

[3, 4, 7, 10, 2]

Ve son bir zaman:

[2, 3, 4, 7, 10]

Ve sıralandı! Yani dizi [10, 2, 3, 4, 7]sürüklenebilir. Netlik için dizinin tüm dönüşleri:

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

Şimdi dizi düşünün [5, 3, 9, 2, 6, 7]. Dönmelerine bakı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]

Bu dizilerin hiçbiri sıralanmamıştır, bu nedenle dizi [5, 3, 9, 2, 6, 7]sürüklenemez.

Amaç Bir programa / işleve girdi olarak boş olmayan bir dizi / tamsayı listesi verilmişse, girişte driftsort uygulayın ve çıktılayın ya da sürüklenemiyorsa bir falsey değeri ( veya boş bir dizi / liste) verin. Tamsayılar dilinize max / dak bağlı, ancak bu en az 255, en az 0 olmalıdır.

Yerleşik sıralama yöntemlerini kullanabilirsiniz, ancak zorluğu çözen yerleşik bir yöntemi kullanamazsınız.

Bu bir kod golf , yani bayt cinsinden en kısa program.

Test durumları

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]

Jöle , 6 bayt

ṙỤċṢȧṢ

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

ṙỤċṢȧṢ  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?Dizideki her bir öğe için bir kereye kadar ateşler, ancak diziliş dizilip dizilenme durumuna getirildikten hemen sonra durur (ve gerçek değerini döndürür). Bu olursa, mutasyona uğramış diziyi döndürürüz. Aksi halde any?döndüren yanlış değeri döndürürüz.

Python 2, 51 bayt

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

Dönme zahmeti yok. Bunun yerine, listeyi sıralar, ardından devredilen listenin ardışık elemanları arasında en fazla bir düşüş olup olmadığını kontrol ederek orijinalin sürüklenebilir olup olmadığını kontrol eder. Sayısıdır <3çünkü mappedleri ile kısa liste Nonesonunda, sahte azalma ekledi.

Pyth, 9 bayt

*SQ}SQ.:+

Açıklama:

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

Burada dene!

Veya bir test takımı kullanın!

Matlab, 61 47 41 bayt

-6 bayt için @Suever teşekkürler!

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

Eğer strfind([a,a],sort(a))çalışırsa kendisi ekinde ayıklanmamış bir 'alt dize' olarak sıralanmış giriş vektörü bulmak için. Doğruysa, giriş sürüklenebilirdir ve boş bir vektör elde etmiyorsak 2 uzunluğunda bir vektör alırız. minsadece bunu sayı / boş bir vektöre dönüştürür. Sıralanan vektörü 0'a eklemek sadece onu görüntüler, boş bir vektöre eklemek hata verir.

Julia, 71 66 52 bayt

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

Bu, bir diziyi kabul eden ve bir dizi veya bir boole döndüren adsız bir işlevdir. Aramak için değişkene atayın.

Bir x giriş dizisi için, tüm x dönüşlerinin kümesini oluştururuz ve sıralanmış sürüm x'in bu listenin bir öğesi olup olmadığını kontrol ederiz. Öyleyse, sıralı x döndürürsek aksi halde false döndürürüz.

Dennis sayesinde 19 bayt kurtarıldı!

Pip , 15 + 1 = 17 16 bayt

Diğer golf dilleri bunu sudan esiyor. Ancak, zaten yazdığımdan beri ...

L#gI$<gPBPOgYgy

Girdiyi boşlukla ayrılmış komut satırı argümanları olarak alır. -pSonuç birleştirmek yerine okunaklı olarak görüntülemek için veya başka bir dizi formatlama bayrağı gerektirir . Sahte vaka, takip eden yeni satır sayesinde görülebilen boş bir dize verir.

                 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 bayt

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

İade 0başarısızlık üzerine. Önceki 85 83 80 bayt sürümü çağırarak kaçınılmalıdır 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)

Düzenleme: Kaydedilen 2 initialising tarafından bayt ciçin -1yerine 0. Geçiş yaparak 5 bayt Kaydedilen reduceiçin mapnefes ...

05AB1E , 12 bayt

Kod:

DgFÀÐ{Qi,}}0

CP-1252 kullanır kodlamasını . Çevrimiçi deneyin! .

Kardan adam 1.0.2 , 27 bayt

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

Bu, mevcut permavardan girdi alan ve çıkan bir alt yordamdır.

Çevrimiçi deneyin!

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

SGthyXfa*

Aynı fikri @ flawr cevabı biz kaçırmak strfind( Xf) girişin iki kopya birleştirme dahilinde girişinin sıralı versiyonunu bulmak için.

Çevrimiçi Deneyin!

açıklama

        % 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 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

Bu bitiştirir dizi x kendisi ve sayıları ile, yani bitişik altdizilimlerden sayısına sırasız çiftlerinin sayısı, [a, b] olan b - a <0 . Eğer c ait düzensiz çiftlerinin sayısı x kendisi ve t ise 1 , eğer x 'in son elemanı ilkinden daha büyük olan, sumdöner + t 2c .

X dizisi sürüklenebilirdir (i, t) = (1, 0) ( X sadece düzensiz çiftin daha küçük bir değere döndürülmesi gereken), (C, T) = (0, 1) ( X sıralanır) veya (c, t) = (0, 0) ( x sıralanır ve tüm öğeleri eşittir), ki bu 2c + t <3 olur .

Javascript ES6, 48 45 43 karakter

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

Ölçek:

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 bayt

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

Gerçekten isteğe bağlı bir argüman eklemem gerekiyor $( - circular permute left kereden fazla vermek ... bu 13 bayt olurdu. Bu, Prolog’da kararlı ve yeni bir aktarıcı kullandıktan sonra bekleyecektir.

açıklama

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 bayt

Özyinelemeli işlevi. İade nilgiriş dizisi driftsorted edilemezse.

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

CJam, 17 13 bayt

4 byte tasarruf için Dennis teşekkür ederiz.

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

Bir liste alıp veren isimsiz blok (işlev)

Test odası.

açıklama

Bu, esasen, xnor'ın sıralı listesinin, sürüklenmesinin sıralanabilir olması durumunda orijinal listenin iki katında göründüğünü gözlemlemesidir:

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

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

Çıktıyı boş bırakamazsam, 252 karakter 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 sürümü 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 << '-';
}

Not: @ MichelfrancisBustillos'un fikrine dayanarak .

Java 7, 207 bayt

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

Detaylı burada deneyin

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

çıktıyı boşlukla ayrılmış değerler olarak yazdırır veya fyanlış bir değer için yazdırır .

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

geçerli diziyi bulana veya bir kombinasyon bitene kadar tamsayı dizisinin tüm kombinasyonlarından geçer. dizi değiştirilmez, ancak sürüklenen sıra, boşlukla ayrılmış bir dize olarak depolanır.

biraz daha okunabilir:

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

çevrimiçi dene

C, 105 bayt

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

Bu, giriş tam sayılarını ayrı komut satırı argümanları olarak kabul eder ve çıktı listesini satır başına bir tam sayı olarak yazdırır.

Liste sürüklenemezse, program kayan nokta istisnası nedeniyle erken çıkar, bu nedenle boş çıktısı boş bir listeyi temsil eder.

Doğrulama

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

nilGirdi sürüklenemezse ya, sıralanan diziyi ya da (sahte bir değerdir) döndürür.

Python, 53 bayt

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

Bu başlığı test etmek istiyorsanız, https://www.repl.it/languages/python3 adresine gidin ve şunu kopyalayın:

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

Nasıl çalışır:

• ssortedlisteleri sıralayan python işlevini saklayan bir değişkendir
• N ana işlev
• Sıralanan giriş listesi: s(x)listenin sürüklenebilir olup olmadığı ile çarpılır str(s(x))[1:-1]in str(x+x)( @xnor sayesinde)
  • Bu çalışır çünkü [1,2,3,4]*falseboş bir listede sonuçlanır[]
  • ve [1,2,3,4]*truesonuçları[1,2,3,4]

Python, 83 bayt

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

Bu, diğer python cevapları tarafından utanç vericiydi, ama yine de gönderebilirim. Ben gerçekten sevmiyorum

range(len(l)))

Bölüm. Listede yinelemenin daha hızlı bir yolu var mı?

MATLAB / Octave, 118 bayt

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 bayt

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

$aBirden fazla azalan çift olup olmadığını görmek için her bir çift eleman (son ve ilk olanlar dahil) kontrol edilerek giriş listesi boyunca ilerler . Eğer belirli çift düşüyorsa, azalırız $c. Sonundaki 0değere bağlı $colarak sıralanmış listeyi veya tek bir öğeyi çıktılar . Eğer birden fazla "kötü" çifti mevcutsa, o ++$czaman hala negatif olacaktır, aksi takdirde en azından olacaktır 0, bu yüzden sahte üçlünün ikinci elemanı seçilir ( $a|sort).

Xnor’ın da benzer bir şey yaptığını görüyorum ama bağımsız olarak bunu buldum.

Faktör, 47 bayt

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

sekansın kendisine eklenir, ardından orijinalin sıralanmış yorumunun bir sıralama olup olmadığını kontrol edin.

C ++, 313 359 370 bayt

Bu çalışmayı ve bana harika golf yöntemlerini öğrettiği için @ Qwertiy'e büyük not!

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

Mathcad, TBD

Mathcad'da 0 (scalar) == yanlış.

(Eşdeğer) bayt sayısı, sayma yöntemi kararlaştırılana kadar TBD'dir. Bir bayt kullanarak yaklaşık 52 bayt = operatör / sembol klavyesi denkliği.

Mathematica 55 50 61 58 bayt

Martin Büttner sayesinde 3 bayt kurtarıldı.

Daha önceki girişimlerim tüm test olayını geçemedi. UnionSırayla girilen listedeki tekrarları önlemek için eklemeye ihtiyacım vardı.

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

Testler

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

açıklama

Giriş listesini 1 nkez sağa döndürün; giriş listesinin nuzunluğu. Sıralanan giriş listesi, çıktısı döndürülmüş listeler arasındaysa, döndürün; aksi takdirde boş bir liste döndürün.

PHP, 98 bayt

Bir Çıkışlar 1ise driftsortable, başka bir şey

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