Виклик:

Введення: Список різних позитивних цілих чисел у межах .$[1, \text{list-size}]$

Вихід: Ціле число: кількість разів, коли список перетасований . Для списку це означає, що список розділений на дві половини, і ці половинки переплетені (тобто, [1,2,3,4,5,6,7,8,9,10]колись перетасування списку одного разу призведе до [1,6,2,7,3,8,4,9,5,10], тому для цього виклику введення [1,6,2,7,3,8,4,9,5,10]призведе до 1).

Правила виклику:

• Ви можете припустити, що список буде містити додатні цілі числа в діапазоні (або якщо ви вирішите мати 0-індексовані списки введення ).$[1, \text{list-size}]$$[0, \text{list-size}-1]$
• Ви можете припустити, що всі списки вхідних даних будуть чи дійсним перетасованим переходом, або відсортованим списком, який не перетасовується (у такому випадку результат є 0).
• Можна припустити, що список вхідних даних буде містити щонайменше три значення.

Покроковий приклад:

Вхід: [1,3,5,7,9,2,4,6,8]

Якщо перемішати його один раз, це стає: [1,5,9,4,8,3,7,2,6]тому що кожен парний 0-індексований елемент виходить спочатку [1, ,5, ,9, ,4, ,8], а потім усі непарні 0-індексовані елементи після цього [ ,3, ,7, ,2, ,6, ].
Список ще не замовлений, тому ми продовжуємо:

Повторне переміщення списку знову стає: [1,9,8,7,6,5,4,3,2]
Знову стає: [1,8,6,4,2,9,7,5,3]
Потім: [1,6,2,7,3,8,4,9,5]
І нарешті:, [1,2,3,4,5,6,7,8,9]який є упорядкованим списком, тому ми робимо непереміщення.

Ми перемістили оригінал [1,3,5,7,9,2,4,6,8]п’ять разів, щоб дістатися [1,2,3,4,5,6,7,8,9], тому вихід 5у цьому випадку є.

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам коду-гольфу відштовхувати вас від публікації відповідей з мов, що не кодують гольф. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Для вашої відповіді застосовуються стандартні правила з правилами вводу / виводу за замовчуванням , тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу повернення. Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду (тобто TIO ).
• Також настійно рекомендується додавати пояснення до своєї відповіді.

Тестові приклади:

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

Желе , 8 байт

ŒœẎ$ƬiṢ’

Спробуйте в Інтернеті!

Як?

ŒœẎ$Ƭ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 байти

Більш коротка версія, запропонована @nwellnhof

Очікує колоду з 1-індексованими картами як вхідні дані.

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

Спробуйте в Інтернеті!

Давши колоду $[c_0,\ldots,c_{L-1}]$ довжини $L$ , визначимо:

І шукаємо $n$ таке, що $c_{x_n}=2$ .

JavaScript (ES6),  57 52  50 байт

Очікує колоду з 0-індексованими картами як вхід.

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

Спробуйте в Інтернеті!

Як?

Оскільки JS не вистачає підтримки для вилучення фрагментів масиву за допомогою користувацького кроку, імітація цілої стрілецької передачі, можливо, буде досить дорогою (але якщо чесно, я навіть не намагався). Однак рішення можна також знайти, просто подивившись на 2-ю карту та загальну кількість карт у колоді.

З огляду на колоду довжиною $L$ , цей код виглядає $n$ таким, що:

де - друга карта, а визначається як:$c_2$$k$

Python 2 , 39 байт

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

Спробуйте в Інтернеті!

-4 завдяки Джонатану Аллану .

R , 58 55 45 байт

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

Спробуйте в Інтернеті!

Моделює процес сортування. Вхід 1-індексований, повернення FALSE0.

Perl 6 , 34 32 байти

-2 байти завдяки Джо Кінгу

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

Спробуйте в Інтернеті!

Схожий на підхід Арнольда . Індекс другої картки після n перетасування 2**n % kвідповідає k, визначеному у відповіді Арнальда.

APL (Dyalog Unicode) , 35 26 23 22 байт ^SBCS

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

Спробуйте в Інтернеті!

Дякуючи Адаму за допомогу, Ерік Аутгольфер за -3 та нгн для -1.

Посилання TIO містить два тестові випадки.

Пояснення:

{⍵≡⍳≢⍵: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 байт

-2 байти завдяки nwellnhof

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

Спробуйте в Інтернеті!

Зворотна стрілецька стрілка переміщується шляхом сортування за індексом за модулем 2 до упорядкування списку, після чого повертає довжину послідовності.

Це смішно, я зазвичай не пробую рекурсивного підходу для Perl 6, але цього разу він виявився коротшим, ніж оригінал.

Пояснення:

$!={.[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 (спадщина) , 9 байт

[DāQ#ι˜]N

Спробуйте в Інтернеті!

Пояснення

[   #  ]     # 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 байт

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

Спробуйте в Інтернеті!

Працює надійно лише для масивів розміром менше 31 або для рішень із меншим рівнем 31 ітерації. Для більш загального рішення див. Таке рішення з 63 байтами:

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

Спробуйте в Інтернеті!

Пояснення

У рифлі наступне положення - попереднє один раз два модулі або довжини, якщо непарна чи довжина - 1, якщо парне.

Тому я повторюю всі індекси за допомогою цієї формули, поки не знайду значення 2 в масиві.

Кредити

• -8 байт завдяки Кевіну Крейссену . (Попередній алгоритм, використовуючи масив)
• -5 байт завдяки Арнольду .

J , 28 26 байт

-2 байти завдяки Йона!

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

Спробуйте в Інтернеті!

Натхненним буде рішення APL від Ven.

Пояснення:

               ^:       ^: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 (нг / к) , 25 байт

Дякуємо ngn за пораду та його перекладачу K!

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

Спробуйте в Інтернеті!

APL (NARS), символи 49, байти 98

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

навіщо використовувати в найглибшій петлі один альго, який повинен бути nlog (n), коли ми можемо використовувати один лінійний n? лише на кілька байт більше? [⍵≡⍵ [⍋⍵] O (nlog n) і протистояння кожному елементу для see в порядку, використовуючи test / ¯1 ↓ ⍵≤1⌽⍵ O (n)] тест:

  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

Рубін , 42 байти

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

Спробуйте в Інтернеті!

Як:

Шукайте номер 2 всередині масиву: якщо він знаходиться на другому положенні, колоду не переміщували, інакше перевіряйте позиції, де послідовні переміщення розміщували б її.

R , 70 72 байти

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

Спробуйте в Інтернеті!

Тепер обробляє корпус нульового переміщення.

C (GCC) 64 63 байт

-1 байт від nwellnhof

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

Це різко коротша відповідь, заснована на відповідях Арнальда та Олів'є Грегоара. Я залишу своє старе рішення нижче, оскільки воно вирішує трохи більш загальну проблему колод з картами, які не є суміжними.

Спробуйте в Інтернеті

C (GCC) 162 байти

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

Спробуйте в Інтернеті

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 байт

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

Спробуйте в Інтернеті.

Пояснення

Дурний (груба сила) метод, набагато менш елегантний, ніж дотримання картки №2.

Замість того, щоб перемикати вхід, sми починаємо з відсортованого вектора, uякий ми поступово переміщуємо, поки він не буде тотожним s. Це дає попередження (але кількість перетасовок все ще є правильним) для непарних довжин введення через складання вектора непарної довжини в матрицю з двома стовпцями; у цьому випадку в R відсутня точка даних заповнюється переробкою першого елемента вводу.

Цикл ніколи не припиняється, якщо ми надаємо вектор, який неможливо змінити.

Додаток: ви зберігаєте один байт, якщо замість цього не змінюєтесь. На відміну від вищезазначеної відповіді, немає необхідності переносити t(), але впорядкування byrow=TRUEсаме тому Tз’являється в matrix().

R , 84 байти

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

Спробуйте в Інтернеті!

PowerShell , 116 114 108 84 78 байт

-24 байт завдяки Ерік Outgolfer «s рішення .

-6 байт завдяки мазі .

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

Спробуйте в Інтернеті!

Мова Вольфрама (Mathematica) , 62 байти

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

Спробуйте в Інтернеті!

Пояснення

Список вводу є a. Він нерозбірливий і порівнюється з відсортованим списком, поки вони не збігаються.

Червоний , 87 79 78 байт

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

Спробуйте в Інтернеті!

Perl 5 -pa , 77 байт

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

Спробуйте в Інтернеті!

Піт , 18 байт

L?SIb0hys%L2>Bb1
y

Спробуйте в Інтернеті!

-2 завдяки @Erik The Outgolfer.

У сценарію є два рядки: перший визначає функцію y, другий рядок викликає аргумент yнеявного Q(оцінюється stdin).

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 байт

+9 байт, коли Тестові приклади з доданою парною кількістю елементів.

-1 байт з бризками.

-4 байт: оберніть вираз з $i, $jв новій області.

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

Спробуйте в Інтернеті!

Japt , 13 11 10 байт

Взяв свого блискучого, нового , дуже незавершеного перекладача для тестового заходу.

ÅÎÍ©ÒßUñÏu

Спробуйте або запустіть усі тестові приклади

ÅÎÍ©Òß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 байт

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

Спробуйте в Інтернеті!

Мені потрібно частіше оновлювати сторінку: пропустив редагування Еріка Outgolfer, зробивши подібний трюк =)