この課題では、あなたの仕事は、ネストされた配列を取り込んで、一次元の平坦化された配列を返すプログラムを作成することです。たとえば、[10,20,[30,[40]],50]出力する必要があります[10,20,30,40,50]。

入力はネストされた配列になります（例：）[10,20,[[[10]]]]。整数（負と正の両方）、文字列、配列のみが含まれます。入力を関数の引数、STDIN、または言語に適したものとして受け取ることができます。入力配列に空の配列がないと仮定できます。

出力

出力は、ネストされた配列と同じ順序で同じタイプの同じ要素を持つフラット化された1次元配列になります。

テストケース

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

コメントを使用して、説明を求めてください。これはcode-golfなので、バイト単位の最短コードが勝ちです！

注： 言語にこれが組み込まれている場合は、使用しないでください。

コードを実行できるWebサイトへのリンクも含めてください。

K、3バイト

,//

これはかなり一般的なイディオムです。「収束に参加」。

ここでoKで試してください。

使い方：

Join（,）は、アトムまたはリストを融合してリストを作成します。Over（/）は動詞（この場合は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} *)

説明

構文糖衣パーティー！

理解するためにどのようにこの作品は、ノートMathematicaのすべての式は、原子のいずれかであること（例えば数値、文字列、記号）またはフォームの複合式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ことに、アトムに何かを加えても、アトムは変更されないままなので、式のタイプをまったく区別する必要はありません。

最後に、小さな問題が1つあり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れているため、チェックするには2つの不等式が必要です。だから、代わりに、l*0空のリストと照合され[]そう与える、0または""。

ルビー、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またはsのNリストであるノードのいずれかであるカスタムデータ型を定義しますD。混合要素の場合Either、ここでは2つのタイプを1つに結合する定義済みのデータタイプを使用します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（テストスイート）

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でテストする

my $a = f($a)34バイトのような配列refにフラット化する必要がある場合：

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

Ideoneでテストします。

Perl 5.22.0 +、27バイト

ホッブズに感謝します。

のようにフラット化する必要がある場合my @a = f(@a)、27バイト：

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

JDoodleでテストする

my $a = f($a)32バイトのような配列refにフラット化する必要がある場合：

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
$
]

オンラインでお試しください！（最初の行は、複数のテストケースを一度に実行するためにのみ使用されます。）

Retinaには配列、文字列リテラル、または数字の概念がないため、文字列内で任意の文字（特に、それ自体）をエスケープするために使用できる[...,...]スタイル配列と"-delimited文字列の「共通」入力フォーマットを\使用することにしました。"\

プログラム自体は、完全な文字列または角かっこに単純に一致し、それらを$1文字列を保持して角かっこを削除するものに置き換えます。制限1>は最初の一致をスキップするため、先頭を削除しません[。ただし、これにより末尾のが削除される]ため、別の段階で追加します。

パイク、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 `]`

または、stdoutへの印刷が許可されている場合は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

list==type(x)トリックをくれたケビン・ラウに感謝します。

ルビー

組み込みflattenメソッドがあります。

ここで実行できます：http : //www.tutorialspoint.com/execute_ruby_online.php

1つの43バイトですが、共有すると考えられます：

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

前と他のルビーの答えよりも効率的な45バイト：

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バイト

ワンライナー。触発マーティンBüttner。

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

Ideoneでテストします。

Clojure、68バイト

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

mapcat最初に各要素に関数を適用し、次に結果を連結します。そのため、1つの「ネストレベル」が連結されるたびに失われます。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バイト

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

配列+配列はarray.toStringと等しい

C＃、48バイト

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

まだ誰もC＃ソリューションを提供していないので、私も投稿すると思いました。提案を歓迎します！

ラケット、63バイト

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

Java 8 165文字

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

クラスにゴルフをかけない：

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

この答えはに基づいています ジェレミー・ハートンのアプローチにます。私はそれをいくつかの場所で変更し、よりゴルフのようなバージョンを作成しました。

JavaScript、17バイト

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

最後に、JavaScriptの型変換を有効に活用できます！これは実際に配列を出力しますが、文字列変換（HTMLに変換）によりコンマ区切りリストになることに注意してください。

コンマ区切りのリストが許容可能な出力である場合、次が有効です。

7バイト

a=>""+a

注：スニペットは何らかの理由で壊れています

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バイト

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

アタッシュ、14バイト

{Reap[Sow@>_]}

オンラインでお試しください！

幸いなことに、Attacheには「ベクトル化」演算子があり、リストのアトムに関数を適用します。この場合は、私たちが行う必要があるすべては、と死神設定することですReapし、Sow入力のすべての原子を_と@>。とてもエレガントだと思います。

代替案

15バイト： Fixpoint{`'^^_}

16バイト： Fixpoint!&Concat

17バイト： {q:=[]q&Push@>_q}

17バイト： Fixpoint[&Concat]

エリクサー、74バイト

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

エリクサーの最初の答えなので、おそらく少しゴルフをすることができます。

オンラインでお試しください。

説明：

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

もちろん、組み込みが許可されている場合、これは代わりに25バイトである可能性があります。

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

オンラインでお試しください。

ゼリー、4つのバイト

;/ÐL

オンラインでお試しください！

説明

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

F許可されている場合、組み込みは1バイトになります。

Wolfram言語（Mathematica）、13バイト

#~Level~{-1}&

オンラインでお試しください！

ゴルフをしていない： F[x_] := Level[x, {-1}]

ツリー構造の最後のレベルで構造の要素を選び出します。これが「組み込みの回避」としてカウントされるかどうかはわかりません（これはFlatten）。