두 가지 입력을받는 함수 또는 프로그램을 작성하십시오.

• 정렬 될 정수 목록 (20 개 미만 요소)
• N몇 번의 비교를해야 하는지를 나타내는 양의 정수

함수는 정지하고 N비교 후 정수 목록을 출력합니다 . N비교 하기 전에 목록이 완전히 정렬 된 경우 정렬 된 목록이 출력되어야합니다.

버블 정렬 알고리즘은 잘 알려진, 나는 대부분의 사람들이 알고 추측된다. 다음 의사 코드 및 애니메이션 (링크 된 Wikipedia-article 모두)은 필요한 세부 정보를 제공해야합니다.

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

아래 애니메이션은 진행 상황을 보여줍니다.

링크 된 Wikipedia 기사에서 직접 가져온 예제는 목록을 정렬하는 단계를 보여줍니다. ( 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

• 예, 내장 버블 정렬 알고리즘이 허용됩니다.
• 아니요, 양의 정수 또는 고유 한 정수만 가정 할 수 없습니다.
• 정렬은 위에서 설명한 순서대로 이루어져야합니다. 당신은 목록의 끝에서 시작할 수 없습니다

젤리 , 25 바이트

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

J의 대답 을 기반으로합니다.

온라인으로 사용해보십시오!

비교 횟수를 확인하십시오.

설명

도우미 링크는 목록을 [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

자바 스크립트 (ES6), 102 82 80 86 80 바이트

@ edc65 덕분에 버그 수정 및 1 바이트 절약

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

하스켈, 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요소를 선택하는 목록에 저장됩니다 .

편집 : 이전 버전은 단일 요소 목록에서 작동하지 않았지만 다행히도 새 버전이 더 짧습니다.

파이썬 3, 77 74 바이트

@Maltysen 덕분에 -3 바이트 ( 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

이데온의 테스트 사례

용도는 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]and n = 1로 들어가는 입력 scan은 1 5 1 4 2 8입니다. 그래서이 프로그램을 실행하려면, 당신은 첫 번째 줄을 실행 , 콘솔에서 하나 숫자 하나를 공급 하고, 다음 나머지를 실행 (이것은 REPL의 답변입니다).

다음 코드는 트릭을 수행합니다.

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 바이트 golfed VLO을 .

Pyth, 34 32 바이트

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

Jonathan Allan의 Python 답변 번역.

여기 사용해보십시오!

자바 스크립트 (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의 원래 답변을 기반으로합니다. 편집 : @JonathanAllan 덕분에 2 바이트가 절약되었습니다. @ edc65 덕분에 1 바이트를 절약했습니다.

J , 62 60 바이트

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

이것은 LHS의 비교 수와 RHS의 정수 목록이라는 두 가지 인수를 취하는 동사입니다. 먼저 목록의 길이가 1보다 큰지 확인합니다. 그렇지 않은 경우 수정되지 않은 목록을 반환하고, 그렇지 않으면 결과를 반환하기 전에 지정된 수의 비교를 수행하여 목록에서 작동합니다.

용법

첫 번째 테스트 사례의 경우 추가 명령을 사용하여 여러 입력 / 출력을 형식화합니다. 두 번째 테스트 사례는 단일 입력 / 출력으로 표시됩니다.

   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

Matlab, 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-- 연산자를 있지만 그다지 많지 않습니다.

설정에 의해 두 개 이상의 바이트를 저장 n=numel(l)-1;한 후 난 그냥 할 수 있기 때문에, while n대신 while n>1하고, i=mod(i,n)+1대신 i=mod(i,n-1)+1.

기록을 위해이 답변은 챌린지가 생성 된 후 몇 시간 후에 작성되었습니다.

그루비 (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}

편집 : 나는 내 자신의 스왑 클로저를 쓸 필요가 없었으며, 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, 148145 바이트

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

편집 : Jörg Hülsermann은 함락 대신에 가입을 상기시켰다.
참고 : 단일 파일 이름을 가진 파일에 있어야합니다.

루비, 52 50 바이트

잠깐만 ... 루비 아냐?

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