# 展开数组

34

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

``````--> [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]]]
``````

## 测试用例

``````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],[]]
``````

ProgramFOX 2015年

@ProgramFOX是的。“您可以在代码中修改输入数组。”

1
@impinball这是我的问题，我将其与问题一同发布，以防止其他人从链接的问题中窃取答案（实际上，这只是该问题的简化版本）。

@MartinBüttner哦。真好 实际上，这也是较短的答案之一。

9

# CJam，18 16 13字节

``````lA,sNerN%l~]z
``````

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

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

``````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";
``````

2015年

@atk：这是有争议的，因为OP仅显式禁止正则表达式。
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 2015年

1

jimmy23013 2015年

@ user23013哇，从来没有想过也要`%`拆分，它也可以拆分多个事件！
Optimizer

@atk是的，因为只禁止了正则表达式，所以我使用了此技术。
Optimizer

25

# JavaScript，ES6、44字节

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

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

3

@fluffy in ES6;）
Optimizer

@Derek朕会功夫幸好没有。`map`与上下文相关，因此第一个映射属于该迭代映射，`a`而下一个映射则属于每个映射`x`。没有其他更短的方法可以引用`map`或区分数组和整数
Optimizer

18

# JavaScript，ES6、41个字节

Optimizer的回答给我留下了深刻的印象，它做得非常巧妙，我学到了很多东西。但是，在查看它时，我发现了一种将其略微缩短并修复一个小错误的方法：

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

2

Optimizer

16

# Dyalog APL，14个字符

``````┌⊖┐
│0│
└~┘
``````

1

Martin Ender 2014年

tryapl使用的图形表示形式（称为`]box on`）无法区分它们。Dyalog中的另一个函数（`display`from `dfns.dws`）确实有所区别，但不幸的是tryapl限制了其他工作空间（即库）的加载。:(
ngn 2014年

1

ngn 2014年

ngn 2014年

ngn 2014年

10

## Python，51岁

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

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

10

# python 2，50

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

`s`是结构，`v`是列表的平面列表。这个想法是检查是否`s`为整数`s<[]`（Python 2将数字视为小于列表）。如果是的话，只需获取并返回的第一个元素`v`，将其从中删除`v`。否则，递归到的子列表`s`

`pop` 在非常实用的代码中，这是命令式魔术。因为所有`v`指向同一实例，所以从一个实例中弹出一个元素会将其从`v`整个执行树中删除，因此in中的每个数字`v`仅使用一次。列表推导`[f(x,v)for x in s]`会创建一个调用树，该调用树按深度优先和从左至右的`v`顺序展开，从而使的元素按正确的顺序排列。

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

9

# 红宝石，39岁

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

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

Martin Ender 2014年

5

# CJam，43 37 35 33字节

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

``````[[[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]]]]
``````

5

``````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
``````

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

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

4

# Mathematica，41个字节

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

• 我们定义一个`Listable`纯函数。可列出函数会自动（递归地）应用于列表参数的元素，而不是列表本身，因此调用`f`结构化列表将基本上返回具有相同结构的列表，其中每个整数`i`都由代替`f[i]`
• 我们将值列表存储在全局变量中，`m`并将计数器存储在中`i`
• 每次调用时`f`（无论参数如何），我们都会返回的下一个元素`m`

4

# Rebol- 87 66 60

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

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

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

4

# C＃，225 + 13 = 239185 + 35 = 220172 + 35 = 207字节

``using System;using o=System.Object;``

``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;}``

``````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;
}``````

2

Kroltan 2015年

1
@Kroltan大提示，谢谢！
ProgramFOX

`Clone`很浅 如果允许修改输入，则根本不需要克隆。如果不允许，则需要正确的克隆。
CodesInChaos

ProgramFOX

3

# Python 2，64字节

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

3

## 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).
``````

``````?- 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]]]].
``````

`[]`查询中的最后一个用于检查元素数量不匹配，在这个问题中似乎没有必要。

1
@UnrelatedString：如果发现不需要正确答案，可以直接直接编辑答案。那时，我的Prolog很糟糕（我使用了库并进行了广泛的削减），如今这些日子甚至更加生锈。
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

2

# Erlang，116 93字节

``````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.
``````

1

# Perl 5，49个字节

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

## 测试程序

``````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;
``````

1

# 动力壳：115

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

\$ h是包含递归函数的字符串，您可以使用。\$ h执行字符串中包含的代码。如果powershell不坚持将单值数组和标量平面化，则它将缩短30个字节。将单个null值设置为null

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

## 编辑：149

``````\$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;
``````

### 编辑：136，内联输出数组的创建和写入输出

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

``````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;
}
}
``````

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

1

## C＃，（40 + 123）= 163字节或（67 + 81）= 148字节

C＃在此遭受其静态类型和长名称空间的困扰。

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

``````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);}
``````

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

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