Câu hỏi

Cho một tập hợp gồm 9 số, m[]chỉ chứa các số từ 1 đến 9 theo thứ tự ngẫu nhiên, không có hai số nào giống nhau, tạo một chương trình theo bất kỳ ngôn ngữ nào sắp xếp lại số theo thứ tự số (1, 2, 3, v.v.) bằng cách chỉ chuyển đổi hai số nằm cạnh nhau (ví dụ: 1, 3, 2 → 1, 2, 3).

Quy tắc

• Bạn chỉ có thể sửa đổi tập hợp bằng cách chuyển đổi hai số nằm cạnh nhau
• Các số kết thúc (1 đến 9 theo thứ tự) nên được chứa trong m[]
• Bạn có thể sử dụng bất kỳ ngôn ngữ nào bạn muốn
• Câu trả lời với số lượng byte nhỏ nhất sẽ thắng

Biên tập:

Mã của bạn không phải in đầu ra, nhưng mảng được sắp xếp lại phải nằm trong m[].

CJam, 15 byte

q~A{{a+$~}*]}*p

Làm thế nào nó hoạt động:

q~                     e# Read the CJam styled input array (For ex. [1 3 4 2 5 6 8 7 9])
  A{        }*         e# Run the loop 10 times. This is enough times for a 10 length
                       e# input array in a bubble sort
    {    }*            e# reduce
     a+$~              e# Rearrange the pair so that they are sorted
           ]           e# After each loop, wrap the numbers back into the array
              p        e# Print the array after the loops are done

Dùng thử trực tuyến tại đây

Toán học, 38 byte

#//.{a___,b_,c_,d___}/;b>c:>{a,c,b,d}&

Đây là một hàm không tên lấy một mảng, áp dụng quy tắc thay thế cho đến khi không thể tìm thấy mẫu nào nữa. Mẫu này là một danh sách có hai phần tử liên tiếp bvà cở đâu b > c, và quy tắc nói để hoán đổi bvà cnhưng nếu không để lại mảng không bị ảnh hưởng.

Có rất nhiều cú pháp cú pháp ở đây, nhưng mã thực sự rất dễ đọc nếu bạn biết một chút về Mathicala:

# //. {a___,b_,c_,d___} /; b>c :> {a,c,b,d} &
^  ^     ^   ^          ^      ^            ^
|  |     |   |          |      |            |
|  |     |   | Declares an unnamed function |
|  |     |   |          |      |
| The function's argument      |
   |     |   |          |      |
   | Replace while possible... |
         |   |          |      |
         | Zero or more list elements.
             |          |      |
             | A single list element
                        |      |
                        | A condition for the pattern
                               |
                               | What to replace the pattern with

Python 3, 72 byte

from random import*
while m!=sorted(m):p=randrange(8);m[p:p]=m.pop(p+1),

Phương pháp bogosort (còn gọi là ngu ngốc sắp xếp): hoán đổi các phần tử lân cận ngẫu nhiên cho đến khi mảng sẽ được sắp xếp. Thường chạy dưới một giây.

2 byte nhờ @xnor.

Con trăn 2, 45

for i in range(8)*8:m[i:i+2]=sorted(m[i:i+2])

Chu kỳ xung quanh danh sách, sắp xếp các cặp yếu tố liên tiếp. Chỉ số quay ivòng qua 0,1,2,3,4,5,6,7tám lần, đảm bảo tất cả các yếu tố bong bóng và danh sách được sắp xếp.

Pyth, 13 - 15 byte

Giải pháp thực hiện trao đổi được yêu cầu và không tạo ra kết quả:

#X=Qhf>FT.:Q2

Giải pháp thực hiện việc hoán đổi được yêu cầu và in ra trạng thái trung gian của danh sách ở mỗi bước:

#QX=Qhf>FT.:Q2

Giải pháp thực hiện việc hoán đổi được yêu cầu và in ra trạng thái cuối cùng của danh sách:

#X=Qhf>FT.:Q2;Q

Trình diễn giải pháp trung gian ở trên.

Phương pháp hoán đổi các giá trị liền kề được lấy từ câu trả lời của @ Jakube.

Chương trình sử dụng #, vòng lặp cho đến khi báo cáo lỗi, để hoán đổi một cặp phần tử bị sai lệch liền kề cho đến khi không có cặp nào như vậy tồn tại, tại thời điểm đó h, hàm head sẽ đưa ra lỗi, kết thúc chương trình.

Võng mạc , 95 93 byte

Không đặc biệt cạnh tranh (và có lẽ vẫn có thể chơi được), nhưng ở đây chúng tôi đi ...

(.)1
1$1
([^1])2
2$1
([4-9])3
3$1
([5-9])4
4$1
([6-9])5
5$1
([7-9])6
6$1
(8|9)7
7$1
)`98
89
<empty>
<empty>

Trường hợp <empty>nên là một dòng trống.

Vì tất cả các số là một chữ số, nên điều này chỉ mong đợi một chuỗi có tất cả 9 chữ số làm đầu vào và sẽ in 123456789sau khi sắp xếp thành công. Mỗi giai đoạn thực hiện một trao đổi duy nhất và )1`chỉ ra rằng tất cả trừ giai đoạn cuối cùng phải được lặp lại cho đến khi kết quả dừng thay đổi.

Giai đoạn trống ở cuối là cần thiết, bởi vì nếu không chúng ta sẽ nhận được kết quả trung gian mỗi khi 98giai đoạn được xử lý.

Dưới đây là tất cả các kết quả trung gian (bất cứ khi nào nó thay đổi) cho một ví dụ chạy:

451629387
451269387
451263987
451263978
415263978
412563978
412536978
412536798
412536789
142536789
124536789
124356789
123456789

(Tôi đã có được điều này bằng cách thêm :tùy chọn cho từng giai đoạn và loại bỏ các bản sao liên tiếp bằng tay.)

Bình thường, 17 byte

uXGhaf>FT.:G2]Z)Q

Chuyển đổi các mục trong một danh sách thực sự tốn kém trong Pyth. Vì vậy, đây là một giải pháp thú vị, kéo dài các quy tắc một chút. Nó có lẽ không hợp lệ.

Dùng thử trực tuyến: Trình biên dịch / thực thi Pyth

Giải trình

Trước hết, độ phức tạp thời gian của mã của tôi là O(n^3). Nhưng đây không phải là phần thú vị. Câu hỏi không nói lên điều gì về sự phức tạp.

Phần quan trọng là, làm thế nào tôi chuyển đổi hai yếu tố trong danh sách. Hãy nói rằng tôi muốn chuyển đổi các yếu tố m[3]và m[4]. Tôi không quan tâm đến các chỉ số 3và 4tất cả. Tôi chỉ đơn giản là tạo một danh sách thứ hai, thay thế mọi phần tử bằng m[3]với số m[4]và mỗi số bằng m[4]với giá trị m[3]. Vì danh sách không chứa các bản sao, điều này mô phỏng việc chuyển đổi hai giá trị này. Nếu có trùng lặp, như trong đầu vào [1, 3, 2, 2], đầu ra sẽ là [1, 2, 3, 3]. Và nếu bạn đưa ra đầu vào [1, 2, 1], nó sẽ kết thúc trong một vòng lặp vô hạn. Tôi không rõ ràng tạo danh sách thứ hai, nó chỉ là một phần trong việc triển khai phương thức dịch của Pyth. Nếu bạn in ra các danh sách hiện tại ( xem tại đây), nó cung cấp các giá trị chính xác, mà bạn mong đợi.

                   implicit: Q = input list
u               Q  set G = Q, update G as long with the following statements, 
                   until it stops changing: 
         .:G2         all pairs (G[i],G[i+1])
     f>FT             filter for pairs T, where T[0] > T[1]
    a        ]Z       add to this list of pairs [0] 
                      (ensures that the filtered list is always non-empty)
   h                  take the first element
 XG            )      translate G by this pair (switches the values T[0] with T[1])
                   print implicitly at the end 

JavaScript (ES6) 56

Một hàm đệ quy sắp xếp lại danh sách đã cho tại chỗ.

F=l=>l.some((v,i)=>v>l[++i]&&[l[i-1]=l[i],l[i]=v])&&F(l)

Ghi chú

• Trong JS, với bất kỳ giá trị số v: v> không xác định == false, v <undinite == false. Vì vậy, đi ra ngoài giới hạn mảng không phải là vấn đề nếu chúng ta sử dụng so sánh đúng

• Khi mảng cuối cùng được sắp xếp, hàm bên trong 'some' trả về false và đệ quy kết thúc

• Giá trị được trả về trong trường hợp trao đổi là một mảng 2 phần tử và giá trị của nó luôn luôn là 'sự thật'. Điều đó hoạt động ngay cả khi một hoặc nhiều phần tử mảng bằng 0

• Trong thực tế, hàm hoạt động với bất kỳ đầu vào số nào, không chỉ các chữ số đơn và không lặp lại. Không tìm thấy cách tận dụng lợi thế từ ràng buộc OP này.

Kiểm tra bằng đoạn mã (trong Firefox) - phiên bản đoạn trích xuất các giá trị danh sách hiện tại ở mỗi bước.

F=l=>(log('L='+l), l.some((v,i)=>v>l[++i]&&[l[i-1]=l[i],l[i]=v])&&F(l))

function log(x) {
   L.innerHTML = L.innerHTML +x+'\n' 
}

function go() {
  l = I.value.split(/\D+/g).map(x=>x|0)
  F(l)
  O.innerHTML = '' + l
}  

go()

Unsorted: <input id=I value="2 8 4 7 5 3 9 1 6"><button onclick="go()">-></button>
<br>Sorted: <span id=O></span>
<br>Operations log:<br>
<pre id=L></pre>

Javascript ( ES6 ), 66 61 53 byte

Nhờ quy tắc mới, tôi có thể giảm hơn nữa :)

f=x=>x.map((a,i)=>a<(b=x[--i])&&f(x,x[i]=a,x[i+1]=b))


// Snippet demo: (Firefox only)
f(z=prompt().split(/\D+/).map(x=>+x))
alert(z.join(', '));

Đã bình luận

f=x=> // recursive function f
    x.map( // map function to array
        (a, i)=> // a = current value, i = current index
            a < (b = x[--i]) && // poll value of previous index, compare less than
                                // comparison always false at first index as undefined will always be less
                f(x, x[i] = a, x[i + 1] = b) // if true, swap values and call f
    )

C, 183

main(c,d,s){int a[10];for(c=0;c<10;c++)scanf("%d", &a[c]);for (c=0;c<10;c++){for(d=0;d<10-c-1;d++){if(a[d]>a[d+1]){s=a[d];a[d]=a[d+1];a[d+1]=s;}}}for(c=0;c<10;c++)printf("%d", a[c]);}

Nó chưa được đánh gôn, ngoài các tên khác nhau.

Haskell, 59 byte

s e(h:t)=min e h:max e h:t
f l=iterate(init.foldr s[9])l!!9

Hàm sđặt một phần tử eở phía trước hoặc ở vị trí thứ hai của danh sách tùy thuộc vào việc nó nhỏ hơn hoặc lớn hơn phần tử đầu tiên của danh sách. Gấp svào danh sách đầu vào cho phép bong bóng phần tử nhỏ nhất ở phía trước. Tôi đang xếp vào một danh sách chứa một danh sách 9mà tôi sẽ xóa ngay lập tức sau đó init, để tôi không phải kiểm tra danh sách trống s. iteratelặp lại quá trình gấp mãi mãi tạo ra một danh sách các kết quả trung gian. Kết quả cuối cùng là yếu tố thứ 9 của danh sách này.

Perl, 68 byte

{for(0..7){if($m[$_]>$m[$_+1]){splice@m,$_,2,$m[$_+1],$m[$_];redo}}}

Mã bị đánh cắp

 {                                             # Block runs once unless redo is called

     for (0..7) {                                 # Loop index is in $_

         if ($m[$_] > $m[$_+1]) {                 # Check if swap needed

             splice @m, $_, 2, $m[$_+1], $m[$_];  # Replace a two element slice of
                                                  # the array with those 
                                                  # two elements reversed

             redo                                 # Restart the block over
         }
     }
}