Dalam tantangan ini, tugas Anda adalah membuat program yang menggunakan array bersarang dan mengembalikan array datar satu dimensi. Sebagai contoh [10,20,[30,[40]],50]harus output [10,20,30,40,50].

Input akan berupa array bersarang (mis. [10,20,[[[10]]]]). Ini hanya akan berisi Integer (baik negatif dan positif), String dan Array. Anda dapat mengambil input sebagai argumen fungsi, STDIN atau apa pun yang sesuai dengan bahasa Anda. Anda dapat mengasumsikan bahwa array input tidak akan memiliki array kosong.

Keluaran

Outputnya akan berupa array dimensi tunggal yang rata dengan elemen yang sama dengan tipe yang sama seperti pada array bersarang dan dalam urutan SAMA.

Uji Kasus

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

Jangan ragu untuk meminta klarifikasi dengan menggunakan komentar. Ini adalah kode-golf , jadi kode terpendek dalam byte menang!

Catatan: Jika bahasa Anda mengandung built-in untuk ini, maka Anda TIDAK harus menggunakannya.

Harap sertakan juga tautan ke situs web tempat kode Anda dapat dieksekusi.

K, 3 byte

,//

Ini adalah ungkapan yang cukup umum. "Bergabunglah di konvergensi".

coba di sini dengan OK .

Bagaimana itu bekerja:

Bergabunglah ( ,) bergabung bersama atom atau daftar untuk menghasilkan daftar. Over ( /) mengambil kata kerja (dalam hal ini bergabung) dan menerapkannya di antara setiap elemen daftar, dari kiri ke kanan. Dengan demikian, senyawa ,/akan meratakan semua elemen tingkat atas daftar. Simbol /sebenarnya memiliki arti yang berbeda tergantung pada valensi (jumlah argumen) dari kata kerja yang dengannya diperparah. Ketika kami menyediakan ,/sebagai kata kerja, /tindakan terakhir sebagai "konvergen" - itu berulang kali berlaku ,/untuk input sampai berhenti berubah. Beberapa bahasa lain menyebut fitur seperti ini sebagai "kombinator titik tetap". Dengan berulang kali menggabungkan daftar tingkat bawah, Anda pada akhirnya akan tiba pada satu daftar datar, dan tidak ada operasi yang akan mengganggu urutan elemen. Ini sepertinya menyelesaikan masalah.

JavaScript (ES6), 35 byte

Terinspirasi oleh jawaban @ user81655 :

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

Mathematica, 16 14 byte

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

Fungsi tanpa nama yang mengambil dan mengembalikan daftar, misalnya:

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

Penjelasan

Pesta gula sintaksis!

Untuk memahami cara kerja ini, catatan bahwa setiap ekspresi dalam Mathematica adalah salah atom (misalnya angka, string, simbol-simbol) atau ekspresi senyawa dari bentuk f[a, b, c, ...], di mana f, a, b, citu sendiri ekspresi sewenang-wenang. Di sini, fdisebut kepala ekspresi. Yang lainnya hanyalah gula sintaksis. Misalnya {a, b, c}saja List[a, b, c].

Kami mulai dengan //@yang memetakan fungsi di semua tingkatan daftar. Contohnya:

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

Perhatikan bahwa ini memetakan f atom dan juga ekspresi majemuk. Apa yang sekarang kita cari adalah cara untuk menyingkirkan daftar kepala dan menyimpan yang lainnya.

The ApplyFungsi ini biasanya digunakan untuk memberi makan elemen dari daftar sebagai argumen terpisah untuk fungsi, tetapi definisi yang sebenarnya adalah lebih umum dan hanya menggantikan kepala ekspresi. Misalnya Apply[g, f[a, b]]memberi g[a, b].

Sekarang ada "kepala" khusus yang disebut Sequenceyang hilang begitu saja. Misalnya {a, Sequence[b, c], d}hanya mengevaluasi {a, b, c, d}. Gagasan untuk meratakan daftar adalah dengan mengganti kepala semua daftar bagian dalam Sequencesehingga mereka dapat disebarkan ke daftar di sekitarnya. Jadi yang kita inginkan adalah Applymenuju Sequenceke daftar. Mudahnya jika kita melakukan Applysesuatu pada atom, itu hanya membuat atom tidak berubah, jadi kita tidak harus membedakan antara jenis ekspresi sama sekali.

Akhirnya, ada satu masalah kecil: fjuga diterapkan ke tingkat terluar, sehingga juga menghilangkan terluar List, yang tidak kita inginkan. Cara paling pendek untuk membalasnya adalah dengan hanya membungkus hasilnya dalam daftar lagi, sehingga sekitarnya Sequencedapat dengan aman menghilang.

Perhatikan bahwa ada tidak Applyatau Sequencedalam kode. @@adalah bentuk operator Applydan ##&merupakan trik golf standar untuk mempersingkat nama bawaan yang panjang Sequence. Jadi ungolfing semuanya sedikit, kita mendapatkan sesuatu seperti:

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

Untuk detail lebih lanjut tentang bagaimana dan mengapa ##&kerjanya, lihat bagian tentang "Urutan argumen" dalam jawaban saya untuk kiat Mathematica .

Python 2, 43 byte

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

Pada daftar, berulang pada elemen dan menyatukan hasilnya. Pada string atau angka, membungkus dalam daftar tunggal.

Sayangnya, pemesanan Python 2 untuk int < list < stringsandwich jenis listantara yang lain, membutuhkan dua ketidaksetaraan untuk memeriksa. Jadi, sebaliknya, l*0diperiksa terhadap daftar kosong [], jika tidak memberi 0atau "".

Ruby, 43 42 34 byte

Solusi rekursif. Sekarang dengan penanganan pengecualian! (mungkin juga kredit @akostadinov untuk menginspirasi perubahan itu)

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

Tautan 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}}}

Penjelasan:

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

Uji:

#! /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 tidak memiliki daftar bersarang dengan kedalaman sublists yang berbeda atau tipe campuran untuk elemen daftar. Untuk bersarang, saya mendefinisikan tipe data khusus Dyang merupakan daun Lyang menampung beberapa elemen atau simpul Nyang merupakan daftar Ds. Untuk elemen campuran saya menggunakan tipe data yang telah ditetapkan Eitheryang menggabungkan dua tipe menjadi satu, di sini Either String Integer. Jenis baru Ddan fungsi rata fsepenuhnya polimorfik dalam jenis elemen daun, jadi saya tidak perlu lebih berhati-hati dalam hal apa pun Either.

Contoh penggunaan: 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 byte

us+]Y

Cobalah online: Demonstrasi atau Test Suite

Tapi tentu saja, ada juga fungsi built-in, yang menangani tugas hanya dalam 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]

Hanya karena saya bahkan bisa menghindari penggunaan concat.

Perl, 34 29 byte

Fungsi

Jika perlu diratakan ke daftar like my @a = f(@a), 29 bytes:

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

Uji di Ideone

Jika perlu rata ke array seperti ref my $a = f($a), 34 byte:

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

Uji di Ideone .

Perl 5.22.0+, 27 byte

Terima kasih untuk hobbs .

Jika perlu diratakan ke daftar like my @a = f(@a), 27 byte:

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

Uji di JDoodle

Jika perlu meratakan ke array ref seperti my $a = f($a), 32 byte:

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

Uji di JDoodle .

Julia, 29 byte

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

Ini adalah pemolesan rekursif menjadi fungsi gabungan hingga mencapai titik perbaikan. Contoh

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

Retina , 30 byte

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

Cobalah online!(Baris pertama hanya digunakan untuk menjalankan beberapa uji sekaligus.)

Retina tidak memiliki konsep array, string literal atau angka, jadi saya memutuskan untuk pergi dengan format input "umum" dari [...,...]array gaya dan "string -drivisi, di mana \dapat digunakan di dalam string untuk melepaskan karakter apa pun (khususnya "dan\ itu sendiri).

Program itu sendiri hanya cocok dengan string penuh atau braket persegi, dan menggantinya dengan $1yang membuat string dan menghilangkan tanda kurung. Batas 1>melewati pertandingan pertama sehingga kami tidak menghapus yang pertama [. Namun, ini menghapus trailing ], jadi kami menambahkannya kembali dalam tahap terpisah.

Pyke, 11 byte

.F~]+=])K~]

Coba di sini!

Penjelasan:

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

Atau 7 byte setelah perbaikan bug

M?+]K~]

Coba di sini!

Penjelasan:

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

Atau bahkan 2 byte jika pencetakan ke stdout diizinkan (Ini mungkin termasuk built-in)

M
<newline required>

Coba di sini!

Ini sangat menerapkan print_newlinefungsi untuk setiap item non-urutan dalam input dan berulang untuk item urutan.

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

Hanya untuk kelengkapan dan semua itu. :) Tidak bisa mengatakan kode Java yang efisien.

Python, 57 byte

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

Cobalah online: Python 2 , Python 3

Terima kasih kepada Kevin Lau untuk list==type(x)triknya.

Rubi

ada flattenmetode builtin .

Anda dapat menjalankannya di sini: http://www.tutorialspoint.com/execute_ruby_online.php

Satu 43 byte, tetapi berpikir untuk berbagi:

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

Satu 45 byte yang lebih efisien daripada jawaban ruby ​​sebelumnya dan lainnya:

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

inilah tolok ukur:

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

hasil:

       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 bendera) 35 byte

Oneliner. Terinspirasi oleh Martin Büttner .

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

Uji di Ideone .

Clojure, 68 byte

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

mapcatpertama berlaku fungsi untuk setiap elemen dan kemudian hasil concat. Jadi setiap kali ia menyimpulkan satu 'level bersarang' hilang. Concat tidak bekerja pada urutan tidak jadi elemen harus dibungkus menjadi vektor jika mereka bukan vektor.

Anda dapat mencobanya di sini: 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(_);}

: - /, ada saran? Btw, saya memang mencoba mencari sumber online untuk mengkompilasi ini tetapi WL ketat untuk mengkompilasi kode ini. Ini akan bekerja untuk VS dan gcc sebaliknya.

JavaScript 20 byte

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

Array + array sama dengan array.toString

C #, 48 byte

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

Kupikir aku akan mempostingnya juga karena belum ada yang memberikan solusi C #. Saran diterima!

Racket, 63 byte

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

Java 8 165 karakter

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

Tidak digabung ke dalam kelas:

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

Jawaban ini didasarkan pada pendekatan Jeremy Harton . Saya menggunakannya mengubahnya di beberapa tempat dan membuat versi yang lebih seperti golf.

JavaScript, 17 Bytes

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

Akhirnya, konversi tipe JavaScript dapat dimanfaatkan dengan baik! Harap dicatat bahwa ini sebenarnya akan menghasilkan array, tetapi konversi string (memasukkannya ke dalam HTML) menyebabkannya menjadi daftar yang dipisahkan koma.

Jika daftar yang dipisahkan koma adalah keluaran yang dapat diterima, maka yang berikut ini valid:

7 Bytes

a=>""+a

CATATAN: Cuplikan rusak karena beberapa alasan

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 byte

{Reap[Sow@>_]}

Cobalah online!

Untungnya, Attache memiliki operator "vektorisasi", yang menerapkan fungsi pada atom-atom daftar. Dalam hal ini, semua kebutuhan kita lakukan adalah untuk mendirikan sebuah penuai dengan Reapdan Sowsemua atom dari input _dengan @>. Saya pikir itu cukup elegan.

Alternatif

15 byte: Fixpoint{`'^^_}

16 byte: Fixpoint!&Concat

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

17 byte: Fixpoint[&Concat]

Elixir , 74 byte

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

Elixir pertama menjawab, jadi mungkin bisa bermain golf sedikit.

Cobalah online.

Penjelasan:

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

Tentu saja, jika builtin diizinkan, ini bisa jadi 25 byte :

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

Cobalah online.

Jelly , 4 byte

;/ÐL

Cobalah online!

Penjelasan

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

Built-in Fakan menjadi satu byte jika diizinkan.

Bahasa Wolfram (Mathematica) , 13 byte

#~Level~{-1}&

Cobalah online!

Tidak golf: F[x_] := Level[x, {-1}]

memilih elemen struktur pada tingkat terakhir dari bentuk pohonnya . Saya tidak yakin ini dianggap sebagai "menghindari builtin" (yang akan menjadi Flatten).