Trong thử thách này, nhiệm vụ của bạn là tạo ra một chương trình lấy một mảng lồng nhau và trả về một mảng phẳng một chiều. Ví dụ [10,20,[30,[40]],50]nên xuất ra [10,20,30,40,50].

Đầu vào sẽ là một mảng lồng nhau (ví dụ. [10,20,[[[10]]]]). Nó sẽ chỉ chứa các số nguyên (cả âm và dương), Chuỗi và Mảng. Bạn có thể lấy đầu vào làm đối số chức năng, STDIN hoặc bất cứ điều gì phù hợp với ngôn ngữ của bạn. Bạn có thể giả sử rằng mảng đầu vào sẽ không có mảng trống.

Đầu ra

Đầu ra sẽ là một mảng một chiều được làm phẳng với các phần tử cùng loại như trong mảng lồng nhau và theo thứ tự CÙNG.

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

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

Hãy yêu cầu làm rõ bất kỳ bằng cách sử dụng ý kiến. Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

Lưu ý: Nếu ngôn ngữ của bạn có tích hợp sẵn cho việc này, thì bạn KHÔNG được sử dụng ngôn ngữ đó.

Vui lòng bao gồm một liên kết đến một trang web nơi mã của bạn có thể được thực thi.

K, 3 byte

,//

Đây là một thành ngữ khá phổ biến. "Tham gia hội tụ".

thử nó ở đây với oK .

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

Nối ( ,) hợp nhất các nguyên tử hoặc danh sách để tạo ra một danh sách. Over ( /) lấy một động từ (trong trường hợp này là nối) và áp dụng nó giữa mỗi thành phần của danh sách, từ trái sang phải. Do đó, hợp chất ,/sẽ làm phẳng tất cả các yếu tố cấp cao nhất của danh sách. Biểu tượng /thực sự có ý nghĩa khác nhau tùy thuộc vào hóa trị (số lượng đối số) của động từ mà nó được ghép. Khi chúng tôi cung cấp ,/dưới dạng động từ, cuối cùng /đóng vai trò là "hội tụ" - nó liên tục áp dụng ,/cho đầu vào cho đến khi nó ngừng thay đổi. Một số ngôn ngữ khác gọi một tính năng như thế này là "tổ hợp điểm cố định". Bằng cách liên tục kết hợp các danh sách cấp dưới, cuối cùng bạn sẽ đến một danh sách phẳng duy nhất và không có thao tác nào sẽ làm xáo trộn thứ tự các phần tử. Điều này dường như để giải quyết vấn đề.

JavaScript (ES6), 35 byte

Lấy cảm hứng từ câu trả lời của @ user81655 :

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

Toán học, 16 14 byte

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

Một hàm không tên sẽ nhận và trả về một danh sách, ví dụ:

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

Giải trình

Bữa tiệc đường cú pháp!

Để hiểu cách thức hoạt động này, lưu ý rằng tất cả các biểu hiện trong Mathematica là một trong hai nguyên tử (ví dụ số, chuỗi, biểu tượng) hoặc một biểu thức hợp chất của hình thức f[a, b, c, ...], nơi f, a, b, clà tự biểu tùy ý. Ở đây, fđược gọi là đầu của biểu thức. Tất cả mọi thứ khác trên đó chỉ là cú pháp đường. Ví dụ {a, b, c}là chỉ List[a, b, c].

Chúng tôi bắt đầu với //@việc ánh xạ một chức năng qua tất cả các cấp của danh sách. Ví dụ:

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

Lưu ý rằng bản đồ này ftrên các nguyên tử cũng như các biểu thức ghép. Những gì chúng ta đang tìm kiếm là một cách để loại bỏ những người đứng đầu danh sách và giữ mọi thứ khác.

Các Applychức năng thường được sử dụng để nuôi các yếu tố của một danh sách như các đối số riêng biệt để một chức năng, nhưng định nghĩa thực tế của nó là tổng quát hơn và chỉ cần thay thế người đứng đầu của một biểu thức. Vd Apply[g, f[a, b]]cho g[a, b].

Bây giờ có một "cái đầu" đặc biệt gọi là Sequenceđơn giản biến mất. Ví dụ: {a, Sequence[b, c], d}chỉ đánh giá {a, b, c, d}. Ý tưởng làm phẳng danh sách là thay thế các đầu của tất cả các danh sách bên trong Sequenceđể chúng được chia thành danh sách xung quanh. Vì vậy, những gì chúng tôi muốn là Applyngười đứng đầu Sequencedanh sách. Thuận tiện nếu chúng ta Applymột cái gì đó cho một nguyên tử, nó chỉ khiến nguyên tử không thay đổi, vì vậy chúng ta không phải phân biệt giữa các loại biểu thức.

Cuối cùng, có một vấn đề nhỏ: fcũng được áp dụng cho cấp độ ngoài cùng, do đó, nó cũng loại bỏ lớp ngoài cùng Listmà chúng ta không muốn. Cách ngắn nhất để chống lại điều đó chỉ đơn giản là bọc lại kết quả trong một danh sách, sao cho xung quanh Sequencecó thể biến mất một cách an toàn.

Lưu ý rằng không có Applyhoặc cũng không có Sequencetrong mã. @@là một hình thức vận hành Applyvà ##&là một thủ thuật đánh golf tiêu chuẩn để rút ngắn tên tích hợp dài Sequence. Vì vậy, không hiểu mọi thứ một chút, chúng tôi nhận được một cái gì đó như:

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

Để biết thêm chi tiết về cách thức và lý do ##&công việc, hãy xem phần "Trình tự lập luận" trong câu trả lời của tôi để biết các mẹo Toán học .

Python 2, 43 byte

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

Trong một danh sách, đệ quy về các yếu tố và nối các kết quả. Trên một chuỗi hoặc số, nằm trong một danh sách đơn.

Thật không may, việc đặt hàng của Python 2 cho các loại int < list < stringbánh sandwich listgiữa các loại khác, đòi hỏi hai bất đẳng thức để kiểm tra. Vì vậy, thay vào đó, l*0được kiểm tra đối với danh sách trống [], nếu không thì cho 0hoặc "".

Ruby, 43 42 34 byte

Giải pháp đệ quy. Bây giờ với xử lý ngoại lệ! (cũng có thể tín dụng @akostadinov để truyền cảm hứng cho sự thay đổi)

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

Liên kết IDEOne

JavaScript (ES6), 41 byte

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 byte

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

Giải trình:

{ # 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 $_
      }
    )
  }
}

Kiểm tra:

#! /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 byte

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

Haskell không có danh sách lồng nhau với độ sâu khác nhau của danh sách phụ cũng như loại hỗn hợp cho các thành phần danh sách. Để lồng nhau, tôi định nghĩa một kiểu dữ liệu tùy chỉnh Dlà một lá Lchứa một số phần tử hoặc một nút Nlà một danh sách của Ds. Đối với các phần tử hỗn hợp, tôi sử dụng kiểu dữ liệu được xác định trước Eitherkết hợp hai loại thành một, ở đây Either String Integer. Loại mới Dvà chức năng làm phẳng fhoàn toàn đa hình trong loại phần tử lá, vì vậy tôi không phải quan tâm thêm bất cứ điều gì liên quan Either.

Ví dụ sử dụng: f (N[N[L(Right 20)], N[L(Left "Hi")], L(Left "Hi") , L(Right 20)])-> [Right 20,Left "Hi",Left "Hi",Right 20].

Bình thường, 7 6 5 byte

us+]Y

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Nhưng tất nhiên, cũng có một hàm dựng sẵn, xử lý tác vụ chỉ trong 2 byte: .n( Test Suite )

JavaScript (Firefox 30-57), 43 byte

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

Chỉ vì tôi thậm chí có thể tránh sử dụng concat.

Perl, 34 29 byte

Chức năng.

Nếu cần làm phẳng để liệt kê như thế my @a = f(@a), 29 byte:

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

Kiểm tra nó trên Ideone

Nếu cần làm phẳng để tham chiếu mảng my $a = f($a), 34 byte:

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

Kiểm tra nó trên Ideone .

Perl 5.22.0+, 27 byte

Cảm ơn hobbs .

Nếu cần làm phẳng để liệt kê như my @a = f(@a), 27 byte:

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

Kiểm tra nó trên JDoodle

Nếu cần làm phẳng để tham chiếu mảng như my $a = f($a)32 byte:

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

Kiểm tra nó trên JDoodle .

Julia, 29 byte

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

Đây là phép nối đệ quy vào một hàm ghép cho đến khi đạt đến một điểm cố định. Thí dụ

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

Võng mạc , 30 byte

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

Hãy thử trực tuyến!(Dòng đầu tiên chỉ được sử dụng để chạy nhiều trường hợp thử nghiệm cùng một lúc.)

Retina không có khái niệm về mảng, chuỗi ký tự hoặc số, vì vậy tôi đã quyết định sử dụng định dạng đầu vào "phổ biến" của [...,...]mảng kiểu và "chuỗi phân cách, \có thể được sử dụng bên trong chuỗi để thoát bất kỳ ký tự nào (cụ thể "và \chính nó).

Bản thân chương trình chỉ đơn giản khớp với một chuỗi đầy đủ hoặc dấu ngoặc vuông và thay thế chúng bằng $1chuỗi giữ và loại bỏ dấu ngoặc vuông. Giới hạn 1>bỏ qua trận đấu đầu tiên để chúng tôi không xóa vị trí dẫn đầu [. Tuy nhiên, điều này không xóa dấu vết ], vì vậy chúng tôi thêm nó trở lại trong một giai đoạn riêng biệt.

Pyke, 11 byte

.F~]+=])K~]

Hãy thử nó ở đây!

Giải trình:

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

Hoặc 7 byte sau một lỗi

M?+]K~]

Hãy thử nó ở đây!

Giải trình:

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

Hoặc thậm chí 2 byte nếu cho phép in ra thiết bị xuất chuẩn (Điều này có thể được tích hợp sẵn)

M
<newline required>

Hãy thử nó ở đây!

Điều này áp dụng sâu sắc print_newlinechức năng cho mọi mục không tuần tự trong đầu vào và đệ quy cho các mục trình tự.

Java (v8) 390 276 byte

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

Chỉ cần cho đầy đủ và tất cả những thứ đó. :) Không thể nói mã Java hiệu quả.

Python, 57 byte

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

Dùng thử trực tuyến: Python 2 , Python 3

Cảm ơn Kevin Lau cho list==type(x)mánh khóe.

Hồng ngọc

có nội dung flatten phương pháp .

Bạn có thể chạy ở đây: http://www.tutorialspoint.com/execute_ruby_online.php

Một 43 byte, nhưng được cho là để chia sẻ:

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

Một 45 byte hiệu quả hơn so với câu trả lời trước đó và câu trả lời khác của ruby:

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

đây là điểm chuẩn:

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

kết quả:

       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 ( -pcờ) 35 byte

Lót. Lấy cảm hứng từ Martin Büttner .

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

Kiểm tra nó trên Ideone .

Clojure, 68 byte

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

mapcatđầu tiên áp dụng chức năng cho từng yếu tố và sau đó concat kết quả. Vì vậy, mỗi khi nó che giấu một 'cấp độ lồng' sẽ bị mất. Concat không hoạt động trên các chuỗi không phải vì vậy các phần tử phải được gói vào vector nếu chúng không phải là vector.

Bạn có thể thử nó ở đây: http://www.tryclj.com

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

ANSI C, 193 byte

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

:-/, bất kỳ đề xuất? Btw, tôi đã cố gắng tìm một nguồn trực tuyến để biên dịch cái này nhưng WL rất nghiêm ngặt đối với mã này để biên dịch. Nó sẽ làm việc cho VS và gcc nếu không.

JavaScript 20 byte

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

Mảng + mảng bằng với mảng.toString

C #, 48 byte

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

Tôi nghĩ tôi cũng sẽ đăng nó vì chưa ai đưa ra giải pháp C #. Gợi ý chào mừng!

Vợt, 63 byte

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

Java 8 165 ký tự

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 vào một lớp học:

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

Câu trả lời này dựa trên phương pháp của Jeremy Harton . Tôi đã sử dụng nó đã thay đổi nó ở một số nơi và tạo ra một phiên bản giống như golf hơn.

JavaScript, 17 byte

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

Cuối cùng, chuyển đổi loại của JavaScript có thể được sử dụng tốt! Xin lưu ý rằng điều này thực sự sẽ tạo ra một mảng, nhưng chuyển đổi chuỗi (đưa nó vào HTML) làm cho nó trở thành một danh sách được phân tách bằng dấu phẩy.

Nếu danh sách được phân tách bằng dấu phẩy là đầu ra có thể chấp nhận, thì sau đây là hợp lệ:

7 byte

a=>""+a

LƯU Ý: Đoạn trích bị hỏng vì một số lý do

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 byte

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

Tùy viên , 14 byte

{Reap[Sow@>_]}

Hãy thử trực tuyến!

May mắn thay, Attache có toán tử "vector hóa", áp dụng một hàm tại các nguyên tử của danh sách. Trong trường hợp này, tất cả những gì chúng ta cần làm là thiết lập một máy gặt với Reapvà Sowtất cả các nguyên tử của đầu vào _với @>. Tôi nghĩ nó khá thanh lịch.

Lựa chọn thay thế

15 byte: Fixpoint{`'^^_}

16 byte: Fixpoint!&Concat

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

17 byte: Fixpoint[&Concat]

Thuốc tiên , 74 byte

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

Câu trả lời đầu tiên của Elixir, vì vậy có lẽ có thể được đánh gôn một chút.

Hãy thử trực tuyến.

Giải trình:

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

Tất nhiên, nếu nội dung được cho phép, thì điều này có thể là 25 byte thay thế:

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

Hãy thử trực tuyến.

Thạch , 4 byte

;/ÐL

Hãy thử trực tuyến!

Giải trình

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

Tích hợp Fsẽ là một byte nếu được phép.

Ngôn ngữ Wolfram (Mathicala) , 13 byte

#~Level~{-1}&

Hãy thử trực tuyến!

Chưa chơi gôn: F[x_] := Level[x, {-1}]

chọn ra các yếu tố của cấu trúc ở cấp độ cuối cùng của dạng cây . Tôi không chắc điều này được tính là "tránh tích hợp" (điều này sẽ xảy ra Flatten).