Thử thách:

Đưa ra một danh sách các danh sách số nguyên không trống, trả về một danh sách các bộ dữ liệu có dạng sau: Các bộ danh sách đầu tiên bắt đầu với mỗi phần tử của danh sách đầu tiên theo sau là phần tử đầu tiên của mỗi danh sách tiếp theo, do đó, bộ dữ liệu thứ i sẽ là [ith element of first list, first element of second list, ... , first element of last list]. Ví dụ:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [[1, 4, 7], [2, 4, 7], [3, 4, 7], ...

Sau đó, làm bộ dữ liệu của biểu mẫu [last element of first list, ith element of second list, first element of third list, ..., first element of last list], vì vậy trong ví dụ của chúng tôi sẽ là:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] =>  ..., [3, 4, 7], [3, 5, 7], [3, 6, 7], ...

Tiếp tục với từng danh sách còn lại, cho đến khi bạn nhận được [last element of first list, ..., last element of second to last list, ith element of last list]:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] => ..., [3, 6, 7], [3, 6, 8], [3, 6, 9]]

Đầu ra đầy đủ như sau:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]] => 
        [[1, 4, 7], [2, 4, 7], [3, 4, 7], [3, 5, 7], [3, 6, 7], [3, 6, 8], [3, 6, 9]]

Một số nồi hơi cho biện pháp tốt:

• Nếu bạn muốn đầu vào là danh sách các chuỗi hoặc danh sách các số nguyên dương, thì tốt. Câu hỏi là về thao túng danh sách, không phải về những gì trong danh sách.
• Đầu vào và đầu ra có thể ở bất kỳ định dạng chấp nhận được .
• Một chương trình hoặc chức năng đầy đủ được cho phép.
• Các sơ hở tiêu chuẩn không được phép theo mặc định.
• Câu hỏi này là mã golf, vì vậy, số byte thấp nhất sẽ thắng.

Ví dụ:

[] => [[]] (or an error, thanks to ngn for correcting the output in this case)

[[1]] => [[1]]

[[1, 2], [3, 4], [5]] => [[1, 3, 5], [2, 3, 5], [2, 4, 5]]

[[1], [2], [5, 6], [3], [4]] => [[1, 2, 5, 3, 4], [1, 2, 6, 3, 4]]

[[1, 2, 3], [4, 5]] => [[1, 4], [2, 4], [3, 4], [3, 5]]

[[1, 2, 3], []] => unspecified behavior (can be an error)

[[3, 13, 6], [9, 2, 4], [5, 10, 8], [12, 1, 11], [7, 14]] => 
     [[3, 9, 5, 12, 7], [13, 9, 5, 12, 7], [6, 9, 5, 12, 7], [6, 2, 5, 12, 7], 
      [6, 4, 5, 12, 7], [6, 4, 10, 12, 7], [6, 4, 8, 12, 7], [6, 4, 8, 1, 7], 
      [6, 4, 8, 11, 7], [6, 4, 8, 11, 14]]  

[[16, 8, 4, 14, 6, 7, 10, 15], [11, 1, 12, 2, 19, 18, 9, 3], [13, 5, 17]] =>
    [[16, 11, 13], [8, 11, 13], [4, 11, 13], [14, 11, 13], [6, 11, 13], 
     [7, 11, 13], [10, 11, 13], [15, 11, 13], [15, 1, 13], [15, 12, 13], [15, 2, 13], 
     [15, 19, 13], [15, 18, 13], [15, 9, 13], [15, 3, 13], [15, 3, 5], [15, 3, 17]]

Nếu bất cứ ai có một tiêu đề tốt hơn, cho tôi biết.

JavaScript (ES6), 59 byte

Hy vọng một danh sách liệt kê của dương số nguyên.

f=a=>[a.map(a=>a[0]),...a.some(a=>a[1]&&a.shift())?f(a):[]]

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

Làm sao?

Ở mỗi lần lặp:

• Chúng tôi đưa ra một danh sách mới bao gồm các yếu tố đầu tiên của mỗi danh sách.
• Chúng tôi xóa phần tử đầu tiên của danh sách đầu tiên chứa ít nhất 2 phần tử và lặp lại quy trình. Hoặc chúng tôi dừng đệ quy nếu không có danh sách đó.

Python 2 , 62 byte

lambda M:[zip(*M)[l.pop(0)*0]for l in M+[[1,1]]for _ in l[1:]]

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

Sử dụng ý tưởng nhạc pop của Chas Brown lấy cảm hứng từ bài nộp JS của Arnauld .

Python 2 , 68 byte

M=input()
for l in[[0,0]]+M:
 for x in l[1:]:l[0]=x;print zip(*M)[0]

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

Đột biến các yếu tố đầu tiên của danh sách để giữ các giá trị mong muốn. Đây [[0,0]]+là một hack xấu xí để in các giá trị đầu tiên ban đầu.

Thạch , 15 byte

ẈṚṪ×€PƊƤFQṚCịŒp

Hãy thử trực tuyến! (chân trang hiển thị danh sách trả về thực tế thay vì đại diện Jelly)

Làm sao?

Lập chỉ mục vào sản phẩm của Cartesian trong danh sách tại các điểm bắt buộc ...

ẈṚṪ×€PƊƤFQṚCịŒp - Link: list of lists  e.g. [[6,8,4,9],[7,1,5],[3,2]]
Ẉ               - length of each            [4,3,2]
 Ṛ              - reverse                   [2,3,4]
       Ƥ        - for each prefix:             [2]      [2,3]      [2,3,4]
      Ɗ         -   last 3 links as a monad:
  Ṫ             -     tail (pop rightmost)     2        3          4
     P          -     product (of remaining)   1        2          6
    €           -     for €ach (range tail)    [1,2]    [1,2,3]    [1,2,3,4]   
   ×            -       multiply               [1,2]    [2,4,6]    [6,12,18,24]
        F       - flatten                   [1,2,2,4,6,6,12,18,24]
         Q      - de-duplicate              [1,2,4,6,12,18,24]
          Ṛ     - reverse                   [24,18,12,6,4,2,1]
           C    - complement (1-x)          [-23,-17,-11,-5,-3,-1,0]
             Œp - Cartesian product (of the input)
                -         -> [[6,7,3],[6,7,2],[6,1,3],[6,1,2],[6,5,3],[6,5,2],[8,7,3],[8,7,2],[8,1,3],[8,1,2],[8,5,3],[8,5,2],[4,7,3],[4,7,2],[4,1,3],[4,1,2],[4,5,3],[4,5,2],[9,7,3],[9,7,2],[9,1,3],[9,1,2],[9,5,3],[9,5,2]]
            ị   - index into (1-based & modular)
                -   indexes:      -23,                                            -17,                                            -11,                                             -5,             -3,             -1,     0
                -    values: [[6,7,3],                                        [8,7,3],                                        [4,7,3],                                        [9,7,3],        [9,1,3],        [9,5,3],[9,5,2]]
                -         -> [[6,7,3],[8,7,3],[4,7,3],[9,7,3],[9,1,3],[9,5,3],[9,5,2]]

ẈṚ’ṣ1T$¦ƬUṚị"€(14 byte) không thành công cho các đầu vào có một danh sách dài (không theo dõi); Nhưng có lẽ ṣ1T$có thể được thay thế bằng một cái gì đó khác?

K (ngn / k) , 40 21 19 18 byte

{x@'/:?|\+|!|#:'x}

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

sử dụng ý tưởng từ câu trả lời của @ H.PWiz

{ } chức năng với đối số x

#:' chiều dài của mỗi

| đảo ngược

! tất cả các bộ chỉ mục cho một mảng với các kích thước đó là các cột trong một ma trận (danh sách các danh sách)

| đảo ngược

+ hoán vị

|\ chạy cực đại

? độc nhất

x@'/: sử dụng mỗi bộ dữ liệu bên phải như các chỉ số trong danh sách tương ứng từ x

Than , 33 byte

ＩＥ⊕ΣＥθ⊖ＬιＥθ§λ⌈⟦⁰⌊⟦⊖Ｌλ⁻ι∧μΣＥ…θμ⊖Ｌν

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｉ

Truyền các số nguyên thành chuỗi trước khi in ngầm bằng cách sử dụng định dạng đầu ra mặc định cho các danh sách, đó là mỗi mục trên một dòng riêng và các danh sách lồng nhau cách nhau hai lần.

Ｅ⊕ΣＥθ⊖Ｌι

Lấy tổng độ dài của danh sách và trừ đi độ dài của danh sách. Sau đó lặp từ 0 đến giá trị này.

Ｅθ§λ

Bản đồ trên danh sách các danh sách và chỉ mục vào mỗi danh sách.

⌈⟦⁰⌊⟦⊖Ｌλ

Kẹp chỉ số về 0 và chỉ mục cuối cùng trong danh sách. (Dấu ngoặc đóng được ngụ ý.)

⁻ι∧μΣＥ…θμ⊖Ｌν

Sau danh sách đầu tiên, trừ độ dài giảm dần của tất cả các danh sách trước đó khỏi chỉ mục ngoài cùng. (Điều này không hoạt động cho danh sách đầu tiên vì độ dài của danh sách trống và tổng không phải là một số.)

Python 2 , 72 byte

f=lambda a:zip(*a)[:1]+(any(len(u)>1and u.pop(0)for u in a)and f(a)or[])

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

Đây là một cổng Python của thuật toán Javascript tuyệt vời của Arnauld .

APL (Dyalog Classic) , 32 30 27 byte

1↓¨∪⊃{(⍵,¨⊃⍺),⍺,¨⍨⊢/⍵}/⌽0,⎕

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

hoàn thành chương trình, đầu vào là từ bàn phím ( ⎕)

cho đầu []ra đầu vào [[]](tương đương APL của chúng là 0⍴⊂⍬và ,⊂⍬)

giả định tính duy nhất của các số trong đầu vào

JavaScript (ES6), 58 54 byte

h=(x,s)=>[x.map(y=>s|y?y[0]:s=y.shift()),...s?h(x):[]]

Sau hơn 14 lần thử chơi mã của tôi (loại bỏ tất cả các trường hợp trong khi các vòng lặp, pushvà concat), tôi đã đi đến một phép lặp tương tự về mặt thuật toán với câu trả lời của @ Arnauld , không ngạc nhiên khi biết nó ngắn gọn như thế nào!

Chấp nhận một danh sách các danh sách các số nguyên dương. Hãy thử trực tuyến!

58 byte

Để có thêm 1 byte, thay thế s = y.shift()bằng y.shift(s = 1)nên xử lý tất cả các số nguyên (có lẽ, vì tôi chưa kiểm tra cá nhân nó).

h=(x,s)=>[x.map(y=>!s/y[1]?s=y.shift():y[0]),...s?h(x):[]]

58 byte

Phiên bản thưởng, với sự sắp xếp lại nhẹ:

h=x=>[x.map(y=>s&&y[1]?y.shift(s=0):y[0],s=[]),...s||h(x)]

Giải trình

Các phiên bản đầu tiên của mã đã cố gắng sửa đổi một bản sao (một mảng) các phần tử đầu tiên của mỗi mảng, nhưng bước bổ sung để khởi tạo mảng đó rất tốn kém ... cho đến khi tôi nhận ra rằng ánh xạ qua các phần tử đầu tiên của mỗi mảng là khoảng hoạt động "duy nhất" cần thiết nếu tôi thay đổi các mảng ban đầu.

Sử dụng cờ boolean để kiểm tra xem có bất kỳ mảng nào đã được dịch chuyển (tức là rút ngắn) chưa. Đánh dấu kiểm tra có điều kiện xuống hơn nữa bằng cách quan sát rằng JS ép buộc các mảng với một giá trị số là phần tử duy nhất của nó thành số đó, trong khi ép các mảng có nhiều giá trị là NaN.

var
h = (x, s) => 
    [
        x.map(y =>                 // map to first element of each array
            s|y                    // if s == 1 (i.e. an array has been shortened)
                                   // or the current array y has length == 1
                ? y[0]
                : s = y.shift()    // remove first element of y and set s to truthy
        ),
        ...s ? h(x) : []           // only concatenate a recurrence of the function if an array has had a value removed
    ]

APL (Dyalog) , 15 byte ( SBCS )

Cảm ơn ngn đã chỉ ra một byte không cần thiết

{∪⌈\,⍉⍳≢¨⍵}⊃¨¨⊂

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

{∪⌈\,⍉⍳≢¨⍵}tạo danh sách để lập chỉ mục vào đầu vào. ví dụ(1 2 3) (4 5 6) (7 8 9) -> (0 0 0) (1 0 0) (2 0 0) (2 1 0) (2 2 0) (2 2 1) (2 2 2)

≢¨⍵: độ dài của mỗi danh sách trong đầu vào

,⍉⍳tạo ra tất cả các kết hợp số cho đến đầu vào của nó. ví dụ2 3 -> (0 0) (1 0) (0 1) (1 1) (0 2) (1 2)

⌈\: quét với mức tối đa. ví dụ như ví dụ trên bây giờ sẽ là(0 0) (1 0) (1 1) (1 1) (1 2) (1 2)

∪: Loại bỏ các bản sao

⊃¨¨⊂ thực hiện lập chỉ mục, chú ý đến độ sâu của một trong hai đối số

Python 2 , 91 byte

f=lambda a,p=():a and[p+(q,)+zip(*a)[0][1:]for q in a[0][p>():]]+f(a[1:],p+(a[0][-1],))or[]

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