চ্যাপ্টা অ্যারে!

Question

এই চ্যালেঞ্জে আপনার কাজ হ'ল একটি প্রোগ্রাম তৈরি করা যা নেস্টেড অ্যারে গ্রহণ করে এবং একক মাত্রিক চ্যাপ্টেন অ্যারে প্রদান করে। উদাহরণস্বরূপ [10,20,[30,[40]],50]আউটপুট করা উচিত [10,20,30,40,50]।

---

ইনপুট

ইনপুটটি নেস্টেড অ্যারে (উদাঃ [10,20,[[[10]]]]) হবে। এটিতে কেবল পূর্ণসংখ্যা (নেতিবাচক এবং ধনাত্মক উভয়), স্ট্রিংস এবং অ্যারে থাকবে। আপনি ইনপুটটিকে ফাংশন আর্গুমেন্ট, STDIN বা আপনার ভাষার উপযুক্ত অনুসারে যা নিতে পারেন। আপনি ধরে নিতে পারেন ইনপুট অ্যারেতে খালি অ্যারে থাকবে না।

---

আউটপুট

আউটপুটটি নেস্টেড অ্যারে এবং এসএমএ ক্রমে একই ধরণের একই উপাদানের সমতল একক মাত্রিক অ্যারে হবে।

---

পরীক্ষার মামলা

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

---

মন্তব্য ব্যবহার করে কোন স্পষ্টতা জিজ্ঞাসা করতে নির্দ্বিধায়। এটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী!

দ্রষ্টব্য: আপনার ভাষায় যদি এর জন্য অন্তর্নির্মিত থাকে তবে আপনাকে অবশ্যই এটি ব্যবহার করবেন না।

---

সম্পাদন করা

দয়া করে কোনও ওয়েবসাইটের লিঙ্ক অন্তর্ভুক্ত করুন যেখানে আপনার কোড কার্যকর করা যেতে পারে।

Comments

কিছু ভাষায় স্ট্রিংকে অ্যারে হিসাবে বিবেচনা করা হয়, [["হাই"], [[10]]] -> ["এইচ", "আই", 10] ঠিক আছে?

— ই

@ মেগো আমিও অবাক হয়ে জানতে পেরেছিলাম যে পিপিসিজিতে unflattenকোনও flattenপ্রশ্ন আছে তবে প্রশ্ন নেই ।

— অর্জুন

যদি আপনার ভাষা কেবল একই আকারের সাবারিগুলিকে সমর্থন করে? (উদাহরণস্বরূপ জাভা?) প্রতিটি উপাদানটির ধরণ একই রকম হলে কী হবে? (যেমন জাভা, সি ++ ইত্যাদি?) এছাড়াও, দয়া করে ["[",[["[",],'[',"['['"]]পরীক্ষার কেস হিসাবে উদাহরণ যোগ করুন ।

— flawr

@flawr যে পরীক্ষা ক্ষেত্রে শুধু তাই সমর্থন বট ভাষার জন্য জ্ঞান করে তোলে 'এবং "বিভেদক রূপে। (কিন্তু আমি যে একটি পরীক্ষা ক্ষেত্রে জড়িত একমত [, ], "এবং \একটি স্ট্রিং ভিতরে দরকারী হবে।)

— মার্টিন Ender

পরীক্ষার কেসগুলি এমন ভাষাগুলিও বাদ দেয় যা একাধিক প্রকারের সাথে বা অ্যারে আক্ষরিক জন্য অন্য স্বরলিপি সহ এই ধরণের অ্যারে সমর্থন করে না।

— flawr

Answer 1

কে, 3 বাইট

,//

এটি একটি মোটামুটি সাধারণ প্রতিমা। "ওভার কনভার্জে যোগ দিন"।

তা এখানে ঠিক আছে দিয়ে চেষ্টা ।

কিভাবে এটা কাজ করে:

,একটি তালিকা তৈরি করতে পরমাণু বা তালিকার একসাথে ফিউজে যোগ দিন ( )। ওভার ( /) একটি ক্রিয়া নেয় (এই ক্ষেত্রে যোগ দিন) এবং এটি তালিকার প্রতিটি উপাদানগুলির মধ্যে বাম থেকে ডানে প্রয়োগ করে app সুতরাং, যৌগিক ,/তালিকার সমস্ত শীর্ষ স্তরের উপাদানগুলিকে সমতল করবে। প্রতীকটির /ক্রিয়াটির ভারসাম্য (আর্গুমেন্টের সংখ্যা) এর উপর নির্ভর করে এটিটির পৃথক পৃথক অর্থ রয়েছে it যখন আমরা ,/ক্রিয়া হিসাবে সরবরাহ করি তখন চূড়ান্তটি /"রূপান্তর" হিসাবে কাজ করে - এটি ,/পরিবর্তন বন্ধ না হওয়া পর্যন্ত এটি ইনপুটটিতে বারবার প্রযোজ্য । কিছু অন্যান্য ভাষা এই জাতীয় বৈশিষ্ট্যটিকে একটি "নির্দিষ্ট পয়েন্ট সংযুক্তকারী" বলে ডাকে। বারবার নীচের স্তরের তালিকাগুলি ফিউজ করার পরে, আপনি অবশেষে একটি একক ফ্ল্যাট তালিকায় পৌঁছে যাবেন এবং কোনও ক্রিয়াকলাপই উপাদানগুলির ক্রমকে ব্যর্থ করবে না। এটি সমস্যার সমাধান বলে মনে হচ্ছে।

Comments

ঠিক আছে, ব্যাখ্যার জন্য ধন্যবাদ! আপনার উপার্জন +1 করুন।

— মান কালি

একটি ভিন্ন সমস্যার একই সমাধান ।

— জন

আমি একই অ্যালগোরিদম নিয়ে এসেছি (তবে এই ভাষায় নয়)। এটি কার্যকর করার জন্য সঠিক ভাষা বাছাই করার জন্য +1!

— সাইয়েস

@ কিয়েস যদি আপনার ভাষার এখানে তিনটি অপারেটরের ব্যবহারের সমতুল্য থাকে তবে এটি একটি অত্যন্ত প্রাকৃতিক সমাধান। যাই হোক না কেন আপনার প্রকরণ পোস্ট করুন।

— জন

@ জন লং স্টোরি, আমি যে অ্যালগরিদমগুলি নিয়ে এসেছি তা থেকে আমি একটি ভাষা অর্জন করছি, সুতরাং ভাষাটি এখনও শেষ হয়নি (এবং এভাবে প্রয়োগ করা হয়নি)।

— সাইয়েস

Answer 2

জাভাস্ক্রিপ্ট (ES6), 35 বাইট

@ ব্যবহারকারী81655 এর উত্তর দ্বারা অনুপ্রাণিত :

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

Comments

খুব চালাক! জেএস-এর অদৃশ্য উপায় হারিয়ে যাওয়া কীগুলি পরিচালনা করার জন্য [আবৃত্তি] জন্য +1!

— সাইয়েস

আমি এটা মারতে পারি।

— বাল্ড বান্থা

@ বাল্ডবাঁথা: আমরা আপনার উত্তরটির অপেক্ষায় রয়েছি :-)

— বার্গি

ক্র্যাপ এনভিএম আমার 33 বাইট সমাধান পরীক্ষার যে কোনও একটিতে ব্যর্থ। NOOOO

— বাল্ড বান্থা

বাল্ডবাঁথা, জোড়-বিভক্ত স্ট্রিমের ভিতরে কমাতে ব্যর্থ হবে।

— কিওয়ারটি

Answer 3

Mathematica, 16 14 bytes

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

An unnamed function which takes and returns a list, e.g.:

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

Explanation

Syntactic sugar party!

To understand how this works, note that every expression in Mathematica is either an atom (e.g. numbers, strings, symbols) or a compound expression of the form f[a, b, c, ...], where f, a, b, c are themselves arbitrary expressions. Here, f is called the head of the expression. Everything else on top of that is just syntactic sugar. E.g. {a, b, c} is just List[a, b, c].

We start with //@ which maps a functions over all levels of a list. For instance:

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

Note that this maps f over atoms as well as compound expressions. What we're now looking for is a way to get rid of the list heads and keep everything else.

The Apply function is normally used to feed the elements of a list as separate arguments to a function, but its actual definition is more general and simply replaces the head of an expression. E.g. Apply[g, f[a, b]] gives g[a, b].

Now there's a special "head" called Sequence that simply vanishes. E.g. {a, Sequence[b, c], d} just evaluates to {a, b, c, d}. The idea for flattening the list is to replace the heads of all inner lists with Sequence so that they get splatted into their surrounding list. So what we want is to Apply the head Sequence to the lists. Conveniently if we Apply something to an atom, it just leaves the atom unchanged, so we don't have to distinguish between types of expressions at all.

Finally, there's one small issue: f is also applied to the outermost level, so that it also removes the outermost List, which we don't want. The shortest way to counter that is simply to wrap the result in a list again, such that the surrounding Sequence can safely vanish.

Note that there's neither Apply nor Sequence in the code. @@ is an operator form of Apply and ##& is a standard golfing trick to shorten the long built-in name Sequence. So ungolfing everything a bit, we get something like:

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

For more details on how and why the ##& works, see the section on "Sequences of arguments" in my answer for the Mathematica tips.

Comments

First time I've seen //@. Very useful to know about!

— DavidC

//@ captures a neat pattern. Reminds me a bit of some of the recursive combinators in Joy. Do you have a link to a good reference to any related functions in Mathematica? I'm very interested in ways of factoring explicit recursion out of programs.

— JohnE

@JohnE Well, here's the docs. You could also look at things like Map, MapAt, Apply, as well as Replace and related functions. In general though there's a lot of function which take an optional levelspec parameter (see my original 16-byte solution), which lets you apply the function at multiple/all levels at once.

— Martin Ender

Answer 4

Python 2, 43 bytes

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

On a list, recurses on the elements and concatenates the results. On a string or number, encases in a singleton list.

Unfortunately, Python 2's ordering for types int < list < string sandwiches list between the others, requiring two inequalities to check. So, instead, l*0 is checked against the empty list [], otherwise giving 0 or "".

Answer 5

Ruby, 43 42 34 bytes

Recursive solution. Now with exception handling! (might as well credit @akostadinov for inspiring the change though)

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

IDEOne link

Comments

kudos for shortness, awesome

— akostadinov

I didn't know you could use rescue like that

— Cyoce

@Cyoce I think it's because Ruby technically doesn't have a try block, so you use begin instead to differentiate the parts you want to be catching for and the parts that you don't. So since you're catching for the entire rest of the block before it, you technically don't need it? The rest is just trimmed whitespace, since Ruby interprets the line as ...inject(:+) rescue [a]

— Value Ink

@KevinLau-notKenny, no, rescue on same line is different, just rescuing that line. e.g. a = raise("haha") rescue 1 would assign 1 to a. It'

— akostadinov

@KevinLau-notKenny There's an inline rescue, like there's an inline if and while.

— Fund Monica's Lawsuit

Answer 6

JavaScript (ES6), 41 bytes

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>

Answer 7

Perl 6, 24 bytes

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

Explanation:

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

Test:

#! /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 - $[[["[]"], "[]"],]

Answer 8

Haskell, 43 bytes

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

Haskell has neither nested lists with different depths of the sublists nor mixed types for the list elements. For nesting I define a custom data type D which is either a leaf L that holds some element or a node N which is a list of Ds. For the mixed elements I use the predefined data type Either which combines two types into one, here Either String Integer. The new type D and the flatten function f are fully polymorphic in the type of the leaf elements, so I don't have to take extra care of anything regarding Either.

Usage example: f (N[N[L(Right 20)], N[L(Left "Hi")], L(Left "Hi") , L(Right 20)]) -> [Right 20,Left "Hi",Left "Hi",Right 20].

Answer 9

Pyth, 7 6 5 bytes

us+]Y

Try it online: Demonstration or Test Suite

But of course, there is also a build-in function, that handles the task in just 2 bytes: .n (Test Suite)

Comments

Just 3 away from the current winner! +1

— Arjun

@Sting: Golfed away another byte. Forgot that Pyth append the last character G implicitly, if I don't write it.

— Jakube

Congratulations!

— Arjun

Answer 10

JavaScript (Firefox 30-57), 43 bytes

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

Just because I could even avoid using concat.

Comments

Isn't it ECMAScript 6 not Firefox 30+?

— Solomon Ucko

@SolomonUcko No, [for(of)] is only available in Firefox 30+. It was proposed for ES7 but later dropped.

— Neil

thanks for explaining! Mostly, i just thought it was for(__ in __)

— Solomon Ucko

@SolomonUcko [for(in)] was an alternative experimental syntax which gave you the keys of the object.

— Neil

Answer 11

Perl, 34 29 bytes

Functions.

If needs to flatten to list like my @a = f(@a), 29 bytes:

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

Test it on Ideone

If needs to flatten to array ref like my $a = f($a), 34 bytes:

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

Test it on Ideone.

Perl 5.22.0+, 27 bytes

Thanks to hobbs.

If needs to flatten to list like my @a = f(@a), 27 bytes:

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

Test it on JDoodle

If needs to flatten to array ref like my $a = f($a), 32 bytes:

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

Test it on JDoodle.

Comments

I haven't tested it, but think ?@{f@$_}: should work instead of ?@{f(@$_)}:, saving two bytes.

— msh210

@msh210 No, it’s not working. The compiler doesn’t khow that f is a function because f not yet declared. sub f{}sub f{... f@$_ ...} working.

— Denis Ibaev

1. ref doesn't need the parens to work, saving 2 bytes. 2. As far as I can see, sub f{map{ref?f(@$_):$_}@_} is within the rules and saves another 5. f takes an array (nonref) as a list, so it can return the same.

— hobbs

@hobbs 1. If no parentheses with ref then the compiler assumes that ? is starting ?PATTERN? operation like ref(?PATTERN?). So the compiler searches second ? and throws error.

— Denis Ibaev

@DenisIbaev ah. ?PATTERN? was removed in 5.22.0 (m?PATTERN? still works) and I'm testing on a recent version. So you can gain those two bytes by specifying 5.22+.

— hobbs

Answer 12

Julia, 29 bytes

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

This is recursive splatting into a concatenate function until a reaching a fix point. Example

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

Answer 13

Retina, 30 bytes

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

Try it online! (The first line is only used to run multiple test cases at once.)

Retina has no concept of arrays, string literals or numbers, so I decided to go with a "common" input format of [...,...] style arrays and "-delimited strings, where \ can be used inside the strings to escape any character (in particular " and \ itself).

The program itself simply matches either a full string or a square bracket, and replaces them with $1 which keeps strings and removes square brackets. The limit 1> skips the first match so that we don't remove the leading [. However, this does remove the trailing ], so we add it back in in a separate stage.

Answer 14

Pyke, 11 bytes

.F~]+=])K~]

Try it here!

Explanation:

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

Or 7 bytes after a bugfix

M?+]K~]

Try it here!

Explanation:

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.

Comments

Just 4 away from K! +1

— Arjun

Answer 15

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.

Comments

Hello, and welcome to PPCG! This question is code-golf, so please try to minimize your code. Thanks!

— NoOneIsHere

Remove all the unnecessary spaces, tabs, and newlines. Change oaf to o, and change flatten to f.

— NoOneIsHere

You don't need the finals, the whole thing can be a lambda, you don't need public static...

— David Conrad

you could save couple characters if you use generics instead object

— user902383

you could also save 2 bytes if you replace false with 1>2, and additional 2 bytes you could get if you declare n but not define (compiler automatically define it as 0)

— user902383

Answer 16

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.

Comments

type(x)==list is shorter than isinstance(x,list).

— Value Ink

“It will contain only Integers (both negative and positive), Strings and Arrays.” How about [`x`>'['and...? (That works in Python 2 only.)

— Lynn

Answer 17

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)

Comments

Hello, and welcome to PPCG! Unfortunately, your answer is not valid, because of this rule: Note: If your language contains a built-in for this, then you must NOT use it.

— NoOneIsHere

@NoOneIsHere, thanks, didn't know that

— akostadinov

How does my new update stack against time-wise against yours? Also, just like my new answer, you can remove the spaces around rescue

— Value Ink

@KevinLau-notKenny updated, thanks! rescue looks to be rather slow btw, like try/catch in java

— akostadinov

Update your bytecount, too

— Value Ink

Answer 18

Perl, 39 34 + 1 (-p flag) 35 bytes

Oneliner. Inspired by Martin Büttner.

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

Test it on Ideone.

Answer 19

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

Comments

Nice first code-golf. +1 :)

— Arjun

Answer 20

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.

Comments

Welcome to PPCG!

— Martin Ender

Welcome to PPCG! Nice first golf. Good luck ahead!

— Arjun

Thanks! It was an attempt to up my points so that I can get commenting privileges elsewhere. It appears things don't work like that the accounts are for different portals. :D I will see if some nifty features from c++ can be used.

— amritanshu

Answer 21

JavaScript 20 bytes

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

The array + array is equal to array.toString

Comments

@WheatWizard thanks for the welcome and I am new to the site. actually a is an argument of the function. I will try to edit out the function now.

— i--

I think now it's ok @WheatWizard. Please let me know if there is a problem with this

— i--

Actually looking at the javaScript docs an anonymous function would definitely be shorter, you would only have to add a=> to the beginning of your code.

— Wheat Wizard

@WheatWizard I updated with the arrow function as you mentioned. But I have to remove the snippet because arrow function doesn't support direct invoke. It is only for callbacks

— i--

This doesn't handle strings with commas in them correctly

— Jo King

Answer 22

C#, 48 bytes

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

Thought I'd post it also since nobody has given a C# solution yet. Suggestions welcome!

Comments

Welcome to the site. I haven't programmed in C# in a while but it looks to me that you might have a couple of issues. For one how is i initialized? and are you sure it works on the [["[]"],"[]"] example?

— Wheat Wizard

Sorry, i is the input passed in as a string. An empty array would just translate to an empty string.

— PmanAce

How about the last testcase? Also, I presume you meant to do i=>$"{i.Replace("[","").Replace("]","")}"?

— Embodiment of Ignorance

Sadly doesn't work in the last case, it will get rid of empty array. :(

— PmanAce

This answer doesn't pass the final test case. Since it has not been fixed for a few months, I'm voting to delete it.

— mbomb007

Answer 23

Racket, 63 bytes

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

Answer 24

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.

Comments

would it be not better when using Arrays.asList() on "array" and then go the foreach with lambda and end this with a Collector?

— Serverfrog

Answer 25

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>

Comments

This doesn't seem to work when run in the console for input ["["]... I tried running (a=>eval([${a}]))(["["]) and got a SyntaxError

— jrich

@jrich. You just get this error when you type character by character. If you copy and paste any valid array, it will work as expected. By the way, nice answer SpeedNinja, I would only change oninput event with a button click.

— Washington Guedes

This doesn't work for strings with commas in them

— Jo King

Answer 26

PHP, 73 Bytes

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

Answer 27

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]

Answer 28

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.

Answer 29

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.

Answer 30

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