Meydan okuma:

Giriş: aralığında farklı pozitif tam sayıların .$[1, \text{list-size}]$

Çıktı: Bir tamsayı: Listenin karıştırılma süresi . Bir liste için, bu, listenin iki yarıya bölündüğü ve bu yarımların birleştirildiği anlamına gelir (yani listenin bir [1,2,3,4,5,6,7,8,9,10]kez karıştırılması, sonuçta ortaya çıkar [1,6,2,7,3,8,4,9,5,10], bu nedenle bu zorlama için giriş [1,6,2,7,3,8,4,9,5,10]sonuçlanır 1).

Meydan okuma kuralları:

• Listenin yalnızca aralığında (veya 0 dizine alınmış giriş listelerine sahip olmayı seçerseniz aralığında pozitif tam sayılar içerdiğini varsayabilirsiniz. ).$[1, \text{list-size}]$$[0, \text{list-size}-1]$
• Tüm giriş listelerinin geçerli bir karıştırmalı karıştırılmış liste veya karıştırılmamış sıralanmış bir liste olacağını varsayabilirsiniz (bu durumda çıktı 0).
• Giriş listesinin en az üç değer içereceğini varsayabilirsiniz.

Adım adım örnek:

Giriş: [1,3,5,7,9,2,4,6,8]

Bir kez karıştırmak, şu şekilde olur: [1,5,9,4,8,3,7,2,6]çünkü her 0 dizine eklenmiş öğe bile önce gelir [1, ,5, ,9, ,4, ,8], ardından bundan sonra tüm 0 dizine eklenmiş öğeleri içerir [ ,3, ,7, ,2, ,6, ].
Liste henüz sipariş edilmedi, devam ediyoruz:

Listenin kaldırılması tekrar olur: [1,9,8,7,6,5,4,3,2]
Tekrar olur: [1,8,6,4,2,9,7,5,3]
Sonra: [1,6,2,7,3,8,4,9,5]
Ve sonunda: [1,2,3,4,5,6,7,8,9]ki bu, sıralı bir listedir, bu yüzden karıştırmayı bitirdik.

Orijinali [1,3,5,7,9,2,4,6,8]elde etmek için beş kez karıştırdık [1,2,3,4,5,6,7,8,9], bu yüzden çıktı 5bu durumda.

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Standart G / Ç kurallarına cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT işlevlerini, uygun parametreleri içeren fonksiyonlar / yöntemleri ve dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuzu test eden bir bağlantı ekleyin (ör. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemek şiddetle tavsiye edilir.

Test durumları:

Input                                                   Output

[1,2,3]                                                 0
[1,2,3,4,5]                                             0
[1,3,2]                                                 1
[1,6,2,7,3,8,4,9,5,10]                                  1
[1,3,5,7,2,4,6]                                         2
[1,8,6,4,2,9,7,5,3,10]                                  2
[1,9,8,7,6,5,4,3,2,10]                                  3
[1,5,9,4,8,3,7,2,6,10]                                  4
[1,3,5,7,9,2,4,6,8]                                     5
[1,6,11,5,10,4,9,3,8,2,7]                               6
[1,10,19,9,18,8,17,7,16,6,15,5,14,4,13,3,12,2,11,20]    10
[1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20]    17
[1,141,32,172,63,203,94,234,125,16,156,47,187,78,218,109,249,140,31,171,62,202,93,233,124,15,155,46,186,77,217,108,248,139,30,170,61,201,92,232,123,14,154,45,185,76,216,107,247,138,29,169,60,200,91,231,122,13,153,44,184,75,215,106,246,137,28,168,59,199,90,230,121,12,152,43,183,74,214,105,245,136,27,167,58,198,89,229,120,11,151,42,182,73,213,104,244,135,26,166,57,197,88,228,119,10,150,41,181,72,212,103,243,134,25,165,56,196,87,227,118,9,149,40,180,71,211,102,242,133,24,164,55,195,86,226,117,8,148,39,179,70,210,101,241,132,23,163,54,194,85,225,116,7,147,38,178,69,209,100,240,131,22,162,53,193,84,224,115,6,146,37,177,68,208,99,239,130,21,161,52,192,83,223,114,5,145,36,176,67,207,98,238,129,20,160,51,191,82,222,113,4,144,35,175,66,206,97,237,128,19,159,50,190,81,221,112,3,143,34,174,65,205,96,236,127,18,158,49,189,80,220,111,2,142,33,173,64,204,95,235,126,17,157,48,188,79,219,110,250]
                                                        45

Jöle , 8 bayt

ŒœẎ$ƬiṢ’

Çevrimiçi deneyin!

Nasıl?

ŒœẎ$ƬiṢ’ - Link: list of integers A
    Ƭ    - collect up until results are no longer unique...
   $     -   last two links as a monad:
Œœ       -     odds & evens i.e. [a,b,c,d,...] -> [[a,c,...],[b,d,...]]
  Ẏ      -     tighten                         -> [a,c,...,b,d,...]
     Ṣ   - sort A
    i    - first (1-indexed) index of sorted A in collected shuffles
      ’  - decrement

JavaScript (ES6), 44 bayt

@Nwellnhof tarafından önerilen daha kısa versiyon

Giriş olarak 1 indeksli kartların bulunduğu bir desteyi bekler.

f=(a,x=1)=>a[x]-2&&1+f(a,x*2%(a.length-1|1))

Çevrimiçi deneyin!

Bir üst kısım göz önüne alındığında, $[c_0,\ldots,c_{L-1}]$ uzunluğu $L$ , tanımlanabilir:

Ve biz bakmak öyle ki .$n$$c_{x_n}=2$

JavaScript (ES6),  57 52  50 bayt

Giriş olarak 0 dizinli kartlara sahip bir desteyi bekler.

f=(a,x=1,k=a.length-1|1)=>a[1]-x%k&&1+f(a,x*-~k/2)

Çevrimiçi deneyin!

Nasıl?

JS, özel bir adımla dizi dilimlerini çıkarmak için yerel desteğe sahip olmadığı için, tüm kırışıklık karıştırmayı taklit etmek muhtemelen oldukça maliyetli olurdu (ama dürüst olmak gerekirse, denemedim bile). Ancak, çözüm sadece 2. karta ve destedeki toplam kart sayısına bakılarak da bulunabilir.

Bir uzunluk güverte verilen , bu kod arar :$L$$n$

nerede ikinci kart ve olarak tanımlanır:$c_2$$k$

Python 2,39 bayt

f=lambda x:x[1]-2and-~f(x[::2]+x[1::2])

Çevrimiçi deneyin!

-4 Jonathan Allan'a teşekkürler .

R , 58 55 45 bayt

a=scan();while(a[2]>2)a=matrix(a,,2,F<-F+1);F

Çevrimiçi deneyin!

Sıralama işlemini simüle eder. Giriş 1 dizinli, FALSE0 için döndürür .

Perl 6 , 34 32 bayt

Jo King sayesinde -2 bayt

{(.[(2 X**^$_)X%$_-1+|1]...2)-1}

Çevrimiçi deneyin!

Arnauld'un yaklaşımına benzer . İkinci kartın n karışmadan sonraki indeksi, 2**n % kArnauld'un cevabında tanımlandığı şekilde k iledir.

APL (Dyalog Unicode) , 35 26 23 22 bayt ^SBCS

{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}

Çevrimiçi deneyin!

Adám'a yardım için teşekkürler, Erik için Outgolfer -3 ve -1 için ngn.

TIO bağlantısı iki test durumu içermektedir.

Açıklama:

{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}
{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]} ⍝ function takes one argument: ⍵, the array
 ⍵≡⍳≢⍵                 ⍝ if the array is sorted:
 ⍵≡⍳≢⍵                 ⍝ array = 1..length(array)
      :0               ⍝ then return 0
        ⋄              ⍝ otherwise
         1+            ⍝ increment
           ∇           ⍝ the value of the recursive call with this argument:
            ⍵[      ]  ⍝ index into the argument with these indexes:
                 ⍳⍴⍵   ⍝ - generate a range from 1 up to the size of ⍵
               2|      ⍝ - %2: generate a binary mask like [1 0 1 0 1 0]
              ⍒        ⍝ - grade (sorts but returns indexes instead of values), so we have the indexes of all the 1s first, then the 0s.

¹

Perl 6 , 36 34 32 bayt

Nwellnhof sayesinde -2 bayt

$!={.[1]-2&&$!(.sort:{$++%2})+1}

Çevrimiçi deneyin!

Liste sıralanıncaya kadar ters mod karışıklığı 2 dizinine göre sıralayarak karıştırır, daha sonra dizinin uzunluğunu döndürür.

Komik, genellikle Perl 6 için özyinelemeli yaklaşımı denemiyorum, ama bu sefer orijinalinden daha kısa sürdü.

Açıklama:

$!={.[1]-2&&$!(.sort:{$++%2})+1}
$!={                           }   # Assign the anonymous code block to $!
    .[1]-2&&                       # While the list is not sorted
            $!(             )      # Recursively call the function on
               .sort:{$++%2}       # It sorted by the parity of each index
                             +1    # And return the number of shuffles

05AB1E (eski) , 9 bayt

[DāQ#ι˜]N

Çevrimiçi deneyin!

açıklama

[   #  ]     # loop until
  ā          # the 1-indexed enumeration of the current list
 D Q         # equals a copy of the current list
     ι˜      # while false, uninterleave the current list and flatten
        N    # push the iteration index N as output

Java (JDK) , 59 bayt

a->{int c=0;for(;a[(1<<c)%(a.length-1|1)]>2;)c++;return c;}

Çevrimiçi deneyin!

Yalnızca 31'den küçük boyuttaki diziler veya 31'den az yineleme içeren çözümler için güvenilir bir şekilde çalışır. Daha genel bir çözüm için, 63 bayt ile aşağıdaki çözüme bakın:

a->{int i=1,c=0;for(;a[i]>2;c++)i=i*2%(a.length-1|1);return c;}

Çevrimiçi deneyin!

açıklama

Bir olukta, bir sonraki konum, bir tuhaf ya da uzunluk - 1 ise eşitse, iki modulo olan önceki bir kezdir.

Bu yüzden, dizideki 2 değerini bulana kadar bu indeksi kullanarak tüm endeksleri yineliyorum.

Kredi

• -8 byte Kevin Cruijssen sayesinde . (Dizi kullanarak önceki algoritma)
• Arnauld sayesinde -5 bayt .

J , 28 26 bayt

Jonah sayesinde -2 bayt!

 1#@}.(\:2|#\)^:(2<1{])^:a:

Çevrimiçi deneyin!

Ven'in APL çözümü ilham verdi.

Açıklama:

               ^:       ^:a:   while 
                 (2<1{])       the 1-st (zero-indexed) element is greater than 2   
     (        )                do the following and keep the intermediate results
          i.@#                 make a list form 0 to len-1
        2|                     find modulo 2 of each element
      /:                       sort the argument according the list of 0's and 1's
1  }.                          drop the first row of the result
 #@                            and take the length (how many rows -> steps)     

K (ngn / k) , 25 bayt

Tavsiye ve K tercümanı için teşekkür ederiz!

{#1_{~2=x@1}{x@<2!!#x}\x}

Çevrimiçi deneyin!

APL (NARS), karakter 49, bayt 98

{0{∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]}⍵}

neden en derin döngüde, bir lineer n kullanabilirken nlog (n) olması gereken bir algo kullanıyoruz? sadece birkaç bayt için daha fazla? [⍵≡⍵ [⍋⍵] O (nlog n) ve görmek için her bir unsurla yüzleşmek için ∧ / ¯1 ↓ ⍵≤1⌽⍵ O (n)] testi kullanılır:

  f←{0{∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]}⍵}
  f ,1
0
  f 1 2 3
0
  f 1,9,8,7,6,5,4,3,2,10
3
  f 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20
17

Ruby , 42 bayt

f=->d,r=1{d[r]<3?0:1+f[d,r*2%(1|~-d.max)]}

Çevrimiçi deneyin!

Nasıl:

Dizinin içindeki 2 sayısını arayın: ikinci konumda ise, güverte karıştırılmamış, aksi halde ardışık karışıklıkların koyacağı konumları kontrol edin.

R , 70 72 bayt

x=scan();i=0;while(any(x>sort(x))){x=c(x[y<-seq(x)%%2>0],x[!y]);i=i+1};i

Çevrimiçi deneyin!

Şimdi sıfır karışık durumda ele alır.

C (GCC) 64 63 bayt

Nwellnhof'tan -1 bayt

i,r;f(c,v)int*v;{for(i=r=1;v[i]>2;++r)i=i*2%(c-1|1);return~-r;}

Bu, Arnauld'un ve Olivier Grégoire'nin cevaplarına dayanan oldukça kısa bir cevap. Eski çözümümü aşağıda bırakacağım, çünkü kartların desteğinin biraz daha genel sorununu bitişik olmayan kartlarla çözdüğüm için.

Çevrimiçi deneyin

C (GCC) 162 bayt

a[999],b[999],i,r,o;f(c,v)int*v;{for(r=0;o=1;++r){for(i=c;i--;(i&1?b:a)[i/2]=v[i])o=(v[i]>v[i-1]|!i)&o;if(o)return r;for(i+=o=c+1;i--;)v[i]=i<o/2?a[i]:b[i-o/2];}}

Çevrimiçi deneyin

a[999],b[999],i,r,o; //pre-declare variables
f(c,v)int*v;{ //argument list
    for(r=0;o=1;++r){ //major loop, reset o (ordered) to true at beginning, increment number of shuffles at end
        for(i=c;i--;(i&1?b:a)[i/2]=v[i]) //loop through v, split into halves a/b as we go
            o=(v[i]>v[i-1]|!i)&o; //if out of order set o (ordered) to false
        if(o) //if ordered
            return r; //return number of shuffles
        //note that i==-1 at this point
        for(i+=o=c+1;i--;)//set i=c and o=c+1, loop through v
            v[i]=i<o/2?a[i]:b[i-o/2];//set first half of v to a, second half to b
    }
}

R, 85 bayt

s=scan();u=sort(s);k=0;while(any(u[seq(s)]!=s)){k=k+1;u=as.vector(t(matrix(u,,2)))};k

Çevrimiçi deneyin.

açıklama

Aptal (kaba kuvvet) yöntemi, 2 numaralı kartı takip etmekten daha az zarif.

Girdiyi kaldırmak yerine , aynı olana kadar aşamalı olarak karıştırdığımız ssıralı bir vektörle başlarız . Bu, tek-uzunluklu bir vektörün 2-sütunlu bir matrise katlanmasından dolayı girişin tek uzunlukları için uyarılar (ancak karıştırma sayıları hala doğrudur); Bu durumda, R'de, eksik veri noktası, ilk girdi elemanının geri dönüşümü ile doldurulur. us

Şaşırtılmayacak bir vektör sağlarsak, döngü asla sona ermez.

Zeyilname: değiştirilirse bir bayt kurtarırsınız. Yukarıdaki cevabın aksine, başkalarına devretmeye gerek yoktur t(), ancak sipariş vermenin byrow=TRUEnedeni budur.T ortaya çıkıyor matrix().

R , 84 bayt

s=scan();u=sort(s);k=0;while(any(s[seq(u)]!=u)){k=k+1;s=as.vector(matrix(s,,2,T))};k

Çevrimiçi deneyin!

PowerShell , 116 114 108 84 78 bayt

' Outgolfer ' Erik sayesinde -24 bayt çözeltisi .

-Mazzy sayesinde 6 bayt .

param($a)for(;$a[1]-2){$n++;$t=@{};$a|%{$t[$j++%2]+=,$_};$a=$t.0+$t.1;$j=0}+$n

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 62 bayt

c=0;While[Sort[a]!=a,a=a[[1;;-1;;2]]~Join~a[[2;;-1;;2]];c++];c

Çevrimiçi deneyin!

açıklama

Giriş listesi a. Eşleşene kadar şaşırmaz ve sıralanmış listeyle karşılaştırılır.

Kırmızı , 87 79 78 bayt

func[b][c: 0 while[b/2 > 2][c: c + 1 b: append extract b 2 extract next b 2]c]

Çevrimiçi deneyin!

Perl 5 -pa , 77 bayt

map{push@{$_%2},$_}0..$#F;$_=0;++$_,@s=sort{$a-$b}@F=@F[@0,@1]while"@F"ne"@s"

Çevrimiçi deneyin!

Pyth , 18 bayt

L?SIb0hys%L2>Bb1
y

Çevrimiçi deneyin!

-2 @ Outrikolfer @Erik sayesinde.

Betikte iki satır vardır: ilki bir işlevi tanımlar y, ikinci satır yise örtük Q(değerlendirilmiş stdin) argümanını çağırır .

L?SIb0hys%L2>Bb1
L                function y(b)
 ?               if...
  SIb            the Invariant b == sort(b) holds
     0           return 0
      h          otherwise increment...
       y         ...the return of a recursive call with:
             B   the current argument "bifurcated", an array of:
              b   - the original argument
            >  1  - same with the head popped off
          L      map...
         % 2     ...take only every 2nd value in each array
        s         and concat them back together

¹

PowerShell , 62 71 70 66 bayt

Denemeye eşit sayıda eleman eklendiğinde, +9 bayt.

Sıçramasına ile -1 bayt.

-4 bayt: ile ifade sarın $i, $jyeni kapsamına.

for($a=$args;$a[1]-2;$a=&{($a|?{++$j%2})+($a|?{$i++%2})}){$n++}+$n

Çevrimiçi deneyin!

Japt , 13 11 10 bayt

Benim parlak, yeni alarak , çok -çalışma-içinde-ilerleme bir test sürüşü için tercüman.

ÅÎÍ©ÒßUñÏu

Dene ya tüm test durumlarını çalıştırın

ÅÎÍ©ÒßUñÏu     :Implicit input of integer array U
Å              :Slice the first element off U
 Î             :Get the first element
  Í            :Subtract from 2
   ©           :Logical AND with
    Ò          :  Negation of bitwise NOT of
     ß         :  A recursive call to the programme with input
      Uñ       :    U sorted
        Ï      :    By 0-based indices
         u     :    Modulo 2

Python 3, 40 bayt

f=lambda x:x[1]-2and 1+f(x[::2]+x[1::2])  # 1-based
f=lambda x:x[1]-1and 1+f(x[::2]+x[1::2])  # 0-based

Çevrimiçi deneyin!

Sayfayı daha sık yenilemem gerekiyor: Erik'in Outgolfer'ın düzenlemesini benzer bir numara yaparak kaçırması =)