En este desafío, su tarea es crear un programa que tome una matriz anidada y devuelva una matriz plana unidimensional. Por ejemplo [10,20,[30,[40]],50]debería salir [10,20,30,40,50].

La entrada será una matriz anidada (p. Ej. [10,20,[[[10]]]]). Contendrá solo números enteros (negativos y positivos), cadenas y matrices. Puede tomar la entrada como argumento de función, STDIN o lo que se adapte a su idioma. Puede suponer que la matriz de entrada no tendrá una matriz vacía.

Salida

La salida será una matriz unidimensional plana con los mismos elementos del mismo tipo que en la matriz anidada y en el MISMO orden.

Casos de prueba

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

No dude en solicitar cualquier aclaración mediante el uso de comentarios. Este es el código de golf , por lo que gana el código más corto en bytes.

Nota: Si su idioma contiene una función incorporada para esto, NO debe usarlo.

Incluya también un enlace a un sitio web donde se pueda ejecutar su código.

K, 3 bytes

,//

Este es un idioma bastante común. "Unirse sobre converger".

Pruébalo aquí con OK .

Cómo funciona:

Join ( ,) fusiona átomos o listas para producir una lista. Over ( /) toma un verbo (en este caso, join) y lo aplica entre cada elemento de una lista, de izquierda a derecha. Por lo tanto, el compuesto ,/aplanará todos los elementos de nivel superior de la lista. El símbolo en /realidad tiene diferentes significados dependiendo de la valencia (número de argumentos) del verbo con el que está compuesto. Cuando proporcionamos ,/como verbo, el final /actúa como "converger": se aplica repetidamente ,/a la entrada hasta que deja de cambiar. Algunos otros idiomas llaman a una característica como esta un "combinador de punto fijo". Al fusionar repetidamente las listas de nivel inferior, finalmente llegará a una sola lista plana, y ninguna de las operaciones perturbará el orden de los elementos. Esto parece resolver el problema.

JavaScript (ES6), 35 bytes

Inspirado por la respuesta de @ user81655 :

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

Mathematica, 16 14 bytes

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

Una función sin nombre que toma y devuelve una lista, por ejemplo:

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

Explicación

¡Fiesta de azúcar sintáctica!

Para entender cómo funciona este, nota que cada expresión en Mathematica es o bien un átomo (por ejemplo, números, cadenas, símbolos) o una expresión compuesto de la forma f[a, b, c, ...], en donde f, a, b, cson en sí mismas expresiones arbitrarias. Aquí, fse llama la cabeza de la expresión. Todo lo demás además de eso es solo azúcar sintáctico. Por ejemplo, {a, b, c}es justo List[a, b, c].

Comenzamos con //@qué asigna una función en todos los niveles de una lista. Por ejemplo:

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

Tenga en cuenta que esto asigna f sobre átomos, así como expresiones compuestas. Lo que estamos buscando ahora es una forma de deshacernos de los encabezados de la lista y conservar todo lo demás.

La Applyfunción se usa normalmente para alimentar los elementos de una lista como argumentos separados para una función, pero su definición real es más general y simplemente reemplaza el encabezado de una expresión. Por ejemplo, Apply[g, f[a, b]]dag[a, b] .

Ahora hay una "cabeza" especial llamada Sequenceque simplemente desaparece. Por ejemplo, {a, Sequence[b, c], d}solo evalúa a {a, b, c, d}. La idea para aplanar la lista es reemplazar los encabezados de todas las listas internas con el Sequencefin de que salpiquen en su lista circundante. Entonces, lo que queremos es Applyencabezar Sequencelas listas. Convenientemente, si hacemos Applyalgo con un átomo, simplemente deja el átomo sin cambios, por lo que no tenemos que distinguir entre tipos de expresiones.

Finalmente, hay un pequeño problema: ftambién se aplica al nivel más externo, de modo que también elimina el más externo List, que no queremos. La forma más corta de contrarrestar eso es simplemente envolver el resultado en una lista nuevamente, de modo que el entorno Sequencepueda desaparecer de forma segura.

Tenga en cuenta que no hay Applyni Sequenceen el código.@@es una forma de operador Applyy ##&es un truco de golf estándar para acortar el largo nombre incorporado Sequence. Entonces, ungolf todo un poco, obtenemos algo como:

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

Para obtener más detalles sobre cómo y por qué ##&funciona, consulte la sección "Secuencias de argumentos" en mi respuesta para los consejos de Mathematica .

Python 2, 43 bytes

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

En una lista, recurre a los elementos y concatena los resultados. En una cadena o número, se encierra en una lista singleton.

Desafortunadamente, el pedido de Python 2 para los tipos de int < list < stringsándwiches listentre los demás, requiere dos desigualdades para verificar. Por lo tanto, en cambio, l*0se verifica con la lista vacía [], de lo contrario se da 0o "".

Ruby, 43 42 34 bytes

Solución recursiva. ¡Ahora con manejo excepcional! (aunque también podría dar crédito a @akostadinov por inspirar el cambio)

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

IDEOne enlace

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>

Perl 6 , 24 bytes

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

Explicación:

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

Prueba:

#! /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 no tiene listas anidadas con diferentes profundidades de las sublistas ni tipos mixtos para los elementos de la lista. Para anidar, defino un tipo de datos personalizado Dque es una hoja Lque contiene algún elemento o un nodo Nque es una lista de Ds. Para los elementos mixtos, uso el tipo de datos predefinido Eitherque combina dos tipos en uno, aquí Either String Integer. El nuevo tipo Dy la función de aplanamiento fson totalmente polimórficos en el tipo de elementos de la hoja, por lo que no tengo que tener mucho cuidado con nada al respecto Either.

Ejemplo de uso: 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

Pruébelo en línea: Demostración o conjunto de pruebas

Pero, por supuesto, también hay una función integrada, que maneja la tarea en solo 2 bytes: .n( Test Suite )

JavaScript (Firefox 30-57), 43 bytes

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

Solo porque incluso podría evitar usarlo concat.

Perl, 34 29 bytes

Funciones

Si necesita aplanarse para enumerar como my @a = f(@a), 29 bytes:

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

Pruébalo en Ideone

Si necesita aplanarse para hacer referencia a la matriz my $a = f($a), 34 bytes:

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

Pruébalo en Ideone .

Perl 5.22.0+, 27 bytes

Gracias a hobbs .

Si necesita aplanarse para mostrar como my @a = f(@a), 27 bytes:

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

Pruébalo en JDoodle

Si necesita aplanarse a la referencia de matriz my $a = f($a), 32 bytes:

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

Pruébelo en JDoodle .

Julia, 29 bytes

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

Esto es salpicaduras recursivas en una función concatenada hasta llegar a un punto fijo. Ejemplo

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

Retina , 30 bytes

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

Pruébalo en línea!(La primera línea solo se usa para ejecutar múltiples casos de prueba a la vez).

Retina no tiene ningún concepto de matrices, literales de cadena o números, por lo que decidí ir con un formato de entrada "común" de [...,...]matrices de estilo y "cadenas delimitadas, donde \se puede usar dentro de las cadenas para escapar de cualquier carácter (en particular "y en \sí mismo).

El programa en sí mismo simplemente combina una cadena completa o un corchete, y los reemplaza con los $1que mantienen las cadenas y eliminan los corchetes. El límite 1>omite la primera coincidencia para que no eliminemos el inicio [. Sin embargo, esto elimina el final ], por lo que lo agregamos nuevamente en una etapa separada.

Pyke, 11 bytes

.F~]+=])K~]

Pruébalo aquí!

Explicación:

.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 bytes después de una corrección de errores.

M?+]K~]

Pruébalo aquí!

Explicación:

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

O incluso 2 bytes si está permitida la impresión en stdout (esto podría estar incluido en los elementos integrados)

M
<newline required>

Pruébalo aquí!

Esto aplica profundamente la print_newlinefunción a cada elemento que no sea de secuencia en la entrada y se repite para los elementos de secuencia.

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

Solo por lo completo y todo eso. :) No puedo decir que el código de Java sea eficiente.

Python, 57 bytes

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

Pruébelo en línea: Python 2 , Python 3

Gracias a Kevin Lau por el list==type(x)truco.

Rubí

hay incorporado flatten método .

Puedes correr aquí: http://www.tutorialspoint.com/execute_ruby_online.php

Uno de 43 bytes, pero pensó compartir:

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

Uno de 45 bytes que es más eficiente que el anterior y el otro rubí responde:

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

Aquí está el punto de referencia:

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

resultado:

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

Un trazador de líneas. Inspirado por Martin Büttner .

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

Pruébalo en Ideone .

Clojure, 68 bytes

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

mapcatprimero aplica la función a cada elemento y luego concatena los resultados. Entonces, cada vez que concatena se pierde un 'nivel de anidación'. Concat no funciona en secuencias no, por lo que los elementos deben envolverse en vectores si no son vectores.

Puedes probarlo aquí: 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(_);}

:-/, ¿alguna sugerencia? Por cierto, intenté encontrar una fuente en línea para compilar esto, pero el WL es estricto para este código. Funcionará para VS y gcc de lo contrario.

JavaScript 20 bytes

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

La matriz + matriz es igual a array.toString

C #, 48 bytes

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

Pensé que también lo publicaría ya que nadie ha dado una solución C # todavía. Sugerencias bienvenidas!

Raqueta, 63 bytes

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

Java 8 165 caracteres

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

Sin golfista en una clase:

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

Esta respuesta se basa en el enfoque de Jeremy Harton . Lo usé, lo cambié en algunos lugares y creé una versión más similar al golf.

JavaScript, 17 bytes

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

¡Finalmente, las conversiones de tipos de JavaScript se pueden usar bien! Tenga en cuenta que esto realmente generará una matriz, pero la conversión de cadenas (ponerla en HTML) hace que se convierta en una lista separada por comas.

Si las listas separadas por comas son resultados aceptables, entonces lo siguiente es válido:

7 bytes

a=>""+a

NOTA: el fragmento está roto por alguna razón

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

Adjunto , 14 bytes

{Reap[Sow@>_]}

Pruébalo en línea!

Afortunadamente, Attache tiene un operador de "vectorización", que aplica una función en los átomos de una lista. En este caso, todo lo que tenemos que hacer es configurar un segador con Reapy Sowtodos los átomos de la entrada _con @>. Creo que es bastante elegante.

Alternativas

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

Primera respuesta de Elixir, por lo que probablemente se pueda jugar un poco al golf.

Pruébalo en línea.

Explicación:

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

Por supuesto, si se permitieran las incorporaciones, esto podría haber sido 25 bytes en su lugar:

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

Pruébalo en línea.

Jalea , 4 bytes

;/ÐL

Pruébalo en línea!

Explicación

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

Incorporado Fsería un byte si está permitido.

Wolfram Language (Mathematica) , 13 bytes

#~Level~{-1}&

Pruébalo en línea!

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

selecciona los elementos de la estructura en el último nivel de su forma de árbol . No estoy seguro de que esto cuente como "evitar la construcción" (que sería Flatten).