Các thách thức

Nó thực sự khá đơn giản, sắp xếp một danh sách các số.

Chi tiết

Bạn phải sắp xếp danh sách các số theo thứ tự tăng dần, mà không sử dụng bất kỳ chức năng sắp xếp / thư viện / vv tích hợp nào (ví dụ như list.sort()trong Python).

Đầu vào / đầu ra có thể được thực hiện trong bất kỳ phương pháp nào bạn chọn, miễn là nó có thể đọc được.

Sơ hở tiêu chuẩn là không được phép như mọi khi.

Mã ngắn nhất trong byte thắng.

Bạn phải giải thích / liệt kê phương pháp sắp xếp nào bạn đã sử dụng (Bong bóng, Chèn, Lựa chọn, v.v.)

Đầu vào sẽ không chứa các bản sao.

Đầu vào / đầu ra mẫu

Đầu vào: 99,-2,53,4,67,55,23,43,88,-22,36,45

Đầu ra: -22,-2,4,23,36,43,45,53,55,67,88,99

Lưu ý: Gần đối diện trực tiếp với Sắp xếp danh sách số

05AB1E , 2 byte

Mã số:

ϧ

Thuật toán tương tự như câu trả lời Jelly . Tính toán tất cả các hoán vị của đầu vào và bật ra cái nhỏ nhất.

Hãy thử trực tuyến!

Một phương pháp hiệu quả hơn là:

E[ß,Ž

Thực hiện lựa chọn sắp xếp . Sử dụng mã hóa CP-1252 .

Hãy thử trực tuyến!

Thạch, 3 byte

Œ!Ṃ

Điều này tạo ra tất cả các hoán vị của danh sách đầu vào, sau đó chọn hoán vị nhỏ nhất theo từ vựng. Rất hiệu quả.

Tín dụng cho @Adnan, người có cùng ý tưởng độc lập.

Hãy thử trực tuyến!

Thạch, 4 byte

ṂrṀf

Điều này xây dựng phạm vi từ tối thiểu của danh sách đến tối đa của danh sách, sau đó loại bỏ các thành phần phạm vi không có trong danh sách ban đầu. Về mặt kỹ thuật đây là một loại xô , với các thùng rất nhỏ. Tôi không biết tên cho biến thể cụ thể này.

Hãy thử trực tuyến!

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

ṂrṀf  Main link. Argument: A (list/comma-separated string)

Ṃ     Compute the minimum of A.
  Ṁ   Compute the maximum of A.
 r    Yield the inclusive range from the minimum to the maximum.
   f  Filter the range by presence in A.

Python, 46 45 byte

lambda l:[l.pop(l.index(min(l)))for _ in 1*l]

Sắp xếp lựa chọn đơn giản.

Brachylog , 12 7 byte

p.'(s>)

Cái này sử dụng sắp xếp hoán vị, rõ ràng là khủng khiếp, nhưng nó ngắn hơn Pyth!

Giải trình

p.       Unifies the output with a permutation of the input
  '(  )  True if what's inside the parentheses cannot be proven, else backtrack and
         try with another permutation of the input.
    s    Take an ordered subset from the output
     >   True if the first element is bigger than the second (hence not sorted)
         We don't need to check that the subset is 2 elements long because > will be false
         for inputs that are not 2 elements long anyway

Haskell, 38 byte

h%t|(a,b)<-span(<h)t=a++h:b
foldr(%)[]

Hàm nhị phân %chèn một phần tử mới hvào danh sách được sắp xếp tbằng cách phân vùng tthành tiền tố acủa các phần tử <hvà hậu tố bcủa các phần tử >hvà dính vào hgiữa chúng.

Hoạt động foldr(%)[]sau đó xây dựng một danh sách được sắp xếp từ trống bằng cách liên tục chèn các phần tử từ danh sách đầu vào.

Đây là một byte ngắn hơn so với thực hiện đệ quy trực tiếp

f(h:t)|(a,b)<-span(<h)$f t=a++h:b
f x=x

Một chiến lược khác cho 41 byte:

f[]=[]
f l|x<-minimum l=x:f(filter(/=x)l)

JavaScript (ES6), 51 byte

a=>a.map(_=>m=Math.min(...a.filter(e=>e>m)),m=-1/0)

Mỗi vòng lặp tìm thấy số nhỏ nhất chưa được tìm thấy cho đến nay.

Python 2, 34 byte

def f(s):m=min(s);print m;f(s-{m})

Đưa đầu vào thành một tập hợp, in các phần tử của nó theo thứ tự tăng dần, kết thúc có lỗi.

Một kết thúc sạch có thể được thực hiện trong 41 byte:

def f(s):
 if s:m=min(s);print m;f(s-{m})

hoặc là

l=input()
while l:m=min(l);print m;l-={m}

Đầu vào có thể được lấy làm danh sách cho 39 byte hoặc 38 byte trong Python 3.5:

def f(l):m=min(l);print m;f(set(l)-{m})
def f(l):m=min(l);print(m);f({*l}-{m})

Haskell, 42 41 38 byte

f u=filter(`elem`u)[(minBound::Int)..]

Vòng lặp thông qua tất cả các số nguyên (đã ký 64 bit, trên máy của tôi) và giữ các số nguyên trong đó u. Tất nhiên nó không hoàn thành trong thời gian hợp lý.

Phiên bản trước được lặp qua [minimum u..maximum u]đó có cùng thời gian chạy tệ nhất.

Chỉnh sửa: @xnor đã lưu một byte. Cảm ơn!

Oracle SQL 11.2, 205 byte

WITH s AS(SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))),v(p,f)AS(SELECT e,e FROM s UNION ALL SELECT p||','||e,e FROM v,s WHERE e+0>f)SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1);         

Không chơi gôn

WITH 
s AS  -- Split the string using ',' as separator
(     -- ||'' cast the xml type to varchar
  SELECT COLUMN_VALUE||''e FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))
),  
v(p,f) AS  -- Recursive view : p = sorted string, f last number added
(
  SELECT e,e FROM s -- use each number as seed
  UNION ALL         -- only add a number if it is > the last added
  SELECT p||','||e,e FROM v,s WHERE e+0>f  -- +0 is needed to compare int and not strings
)  
-- The valid string has the same length as the input
SELECT p FROM v WHERE LENGTH(p)=LENGTH(:1)          

Đối với phương pháp sắp xếp đó là gì, tôi không biết, ORDER BYchắc chắn rằng tôi đã quên chúng.

Mã máy x86-16 (BubbleSort int8_t), 20 19 byte

mã máy x86-64 / 32 (JumpDownSort) 21 19 byte

Thay đổi:

• Cảm ơn @ ped7g cho lodsb/ cmp [si],alý tưởng và đặt nó cùng với việc tăng / đặt lại con trỏ mà tôi đang xem xét. Không cần al/ ahcho phép chúng tôi sử dụng gần như cùng một mã cho các số nguyên lớn hơn.

• Thuật toán mới (nhưng có liên quan), nhiều thay đổi triển khai: Bubbly SelectionSort cho phép triển khai x86-64 nhỏ hơn cho byte hoặc dwords; hòa vốn trên x86-16 (byte hoặc từ). Cũng tránh được lỗi về kích thước = 1 mà BubbleSort của tôi có. Xem bên dưới.

• Nó chỉ ra rằng Sắp xếp lựa chọn Bubbly của tôi với các giao dịch hoán đổi mỗi khi bạn tìm thấy một min mới đã là một thuật toán được biết đến, JumpDown Sort. Nó được đề cập trong Bubble Sort: Phân tích thuật toán khảo cổ học (tức là cách Bubble Sort trở nên phổ biến mặc dù hút).

Sắp xếp các số nguyên có chữ ký 8 bit tại chỗ . (Chưa ký là cùng kích thước mã, chỉ cần thay đổi jgethành a jae). Bản sao không phải là một vấn đề. Chúng tôi trao đổi bằng cách sử dụng xoay 16 bit bằng 8 (với đích bộ nhớ).

Bubble Sort hút hiệu năng , nhưng tôi đã đọc rằng đó là một trong những cách nhỏ nhất để thực hiện trong mã máy. Điều này có vẻ đặc biệt đúng khi có các thủ thuật đặc biệt để hoán đổi các yếu tố liền kề. Đây là lợi thế duy nhất của nó, nhưng đôi khi (trong các hệ thống nhúng ngoài đời thực) đó là đủ lợi thế để sử dụng nó cho các danh sách rất ngắn.

Tôi đã bỏ qua việc chấm dứt sớm mà không có giao dịch hoán đổi . Tôi đã sử dụng vòng lặp BubbleSort "được tối ưu hóa" của Wikipedia để tránh nhìn vào các n − 1mục cuối cùng khi chạy nlần thứ-3, vì vậy bộ đếm vòng ngoài là giới hạn trên của vòng lặp bên trong.

Danh sách NASM ( nasm -l /dev/stdout) hoặc nguồn đơn giản

 2 address  16-bit       bubblesort16_v2:
 3          machine      ;; inputs: pointer in ds:si,  size in in cx
 4          code         ;; requires: DF=0  (cld)
 5          bytes        ;; clobbers: al, cx=0
 6                       
 7 00000000 49               dec     cx          ; cx = max valid index.  (Inner loop stops 1 before cx, because it loads i and i+1).
 8                       .outer:                 ; do{
 9 00000001 51               push    cx          ;   cx = inner loop counter = i=max_unsorted_idx
10                       .inner:                 ;   do{
11 00000002 AC               lodsb               ;     al = *p++
12 00000003 3804             cmp     [si],al     ;     compare with *p (new one)
13 00000005 7D04             jge     .noswap
14 00000007 C144FF08         rol     word [si-1], 8    ; swap
15                       .noswap:
16 0000000B E2F5             loop    .inner      ;   } while(i < size);
17 0000000D 59               pop     cx          ;  cx = outer loop counter
18 0000000E 29CE             sub     si,cx       ;  reset pointer to start of array
19 00000010 E2EF             loop    .outer      ; } while(--size);
20 00000012 C3               ret

22 00000013  size = 0x13 = 19 bytes.

đẩy / bật cxxung quanh vòng lặp bên trong có nghĩa là nó chạy với cx= outs_cx xuống 0.

Lưu ý rằng đó rol r/m16, imm8không phải là một lệnh 8086, nó đã được thêm vào sau (186 hoặc 286), nhưng đây không phải là mã 8086, chỉ là 16 bit x86. Nếu SSE4.1 phminposuwcó ích, tôi sẽ sử dụng nó.

Phiên bản 32 bit này (vẫn hoạt động trên số nguyên 8 bit nhưng với con trỏ / bộ đếm 32 bit) là 20 byte (bật tiền tố kích thước toán hạng rol word [esi-1], 8)

Lỗi: size = 1 được coi là size = 65536, vì không có gì ngăn chúng ta vào bên ngoài do / while với cx = 0. (Bạn thường sử dụng jcxzcho điều đó.) Nhưng may mắn thay, JumpDown Sort 19 byte là 19 byte và không có vấn đề đó.

Phiên bản gốc x86-16 20 byte (không có ý tưởng của Ped7g). Bỏ qua để tiết kiệm không gian, xem lịch sử chỉnh sửa cho nó với một mô tả.

Hiệu suất

Cửa hàng / tải lại chồng chéo một phần (trong xoay vòng đích-bộ nhớ) gây ra một gian hàng chuyển tiếp cửa hàng trên các CPU x86 hiện đại (ngoại trừ theo thứ tự Atom). Khi một giá trị cao đang sủi bọt lên trên, độ trễ thêm này là một phần của chuỗi phụ thuộc mang theo vòng lặp. Lưu trữ / tải lại hút ở vị trí đầu tiên (như độ trễ chuyển tiếp lưu trữ 5 chu kỳ trên Haswell), nhưng một gian hàng chuyển tiếp mang đến cho nó nhiều hơn 13 chu kỳ. Thực hiện ngoài trật tự sẽ gặp khó khăn trong việc che giấu điều này.

Xem thêm: Stack Overflow: sắp xếp bong bóng để sắp xếp chuỗi cho phiên bản này với cách triển khai tương tự, nhưng với việc ra sớm khi không cần hoán đổi. Nó sử dụng xchg al, ah/ mov [si], axđể hoán đổi, dài hơn 1 byte và gây ra tình trạng đăng ký một phần trên một số CPU. (Nhưng nó vẫn có thể tốt hơn xoay vòng bộ nhớ, cần tải lại giá trị). Nhận xét của tôi có một số gợi ý ...

x86-64 / x86-32 JumpDown Sắp xếp, 19 byte (sắp xếp int32_t)

Có thể gọi từ C bằng cách sử dụng quy ước gọi Hệ thống V x86-64 là
int bubblyselectionsort_int32(int dummy, int *array, int dummy, unsigned long size); (return value = max (mảng [])).

Đây là https://en.wikipedia.org/wiki/Selection_sort , nhưng thay vì nhớ vị trí của phần tử min, hãy trao đổi ứng viên hiện tại vào mảng . Khi bạn đã tìm thấy min (unsort_region), hãy lưu nó vào cuối khu vực được sắp xếp, như Sắp xếp lựa chọn bình thường. Điều này phát triển các khu vực được sắp xếp theo một. (Trong mã, rsichỉ đến một điểm cuối của khu vực được sắp xếp; lodsdtiến bộ và mov [rsi-4], eaxlưu trữ lại tối thiểu vào đó.)

Tên Jump Down Sort được sử dụng trong Bubble Sort: Phân tích thuật toán khảo cổ . Tôi đoán sắp xếp của tôi thực sự là một loại Jump Up, bởi vì các yếu tố cao nhảy lên, để lại phía dưới được sắp xếp, không phải là kết thúc.

Thiết kế trao đổi này dẫn đến phần chưa sắp xếp của mảng kết thúc theo thứ tự sắp xếp ngược, dẫn đến nhiều giao dịch hoán đổi sau này. (Bởi vì bạn bắt đầu với một ứng cử viên lớn, và tiếp tục nhìn thấy các ứng cử viên thấp hơn và thấp hơn, vì vậy bạn tiếp tục trao đổi.) Tôi gọi nó là "bong bóng" mặc dù nó di chuyển các yếu tố theo hướng khác. Cách nó di chuyển các phần tử cũng hơi giống một kiểu sắp xếp ngược. Để xem nó hoạt động, sử dụng GDB display (int[12])buf, đặt điểm dừng trên loophướng dẫn bên trong và sử dụng c(tiếp tục). Nhấn quay lại để lặp lại. (Lệnh "display" nhận được GDB để in toàn bộ trạng thái mảng mỗi khi chúng ta đạt điểm dừng).

xchgvới mem có một locktiền tố ngầm làm cho điều này thêm chậm. Có lẽ là về một thứ tự cường độ chậm hơn so với trao đổi tải / cửa hàng hiệu quả; xchg m,rlà một thông lượng trên 23c trên Skylake, nhưng tải / lưu trữ / Mov với một tmp reg để trao đổi hiệu quả (reg, mem) có thể thay đổi một yếu tố trên mỗi đồng hồ. Nó có thể là một tỷ lệ tồi tệ hơn trên CPU AMD khi loophướng dẫn nhanh và sẽ không làm tắc nghẽn vòng lặp bên trong, nhưng các lỗi nhánh sẽ vẫn là một nút cổ chai lớn vì các giao dịch hoán đổi là phổ biến (và trở nên phổ biến hơn khi vùng không được sắp xếp trở nên nhỏ hơn ).

 2 Address               ;; hybrib Bubble Selection sort
 3        machine         bubblyselectionsort_int32:   ;; working, 19 bytes.  Same size for int32 or int8
 4        code               ;; input: pointer in rsi, count in rcx
 5        bytes              ;; returns: eax = max
 6                       
 7                           ;dec  ecx           ; we avoid this by doing edi=esi *before* lodsb, so we do redundant compares
 8                                               ; This lets us (re)enter the inner loop even for 1 element remaining.
 9                       .outer:
10                           ; rsi pointing at the element that will receive min([rsi]..[rsi+rcx])
11 00000000 56               push   rsi
12 00000001 5F               pop    rdi
13                           ;mov    edi, esi     ; rdi = min-search pointer
14 00000002 AD               lodsd
16 00000003 51               push   rcx          ; rcx = inner counter
17                       .inner:                   ; do {
18                           ; rdi points at next element to check
19                           ; eax = candidate min
20 00000004 AF               scasd                 ; cmp eax, [rdi++]
21 00000005 7E03             jle  .notmin
22 00000007 8747FC           xchg   [rdi-4], eax   ; exchange with new min.
23                         .notmin:
24 0000000A E2F8             loop  .inner          ; } while(--inner);
26                           ; swap min-position with sorted position
27                           ; eax = min.  If it's not [rsi-4], then [rsi-4] was exchanged into the array somewhere
28 0000000C 8946FC           mov    [rsi-4], eax
29 0000000F 59               pop   rcx           ; rcx = outer loop counter = unsorted elements left
30 00000010 E2EE             loop  .outer        ; } while(--unsorted);
32 00000012 C3               ret

34 00000013 13           .size: db $ - bubblyselectionsort_int32
           0x13 = 19 bytes long

Mã kích thước tương tự cho int8_t: sử dụng lodsb/ scasb, ALvà thay đổi các [rsi/rdi-4]đến -1. Mã máy tương tự hoạt động ở chế độ 32 bit cho các phần tử 8/32 bit. Chế độ 16 bit cho các phần tử 8/16 bit cần được xây dựng lại với các độ lệch được thay đổi (và chế độ địa chỉ 16 bit sử dụng mã hóa khác nhau). Nhưng vẫn còn 19 byte cho tất cả.

Nó tránh được sự khởi đầu dec ecxbằng cách so sánh với phần tử mà nó vừa tải trước khi tiếp tục. Ở lần lặp cuối cùng của vòng lặp bên ngoài, nó tải phần tử cuối cùng, kiểm tra xem nó có nhỏ hơn chính nó không, sau đó đã xong. Điều này cho phép nó hoạt động với size = 1, trong đó BubbleSort của tôi không thành công (coi nó là size = 65536).

Tôi đã thử nghiệm phiên bản này (bằng GDB) bằng cách sử dụng trình gọi này: Dùng thử trực tuyến! . Bạn có thể chạy nó trên TIO, nhưng tất nhiên không có trình gỡ lỗi hoặc in. Tuy nhiên, _startlệnh gọi nó thoát với exit-status = lớn nhất = 99, vì vậy bạn có thể thấy nó hoạt động.

C, 72 byte

i,j;a(int*l,int n){for(i=0;i=i?:--n;j>l[n]?l[i]=l[n],l[n]=j:0)j=l[--i];}

Bong bóng. Đối số đầu tiên là một con trỏ tới mảng, đối số thứ hai là chiều dài của mảng. Hoạt động với gcc.

MATL , 11 10 byte

Y@t!d0>AY)

Kiểm tra cực kỳ không hiệu quả của tất cả các hoán vị của đầu vào.

Hãy thử trực tuyến!

Giải trình

        % Implicitly grab input array
Y@      % Compute all permutations (each permutation as a row)
t       % Duplicate this matrix
!d      % Transpose and take the differences between the values
0>A     % Find the rows where all differences are > 0
Y)      % Return only the row where this is true
        % Implicitly display the result

Ruby, 40 byte

Lựa chọn sắp xếp. Chức năng ẩn danh; lấy danh sách làm đối số.

->a{r=[];r<<a.delete(a.min)while[]!=a;r}

Con trăn, 120 byte

def f(a):import time,threading;[threading.Thread(None,lambda b=b,c=min(a):print(time.sleep(b-c)or b)).start()for b in a]

Đây có lẽ sẽ không phải là câu trả lời ngắn nhất nhưng tôi cảm thấy thuật toán này thuộc về nơi này. gọi với một danh sách các số nguyên, chúng sẽ được in theo cách được sắp xếp theo thiết bị xuất chuẩn. Tôi sẽ không thử nó với số lượng quá lớn mặc dù.

MIPS, 68 byte

Tôi đã viết một triển khai sắp xếp bong bóng không tối ưu hóa đơn giản một thời gian trước đây. Số lượng byte bắt đầu tại loopvà kết thúc tại li $v0, 10, giả sử rằng địa chỉ danh sách và độ dài danh sách đã có trong bộ nhớ.

 Address    Code        Basic                     Source

0x00400000  0x3c011001  lui $1,4097           5    main:   la      $s0, list       # List address
0x00400004  0x34300000  ori $16,$1,0               
0x00400008  0x2411000a  addiu $17,$0,10       6            li      $s1, 10         # List length
0x0040000c  0x24080000  addiu $8,$0,0         8    loop:   li      $t0, 0          # swapped
0x00400010  0x24090001  addiu $9,$0,1         9            li      $t1, 1          # for loop "i"
0x00400014  0x1131000b  beq $9,$17,11         11   for:    beq     $t1, $s1, fend  # break if i==length
0x00400018  0x00095080  sll $10,$9,2          13           sll     $t2, $t1, 2     # Temp index, multiply by 4
0x0040001c  0x01505020  add $10,$10,$16       14           add     $t2, $t2, $s0   # Combined address
0x00400020  0x8d4b0000  lw $11,0($10)         15           lw      $t3, 0($t2)     # list[i]
0x00400024  0x8d4cfffc  lw $12,-4($10)        16           lw      $t4, -4($t2)    # list[i-1]
0x00400028  0x21290001  addi $9,$9,1          18           addi    $t1, $t1, 1     # i++
0x0040002c  0x016c082a  slt $1,$11,$12        20           ble     $t4, $t3, for   # if list[i-1] > list[i]
0x00400030  0x1020fff8  beq $1,$0,-8               
0x00400034  0xad4bfffc  sw $11,-4($10)        21           sw      $t3, -4($t2)    # swap and store
0x00400038  0xad4c0000  sw $12,0($10)         22           sw      $t4, 0($t2)     
0x0040003c  0x24080001  addiu $8,$0,1         23           li      $t0, 1          # swapped=true
0x00400040  0x08100005  j 0x00400014          24           j       for
0x00400044  0x20010001  addi $1,$0,1          26   fend:   subi    $s1, $s1, 1     # length--
0x00400048  0x02218822  sub $17,$17,$1             
0x0040004c  0x1500ffef  bne $8,$0,-17         27           bnez    $t0, loop       # Repeat if swapped==true
0x00400050  0x2402000a  addiu $2,$0,10        29           li      $v0, 10        
0x00400054  0x0000000c  syscall               30           syscall

Bây giờ tôi chờ đợi để được thổi ra khỏi nước với x86 ...

Awk, 66 byte

{b=$0;a[b]}m<b{m=b}n>b{n=b}END{for(i=n;i<=m;i++)if(i in a)print i}

Mảng trong awk giống như từ điển, không giống như mảng C. Các chỉ mục có thể không liền kề, và chúng phát triển (và được tạo ra) khi cần thiết. Vì vậy, chúng tôi tạo một mảng acho đầu vào, với mỗi dòng là một khóa. Và chúng tôi lưu các giá trị tối thiểu và tối đa. Sau đó, chúng tôi lặp từ min đến max và in tất cả các khóa tồn tại a. bchỉ để tránh sử dụng nhiều lần $0.

Python 3, 91 62 47 byte

def f(z):
 while z:m=min(z);z.remove(m);yield m

Cảm ơn wnnmaw và Seeq đã giúp đỡ chơi golf.

Đối số znên là một danh sách. Đây là một biến thể của lựa chọn sắp xếp.

Tôi không chắc chắn làm thế nào minđể chống lại built-in sorting functions, vì tôi không chắc Python thực hiện như thế nào min. Hy vọng, giải pháp này vẫn ổn. Bất kỳ đề xuất chơi gôn nào trong các bình luận hoặc trong trò chuyện PPCG đều được chào đón.

MATL , 11 byte

`t4#X<2#)tn

Hãy thử trực tuyến!

Điều này sắp xếp theo thủ tục sau đây, đó là O ( n ² ):

1. Lấy tối thiểu của mảng.
2. Xóa giá trị đó khỏi mảng và lưu trữ nó để hiển thị tiếp theo.
3. Áp dụng quy trình tương tự với phần còn lại của mảng, cho đến khi nó trở nên trống rỗng.
4. Hiển thị tất cả các số theo thứ tự mà chúng được lấy.

MATL dựa trên ngăn xếp. Mảng với các giá trị còn lại được giữ ở đầu ngăn xếp. Các giá trị bị loại bỏ dưới đây, theo thứ tự. Vào cuối chương trình, tất cả các giá trị được hiển thị. Mảng ở trên cùng cũng sẽ được hiển thị, nhưng vì nó trống nên nó không được hiển thị.

`        % Do...while loop
  t      %   Duplicate. Implicitly take input in the first iteration
  4#X<   %   Compute index of mininum of the array
  2#)    %   Push the minimum, and then the array with remaining entries
  tn     %   Duplicate and push number of elements, to be used as loop condition
         % Implicitly end do...while loop
         % Implicitly display stack contents

Pyth - 15 13 11 10 byte

Hai byte được lưu nhờ @Jakube.

Không có thuốc.

f!s>VTtT.p

Hãy thử trực tuyến tại đây .

Tôi không cần hvì chúng tôi được đảm bảo không có bản sao.

Nghiêm túc, 6 byte

,;l@╨m

Hãy thử trực tuyến!

Điều này thực hiện tương tự như nhiều câu trả lời khác: tạo ra tất cả các hoán vị, chọn tối thiểu. Tôi hơi quên rằng điều này sẽ hoạt động trong khi tôi đang làm việc với giải pháp dưới đây.

Giải trình:

,;l@╨m
,;l@    push len(input), input
    ╨m  minimum permutation

Nghiêm túc, 25 byte (không cạnh tranh)

Điều này sẽ cạnh tranh nếu không có lỗi trong lệnh xáo trộn mà tôi vừa sửa.

,1WX╚;;pX@dXZ`i@-0<`MπYWX

Hãy thử trực tuyến! Điều này thực hiện thuật toán sắp xếp tốt nhất từ ​​trước đến nay: Bogosort !

Giải trình:

,1WX╚;;pX@dXZ`i@-0<`MπYWX
,                          get input
 1W                    WX  do-while:
   X                         discard
    ╚                        shuffle
     ;;                      dupe twice
       pX@dX                 remove first element of first dupe and last element of second dupe
            Z                zip
             `i@-0<`MπY      test if all differences are positive (if any are not, the list is not sorted), negate (1 if not sorted else 0)

MATL, 17 16 byte

Đã lưu một byte tạo mảng null nhờ @LuisMendo

vTbtX<-QI$(f8M+q

Sắp xếp xô. Đừng thử nó với phạm vi lớn hơn 2 ³¹ -1.

Hãy thử trực tuyến!

Giải trình

v                  % push an empty array
 T                 % push 1
  b                % bubble the input array up to the top of the stack
   t               % duplicate it
    X<             % find the minimum
      -            % subtract min from input array
       Q           % and increment to adjust for 1-based indexing
        I$(        % resulting array used as indices of empty array 
                   % (the [] way up at the top) that are assigned 1 (from T)
           f       % find the nonzero indices
            8M     % magically retrieve the 4th previous function input :/
                     (aka, the min input array value)
              +    % add it to the indices
               q   % and decrement

TIL:

• Bạn có thể khởi tạo một mảng trống trong MATL bằng cách sử dụng [] và phát triển nó, giống như trong MATLAB
• Cách sử dụng ( để lập chỉ mục bài tập
• Cách sử dụng Mclipboard tự động

Ngày mới, TIL mới:

• vertcat kỳ diệu tạo ra một mảng trống khi không có gì trên ngăn xếp để ghép

Julia, 28 27 byte

x->colon(extrema(x)...)∩x

Hãy thử trực tuyến!

R, 68 byte

Đưa đầu vào ivà đầu ra olà danh sách được sắp xếp.

o<-i
for(j in 1:length(i)){
x<-(i-min(i))==0
o[j]<-i[x]
i<-i[!x]
}
o

Giải trình:

o<-i                      # Defines output as o
 for(j in 1:length(i)){   # Initializes loop for length of input
  x<-(i-min(i))==0        # Generates logical vector by finding the value 0 
                          # of input less the minimum of input. 
   o[j]<-i[x]             # Puts the smallest value at position j
    i<-i[!x]              # Removes the smallest value from input
      }                   # Ends loop
       o                  # Returns sorted list

Tránh hoán vị có nghĩa là nó có thể sắp xếp danh sách lớn tương đối nhanh chóng. "Bí quyết" là trừ đi giá trị nhỏ nhất từ ​​đầu vào để lại một 0 xác định cả giá trị nhỏ nhất và vị trí của giá trị nhỏ nhất.

Java 8, 112 92 byte

Đây là một loại lựa chọn. Đầu vào là một List tsố nguyên và đầu ra được sắp xếp được in ra tiêu chuẩn.

t->{for(;0<t.size();System.out.println(t.remove(t.indexOf(java.util.Collections.min(t)))));}

Cập nhật

• -20 [16-08-21] Đã sử dụng lambda

Võng mạc, 95

Sắp xếp bong bóng sửa đổi. Tôi nghi ngờ có nhiều cách tốt hơn để làm điều này, ngay cả khi không có nội dung sắp xếp võng mạc.

-\d+
$*n
\d+
$*11
+`(1+) (n+)
$2 $1
+`\b(n+) (\1n+)|(1+)(1+) \3\b
$2$3 $1$3$4
1(1*)
$.1
n+
-$.&

• Giai đoạn 1 - chuyển đổi số nguyên -ve thành unary với ndạng chữ số; thả- dấu hiệu.
• Giai đoạn 2 - convert + ve và zero số nguyên thành unary với 1dạng chữ số; thêm 1vào từng cái, sao cho số 0 được biểu thị bằng 1.
• Giai đoạn 3 - Di chuyển tất cả các phía trước.
• Giai đoạn 4 - Sắp xếp: di chuyển tất cả các con có độ lớn lớn nhất (tức là số nhỏ nhất) trước các con cao hơn. Di chuyển nhỏ hơn + ves trước lớn hơn + ves.
• Giai đoạn 5 - Xóa 1 khỏi và chuyển đổi + ve unaries trở lại thập phân.
• Giai đoạn 6 - chuyển đổi -ve unaries trở lại thập phân, bao gồm cả dấu hiệu.

Hãy thử trực tuyến.

Ruby, 22 byte

Một loại hoán vị nhanh chóng . Chạy trong không gian và thời gian O (n!).

->a{a.permutation.min}

Clojure, 73 35 byte

Không có gì cả :)

#(if(apply < %)%(recur(shuffle %)))

Phiên bản trước đó:

#(reduce(fn[r i](let[[a b](split-with(partial > i)r)](concat a[i]b)))[]%)

Giảm xuống một danh sách được sắp xếp rbằng cách chia nó thành các phần "nhỏ hơn i" và "lớn hơn i". Tôi đoán đây là loại chèn .

Ruby, 26 24 byte

Lựa chọn sắp xếp, tương tự như câu trả lời của Value Ink, nhưng sử dụng một cách tiếp cận khác để có tính golf cao hơn.

Theo đặc điểm kỹ thuật: "Đầu vào / đầu ra có thể được thực hiện trong bất kỳ phương pháp nào bạn chọn, miễn là nó có thể đọc được". Tôi nghĩ rằng điều này phù hợp với mô tả, đầu ra là một mảng các mảng với một phần tử duy nhất.

->l{l.map{l-l-=[l.min]}}

thí dụ:

->l{l.map{l-l-=[l.min]}}[[2,4,3,1]]
=> [[1], [2], [3], [4]]

Java 7, 106 104 byte

void a(int[]a){for(int b=a.length-1,d=0,c=0,e;d<b*b;c=++d%b)if(a[c]>a[c+1]){e=a[c];a[c++]=a[c];a[c]=e;}}

Đây là một loại bong bóng ole tốt. Tham số chức năng được sửa đổi tại chỗ vì vậy tôi không phải trả lại bất cứ điều gì. Vẫn đang cố gắng vắt một số byte ra khỏi đây để tôi có thể đánh bại java lambda mà ai đó đã đăng.

-1 byte nhờ Geobits đã chỉ ra rằng việc hoán đổi nhịp đập bình thường xor'ing
-1 byte nhờ Leaky Nun đã chỉ ra rằng tôi có thể di chuyển tất cả các khai báo int vào vòng lặp for

Hãy thử trực tuyến!

Ruby, 22 byte

->a{[*a.min..a.max]&a}

Xây dựng một mảng ngoài phạm vi giữa các phần tử tối thiểu và tối đa của mảng đầu vào. Trả về giao điểm giữa hai mảng.