Створіть функцію або програму, яка займає два входи:

• Список цілих чисел, які мають бути відсортовані (менше 20 елементів)
• Позитивне ціле число, Nкажучи, скільки порівнянь ви повинні провести

Функція зупиняється та виводить отриманий список цілих чисел після Nпорівнянь. Якщо список буде повністю відсортований перед Nпорівнянням, то відсортований список повинен бути виведений.

Алгоритм сортування бульбашок добре відомий, і, мабуть, це знає більшість людей. Наступний псевдокод та анімація (обидві із пов'язаної статті Вікіпедії) повинні містити необхідні деталі:

procedure bubbleSort( A : list of sortable items )
   n = length(A)
   repeat 
     swapped = false
     for i = 1 to n-1 inclusive do
       /* if this pair is out of order */
       if A[i-1] > A[i] then    
         /* swap them and remember something changed */
         swap( A[i-1], A[i] )
         swapped = true
       end if
     end for
   until not swapped
end procedure

Анімація нижче показує прогрес:

Приклад (взятий безпосередньо із пов'язаної статті Вікіпедії) показує кроки при сортуванні списку ( 5 1 4 2 8 ):

Перший прохід

1: ( 5 1 4 2 8 ) ->  ( 1 5 4 2 8 ) // Here, algorithm compares the first two elements, 
                                   // and swaps since 5 > 1.
2: ( 1 5 4 2 8 ) ->  ( 1 4 5 2 8 ) // Swap since 5 > 4
3: ( 1 4 5 2 8 ) ->  ( 1 4 2 5 8 ) // Swap since 5 > 2
4: ( 1 4 2 5 8 ) ->  ( 1 4 2 5 8 ) // Now, since these elements are already in order 
                                   // (8 > 5), algorithm does not swap them.

Другий прохід

5: ( 1 4 2 5 8 ) ->  ( 1 4 2 5 8 )
6: ( 1 4 2 5 8 ) ->  ( 1 2 4 5 8 ) // Swap since 4 > 2
7: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
8: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )

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

Третій перевал

9: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
10:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
11:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
12:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )

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

Формат: Number of comparisons (N): List after N comparisons

Input list:
5  1  4  2  8
Test cases: 
1: 1  5  4  2  8
2: 1  4  5  2  8
3: 1  4  2  5  8
4: 1  4  2  5  8
5: 1  4  2  5  8
6: 1  2  4  5  8
10: 1  2  4  5  8
14: 1  2  4  5  8

Input list:
0: 15  18  -6  18   9  -7  -1   7  19  19  -5  20  19   5  15  -5   3  18  14  19
Test cases:
1: 15  18  -6  18   9  -7  -1   7  19  19  -5  20  19   5  15  -5   3  18  14  19
21: -6  15  18   9  -7  -1   7  18  19  -5  19  19   5  15  -5   3  18  14  19  20
41: -6   9  -7  15  -1   7  18  18  -5  19  19   5  15  -5   3  18  14  19  19  20
60: -6  -7  -1   9   7  15  18  -5  18  19   5  15  -5   3  18  14  19  19  19  20
61: -6  -7  -1   7   9  15  18  -5  18  19   5  15  -5   3  18  14  19  19  19  20
81: -7  -6  -1   7   9  15  -5  18  18   5  15  -5   3  18  14  19  19  19  19  20
119: -7  -6  -1  -5   7   9  15   5  15  -5   3  18  14  18  18  19  19  19  19  20
120: -7  -6  -1  -5   7   9  15   5  15  -5   3  18  14  18  18  19  19  19  19  20
121: -7  -6  -1  -5   7   9   5  15  15  -5   3  18  14  18  18  19  19  19  19  20
122: -7  -6  -1  -5   7   9   5  15  15  -5   3  18  14  18  18  19  19  19  19  20
123: -7  -6  -1  -5   7   9   5  15  -5  15   3  18  14  18  18  19  19  19  19  20
201: -7  -6  -5  -1  -5   3   5   7   9  14  15  15  18  18  18  19  19  19  19  20
221: -7  -6  -5  -5  -1   3   5   7   9  14  15  15  18  18  18  19  19  19  19  20

• Так, дозволені вбудовані алгоритми сортування Bubble.
• Ні, ви не можете вважати лише додатні цілі чи унікальні цілі числа.
• Сортування повинно проводитись у порядку, описаному вище. Не можна починати в кінці списку

Желе , 25 байт

ḣ©ṫ-Ṣ®ṖṖ¤;;ṫḊ¥
JḊṁ¹³W¤;ç/

Спираючись на мою відповідь Дж.

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

Перевірте кількість порівнянь.

Пояснення

Посилання помічника модифікує список в індексі [i-1, i], сортуючи його, що дає такий же результат, як порівняння сортування міхурів.

ḣ©ṫ-Ṣ®ṖṖ¤;;ṫḊ¥  Helper link - Input: list A, index i
ḣ               Take the first i values
 ©              Save a copy of it
  ṫ-            Take the last two values
    Ṣ           Sort them
         ;      Append them to
     ®            Get the copy
      ṖṖ¤         Pop the last two values (Ṗ is pop)
          ;     Prepend it to
           ṫ      Take the last i values
            Ḋ¥    Dequeue - remove the head

JḊṁ¹³W¤;ç/  Input: list A and # of comparisons n
J           Enumerate the indices of A
 Ḋ          Dequeue - remove the head
  ṁ         Reshape it cyclically to length n
   ¹        Identity function (Just to avoid parsing rules)
       ;    Append it to
    ³         The list A
     W¤       Wrap it as an array
        ç/  Reduce from left to right using the helper link and return

JavaScript (ES6), 102 82 80 86 80 байт

Виправлення помилок та 1 байт збережено завдяки @ edc65

(a,m)=>eval("for(i=0;m;a[j=i-1]>(b=a[i])?a[a[i]=a[j],j]=b:0)1/a[++i]?m--:i=0;a")

Рекурсії може не бути, це точно не є, мабуть, найкращим підходом, але я зараз дотримуюся циклу.

Спробуй:

f=(a,m)=>eval("for(i=0;m;a[j=i-1]>(b=a[i])?a[a[i]=a[j],j]=b:0)1/a[++i]?m--:i=0;a")

Enter your numbers:<br>
<input id=A rows=10 value="5 1 4 2 8"><br>
Enter the number of steps:<br>
<input type="number" min=0 id=B rows=10 value="1"><br>
<button onclick="C.innerHTML=f((A.value.match(/-?\d+/g)||[]).map(Number),B.value)">Run</button><br>
<pre id=C></pre>

Haskell, 83 82 81 байт

y%x@(a:b:c)=(y++x):(y++[min a b])%(max a b:c)
y%x=[]%(y++x)
[x]!_=[x] 
x!n=[]%x!!n

Приклад використання: [5,1,4,2,8] ! 5-> [1,4,2,5,8].

У функції % yвідслідковує елементи, відвідані поки що під час поточного проходу, xїх ще слід вивчити. aі bє наступними двома, тобто кандидатами на обмін. Якщо ми досягаємо кінця списку, ми почнемо з самого початку: y%x = []%(y++x). Усі кроки зберігаються у списку, де головна функція вибирає цей nелемент.

Редагувати: попередні версії не працювали для списків одного елемента, на щастя, нова версія ще коротша.

Python 3, 77 74 байт

-3 байти завдяки @Maltysen (init jу декларації)

lambda l,n,j=0:exec('j*=j<len(l)-1;l[j:j+2]=sorted(l[j:j+2]);j+=1;'*n)or l

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

Використовує sortedдля кожної операції порівняння та заміни, але вона виконує сортування бульбашок.

Встановлює j=0(лівий індекс), потім виконує nпорівняння та заміни суміжних елементів списку, скидаючи jїх, 0коли це вікно виходить за межі.

У цій точці j*=j<len(l)-1множиться jна False(тобто 0), тоді як кожен інший раз помножиться jна True(тобто 1).

(Він все одно буде працювати і для порожнього списку.)

PowerShell v2 +, 135 129 байт

param($a,$n)for($s=1;$s){($s=0)..($a.count-2)|%{if($a[$_]-gt$a[$_+1]){$a[$_],$a[$_+1]=$a[$_+1],$a[$_];$s=1}if(!--$n){$a;exit}}}$a

Так. Багато. Доларів.

( Збережено шість байтів, зрозумівши, що цей виклик не включає оптимізацію "для безкоштовного" пропускання останнього елемента на кожному пропуску, оскільки це гарантовано відсортовано, а замість цього щоразу проходить повний пропуск. Це перемістило $a.countв forцикл і усунув $zзмінну. )

Прямо вгору сорти міхура, з однією чудовою плямою, роблячи своп в один крок -
$a[$_],$a[$_+1]=$a[$_+1],$a[$_]

Логіка виходу обробляється через if(!--$n){$a;exit}

Випробування

(Масив відображається тут як розділений пробілом, тому що за замовчуванням роздільник поля вихідного поля для струфікації масиву є пробілом. Розташування відбувається тому, що ми поєднуємо з мітками "$_ -> ".)

PS C:\Tools\Scripts\golfing> 1,2,3,4,5,6,10,14|%{"$_ -> "+(.\bubble-sorting-in-progress.ps1 @(5,1,4,2,8) $_)}
1 -> 1 5 4 2 8
2 -> 1 4 5 2 8
3 -> 1 4 2 5 8
4 -> 1 4 2 5 8
5 -> 1 4 2 5 8
6 -> 1 2 4 5 8
10 -> 1 2 4 5 8
14 -> 1 2 4 5 8

PS C:\Tools\Scripts\golfing> 1,21,41,60,61,81,119,120,121,122,123,201,221|%{"$_ -> "+(.\bubble-sorting-in-progress.ps1 @(15,18,-6,18,9,-7,-1,7,19,19,-5,20,19,5,15,-5,3,18,14,19) $_)}
1 -> 15 18 -6 18 9 -7 -1 7 19 19 -5 20 19 5 15 -5 3 18 14 19
21 -> -6 15 18 9 -7 -1 7 18 19 -5 19 19 5 15 -5 3 18 14 19 20
41 -> -6 9 -7 15 -1 7 18 18 -5 19 19 5 15 -5 3 18 14 19 19 20
60 -> -6 -7 -1 9 7 15 18 -5 18 19 5 15 -5 3 18 14 19 19 19 20
61 -> -6 -7 -1 7 9 15 18 -5 18 19 5 15 -5 3 18 14 19 19 19 20
81 -> -7 -6 -1 7 9 15 -5 18 18 5 15 -5 3 18 14 19 19 19 19 20
119 -> -7 -6 -1 -5 7 9 15 5 15 -5 3 18 14 18 18 19 19 19 19 20
120 -> -7 -6 -1 -5 7 9 15 5 15 -5 3 18 14 18 18 19 19 19 19 20
121 -> -7 -6 -1 -5 7 9 5 15 15 -5 3 18 14 18 18 19 19 19 19 20
122 -> -7 -6 -1 -5 7 9 5 15 15 -5 3 18 14 18 18 19 19 19 19 20
123 -> -7 -6 -1 -5 7 9 5 15 -5 15 3 18 14 18 18 19 19 19 19 20
201 -> -7 -6 -5 -1 -5 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20
221 -> -7 -6 -5 -5 -1 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20

R, 132 131 112 136 байт

Програма отримує вхід таким чином: спочатку N, потім сам вектор. Наприклад, якщо ви хочете v = [5 1 4 2 8]і n = 1, вхід, який переходить у значення scanє 1 5 1 4 2 8. Отже, щоб запустити цю програму, ви запускаєте перший рядок , подаєте цифри по черзі в консолі , а потім запускаєте решту (це відповідь на відповідь).

Тоді наступний код виконує трюк:

v=scan()
s=m=0
while(!s){s=T;for(i in 3:length(v)){m=m+1
if(m>v[1]){s=T;break}
if(v[i-1]>v[i]){v[c(i-1,i)]=v[c(i,i-1)];s=F}}}
cat(v[-1])

Тест:

Input: a vector with N first and the elements to be sorted next
1 5 1 4 2 8
5 5 1 4 2 8
14 5 1 4 2 8
60 15 18 -6 18  9 -7 -1  7 19 19 -5 20 19  5 15 -5  3 18 14 19

Output: 
1 5 4 2 8
1 4 2 5 8
1 2 4 5 8
-6 -7 -1  9  7 15 18 -5 18 19  5 15 -5  3 18 14 19 19 19 20

Оновлення: 1 байт для гольфу завдяки Вло .

Піта, 34 32 байт

AQVH=*<ZtlGZ=GsXJcG,Zh=hZ1ShtJ;G

Переклад відповіді Джонатана Аллана на Python.

Спробуйте тут!

JavaScript (ES6), 82 80 79 байт

f=(a,m,n=0,_,b=a[n+1])=>1/b?m?f(a,m-1,n+1,a[n]>b?a[a[n+1]=a[n],n]=b:0):a:f(a,m)

На основі оригінальної відповіді @ ETHproduction. Редагувати: збережено 2 байти завдяки @JonathanAllan. Збережено 1 байт завдяки @ edc65.

J , 62 60 байт

>@([:({.,(2/:~@{.}.),]}.~2+[)&.>/]|.@;<:@#@]<@|i.@[)^:(]1<#)

Це дієслово, яке бере два аргументи: кількість порівнянь на LHS та список цілих чисел на RHS. Спочатку він перевіряє, чи довжина списку, якщо більша одиниці. Якщо це не так, він повертає список немодифікованим, інакше він працює над ним, виконуючи вказану кількість порівнянь перед поверненням результату.

Використання

У першому тестовому випадку для допоміжного введення / виводу використовуються команди "Додаткові". Другий тестовий випадок показаний як один вхід / вихід.

   f =: >@([:({.,(2/:~@{.}.),]}.~2+[)&.>/]|.@;<:@#@]<@|i.@[)^:(]1<#)
   1 2 3 4 5 6 10 14 ([;f)"0 1 ] 5 1 4 2 8
┌──┬─────────┐
│1 │1 5 4 2 8│
├──┼─────────┤
│2 │1 4 5 2 8│
├──┼─────────┤
│3 │1 4 2 5 8│
├──┼─────────┤
│4 │1 4 2 5 8│
├──┼─────────┤
│5 │1 4 2 5 8│
├──┼─────────┤
│6 │1 2 4 5 8│
├──┼─────────┤
│10│1 2 4 5 8│
├──┼─────────┤
│14│1 2 4 5 8│
└──┴─────────┘
   1 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
   123 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
_7 _6 _1 _5 7 9 5 15 _5 15 3 18 14 18 18 19 19 19 19 20
   221 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
_7 _6 _5 _5 _1 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20

Пояснення

Важко написати короткий код у J, який використовує мутабельність, тому замість цього я перетворюю проблему на скорочення списку на наборі індексів. Я вважаю, що цей код безладний, тому я буду детально виконувати завдання кожної фрази замість кожної примітивної. Перша частина схоплює довжину списку і створює діапазон. Потім оперуйте кожною вставкою розміром 2, щоб імітувати один прохід порівнянь.

   i. # 5 1 4 2 8
0 1 2 3 4
   2 <\ i. # 5 1 4 2 8
┌───┬───┬───┬───┐
│0 1│1 2│2 3│3 4│
└───┴───┴───┴───┘
   2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┐
│0│1│2│3│
└─┴─┴─┴─┘

Це початкові показники кожного порівняння. Якщо проводиться 7 порівнянь, переформатуйте її, щоб отримати бажану суму. J аналізує праворуч ліворуч, тому його зменшується праворуч ліворуч, як складка праворуч. Додайте початковий список і переверніть його.

   7 $ 2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│0│1│2│
└─┴─┴─┴─┴─┴─┴─┘
   |. 5 1 4 2 8 ; 7 $ 2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┬─┬─┬─┬─────────┐
│2│1│0│3│2│1│0│5 1 4 2 8│
└─┴─┴─┴─┴─┴─┴─┴─────────┘

Альтернативно, діапазон [0, 7) може бути зроблений, і кожне значення приймається по модулю довжиною списку мінус 1 для створення одного і того ж діапазону.

   (<: # 5 1 4 2 8) <@| i. 7
┌─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│0│1│2│
└─┴─┴─┴─┴─┴─┴─┘

Остання частина - це дієслово, яке містить список на RHS та індекс на LHS, який позначає стартовий індекс порівняння. Виберіть два елементи, починаючи з цього індексу, відсортуйте їх та підключіть їх до списку та поверніть його.

   > ({.,(2/:~@{.}.),]}.~2+[)&.>/ |. 5 1 4 2 8 ; 7 $ 2 <@{.\ i. # 5 1 4 2 8
1 2 4 5 8

Матлаб, 93 91 байт

function l=f(l,m)
n=numel(l)-1;i=0;while n&m;i=mod(i,n)+1;m=m-1;l(i:i+1)=sort(l(i:i+1));end

Заощаджує 11 байт, опускаючи if l(i)>l(i+1);l(i:i+1)=l([i+1,i]), а замість цього щоразу просто сортуйте два елементи. Працює для списків довжиною 1. Не m--вдалося зберегти байт або два за допомогою оператора Octave , але це не так багато.

Зберігає ще два байти, встановивши n=numel(l)-1;, бо тоді я можу просто робити while nзамість while n>1, а i=mod(i,n)+1не i=mod(i,n-1)+1.

Для запису ця відповідь була написана через багато годин після створення виклику.

Groovy (101 байт)

{l,n->(l.size()..0).each{i->(0..i-2).each{if(l[it]>l[it+1] && n>0 && it>-1){l.swap(it,it+1)};n--}};l}

EDIT: Мені не потрібно було писати власне закриття свопу, groovy було вбудовано.
Спробуйте тут: https://groovyconsole.appspot.com/script/5104724189642752

Приклад сліду виведення:

4:[1, 5, 4, 2, 8]
3:[1, 4, 5, 2, 8]
2:[1, 4, 2, 5, 8]
1:[1, 4, 2, 5, 8]
0:[1, 4, 2, 5, 8] - Locks in the final answer.
-1:[1, 4, 2, 5, 8]
-2 (Return):[1, 4, 2, 5, 8]

Стара реалізація (122 байти)

m={l,n->s={x,y->t=l[x];l[x]=l[y];l[y]=t};((l.size()-2)..2).each{i->(0..i).each{if(l[it]>l[it+1] && n){s(it,it+1)};n--}};l}

Спробуйте тут: https://groovyconsole.appspot.com/script/6316871066320896

php, 148 145 байт

<?php for($i=2,$a=$argv;$a[1]--;$i=$i==count($a)-2?2:$i+1)if($a[$i]>$a[$i+1])list($a[$i],$a[$i+1])=[$a[$i+1],$a[$i]];echo substr(join(' ',$a),5);

Я не дуже задоволений структурою циклу, але мені подобається перемикач списку, і він працює, тому я все-таки публікую його. php7.1 дозволить мені зберегти принаймні 4 байти.

З кращим форматуванням:

<?php 
for($i=2,$a=$argv;$a[1]--;$i=$i==count($a)-2?2:$i+1)
  if($a[$i]>$a[$i+1])
    list($a[$i],$a[$i+1])=[$a[$i+1],$a[$i]];
echo substr(join(' ',$a),5);

Редагувати: Йорг Гюльсерманн нагадав мені про приєднання, а не заклик.
Примітка: має бути у файлі з одним іменем файлу символів.

Рубін, 52 50 байт

Зачекайте ... ні Рубі?

->l,n{n.times{|a|l[s=a%~-l.size,2]=l[s,2].sort};l}