У цьому виклику ваше завдання - створити програму, яка займає вкладений масив і повертає одновимірний сплющений масив. Для прикладу [10,20,[30,[40]],50]слід вивести [10,20,30,40,50].

Вхід буде вкладеним масивом (напр. [10,20,[[[10]]]]). Він буде містити лише цілі числа (як негативні, так і позитивні), рядки та масиви. Ви можете взяти введення як аргумент функції, STDIN або що завгодно відповідно до вашої мови. Можна припустити, що вхідний масив не матиме порожній масив.

Вихідні дані

Виведенням буде плоский одновимірний масив з тими ж елементами того ж типу, що і в вкладеному масиві та в порядку SAME.

Випробування

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

Не соромтеся запитувати будь-які роз’яснення, використовуючи коментарі. Це код-гольф , тому найкоротший код у байтах виграє!

Примітка: Якщо ваша мова містить вбудований для цього, ви її НЕ повинні використовувати.

Будь ласка, додайте посилання на веб-сайт, на якому ваш код може бути виконаний.

К, 3 байти

,//

Це досить поширена ідіома. Msgstr "Приєднатися до конвергенції".

спробуйте тут .

Як це працює:

Join ( ,) зливається разом з атомами або списками, щоб створити список. Over ( /) приймає дієслово (в даному випадку приєднуйтесь) і застосовує його між кожним елементом списку, зліва направо. Таким чином, з'єднання ,/вирівняє всі елементи верхнього рівня списку. Символ /насправді має різні значення залежно від валентності (кількості аргументів) дієслова, з яким він складається. Коли ми подаємо ,/як дієслово, остаточні /дії діють як "конвергенція" - це неодноразово застосовується ,/до вводу, поки він не перестане змінюватися. Деякі інші мови називають таку функцію, як "комбінатор з фіксованою точкою". Неодноразово перетворюючи списки нижнього рівня, ви зрештою дістанетесь до єдиного плоского списку, і жодна операція не порушить порядок елементів. Це, здається, вирішує проблему.

JavaScript (ES6), 35 байт

Натхненний відповіддю @ user81655 :

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

Математика, 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щось до атома, він просто залишає атом незмінним, тому нам взагалі не потрібно розрізняти типи виразів.

Нарешті, є одна невелика проблема: fтакож застосовується до самого зовнішнього рівня, так що вона також видаляє самий зовнішній List, який ми не хочемо. Найкоротший спосіб боротьби з цим - просто знову загорнути результат у список, щоб оточуючі Sequenceмогли спокійно зникнути.

Зауважте, що в коді немає ні цього, Applyні Sequence. @@це форма оператора Applyі ##&є стандартним трюком для гольфу, щоб скоротити довге вбудоване ім'я Sequence. Тож, дещо все переймаємось, ми отримуємо щось на кшталт:

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

Детальніше про те, як і чому це ##&працює, дивіться у розділі "Послідовність аргументів" у моїй відповіді на поради щодо математики .

Python 2, 43 байти

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

У списку рекурсує по елементах і об'єднує результати. У рядку чи цифрі, укладається в однотонний список.

На жаль, Python 2 замовляє тип int < list < stringбутербродів listміж іншими, вимагаючи перевірити дві нерівності. Отже, натомість 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який містить якийсь елемент, або вузлом, Nякий є списком Ds. Для змішаних елементів я використовую попередньо визначений тип даних, 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( Тестовий набір )

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

Спробуйте в Інтернеті!(Перший рядок використовується лише для запуску декількох тестових випадків одночасно.)

У Retina немає поняття масивів, рядкових літералів чи чисел, тому я вирішив перейти з "загальним" вхідним форматом [...,...]масивів стилів і "-розділеними рядками, де \можна використовувати всередині рядків, щоб уникнути будь-якого символу (зокрема "і\ сам по собі).

Сама програма просто відповідає або повному рядку, або квадратній дужці, і замінює їх, $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 `]`

Or even 2 bytes if printing to stdout is allowed (This might come under built-ins)

M
<newline required>

Try it here!

This deeply applies the print_newline function to every non-sequence item in the input and recurses for sequence items.

Java (v8) 390 276 bytes

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

Just for completeness and all that. :) Can't say Java's code-efficient.

Python, 57 bytes

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

Try it online: Python 2, Python 3

Thanks to Kevin Lau for the list==type(x) trick.

Ruby

there is builtin flatten method.

You can run here: http://www.tutorialspoint.com/execute_ruby_online.php

One 43 bytes, but thought to share:

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

One 45 bytes that is more efficient than the previous and the other ruby answer:

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

here's benchmark:

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

result:

       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 flag) 35 bytes

Oneliner. Inspired by Martin Büttner.

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

Test it on Ideone.

Clojure, 68 bytes

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

mapcat first applies function to each element and then concats results. So every time it concats one 'nesting level' is lost. Concat does not work on not sequences so elements have to be wrapped into vector if they're not vector.

You can try it here: http://www.tryclj.com

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

ANSI C, 193 bytes

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

:-/, any suggestions? Btw, I did try to find an online source to compile this but the WL is strict for this code to compile. It will work for VS and gcc otherwise.

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).