In questa sfida, il tuo compito è quello di creare un programma che accetta un array nidificato e restituisce un array appiattito monodimensionale. Ad esempio [10,20,[30,[40]],50]dovrebbe essere prodotto [10,20,30,40,50].

L'input sarà un array nidificato (ad es. [10,20,[[[10]]]]). Conterrà solo numeri interi (sia negativi che positivi), stringhe e array. Puoi prendere l'input come argomento di funzione, STDIN o qualunque cosa sia adatta alla tua lingua. Si può presumere che l'array di input non abbia un array vuoto.

Produzione

L'output sarà un array monodimensionale piatto con gli stessi elementi dello stesso tipo dell'array nidificato e nell'ordine SAME.

Casi test

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

Sentiti libero di chiedere qualsiasi chiarimento usando i commenti. Questo è code-golf , quindi vince il codice più corto in byte!

Nota: se la tua lingua contiene un built-in per questo, NON devi usarlo.

Includere anche un collegamento a un sito Web in cui è possibile eseguire il codice.

K, 3 byte

,//

Questo è un linguaggio abbastanza comune. "Join over converge".

provalo qui con oK .

Come funziona:

Join ( ,) fonde insieme atomi o liste per produrre un elenco. Over ( /) prende un verbo (in questo caso join) e lo applica tra ogni elemento di un elenco, da sinistra a destra. Pertanto, il composto ,/appiattirà tutti gli elementi di livello superiore dell'elenco. Il simbolo in /realtà ha significati diversi a seconda della valenza (numero di argomenti) del verbo con cui è composto. Quando forniamo ,/come verbo, il finale /funge da "convergenza" - si applica ripetutamente ,/all'input fino a quando non smette di cambiare. Alcune altre lingue chiamano una caratteristica come questa un "combinatore a punto fisso". Unendo ripetutamente gli elenchi di livello inferiore, alla fine arriverete a un unico elenco piatto e nessuna delle operazioni perturberà l'ordine degli elementi. Questo sembra risolvere il problema.

JavaScript (ES6), 35 byte

Ispirato dalla risposta di @ user81655 :

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

Mathematica, 16 14 byte

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

Una funzione senza nome che accetta e restituisce un elenco, ad esempio:

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

Spiegazione

Zucchero sintattico!

Per capire come funziona, nota che ogni espressione in Mathematica è o un atomo (ad esempio numeri, stringhe, simboli) o un'espressione composto di forma f[a, b, c, ...], in cui f, a, b, csono essi stessi espressioni arbitrarie. Qui, fsi chiama il capo dell'espressione. Tutto il resto è solo zucchero sintattico. Ad esempio {a, b, c}è giusto List[a, b, c].

Iniziamo con //@quale mappa funziona a tutti i livelli di un elenco. Per esempio:

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

Si noti che questo mappa fsu atomi e espressioni composte. Ciò che stiamo cercando ora è un modo per sbarazzarci delle intestazioni dell'elenco e mantenere tutto il resto.

La Applyfunzione viene normalmente utilizzata per alimentare gli elementi di un elenco come argomenti separati di una funzione, ma la sua definizione effettiva è più generale e sostituisce semplicemente la testa di un'espressione. Ad esempio, Apply[g, f[a, b]]dà g[a, b].

Ora c'è una speciale "testa" chiamata Sequenceche svanisce semplicemente. Ad esempio, {a, Sequence[b, c], d}valuta solo {a, b, c, d}. L'idea di appiattire l'elenco è quella di sostituire le teste di tutti gli elenchi interni in Sequencemodo che vengano divisi nella loro lista circostante. Quindi quello che vogliamo è andare in Applytesta Sequencealle liste. Convenientemente, se noi facciamo Applyqualcosa per un atomo, questo lascia solo invariato l'atomo, quindi non dobbiamo affatto distinguere tra tipi di espressioni.

Infine, c'è un piccolo problema: fviene applicato anche al livello più esterno, in modo da rimuovere anche quello più esterno List, che non vogliamo. Il modo più breve per contrastare è semplicemente quello di racchiudere il risultato in un elenco, in modo che l'ambiente circostante Sequencepossa svanire in modo sicuro.

Nota che non c'è né Applyné Sequencenel codice. @@è una forma di operatore Applyed ##&è un trucco da golf standard per abbreviare il nome incorporato lungo Sequence. Quindi ungolf tutto un po ', otteniamo qualcosa di simile:

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

Per maggiori dettagli su come e perché ##&funziona, vedere la sezione "Sequenze di argomenti" nella mia risposta per i suggerimenti di Mathematica .

Python 2, 43 byte

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

In un elenco, ricorre agli elementi e concatena i risultati. Su una stringa o un numero, racchiude in un elenco singleton.

Sfortunatamente, l'ordinamento di Python 2 per tipi di int < list < stringpanini listtra gli altri, che richiede due disuguaglianze da verificare. Quindi, invece, l*0viene confrontato con l'elenco vuoto [], altrimenti dando 0o "".

Rubino, 43 42 34 byte

Soluzione ricorsiva. Ora con gestione delle eccezioni! (potrebbe anche dare credito a @akostadinov per aver ispirato il cambiamento)

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 byte

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

Spiegazione:

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

Haskell, 43 byte

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

Haskell non ha elenchi nidificati con profondità diverse delle liste secondarie né tipi misti per gli elementi della lista. Per l'annidamento, definisco un tipo di dati personalizzato Dche è una foglia Lche contiene un elemento o un nodo Nche è un elenco di Ds. Per gli elementi misti uso il tipo di dati predefinito Eitherche combina due tipi in uno, qui Either String Integer. Il nuovo tipo De la funzione appiattisci fsono completamente polimorfici nel tipo di elementi fogliari, quindi non devo preoccuparmi di nulla Either.

Esempio di utilizzo: 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

Provalo online: Dimostrazione o Test Suite

Ma ovviamente c'è anche una funzione integrata che gestisce l'attività in soli 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]

Solo perché ho persino potuto evitare di usarlo concat.

Perl, 34 29 byte

Funzioni.

Se è necessario appiattire per elencare come my @a = f(@a), 29 byte:

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

Provalo su Ideone

Se è necessario appiattire come l'array ref my $a = f($a), come 34 byte:

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

Provalo su Ideone .

Perl 5.22.0+, 27 byte

Grazie a Hobbs .

Se è necessario appiattire per elencare come my @a = f(@a) , 27 byte:

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

Provalo su JDoodle

Se è necessario appiattire come l'array ref my $a = f($a), 32 byte:

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

Provalo su JDoodle .

Julia, 29 byte

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

Questo è lo splatting ricorsivo in una funzione concatenata fino al raggiungimento di un punto fisso. Esempio

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

Retina , 30 byte

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

Provalo online!(La prima riga viene utilizzata solo per eseguire più casi di test contemporaneamente.)

Retina non ha alcun concetto di array, letterali o numeri di stringhe, quindi ho deciso di scegliere un formato di input "comune" di [...,...]array di stili e "stringhe delimitate, dove \può essere utilizzato all'interno delle stringhe per sfuggire a qualsiasi carattere (in particolare "e\ se stesso).

Il programma stesso abbina semplicemente una stringa intera o una parentesi quadra e le sostituisce con le $1quali mantiene le stringhe e rimuove le parentesi quadre. Il limite 1>salta la prima partita in modo da non rimuovere il primo [. Tuttavia, questo rimuove il finale ], quindi lo aggiungiamo di nuovo in una fase separata.

Pyke, 11 byte

.F~]+=])K~]

Provalo qui!

Spiegazione:

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

O 7 byte dopo un bugfix

M?+]K~]

Provalo qui!

Spiegazione:

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

O anche 2 byte se è consentita la stampa su stdout (questo potrebbe essere incorporato)

M
<newline required>

Provalo qui!

Questo applica profondamente la print_newlinefunzione a ogni elemento non in sequenza nell'input e ricorre per gli elementi in sequenza.

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

Solo per completezza e tutto il resto. :) Non posso dire che il codice Java sia efficiente.

Python, 57 byte

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

Provalo online: Python 2 , Python 3

Grazie a Kevin Lau per il list==type(x)trucco.

Rubino

c'è un flattenmetodo incorporato .

Puoi eseguire qui: http://www.tutorialspoint.com/execute_ruby_online.php

43 byte, ma ho pensato di condividere:

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

Uno 45 byte che è più efficiente del precedente e l'altro rubino risponde:

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

ecco il 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

risultato:

       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 byte

Oneliner. Ispirato da Martin Büttner .

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

Provalo su Ideone .

Clojure, 68 byte

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

mapcatapplica prima la funzione a ciascun elemento e quindi concede i risultati. Quindi ogni volta che si perde un "livello di nidificazione" si perde. Concat non funziona su sequenze non così gli elementi devono essere avvolti nel vettore se non sono vettoriali.

Puoi provarlo qui: 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(_);}

:-/, eventuali suggerimenti? A proposito, ho provato a trovare una fonte online per compilare questo, ma il WL è rigoroso per la compilazione di questo codice. In caso contrario funzionerà per VS e gcc.

JavaScript 20 byte

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

L'array + array è uguale a array.toString

C #, 48 byte

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

Ho pensato di pubblicarlo anche dal momento che nessuno ha ancora dato una soluzione C #. Suggerimenti benvenuti!

Racchetta, 63 byte

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

Java 8 165 caratteri

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

Ungolf in una classe:

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

Questa risposta si basa sull'approccio di Jeremy Harton . L'ho usato e l'ho cambiato in alcuni punti e ho creato una versione più simile al golf.

JavaScript, 17 byte

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

Infine, le conversioni di tipo JavaScript possono essere utili! Si noti che ciò genererà effettivamente un array, ma la conversione di stringhe (inserendola in HTML) fa sì che diventi un elenco separato da virgole.

Se gli elenchi separati da virgola sono accettabili, allora è valido quanto segue:

7 byte

a=>""+a

NOTA: lo snippet è rotto per qualche motivo

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

Attache , 14 byte

{Reap[Sow@>_]}

Provalo online!

Fortunatamente, Attache ha un operatore di "vettorializzazione", che applica una funzione agli atomi di un elenco. In questo caso, tutto ciò che dobbiamo fare è impostare un mietitore con Reape Sowtutti gli atomi dell'input _con @>. Penso che sia abbastanza elegante.

alternative

15 byte: Fixpoint{`'^^_}

16 byte: Fixpoint!&Concat

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

17 byte: Fixpoint[&Concat]

Elisir , 74 byte

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

Prima risposta all'elisir, quindi probabilmente si può giocare un po 'a golf.

Provalo online.

Spiegazione:

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

Naturalmente, se i builtin fossero consentiti, avrebbero potuto essere invece 25 byte :

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

Provalo online.

Gelatina , 4 byte

;/ÐL

Provalo online!

Spiegazione

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

Incorporato Fsarebbe un byte se consentito.

Wolfram Language (Mathematica) , 13 byte

#~Level~{-1}&

Provalo online!

Un-giocato a golf: F[x_] := Level[x, {-1}]

seleziona gli elementi della struttura all'ultimo livello della sua forma ad albero . Non sono sicuro che questo valga come "evitare l'integrato" (che sarebbe Flatten).