^{Thử thách này được lấy cảm hứng từ một câu hỏi trên Mathematica.SE .}

Giả sử bạn đã có một danh sách / mảng lồng nhau của một số cấu trúc tùy ý (các danh sách ở mỗi cấp không nhất thiết phải có cùng độ dài). Để đơn giản, chúng tôi sẽ giả sử rằng các nút là số nguyên không âm hoặc mảng trống. Làm ví dụ

[[[1, 3], 2], [1, 4], 12, [[0, [], 0], [5, [7]]]]

Đôi khi, thuận tiện hơn để làm phẳng danh sách đó để thực hiện một số thao tác của các nút, ví dụ:

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

Nhưng cuối cùng bạn thực sự muốn giữ nguyên cấu trúc ban đầu, vì vậy bạn muốn biến nó trở lại thành

--> [[[1, 1], 0], [1, 0], 0, [[0, [], 0], [1, [1]]]

Nhiệm vụ của bạn là thực hiện bước cuối cùng đó.

Đưa ra một danh sách lồng các số nguyên không âm tùy ý, đại diện cho cấu trúc mong muốn của kết quả và một danh sách phẳng các số nguyên không âm, biểu thị các giá trị mong muốn, định hình lại danh sách phẳng thành dạng của danh sách có cấu trúc. Bạn có thể giả sử rằng cả hai danh sách đều chứa cùng một số nguyên.

Như thường lệ, bạn không phải đối phó với đầu vào không hợp lệ (ví dụ: danh sách thứ hai không bằng phẳng, đầu vào bị sai lệch về mặt cú pháp, không có số nguyên dưới dạng nút, v.v.). Bạn có thể sửa đổi các mảng đầu vào trong mã của bạn.

Bạn có thể viết một hàm hoặc chương trình, lấy đầu vào qua STDIN, đối số dòng lệnh hoặc đối số hàm và bạn có thể trả về kết quả hoặc in nó sang STDOUT. Bạn có thể sử dụng bất kỳ danh sách hoặc định dạng chuỗi thuận tiện để thể hiện đầu vào và đầu ra (miễn là định dạng không rõ ràng và đầu vào không được xử lý trước). Ngoài ra, định dạng của cả hai đầu vào cần nhất quán (vì vậy, bạn không thể lấy một đầu vào dưới dạng một chuỗi và ví dụ khác là một danh sách). Bạn có thể lấy danh sách đầu vào theo thứ tự, nhưng vui lòng chỉ định phương thức nhập chính xác trong câu trả lời của bạn.

Thêm một hạn chế: bạn không được sử dụng các biểu thức thông thường. Đây là một thách thức thao tác mảng, không phải là một thách thức thao tác chuỗi.

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

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

Structure                             Values                 Result
[[[1,3],2],[1,4],12,[[0,0],[5,[7]]]]  [1,1,0,1,0,0,0,0,1,1]  [[[1,1],0],[1,0],0,[[0,0],[1,[1]]]]
[[[0,0],0],[0,0],0,[[0,0],[0,[0]]]]   [1,1,0,1,0,0,0,0,1,1]  [[[1,1],0],[1,0],0,[[0,0],[1,[1]]]]
[]                                    []                     []
[[]]                                  []                     [[]]
[0,1,2,3]                             [5,1,0,5]              [5,1,0,5]
[[[[[0]]]]]                           [123]                  [[[[[123]]]]]
[0,[1,[]],[[]],[2,3],[]]              [1,6,1,8]              [1,[6,[]],[[]],[1,8],[]]

CJam, 18 16 13 byte

lA,sNerN%l~]z

Đưa đầu vào qua STDIN theo cùng định dạng với câu trả lời của CJam trước đó:

[0 [11 []] [[]] [2 3] []]
[1 6 1 8] 

và đưa ra chuỗi kết quả thành STDOUT

[1 [6 []] [[]] [1 8] []]

Tôi chỉ đơn giản coi dòng đầu tiên là chuỗi, chuyển đổi tất cả các ký tự chữ số thành dòng mới, phân chia trên một hoặc nhiều lần xuất hiện của dòng mới, đặt dòng thứ hai dưới dạng một mảng trên ngăn xếp, bọc trong một mảng và nén hai mảng (hàng) lại với nhau. In là tự động và vì hàng đầu tiên được coi là chuỗi, nó vẫn giữ dấu ngoặc.

Mở rộng mã

lA,sNerN%l~]z
l                     "Read the first line of input. This is the nested array";
 A,s                  "Get array [0,1,2...9] and  convert it to string '012..9'";
    Ner               "Replace all occurrences of 0,1,2,..9 with new line";
       N%             "Split on one or more occurrences of new line";
         l~           "Read the second line as an array";
           ]          "Wrap both the splitted string and the second line array";
                      "in an array";
            z         "Transpose the array, there by placing the numbers from second";
                      "input array in the split holes of first input string";

Cảm ơn @ user23013 vì đã lưu 3 byte.

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

JavaScript, ES6, 44 byte

f=(a,b,i=0)=>a.map(x=>x.map?f(x,b,i):b[i++])

Điều này tạo ra một chức năng fcó thể được gọi là như

f([0,[1,[]],[[]],[2,3],[]],[1,6,1,8])

tức là mảng lồng nhau và mảng giá trị làm đối số đầu vào. Đầu ra của hàm là mảng lồng nhau được chuyển đổi.

Câu hỏi này là một câu hỏi rất hay cho đệ quy, đó là lý do tại sao câu trả lời là một hàm đệ quy gọn gàng và ngọt ngào. Tôi tạo một hàm fchuyển đổi đối số đầu tiên bằng mapphương thức. Đối với mỗi phần tử, nếu phần tử là một mảng, nó sẽ gọi flại, nếu không, đối với các số nguyên, nó nhận được mục ^thứ i và trả về giá trị đó, tăng giá trị của i. Giá trị của iđược truyền lại trong mỗi cuộc gọi đệ quy, để duy trì thứ tự chính xác.

Phát hiện mảng so với Integer một lần nữa được thực hiện bằng mapphương thức. Đối với một biến mảng, maplà một hàm hợp lệ, trong khi đối với các biến số nguyên, không có thuộc tính hoặc hàm nào được gọi là mapđịnh nghĩa cho biến đó.

Điều này hoạt động trong một trình duyệt Firefox mới nhất (do ES6).

JavaScript, ES6, 41 byte

Tôi thực sự ấn tượng với câu trả lời của Trình tối ưu hóa , nó được thực hiện rất thông minh và tôi đã học được rất nhiều. Tuy nhiên, khi nhìn qua, tôi thấy có một cách rút ngắn nó và sửa một lỗi nhỏ:

f=(a,b)=>a.map(x=>x.map?f(x,b):b.shift())

Tôi lấy ra ibiến và thay thế nó bằng a shift(). Điều này làm cho nó ngắn hơn một chút và khắc phục vấn đề với thực tế iđược truyền bằng giá trị chứ không phải tham chiếu, phù thủy khiến một số số từ mảng cuối cùng lặp lại và một số ở cuối không được sử dụng. Một lần nữa, câu trả lời của Trình tối ưu hóa thực sự được cân nhắc kỹ lưỡng, tốt hơn những gì tôi có thể làm, tôi chỉ sửa nó một chút.

APL Dyalog, 14 ký tự

Đây là một không có trí tuệ : (∊a)←b.

Thông thường, ∊acó nghĩa là alàm phẳng, nhưng khi nó xảy ra ở phía bên trái của một bài tập, nó thực hiện chính xác những gì vấn đề này đang yêu cầu. Để tuân thủ yêu cầu là một hàm, nó cần thêm một số squiggles: {a←⍺⋄(∊a)←⍵⋄a}(dấu ngoặc nhọn cho lambda; ⍺và ⍵cho đối số trái và phải; ⋄cho dấu phân cách câu lệnh).

Thử nghiệm trên tryapl.org. Lưu ý rằng trong APL, vectơ số trống được ký hiệu là ⍬("zilde"). Các vectơ một phần tử được xây dựng với (,A)vì (A)có nghĩa là vô hướng. Trong đầu ra, điều này:

┌⊖┐
│0│
└~┘

đại diện cho một vectơ số rỗng. Ở 0trung tâm hiển thị "phần tử nguyên mẫu" không phải là một phần tử của mảng.

Con trăn, 51

f=lambda a,b:[b.pop(0)if x<[]else f(x,b)for x in a]

Thí dụ:

>>> f([0,[1,[]],[[]],[2,3],[]], [1,6,1,8])
[1, [6, []], [[]], [1, 8], []]

Con trăn 2, 50

f=lambda s,v:v.pop(0)if s<[]else[f(x,v)for x in s]

Đây là một vấn đề rất đẹp. Khi tôi tiếp tục làm việc với nó, tôi tiếp tục nhận ra rằng các bit của mã của tôi là không cần thiết và logic được thu gọn thành một biểu thức đơn giản. Hầu hết các môn đánh gôn là tìm ra thuật toán phù hợp.

slà cấu trúc và vlà danh sách phẳng của danh sách. Ý tưởng là kiểm tra xem smột số nguyên có s<[](Python 2 xử lý các số nhỏ hơn danh sách) hay không. Nếu có, chỉ cần lấy và trả lại phần tử đầu tiên của v, loại bỏ nó khỏi v. Nếu không, hãy lặp lại vào danh sách con của s.

Đây pop là một phần của phép thuật bắt buộc trong mã kiểu rất chức năng. Bởi vì tất cả đều vtrỏ đến cùng một thể hiện, việc bật một phần tử từ một phần tử sẽ loại bỏ nó khỏi vtoàn bộ cây thực thi, do đó mỗi số trong vchỉ được sử dụng một lần. Việc hiểu danh sách [f(x,v)for x in s]tạo ra một cây cuộc gọi được mở rộng theo chiều sâu và từ trái sang phải, làm cho các phần tử của vnó được đặt theo đúng thứ tự.

Tôi đã viết điều này một cách độc lập với câu trả lời của grc , nhưng hóa ra lại giống với việc di chuyển một [(và tên biến). Việc di chuyển tiết kiệm một char do khoảng cách. Di chuyển khung có nghĩa là xử lý trường hợp nút ngay lập tức trong hàm, chứ không phải là một phần của việc hiểu danh sách, mà tôi đã không xem xét.

Chúng ta có thể lưu một char cho 49 nếu chúng ta kéo dài các yêu cầu đầu vào để lấy giá trị từ STDIN và cấu trúc làm đối số hàm. Điều này cho phép chúng tôi sử dụng map.

v=input()
g=lambda s:v.pop(0)if s<[]else map(g,s)

Ruby, 39

f=->a,b{a.map{|d|f[d,b]}rescue b.shift}

Đệ quy cho đến khi phần tử trong danh sách là một số nguyên.
Vì việc gọi Integer.map đưa ra một ngoại lệ,
nó sẽ chuyển đến phần giải cứu, phần "bật / dịch chuyển" phần tử thứ 1 ra khỏi danh sách thứ 2.

Regex soln ... lâu hơn một chút:

f=->a,b{eval a.to_s.split(/\d+/).zip(b)*''}

Hãy thử nó với một số trường hợp thử nghiệm

CJam, 43 37 35 33 byte

Đây là một chuyển đổi trực tiếp của câu trả lời JS của tôi . Một chút dài, hầu hết được đưa lên bằng cách phát hiện loại.

q~:B;{{_`La`&{F}{;BW):W=}?}%}:F~`

Đưa hai mảng đầu vào trên hai dòng STDIN như

[[[1 3] 2] [1 4] 12 [] [[0 0] [5 [7]]]]
[1 1 0 1 0 0 0 0 1 1]

và đầu ra cho STDOUT như

[[[1 1] 0] [1 0] 0 "" [[0 0] [1 [1]]]]

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

Haskell, 113 104 byte (86 + 18 từ khai báo kiểu dữ liệu)

data N=I Int|L[N]
L[]!v=(L[],v)
L(a:b)!v|(c,w)<-a!v,(L d,u)<-L b!w=(L$c:d,u)
_!(n:m)=(I n,m)
s#v=fst$s!v

Haskell không có kiểu dữ liệu mảng lồng sẵn, vì vậy tôi phải tự cuộn. Vì lý do này, chương trình chỉ chứa khớp mẫu và đệ quy cấu trúc rõ ràng. Trường hợp thử nghiệm cuối cùng đọc

L[I 0,L[I 1,L[]],L[L[]],L[I 2,I 3],L[]]#[1,6,1,8]

và đánh giá

L[I 1,L[I 6,L[]],L[L[]],L[I 1,I 8],L[]]

Toán học, 41 byte

Function[,m[[i++]],Listable][i=1;m=#2;#]&

Đây là một hàm không tên, lấy cấu trúc làm đối số thứ nhất và danh sách các giá trị làm đối số thứ hai (và trả về một danh sách).

Đây là một phiên bản golf của câu trả lời được chấp nhận cho câu hỏi đã truyền cảm hứng cho thử thách này. Tôi đang tự đăng bài này và sẽ không chấp nhận câu trả lời này (nếu nó thực sự vẫn là ngắn nhất, điều mà tôi nghi ngờ). Điều này là để ngăn chặn bất kỳ ai khác chiến thắng thử thách bằng cách sao chép câu trả lời.

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

• Chúng tôi xác định một Listablechức năng thuần túy. Các hàm có thể liệt kê được tự động áp dụng cho các phần tử của đối số danh sách (đệ quy) thay vì chính danh sách, do đó, việc gọi fvào danh sách có cấu trúc về cơ bản sẽ trả về một danh sách có cùng cấu trúc với mỗi số nguyên được ithay thế bởi f[i].
• Chúng tôi lưu trữ danh sách giá trị trong toàn cầu mvà một quầy trong i.
• Mỗi lần chúng tôi gọi f(bất kể đối số), chúng tôi sẽ trả về phần tử tiếp theo của m.

Nổi loạn - 87 66 60

f: func[a[block!]b][map-each n a[any[attempt[f n b]take b]]]

Ung dung:

f: func [a [block!] b] [
    map-each n a [
        any [
            attempt [f n b]  
            take b
        ]
    ]
]

Thí dụ:

>> f [0 [1 []] [[]] [2 3] []]   [1 6 1 8]           
== [1 [6 []] [[]] [1 8] []]

C #, 225 + 13 = 239 185 + 35 = 220 172 + 35 = 207 byte

Yêu cầu này:

using System;using o=System.Object;

Chấp nhận object[]s làm đối số.

o[]u(o[]a,o[]b){var c=a;int i=0;Action<o[],o[]>d=null;d=(e, f)=>{for(int j=0;j<e.Length;j++){if(e[j]is int){f[j]=b[i];i++;}else{d((o[])e[j],(o[])f[j]);}}};d(a,c);return c;}

Mã bị đánh cắp:

object[] Unflatten(object[] structure, object[] values)
{
    var c = structure;
    int i = 0;
    Action<object[], object[]> recursiveFunc = null;
    recursiveFunc = (e, f) =>
    {
        for (int j = 0; j < e.Length; j++)
        {
            if (e[j] is int)
            {
                f[j] = values[i]; i++;
            }
            else
            {
                recursiveFunc((object[])e[j], (object[])f[j]);
            }
        }
    };
    recursiveFunc(structure, c);
    return c;
}

Python 2, 64 byte

def g(N,L):f=lambda N:L.pop(0)if`N`<":"else map(f,N);return f(N)

Tôi nghe nói bạn thích danh sách trong danh sách vì vậy tôi đặt chức năng trong chức năng.

Chỉnh sửa: Nhìn vào câu trả lời của grc bây giờ tôi nhận ra rằng điều đó là hoàn toàn không cần thiết. Ồ tốt ...

SWI-Prolog 82

f([],A,[],A):-!.
f([H|T],A,[J|U],B):-(is_list(H),!,f(H,A,J,C);A=[J|C]),f(T,C,U,B).

Chạy mẫu:

?- f([[[1,3],2],[1,4],12,[[0,[],0],[5,[7]]]],[1,1,0,1,0,0,0,0,1,1],R,[]).
R = [[[1,1],0],[1,0],0,[[0,[],0],[1,[1]]]].

Câu hỏi cuối cùng []trong câu hỏi là để kiểm tra số lượng phần tử không khớp, dường như không cần thiết trong câu hỏi này.

Erlang, 116 93 byte

f(R,F)->put(n,F),[g(X)||X<-R].
g([H|T])->[g(H)|g(T)];g([])->[];g(E)->[H|T]=get(n),put(n,T),H.

Sử dụng hai hàm không tinh khiết fvà g. fthao tác từ điển quy trình bằng cách đặt nvào danh sách phẳng và ánh xạ từng phần tử của danh sách lồng vào g(X). gsau đó đặt nvào đuôi của danh sách phẳng mỗi khi nó gặp một giá trị không phải là danh sách và trả về phần đầu của danh sách phẳng.

Perl 5, 49 byte

Đối số đầu tiên là cấu trúc mẫu, thứ hai là các giá trị.

sub u{($t,$l)=@_;ref$t?[map{u$_,$l}@$t]:shift@$l}

Chương trình kiểm tra

use Test::More;
use Test::Deep;

sub u{($t,$l)=@_;ref$t?[map{u$_,$l}@$t]:shift@$l}

cmp_deeply u([[[1,3],2],[1,4],12,[[0,0],[5,[7]]]],[1,1,0,1,0,0,0,0,1,1]),[[[1,1],0],[1,0],0,[[0,0],[1,[1]]]];
cmp_deeply u([[[0,0],0],[0,0],0,[[0,0],[0,[0]]]],[1,1,0,1,0,0,0,0,1,1]),[[[1,1],0],[1,0],0,[[0,0],[1,[1]]]];
cmp_deeply u([], []), [];
cmp_deeply u([[]], []), [[]];
cmp_deeply u([0,1,2,3], [5,1,0,5]), [5,1,0,5];
cmp_deeply u([[[[[0]]]]], [123]), [[[[[123]]]]];
cmp_deeply u([0,[1,[]],[[]],[2,3],[]], [1,6,1,8]), [1,[6,[]],[[]],[1,8],[]];
done_testing;

Quyền hạn: 115

mảng đầu vào là $ i, ánh xạ là $ m, đầu ra là $ o

$h={if($_.GetType().IsArray){if($_.c -eq 0){,@()}else{,@($_|%{.$h})}}else{$m[$c++]}};$i|%{$o=@();$c=0}{$o+=,(.$h)}

$ h là một chuỗi chứa hàm đệ quy và bạn có thể thực thi mã chứa trong một chuỗi với. $ h ... Và nó sẽ ngắn hơn 30 byte nếu powershell không khăng khăng làm phẳng các mảng giá trị đơn thành vô hướng và một mảng với một giá trị null thành null

và một trình xem cấu trúc mảng tiện dụng để xác minh kết quả

$j={if($_.GetType().IsArray){write-host '(' -n;($_|%{.$j});write-host ')' -n}else{write-host "$_" -n}};write-host '(' -n;$o|%{(.$j)}; write-host ')' -n;

chỉnh sửa: 149

lưu dưới dạng unflatten.ps1:

$m=[array]$args[1];$h={if($_.GetType().IsArray){if($_.c -eq 0){,@()}else{,@($_|%{.$h})}}else{$m[$c++]}};$args[0]|%{$o=@();$c=0}{$o+=,(.$h)};echo $o;

chỉnh sửa: 136, tạo mảng đầu ra nội tuyến và đầu ra ghi

$m=[array]$args[1];$h={if($_.GetType().IsArray){if($_.c -eq 0){,@()}else{,@($_|%{.$h})}}else{$m[$c++]}};echo(,@($args[0]|%{$c=0}{.$h}))

gọi với. \ unflatten.ps1 [mảng đầu vào] [mảng ánh xạ]

đầu ra được ghi vào đường ống - vì vậy hãy chạy nó trước:

Function View-Array{
Param([Parameter(ValueFromPipeline=$True,ValueFromPipelinebyPropertyName=$True)]
      [array]$o)

    PROCESS{
    $j={if($_.GetType().IsArray){write-host '(' -n;($_|%{.$j});write-host ')' -n}else{write-host "$_" -n}};
    write-host '(' -n;$o|%{(.$j)}; write-host ')' -n;
    }
}

và chạy với

.\unflatten.ps1 [input array] [mapping array] | View-Array

C #, (40 + 123) = 163 byte HOẶC (67 + 81) = 148 byte

C # chịu đựng kiểu gõ tĩnh và không gian tên dài ở đây.

Phương thức mảng

Sử dụng báo cáo:

using o=System.Object;using System.Linq;

Mã số:

o[] u(o[] x,o[] y){int i=0;Func<o[],o[],o[]> f=null;f=(a,b)=>a.Select(e=>e is int?b[i++]:f((o[])e,b)).ToArray();return f(x,y);}

Phương thức ngăn xếp (sử dụng cấu trúc Stack thay vì mảng)

Sử dụng báo cáo:

using s=System.Collections.Generic.Stack<object>;using System.Linq;

Mã số:

System.Func<s,s,s>f=null;f=(a,b)=>new s(a.Select(e=>e is int?b.Pop():f((s)e,b)));

Nỗ lực đầu tiên, mã golf đầu tiên ở đây.