Xác định một chuỗi độ dài nối thêmn vào là một hoán vị của các số 1, 2, ..., ncó thể được tạo bằng thủ tục sau:

• Bắt đầu với số lượng 1.

• Đối với mỗi số từ 2đến n, đặt số này vào đầu hoặc cuối của chuỗi ( thêm vào hoặc nối thêm nó, do đó là tên của chuỗi).

Ví dụ: đây là một cách hợp lệ để tạo ra một chuỗi bổ sung có độ dài 4:

1
21     [beginning]
213    [end]
2134   [end]

Nhiệm vụ của bạn là xây dựng một chương trình hoặc chức năng đó sẽ mất một số ntừ 3để 30làm đầu vào, và in hoặc trả lại toàn bộ trình tự thêm vào trước-append chiều dài ntrong thứ tự từ điển (nếu bạn đang xuất ra chuỗi và không liệt kê, số trên 9 sẽ được đại diện dưới dạng chữ cái a-u, để duy trì độ dài chuỗi). Ví dụ: đây là thứ tự cho n = 4:

1234  [RRR]
2134  [LRR]
3124  [RLR]
3214  [LLR]
4123  [RRL]
4213  [LRL]
4312  [RLL]
4321  [LLL]

Nói chung, có 2 hoán vị bổ sung ^n-1 có độ dài n.

Bạn không được sử dụng bất kỳ chức năng sắp xếp tích hợp nào trong ngôn ngữ của bạn trong mã của bạn. Chương trình ngắn nhất để làm điều này trong bất kỳ ngôn ngữ nào sẽ thắng.

CJam, 22 20 19 17 byte

]]l~{)f+_1fm>|}/p

Mở rộng mã :

]]                   "Put [[]] onto stack. What we will do with this array of array is";
                     "that in each iteration below, we will first append the next";
                     "number to all present arrays, then copy all the arrays and";
                     "move the last element to first in the copy";
  l~                 "Read input number. Lets call it N";
    {         }/     "Run this code block N times ranging from 0 to N - 1";
     )f+             "Since the number on stack starts from 0, add 1 to it and append";
                     "it to all arrays in the array of array beginning with [[]]";
        _1fm>        "Copy the array of array and move last element from all arrays";
                     "to their beginning";
             |       "Take set union of the two arrays, thus joining them and eliminating";
                     "duplicates. Since we started with and empty array and started adding";
                     "numbers from 1 instead of 2, [1] would have appeared twice if we had";
                     "simply done a concat";
                p    "Print the array of arrays";

Cách thức hoạt động :

Đây là phiên bản gỡ lỗi của mã:

]]l~ed{)edf+ed_ed1fm>ed|ed}/edp

Hãy xem cách nó hoạt động cho đầu vào 3:

[[[]] 3]                                 "]]l~"            "Empty array of array and input";
[[[]] 1]                                 "{)"              "First iteration, increment 0";
[[[1]]]                                  "{)f+"            "Append it to all sub arrays";
[[[1]] [[1]]]                            "{)f+_"           "Copy the final array of array";
[[[1]] [[1]]]                            "{)f+_1fm>"       "shift last element of each";
                                                           "sub array to the beginning";
[[[1]]]                                  "{)f+_1fm>|}"     "Take set based union";
[[[1]] 2]                                "{)"              "2nd iteration. Repeat";
[[[1 2]]]                                "{)f+"
[[[1 2]] [[1 2]]]                        "{)f+_";
[[[1 2]] [[2 1]]]                        "{)f+_1fm>";
[[[1 2] [2 1]]]                          "{)f+_1fm>|}";
[[[1 2] [2 1]] 3]                        "{)";
[[[1 2 3] [2 1 3]]]                      "{)f+"
[[[1 2 3] [2 1 3]] [[1 2 3] [2 1 3]]]    "{)f+_";
[[[1 2 3] [2 1 3]] [[3 1 2] [3 2 1]]]    "{)f+_1fm>";
[[[1 2 3] [2 1 3] [3 1 2] [3 2 1]]]      "{)f+_1fm>|}";
[[[1 2 3] [2 1 3] [3 1 2] [3 2 1]]]      "{)f+_1fm>|}/";

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

Haskell, 47 byte

f 1=[[1]]
f n=(\x->map(++[n])x++map(n:)x)$f$n-1

Con trăn 2, 68

f=lambda n:[[1]]*(n<2)or[x*b+[n]+x*-b for b in[1,-1]for x in f(n-1)]

Xuất ra một danh sách các danh sách các số.

Một giải pháp đệ quy. Đối với n==1, đầu ra [[1]]. Mặt khác, thêm nvào đầu hoặc cuối của tất cả các điều (n-1)kiện. Chuẩn bị làm cho hoán vị từ vựng muộn hơn so với nối thêm, vì vậy các hoán vị vẫn được sắp xếp.

"Boolean" bmã hóa xem nên đặt [n]ở đầu hay cuối. Trên thực tế, chúng tôi di chuyển phần còn lại của danh sách xtrong biểu thức x*b+[n]+x*-b. Đặt bdưới dạng -1hoặc 1cho phép sử dụng lật bằng cách phủ định, vì một danh sách được nhân với -1là danh sách trống.

Bình thường, 19

usCm,+dH+HdGr2hQ]]1

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

Đây là một chương trình đầy đủ lấy đầu vào từ stdin.

Điều này hoạt động theo cách tương tự như giải pháp của xnor, nhưng tạo ra các giá trị hơi sai lệch, do đó chúng phải được sắp xếp lại. Điều xảy ra ở mỗi cấp là mỗi danh sách giá trị trước đó có giá trị mới được thêm vào cuối và ở đầu và mỗi giá trị này được gói trong 2 tuple được gói lại trong một danh sách. Ví dụ: bước đầu tiên thực hiện việc này:

[[1]]
[([1,2], [2,1])]

Sau đó, danh sách các bộ dữ liệu này được nén (và sau đó được tóm tắt để xóa danh sách ngoài cùng). Trong trường hợp đầu tiên, điều này chỉ đưa ra giá trị chưa được bao bọc từ phía trên, vì chỉ có một giá trị trong danh sách.

Các bước hiển thị 2-> 3:

([1,2], [2,1])
[([1,2,3],[3,1,2]),([2,1,3],[3,2,1])]
([1,2,3],[2,1,3],[3,1,2],[3,2,1])

Toán học, 57 54 49 byte

f@1={{1}};f@n_:=#@n/@f[n-1]&/@Append~Join~Prepend

Thí dụ:

f[4]

{{1, 2, 3, 4}, {2, 1, 3, 4}, {3, 1, 2, 4}, {3, 2, 1, 4}, {4, 1, 2, 3} , {4, 2, 1, 3}, {4, 3, 1, 2}, {4, 3, 2, 1}}

J, 26 byte

   0|:<:((,,.,~)1+#)@[&0,.@1:

   (0|:<:((,,.,~)1+#)@[&0,.@1:) 3
1 2 3
2 1 3
3 1 2
3 2 1

Cải thiện 1 byte nhờ FUZxxl .

Bình thường 34 33 31 29

Về cơ bản một bản dịch của XNOR 's Python câu trả lời . Tôi vẫn không tuyệt vời với Pyth, vì vậy các đề xuất cải tiến đều được chào đón.

Xác định hàm yđể trả về danh sách các số nguyên.

L?]]1<b2smm++*kdb*k_dy-b1,1_1

Cập nhật: Đã lưu 2 byte nhờ FryAmTheEggman .

Giải trình:

L                                  define a function y with argument b that returns
 ?*]]1<b2                          [[1]] if b < 2 else
         s                         sum(
          m                        map(lambda d:
           m                       map(lambda k:
            ++*kdb*k_d             k*d + [b] + k*-d
                      y-b1         , y(b - 1))
                          ,1_1)    , (1, -1))

Bash tinh khiết, 103

Lâu hơn tôi mong đợi:

a=1..1
for i in {2..9} {a..u};{
((++c<$1))||break
a={${a// /,}}
a=`eval echo $a$i $i$a`
}
echo ${a%%.*}

JavaScript (ES6) 73 80

JavaScript triển khai giải pháp tốt đẹp của @ Tối ưu hóa.

Đệ quy (73):

R=(n,i=1,r=[[1]])=>++i>n?r:r.map(e=>r.push([i,...e])+e.push(i))&&R(n,i,r)

Lặp lại (74):

F=n=>(i=>{for(r=[[1]];++i<=n;)r.map(e=>r.push([i,...e])+e.push(i))})(1)||r

Kiểm tra trong bảng điều khiển Firefox / FireBug

R(4)

[[1, 2, 3, 4], [2, 1, 3, 4], [3, 1, 2, 4], [3, 2, 1, 4], [4, 1, 2, 3] , [4, 2, 1, 3], [4, 3, 1, 2], [4, 3, 2, 1]]

Giải pháp Java của tôi:

public static void main(String[] args) {
    listPrependAppend(4);
}

private static void listPrependAppend(int n) {
    int total = (int) Math.pow(2, n - 1);
    int ps;
    boolean append;
    String sequence;
    String pattern;

    for (int num = 0; num < total; num++) {
        sequence = "";
        pattern = "";
        append = false;
        ps = num;
        for (int pos = 1; pos < n + 1; pos++) {
            sequence = append ? (pos + sequence) : (sequence + pos);
            append = (ps & 0x01) == 0x01;
            ps = ps >> 1;
            if (pos < n) {
                pattern += append ? "L" : "R";
            }
        }
        System.out.format("%s\t[%s]%n", sequence, pattern);
    }
}