In dieser Herausforderung besteht Ihre Aufgabe darin, ein Programm zu erstellen, das ein verschachteltes Array aufnimmt und ein eindimensionales abgeflachtes Array zurückgibt. Zum Beispiel [10,20,[30,[40]],50]sollte ausgeben [10,20,30,40,50].

Die Eingabe ist ein verschachteltes Array (z. B. [10,20,[[[10]]]]). Es enthält nur Ganzzahlen (sowohl negative als auch positive), Strings und Arrays. Sie können die Eingabe als Funktionsargument nehmen, STDIN oder was auch immer zu Ihrer Sprache passt. Sie können davon ausgehen, dass das Eingabearray kein leeres Array enthält.

Ausgabe

Die Ausgabe ist ein abgeflachtes eindimensionales Array mit den gleichen Elementen des gleichen Typs wie im verschachtelten Array und in der gleichen Reihenfolge.

Testfälle

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

Fühlen Sie sich frei, um Klarstellung durch die Verwendung von Kommentaren zu bitten. Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Hinweis: Wenn Ihre Sprache eine integrierte Funktion enthält, dürfen Sie diese NICHT verwenden.

Bitte fügen Sie auch einen Link zu einer Website hinzu, auf der Ihr Code ausgeführt werden kann.

K, 3 Bytes

,//

Dies ist eine ziemlich verbreitete Redewendung. "Join over converge".

versuche es hier mit oK .

Wie es funktioniert:

Join ( ,) verschmilzt Atome oder Listen zu einer Liste. Over ( /) nimmt ein Verb (in diesem Fall join) und wendet es von links nach rechts zwischen den einzelnen Elementen einer Liste an. Auf diese Weise wird die Verbindung ,/alle Elemente der obersten Ebene der Liste verflachen. Das Symbol hat /tatsächlich unterschiedliche Bedeutungen, abhängig von der Valenz (Anzahl der Argumente) des Verbs, mit dem es zusammengesetzt ist. Wenn wir ,/als Verb angeben, fungiert das Finale /als "Konvergenz" - es wird wiederholt ,/auf die Eingabe angewendet, bis die Änderung aufhört. Einige andere Sprachen bezeichnen eine solche Funktion als "Festkomma-Kombinator". Durch wiederholtes Zusammenführen von Listen der untersten Ebene gelangen Sie schließlich zu einer einzelnen flachen Liste, und keine der Operationen stört die Reihenfolge der Elemente. Dies scheint das Problem zu lösen.

JavaScript (ES6), 35 Byte

Inspiriert von @ user81655s Antwort :

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

Mathematica, 16 14 Bytes

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

Eine unbenannte Funktion, die eine Liste aufnimmt und zurückgibt, zB:

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

Erläuterung

Syntaktische Zuckerparty!

Um zu verstehen , wie dies funktioniert, beachten Sie, dass jeder Ausdruck in Mathematica ist entweder ein Atom (zB Zahlen, Strings, Symbole) oder eine Verbindung , Ausdruck der Form f[a, b, c, ...], in der f, a, b, csind sie beliebige Ausdrücke. Hier fwird der Kopf des Ausdrucks genannt. Alles andere ist nur syntaktischer Zucker. ZB {a, b, c}ist gerade List[a, b, c].

Wir beginnen damit, //@welche Maps und Funktionen über alle Ebenen einer Liste hinweg funktionieren . Zum Beispiel:

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

Beachten Sie, dass dies sowohl fAtome als auch zusammengesetzte Ausdrücke abbildet . Was wir jetzt suchen, ist eine Möglichkeit, die Listenköpfe loszuwerden und alles andere zu behalten.

Die ApplyFunktion wird normalerweise verwendet, um die Elemente einer Liste als separate Argumente an eine Funktion weiterzuleiten. Die eigentliche Definition ist jedoch allgemeiner und ersetzt einfach den Kopf eines Ausdrucks. ZB Apply[g, f[a, b]]gibtg[a, b] .

Jetzt gibt es einen speziellen "Kopf" Sequence, der einfach verschwindet. ZB {a, Sequence[b, c], d}nur auswertet {a, b, c, d}. Die Idee zum Reduzieren der Liste besteht darin, die Köpfe aller inneren Listen durch zu ersetzen Sequence, damit sie in ihre umgebende Liste aufgeteilt werden. Also, was wir wollen, ist Applyden Kopf Sequencezu den Listen. Wenn wir Applyetwas zu einem Atom machen, lässt es das Atom einfach unverändert, so dass wir überhaupt nicht zwischen Arten von Ausdrücken unterscheiden müssen.

Schließlich gibt es noch ein kleines Problem: fWird auch auf die äußerste Ebene angewendet, sodass auch die äußerste Ebene entfernt wird List, die wir nicht möchten. Der kürzeste Weg, dem entgegenzuwirken, besteht darin, das Ergebnis erneut in eine Liste zu schreiben, sodass die Umgebung Sequencesicher verschwinden kann.

Beachte, dass es weder im Code Applynoch Sequenceim Code gibt. @@ist eine Betreiberform von Applyund ##&ein Standard-Golftrick, um den langgezogenen Namen zu verkürzen Sequence. Wenn wir also alles ein bisschen ungolfing, bekommen wir so etwas wie:

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

Weitere Einzelheiten dazu, wie und warum das ##&funktioniert, finden Sie im Abschnitt "Folgen von Argumenten" in meiner Antwort auf die Mathematica-Tipps .

Python 2, 43 Bytes

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

Rekursiert in einer Liste die Elemente und verkettet die Ergebnisse. Umschließt einen String oder eine Zahl mit einer Singleton-Liste.

Leider werden in Python 2 int < list < stringSandwiches listzwischen den anderen Typen bestellt , was zwei Ungleichungen zur Überprüfung erfordert. Also wird stattdessen l*0gegen die leere Liste geprüft [], sonst gibst 0oder "".

Ruby, 43 42 34 Bytes

Rekursive Lösung. Jetzt mit Ausnahmebehandlung! (Könnte auch @akostadinov dafür danken, dass er die Veränderung inspiriert hat)

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

IDEOne Link

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 Bytes

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

Erläuterung:

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

Prüfung:

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

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

Haskell hat weder verschachtelte Listen mit unterschiedlichen Tiefen der Unterlisten noch gemischte Typen für die Listenelemente. Zum Verschachteln definiere ich einen benutzerdefinierten Datentyp, Dder entweder ein Blatt ist L, das ein Element enthält, oder einen Knoten, Nder eine Liste von Ds ist. Für die gemischten Elemente verwende ich den vordefinierten Datentyp Either, der hier zwei Typen zu einem kombiniert Either String Integer. Der neue Typ Dund die Abflachungsfunktion fsind in der Art der Blattelemente vollständig polymorph, so dass ich mich um nichts mehr kümmern mussEither .

Anwendungsbeispiel: 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 Bytes

us+]Y

Probieren Sie es online aus: Demo oder Test Suite

Natürlich gibt es auch eine eingebaute Funktion, die die Aufgabe in nur 2 Bytes erledigt: .n( Test Suite )

JavaScript (Firefox 30-57), 43 Byte

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

Nur weil ich es vermeiden konnte concat.

Perl, 34 29 Bytes

Funktionen.

Wenn abgeflacht werden muss, um aufzulisten, wie my @a = f(@a)29 Bytes:

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

Teste es auf Ideone

Wenn das Array abgeflacht werden soll my $a = f($a), sind es 34 Bytes:

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

Teste es auf Ideone .

Perl 5.22.0+, 27 Byte

Vielen Dank an Hobbs .

Wenn abgeflacht werden muss, um aufzulisten, wie my @a = f(@a)27 Bytes:

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

Teste es auf JDoodle

Wenn das Array abgeflacht werden soll my $a = f($a), werden 32 Bytes benötigt:

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

Teste es auf JDoodle .

Julia, 29 Bytes

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

Dies ist eine rekursive Aufteilung in eine Verkettungsfunktion, bis ein Fixpunkt erreicht ist. Beispiel

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

Netzhaut , 30 Bytes

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

Probieren Sie es online!(In der ersten Zeile werden nur mehrere Testfälle gleichzeitig ausgeführt.)

Retina kennt keine Arrays, Stringliterale oder Zahlen. Deshalb habe ich mich für ein "allgemeines" Eingabeformat von [...,...]Style-Arrays und "-begrenzten Strings entschieden, bei denen \innerhalb der Strings Zeichen (insbesondere "und \selbst) ausgeblendet werden können .

Das Programm selbst vergleicht einfach entweder eine vollständige Zeichenfolge oder eine eckige Klammer und ersetzt diese, wobei $1Zeichenfolgen beibehalten und eckige Klammern entfernt werden. Das Limit 1>überspringt das erste Match, damit wir das Leading nicht entfernen [. Dadurch wird jedoch das Trailing entfernt ], sodass wir es in einer separaten Phase wieder hinzufügen.

Pyke, 11 Bytes

.F~]+=])K~]

Probieren Sie es hier aus!

Erläuterung:

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

Oder 7 Bytes nach einem Bugfix

M?+]K~]

Probieren Sie es hier aus!

Erläuterung:

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

Oder sogar 2 Bytes, wenn das Drucken nach stdout erlaubt ist (Dies könnte unter Built-Ins fallen)

M
<newline required>

Probieren Sie es hier aus!

Dies wendet die print_newlineFunktion zutiefst auf alle nicht sequenziellen Elemente in der Eingabe an und rekursiert für sequenzielle Elemente.

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

Nur der Vollständigkeit halber und so weiter. :) Kann nicht sagen, Java ist Code-effizient.

Python, 57 Bytes

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

Probieren Sie es online aus: Python 2 , Python 3

Danke an Kevin Lau für den list==type(x)Trick.

Rubin

Es gibt eine eingebaute flattenMethode.

Sie können hier ausführen: http://www.tutorialspoint.com/execute_ruby_online.php

Eine 43 Bytes, aber gedacht zu teilen:

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

Eine 45-Byte-Antwort ist effizienter als die vorherige und die andere Ruby-Antwort:

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

hier ist 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

Ergebnis:

       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 ( -pFlag) 35 Bytes

Einzeiler. Inspiriert von Martin Büttner .

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

Teste es auf Ideone .

Clojure, 68 Bytes

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

mapcatWendet zuerst die Funktion auf jedes Element an und setzt dann die Ergebnisse zusammen. Jedes Mal, wenn es sich um eine Verschachtelungsebene handelt, geht dies verloren. Concat arbeitet nicht mit Nicht-Sequenzen, daher müssen Elemente in Vektor eingeschlossen werden, wenn sie nicht Vektor sind.

Sie können es hier ausprobieren: 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(_);}

:-/, irgendwelche Vorschläge? Übrigens habe ich versucht, eine Online-Quelle zu finden, um dies zu kompilieren, aber die WL ist streng, damit dieser Code kompiliert werden kann. Ansonsten funktioniert es für VS und gcc.

JavaScript 20 Bytes

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

Das Array + Array ist gleich array.toString

C #, 48 Bytes

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

Dachte, ich würde es auch posten, da noch niemand eine C # -Lösung angegeben hat. Vorschläge willkommen!

Schläger, 63 Bytes

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

Java 8 165 Zeichen

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 in eine Klasse:

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

Diese Antwort basiert auf Jeremy Hartons Ansatz . Ich habe es an einigen Stellen geändert und eine Golf-ähnliche Version erstellt.

JavaScript, 17 Bytes

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

Schließlich können die Typkonvertierungen von JavaScript sinnvoll eingesetzt werden! Beachten Sie, dass dies tatsächlich ein Array ausgibt, bei der Konvertierung von Zeichenfolgen (in HTML) wird es jedoch zu einer durch Kommas getrennten Liste.

Wenn durch Kommas getrennte Listen als Ausgabe zulässig sind, gilt Folgendes:

7 Bytes

a=>""+a

HINWEIS: Das Snippet ist aus irgendeinem Grund defekt

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@>_]}

Probieren Sie es online!

Glücklicherweise hat Attache einen "Vektorisierungs" -Operator, der eine Funktion auf die Atome einer Liste anwendet. In diesem Fall müssen wir nur einen Schnitter mit Reapund Sowalle Atome des Eingangs _mit einrichten @>. Ich finde es ziemlich elegant.

Alternativen

15 Bytes: Fixpoint{`'^^_}

16 Bytes: Fixpoint!&Concat

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

17 Bytes: Fixpoint[&Concat]

Elixier , 74 Bytes

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

Erste Elixier-Antwort, damit kann wohl ein bisschen golfen werden.

Probieren Sie es online aus.

Erläuterung:

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

Wenn Builtins erlaubt wären, könnten dies natürlich stattdessen 25 Bytes sein :

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

Probieren Sie es online aus.

Gelee , 4 Bytes

;/ÐL

Probieren Sie es online!

Erläuterung

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

Eingebaut Fwäre ein Byte, wenn erlaubt.

Wolfram Language (Mathematica) , 13 Byte

#~Level~{-1}&

Probieren Sie es online!

Nicht golfen: F[x_] := Level[x, {-1}]

wählt die Elemente der Struktur auf der letzten Ebene ihrer Baumform aus . Ich bin nicht sicher, ob dies als "Vermeiden des eingebauten" (was wäre Flatten) gilt.