在这个挑战中，您的任务是创建一个程序，该程序接受一个嵌套数组并返回一维扁平化数组。例如[10,20,[30,[40]],50]应该输出[10,20,30,40,50]。

输入将是一个嵌套数组（例如[10,20,[[[10]]]]）。它仅包含整数（负数和正数），字符串和数组。您可以将输入作为函数参数STDIN或任何适合您的语言的参数。您可以假设输入数组将没有空数组。

输出量

输出将是一个扁平的一维数组，具有与嵌套数组中相同类型的相同元素，并且顺序相同。

测试用例

[10,20,30] -> [10,20,30]
[[10]] -> [10]
[["Hi"],[[10]]] -> ["Hi",10]
[[[20],["Hi"],"Hi",20]] -> [20,"Hi","Hi",20]
[[["[]"],"[]"]] -> ["[]","[]"]

随时要求使用注释进行任何澄清。这是代码高尔夫球，因此以字节为单位的最短代码胜出！

注意： 如果您的语言中包含内置语言，则不得使用它。

另请提供指向可以执行您的代码的网站的链接。

K，3个字节

,//

这是一个相当普遍的习惯用法。“加入融合”。

可以在这里尝试。

怎么运行的：

Join（,）将原子或列表融合在一起以生成列表。结束于/）接受动词（在这种情况下为join），并将其从左到右应用于列表的每个元素之间。因此，该化合物,/将使列表的所有顶级元素变平。该符号/实际上具有不同的含义，具体取决于与其混合的动词的价态（参量）。当我们提供,/动词时，最终词/充当“收敛”-它反复应用于,/输入，直到停止更改。其他一些语言将这种功能称为“定点组合器”。通过重复融合底层列表，您最终将到达一个平面列表，并且所有操作都不会干扰元素的顺序。这似乎解决了问题。

JavaScript（ES6），35个字节

受到@ user81655的回答的启发：

f=a=>a.map?[].concat(...a.map(f)):a

Mathematica，16个 14字节

{##&@@#&//@#}&

一个未命名的函数，它接收并返回一个列表，例如：

{##&@@#&//@#}& @ {{{20}, {"Hi"}, "Hi", 20}}
(* {20, "Hi", "Hi", 20} *)

说明

语法糖方！

为了理解这个作品，注意在数学每个表达式或者是一个原子（例如数字，字符串，符号）或以下形式的化合物的表达如何f[a, b, c, ...]，其中f，a，b，c本身是任意表达式。在这里，f称为表达式的头。最重要的是语法糖。例如{a, b, c}，只是List[a, b, c]。

我们从//@将功能映射到列表的所有级别开始。例如：

f //@ {{{20}, {"Hi"}, "Hi", 20}}
(* f[{f[{f[{f[20]}], f[{f["Hi"]}], f["Hi"], f[20]}]}] *)

请注意，此地图 f了原子以及化合物表达式。我们现在正在寻找的是摆脱列表头并保留所有其他内容的方法。

该Apply函数通常用于将列表的元素作为单独的参数提供给函数，但是其实际定义更为笼统，并且仅替换表达式的头部。例如Apply[g, f[a, b]]给g[a, b]。

现在有一个特殊的“头” Sequence，它消失了。例如{a, Sequence[b, c], d}，计算结果为{a, b, c, d}。扁平化列表的想法是将所有内部列表的头替换为，以Sequence使它们被溅入周围的列表中。因此，我们想要的是Apply头部Sequence到列表中。如果我们方便Apply对某个原子进行处理，它只会使该原子保持不变，因此我们根本不必区分表达式的类型。

最后，有一个小问题：f也应用于最外层，因此它也删除了List我们不想要的最外层。最简单的应对方法是将结果再次包装在列表中，以便周围环境Sequence可以安全消失。

请注意，代码中既没有Apply也不存在Sequence。@@是的操作形式Apply和##&是一个标准的高尔夫球技巧，以缩短久内置名Sequence。因此，将所有内容解囊化，我们得到的是：

flatten[list_] := { MapAll[Apply[Sequence], list] }

有关如何工作以及为什么##&工作的更多详细信息，请参阅我对Mathematica技巧的回答中的 “参数序列”部分。

Python 2，43个字节

f=lambda l:[l]*(l*0!=[])or sum(map(f,l),[])

在列表上，递归于元素并连接结果。在字符串或数字上，包含在单例列表中。

不幸的是，Python 2对类型的排序int < list < string夹list在其他类型之间，需要检查两个不等式。因此，将l*0对照空列表进行检查[]，否则给出0或""。

Ruby，43 42 34字节

递归解决方案。现在有了异常处理！（尽管值得赞扬@akostadinov，但它启发了这一变化）

f=->a{a.map(&f).inject:+rescue[a]}

IDEOne链接

JavaScript（ES6），41个字节

f=a=>[].concat(...a.map(v=>v.pop?f(v):v))

<textarea id="input" rows="6" cols="40">[[[20],["Hi"],"Hi",20]]</textarea><br /><button onclick="result.textContent=JSON.stringify(f(eval(input.value)))">Go</button><pre id="result"></pre>

Perl 6，24个字节

{gather {$_».&{.take}}}

说明：

{ # has $_ as an implicit parameter

  gather {

    $_\ # the parameter from the outer block
    »\  # for each single value in the structure
    .&( # call the following block as if it was a method
      { # this block has its own $_ for a parameter
        .take # call the .take method implicitly on $_
      }
    )
  }
}

测试：

#! /usr/bin/env perl6

use v6.c;
use Test;

my &flatten = {gather {$_».&{.take}}}

my @tests = (
  [10,20,30], [10,20,30],
  [[10,],], [10,],
  [["Hi",],[[10,],],], ["Hi",10],
  [[["[]",],"[]"],], ["[]","[]"],
);

plan @tests / 2;

for @tests -> $input, $expected {
  # is-deeply cares about the exact type of its inputs
  # so we have to coerce the Seq into an Array
  is-deeply flatten($input).Array, $expected, $input.perl;
}

1..4
ok 1 - $[10, 20, 30]
ok 2 - $[[10],]
ok 3 - $[["Hi"], [[10],]]
ok 4 - $[[["[]"], "[]"],]

Haskell，43个字节

data D a=L a|N[D a]
f(L x)=[x]
f(N l)=f=<<l

Haskell既没有具有不同深度的子列表的嵌套列表，也没有列表元素的混合类型。对于嵌套，我定义了一个自定义数据类型D，该数据类型可以是L包含某些元素的叶子，也N可以是包含Ds 的列表的节点。对于混合元素，我使用预定义的数据类型Either，该数据类型将两种类型合并为一种Either String Integer。新类型D和flatten函数f在叶子元素的类型中是完全多态的，因此，我无需特别注意Either。

用法示例：f (N[N[L(Right 20)], N[L(Left "Hi")], L(Left "Hi") , L(Right 20)])-> [Right 20,Left "Hi",Left "Hi",Right 20]。

Pyth，7 6 5字节

us+]Y

在线尝试：演示或测试套件

但是当然，还有一个内置函数，可以仅用2个字节来处理任务：.n（Test Suite）

JavaScript（Firefox 30-57），43个字节

f=a=>a.map?[for(b of a)for(c of f(b))c]:[a]

仅仅因为我什至可以避免使用concat。

Perl，34个 29字节

功能。

如果需要扁平化列出，如my @a = f(@a)29个字节：

sub f{map{ref()?f(@$_):$_}@_}

在Ideone上测试

如果需要展平到数组ref，如my $a = f($a)34个字节：

sub f{[map{ref()?@{f(@$_)}:$_}@_]}

在Ideone上进行测试。

Perl 5.22.0 +，27个字节

多亏霍布斯。

如果需要扁平化列出，例如my @a = f(@a)27个字节：

sub f{map{ref?f(@$_):$_}@_}

在JDoodle上测试

如果需要展平到数组ref，如my $a = f($a)32个字节：

sub f{[map{ref?@{f(@$_)}:$_}@_]}

在JDoodle上测试。

朱莉娅，29个字节

f(x,y=vcat(x...))=x==y?x:f(y)

这是递归地喷射到连接函数中，直到到达固定点为止。例

julia> f([1,[2,[3,[4,[5,[6]]]]]])
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

视网膜，30字节

1>`("(\\.|[^"])+")|[][]
$1
$
]

在线尝试！（第一行仅用于一次运行多个测试用例。）

视网膜有没有数组，字符串文字或数字的概念，所以我决定去与一个“普通”的输入格式[...,...]风格数组和"-delimited串，在那里\可以将字符串中使用转义的任何字符（尤其是"和\本身）。

程序本身仅匹配完整的字符串或方括号，然后替换为$1保留字符串并删除方括号的字符串。该限制会1>跳过第一个比赛，因此我们不会删除前导[。但是，这确实删除了结尾]，因此我们在一个单独的阶段中将其重新添加。

Pyke，11个字节

.F~]+=])K~]

在这里尝试！

说明：

.F~]+=])    - Deep for loop
  ~]        -    contents of `]` ([] by default)
    +       -  ^+i
     =]     - `]` = ^
        K~] - Output value
        K   - Remove the output from the for loop
         ~] - Return the contents of `]`

或错误修正后的7个位元组

M?+]K~]

在这里尝试！

说明：

M?+]    - Deep map
 ?+]    -  `]` = `]`+i
    K~] - Output value
    K   - Remove the output from the for loop
     ~] - Return the contents of `]`

如果允许打印到标准输出，则甚至是2个字节（这可能是内置的）

M
<newline required>

在这里尝试！

这将print_newline功能深深地应用到输入中的每个非序列项，并递归序列项。

的Java（V8）390个 276字节

public static Object[] f(final Object[]a) {
    List<Object>r=new ArrayList<>();boolean t=false;int n=0;
    for(final Object p:a)
        if(t=p instanceof Object[]){for(final Object q:(Object[])p) r.add(q);}
        else r.add(p);
    return(t)?f(r.toArray()):r.toArray();
}  

仅出于完整性和所有目的。:)不能说Java的代码效率高。

Python，57个字节

f=lambda a:sum([list==type(x)and f(x)or[x]for x in a],[])

在线尝试：Python 2和Python 3

感谢Kevin Lau的for list==type(x)俩。

红宝石

有内置flatten方法。

您可以在此处运行：http : //www.tutorialspoint.com/execute_ruby_online.php

一个43字节，但可以共享：

f=->a{a.inject([]){|r,e|r+(f[e]rescue[e])}}

一个45个字节比前一个和另一个ruby回答更有效：

f=->a{a.map{|e|Array===e ?f[e]:[e]}.inject:+}

这是基准：

require 'benchmark'
n=10^9
arr=[[[20],[[[[[[[[123]]]]]]]],"ads",[[[[[[[4]]]]]]],5,[[[[[[[[[[6]]]]]]]]]],7,8,[[[[[[[[[[9]]]]]]]]]],[[[[[[[[[[0]]]]]]]]]],[[[[[[[[[[[["Hi"]]]]]]]]]]]],[[[[[["Hi"]]]]]],[[[[[20]]]]]]]
Benchmark.bm do |x|
  x.report { f=->a{a.map(&f).inject:+rescue[a]}; f[arr] }
  x.report { f=->a{a.map{|e|e!=[*e]?[e]:f[e]}.inject:+}; f[arr] }
  x.report { f=->a{a.inject([]){|r,e|r+(f[e]rescue[e])}}; f[arr] }
  x.report { f=->a{a.map{|e|Array===e ?f[e]:[e]}.inject:+}; f[arr] }
end

结果：

       user     system      total        real
   0.010000   0.000000   0.010000 (  0.000432)
   0.000000   0.000000   0.000000 (  0.000303)
   0.000000   0.000000   0.000000 (  0.000486)
   0.000000   0.000000   0.000000 (  0.000228)

Perl，39 34 +1（-p标志）35个字节

Oneliner。受到MartinBüttner的启发。

#!perl -p
s/("(\\.|[^"])+"|]$|^\[)|[][]/$1/g

在Ideone上进行测试。

Clojure，68个字节

(def f #(if(some vector? %)(f(mapcat(fn[z](if(vector? z)z[z]))%))%))

mapcat首先将函数应用于每个元素，然后合并结果。因此，每当出现这种情况时，都会失去一个“嵌套级别”。Concat不适用于非序列，因此如果元素不是向量，则必须将其包装到向量中。

您可以在这里尝试：http : //www.tryclj.com

(f [[[20],["Hi"],"Hi",20]])
(f [[["[]"],"[]"]])

ANSI C，193个字节

#define b break;
#define c case
#define p putch(_);
char f;main(_){switch(_){c 1:putch(91);b c 34:f^=1;p b c 91:f&&p b c 93:f&&p b c 10:c 13:putch(93);return;default:p}_=getch();main(_);}

：-/， 有什么建议么？顺便说一句，我确实尝试找到了一个在线源来进行编译，但是WL对于编译此代码非常严格。否则它将适用于VS和gcc。

JavaScript 20 bytes

a=>(a+[]).split(',')

The array + array is equal to array.toString

C#, 48 bytes

()=>{$"[{i.Replace("[","").Replace("]","")}]";};

Thought I'd post it also since nobody has given a C# solution yet. Suggestions welcome!

Racket, 63 bytes

(define(f l)(apply append(map(λ(x)(if(list? x)(f x)`(,x)))l)))

Java 8 165 chars

import java.util.*;<T>T[]f(T[]a){List<T>l=new ArrayList<>();for(T e:a)if(e instanceof Object[])Collections.addAll(l,f((T[])e));else l.add(e);return(T[])l.toArray();}

Ungolfed into a class:

public class Q80096 {

    public static <T> T[] flatten(T[] array) {
        List<T> flattenedList = new ArrayList<>();
        for (T element : array)
            if (element instanceof Object[])
                 Collections.addAll(flattenedList, flatten((T[]) element));
            else
                flattenedList.add(element);
        return (T[]) flattenedList.toArray();
    }
}

This answer is based on Jeremy Harton's approach. I used it changed it in some places and created a more golf-like version.

JavaScript, 17 Bytes

a=>eval(`[${a}]`)

Finally, JavaScript's type conversions can be put to some good use! Please note that this will actually output an array, but string conversion (putting it into HTML) causes it to become a comma separated list.

If comma separated lists are acceptable output, then the following is valid:

7 Bytes

a=>""+a

NOTE: Snippet is broken for some reason

var subject = 
  a=>eval(`[${a}]`)

<input oninput="try {output.innerHTML = subject(this.value)} catch(e) {output.innerHTML='Invaild Input'}" />
<div id="output"></div>

PHP, 73 Bytes

<?array_walk_recursive($_GET,function($i)use(&$r){$r[]=$i;});print_r($r);

Attache, 14 bytes

{Reap[Sow@>_]}

Try it online!

Fortunately, Attache has a "vectorization" operator, which applies a function at the atoms of a list. In this case, all we need to do is to set up a reaper with Reap and Sow all atoms of the input _ with @>. I think it's quite elegant.

Alternatives

15 bytes: Fixpoint{`'^^_}

16 bytes: Fixpoint!&Concat

17 bytes: {q:=[]q&Push@>_q}

17 bytes: Fixpoint[&Concat]

Elixir, 74 bytes

def d(l)do l|>Stream.flat_map(fn x->if is_list(x)do d(x)else[x]end end)end

First Elixir answer, so can probably be golfed a bit.

Try it online.

Explanation:

def d(l)do l|>            # Recursive method taking a list as input:
  Stream.flat_map(fn x->  #  Map over each item `x` of the input-list:
    if is_list(x)do       #   If `x` is a list itself:
      d(x)                #    Do a recursive call with `x`
    else                  #   Else:
      [x]                 #    Simply leave `x` unchanged
    end                   #   End of the if-else statements
  end)                    #  End of the map
end                       # End of the recursive method

Of course, if builtins were allowed, this could have been 25 bytes instead:

fn(l)->List.flatten(l)end

Try it online.

Jelly, 4 bytes

;/ÐL

Try it online!

Explanation

;/   | Reduce by concatenation
  ÐL | Loop until no further changes

Built-in F would be one byte if allowed.

Wolfram Language (Mathematica), 13 bytes

#~Level~{-1}&

Try it online!

Un-golfed: F[x_] := Level[x, {-1}]

picks out the elements of the structure at the last level of its tree form. I'm not sure this counts as "avoiding the builtin" (which would be Flatten).