Mục tiêu

Tạo danh sách được xáo trộn ban đầu, từ các chuyển động mà Sắp xếp chèn sẽ làm để sắp xếp nó. Danh sách ban đầu sẽ có tất cả các số từ 0đến N-1(bao gồm) trong đó Nkích thước của đầu vào.

Đầu vào

Một danh sách chứa các di chuyển cần thiết để sắp xếp danh sách. Mỗi giá trị đại diện cho số lượng vị trí được dịch chuyển bởi số gốc (được xáo trộn) ở vị trí bên phải của anh ấy, hãy nhớ rằng quá trình này là từ trái sang phải.
Giá trị tại vị trí (được lập chỉ mục 0) itrong danh sách đầu vào sẽ nằm giữa 0và ibao gồm.
Bạn không cần xử lý các đầu vào không hợp lệ, mọi hành vi đều được chấp nhận trong trường hợp này (sự cố, vòng lặp vô hạn, v.v.).

Đầu ra

Danh sách xáo trộn

Từng bước để tạo ra các di chuyển

Scrambled List | Moves to sort
[4,0,2,1,3,5]  | [0, , , , , ] #4 stay in place
[4,0,2,1,3,5]  | [0,1, , , , ] #0 is moved 1 slot to the left
[0,4,2,1,3,5]  | [0,1,1, , , ] #2 is moved 1 slot
[0,2,4,1,3,5]  | [0,1,1,2, , ] #1 is moved 2 slot
[0,1,2,4,3,5]  | [0,1,1,2,1, ] #3 is moved 1 slot
[0,1,2,3,4,5]  | [0,1,1,2,1,0] #5 is in the right place already
[0,1,2,3,4,5]

Vì vậy, đối với đầu vào [0,1,1,2,1,0]chương trình của bạn cần phải xuất [4,0,2,1,3,5].
Hãy nhớ rằng các chuyển động không đến vị trí trong danh sách được sắp xếp (cuối cùng), nhưng trong phân đoạn được sắp xếp (phần in đậm)

Các trường hợp thử nghiệm

[0,0,0] -> [0,1,2]
[0,1,0,1] -> [1,0,3,2]
[0,0,0,0,0,5] -> [1,2,3,4,5,0]
[0,1,2,3] -> [3,2,1,0]
[0,1,1,1] -> [3,0,1,2]
[0,1,1,2,1,0] -> [4,0,2,1,3,5]

Chiến thắng

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất sẽ thắng.

Thạch , 12 byte

L!_UÆ¡$œ?J’U

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

Giải trình

Về cơ bản chúng ta có thể xem hai danh sách (đầu vào và đầu ra) dưới dạng mã hóa một số nguyên; đầu vào mã hóa một số nguyên trong cơ sở giai thừa và đầu ra mã hóa một số nguyên dưới dạng hoán vị. May mắn thay, Jelly có các nội dung đã rất gần với cả hai bảng mã này, do đó, đơn giản chỉ là viết các đoạn mã nhỏ để chuyển đổi thành một số nguyên, sau đó quay lại mã hóa khác.

L!_UÆ¡$œ?J’U
   U           Reverse {the input}
    Æ¡         and convert from base factorial to integer;
  _   $        subtract that from
L!             the factorial of the length of {the input};
       œ?      then take the nth permutation of
         J     [1,2,...,l], where l is the length of {the input},
          ’    subtract 1 from every elevent,
           U   and reverse it

Trong trường hợp giai thừa cơ sở, chúng ta có thể quan sát rằng phần tử đầu tiên của danh sách phải là 0, phần thứ hai có thể là 0 hoặc 1, phần thứ ba phải là 0/1/2, v.v. Vì vậy, chúng ta phải đảo ngược đầu vào để đưa các phần tử của nó vào thứ tự viết thông thường để chuyển đổi cơ sở.

Ngoài ra, để các lệnh tương đối của chuyển đổi giai thừa và chuyển đổi hoán vị phù hợp với thao tác sắp xếp chèn, chúng ta cần thực hiện hai điều chỉnh: đảo ngược trình tự hoán vị và đảo ngược thứ tự của danh sách đầu ra. Đảo ngược danh sách đầu ra là đủ dễ dàng, chỉ cần một Uở cuối chương trình. Để đảo ngược chuỗi hoán vị, chúng tôi trừ đi giai thừa của độ dài đầu vào (điều này hoạt động vì giai thừa cơ sở tạo ra một số trong phạm vi từ 0 đến (chiều dài! -1), trong khi các hoán vị được đánh số bởi Jelly từ 1 đến chiều dài! , tạo ra một by-by-one ẩn mà loại bỏ off-by-one mà bạn thường nhận được khi trừ đi một chỉ số hoán vị từ một giai thừa).

Jelly , 9 byte, phối hợp với @Jonathan ALLan

UÆ¡Nœ?J’U

Phiên bản này của chương trình rất giống nhau, nhưng sử dụng một phương pháp khác để đảo ngược chuỗi hoán vị; chỉ cần phủ định đầu vào với Nlà đủ để œ?xử lý thứ tự ngược lại. Ngoài ra, nó hoạt động giống hệt với chương trình trước đó.

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

Toán học, 92 byte

Permute[Range[l=Length@#]-1,(c=Cycles@{#}&)@{}©##&@@c[i-0~Range~#[[i]]]~Table~{i,l,1,-1}]&

Hàm thuần túy lấy danh sách các số nguyên không âm làm đầu vào và trả về danh sách các số nguyên không âm. Đoạn mã trên chứa a ©, không chính xác: đó là một trình giữ chỗ cho ký hiệu 3 byte U + F3DE, mà Mathicala biểu thị bằng một vòng tròn có dấu chấm trong đó và đại diện cho thành phần hoán vị.

c=Cycles@{#}&định nghĩa một hàm chuyển đổi danh sách các số nguyên thành một Cyclesđối tượng biểu thị một hoán vị; ví dụ, c[{3,4}]là các phần tử hoán đổi vị trí 3 và 4 của một danh sách. c[i-0~Range~#[[i]]]~Table~{i,l,1,-1}]lấy danh sách đầu vào và tạo các hoán vị cần thiết để hoàn tác sắp xếp chèn. Sau đó kết hợp c@{}©##&@@tất cả các hoán vị này với nhau, bắt đầu với hoán vị danh tính c@{}. Cuối cùng, Permute[Range[l=Length@#]-1,...]áp dụng hoán vị này cho danh sách 0 chỉ số có độ dài phù hợp.

Python 2, 79 68 byte

Cảm ơn Krazor đã tiết kiệm 10 byte

Cảm ơn TuukkaX vì đã tiết kiệm 1 byte

a=input();b=range(len(a));print[b.pop(j-a[j])for j in b[::-1]][::-1]

Hoạt động bằng cách tạo ra các di chuyển ngược lại

JavaScript (ES6), 69 65 63 byte

a=>a.reverse(b=[...a.keys()]).map(o=>+b.splice(~o,1)).reverse()

Khó chịu cả đầu vào và đầu ra đều sai thứ tự. Chỉnh sửa: Đã lưu 4 byte nhờ @Arnauld. Đã lưu 2 byte nhờ @ETHproductions.

JavaScript (ES6), 73 71 byte

Đã lưu 2 byte nhờ vào ETHproductions

m=>(a=m.map((_,i)=>j=i)).map(_=>a.splice(j,0,+a.splice(j-m[j--],1)))&&a

Các trường hợp thử nghiệm

let f =

m=>(a=m.map((_,i)=>j=i)).map(_=>a.splice(j,0,+a.splice(j-m[j--],1)))&&a

console.log(JSON.stringify(f([0,0,0])));       // -> [0,1,2]
console.log(JSON.stringify(f([0,1,0,1])));     // -> [1,0,3,2]
console.log(JSON.stringify(f([0,0,0,0,0,5]))); // -> [1,2,3,4,5,0]
console.log(JSON.stringify(f([0,1,2,3])));     // -> [3,2,1,0]
console.log(JSON.stringify(f([0,1,1,1])));     // -> [3,0,1,2]
console.log(JSON.stringify(f([0,1,1,2,1,0]))); // -> [4,0,2,1,3,5]

Haskell , 85 byte

f x|n<-length x-1=reverse x#[n,n-1..0]
(n:r)#l=r#(take n l++drop(n+1)l)++[l!!n]
x#l=x

Hãy thử trực tuyến! Ví dụ sử dụng: f [0,1,1,2,1,0]sản lượng [4,0,2,1,3,5].

f xgọi hàm #với danh sách xđảo ngược và một danh sách [length x - 1, length x - 2, ... , 0]. (n:r)#lthực hiện sắp xếp chèn ngược bằng cách đệ quy nphần tử th ra l, trong đó l!!nmang lại nphần tử thứ và đưa take n l++drop(n+1)lra danh sách lvới nphần tử thứ bị loại bỏ.

perl, 61 byte

@o=@p=0..@ARGV-1;splice@o,$_,0,splice@o,$_-pop,1for reverse@p

Đầu ra kết thúc trong mảng @o. Ví dụ với mảng đầu vào là đối số dòng lệnh:

perl -le'@o=@p=0..@ARGV-1;splice@o,$_,0,splice@o,$_-pop,1for reverse@p;print@o' 0 1 1 2 1 0
402135

Ruby, 49 byte

->l{(w=l.size).times{l.insert(l.shift+w-=1,w)};l}

Thực hiện "chèn ngược" vào vị trí bên trong danh sách, bắt đầu với số lớn nhất.