이 도전에서, 당신의 임무는 중첩 된 배열을 취하고 1 차원 평탄화 된 배열을 반환하는 프로그램을 만드는 것입니다. 예를 들어 [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 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

참고 : 언어에 내장 언어가 포함되어 있으면 사용해서는 안됩니다.

코드를 실행할 수있는 웹 사이트에 대한 링크도 포함하십시오.

K, 3 바이트

,//

이것은 상당히 일반적인 관용구입니다. "수렴에 참여".

여기를 확인하십시오 .

작동 방식 :

결합 ( ,)은 원자 또는 목록을 융합하여 목록을 생성합니다. 오버 ( /)는 동사 (이 경우 조인)를 가져 와서 목록의 각 요소 사이에서 왼쪽에서 오른쪽으로 적용합니다. 따라서 화합물 ,/은 목록의 모든 최상위 요소를 평평하게 만듭니다. 기호는 /실제로 복합 동사의 원자가 (인수)에 따라 다른 의미를 갖습니다. ,/동사를 제공 할 때 최종 /은 "수렴"으로 작동 ,/합니다. 변경이 멈출 때까지 입력에 반복적으로 적용됩니다 . 일부 다른 언어에서는 이와 같은 기능을 "고정 점 조합기"라고합니다. 최하위 레벨 목록을 반복적으로 융합하면 결국 단일 플랫 목록에 도달하게되며 어떤 조작도 요소 순서를 혼란스럽게하지 않습니다. 이것은 문제를 해결하는 것 같습니다.

자바 스크립트 (ES6), 35 바이트

@ user81655의 답변에서 영감을 얻었습니다 .

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

수학, 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 팁에 대한 답변에서 "인수 순서"섹션을 참조하십시오 .

파이썬 2, 43 바이트

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

목록에서 요소를 되풀이하고 결과를 연결합니다. 문자열 또는 숫자에서 단일 목록으로 묶습니다.

불행히도, 파이썬 2 는 다른 유형 사이 에 유형 int < list < string샌드위치 list를 주문 하므로 두 가지 불평등이 필요합니다. 그래서, 대신, l*0빈리스트에 체크 []그렇지 않으면 제공, 0또는 "".

루비, 43 42 34 바이트

재귀 솔루션. 이제 예외 처리와 함께! (그러나 변화를 고무시키는 데 @akostadinov를 신용하게 할 수도 있음)

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

IDEOne 링크

자바 스크립트 (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>

펄 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 - $[[["[]"], "[]"],]

하스켈, 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경우 여기에 두 가지 유형을 하나로 결합 하는 사전 정의 된 데이터 유형 을 사용합니다 Either String Integer. 새 유형 D과 평면화 함수 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 )

자바 스크립트 (Firefox 30-57), 43 바이트

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

그냥 사용을 피할 수 있기 때문에 concat.

펄, 34 29 바이트

기능.

다음과 같이 나열하기 위해 평평 해야하는 경우 my @a = f(@a)29 바이트 :

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

Ideone에서 테스트

ref와 같이 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에서 테스트

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

온라인으로 사용해보십시오! 첫 번째 줄은 한 번에 여러 테스트 사례를 실행하는 데만 사용됩니다.

내가의 "일반적인"입력 형식에 가기로 결정 그래서 망막은, 배열, 문자열 리터럴 또는 숫자의 개념이 없습니다 [...,...]스타일의 배열과 "-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입력의 모든 비 시퀀스 항목에 기능을 깊이 적용하고 시퀀스 항목에 대해 반복됩니다.

자바 (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의 코드 효율적이라고 말할 수 없습니다.

파이썬, 57 바이트

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

온라인으로 사용해보십시오 : Python 2 , Python 3

list==type(x)트릭을 해준 Kevin Lau에게 감사합니다 .

루비

내장 flatten방법이 있습니다.

여기에서 실행할 수 있습니다 : http://www.tutorialspoint.com/execute_ruby_online.php

하나의 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 바이트

짧막 한 농담. Martin Büttner에서 영감을 받았습니다 .

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

Ideone에서 테스트하십시오 .

클로저, 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(_);}

:-/, 어떤 제안? Btw, 이것을 컴파일 할 온라인 소스를 찾으려고했지만 WL 은이 코드가 컴파일하기에 엄격합니다. 그렇지 않으면 VS와 gcc에서 작동합니다.

자바 스크립트 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)))

자바 8165 자

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

이 답변은 Jeremy Harton의 접근 방식을 기반으로 합니다. 나는 그것을 어떤 곳에서 사용하고 더 골프 같은 버전을 만들었습니다.

자바 스크립트, 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 Language (Mathematica) , 13 바이트

#~Level~{-1}&

온라인으로 사용해보십시오!

언 골프 : F[x_] := Level[x, {-1}]

트리 양식 의 마지막 레벨에서 구조의 요소를 선택합니다 . 나는 이것이 "내장을 피하는 것"이라고 확신하지 않습니다 ( Flatten).