Dans ce défi, votre tâche consiste à créer un programme qui intègre un tableau imbriqué et retourne un tableau aplati à une dimension. Par exemple [10,20,[30,[40]],50]devrait sortir [10,20,30,40,50].

L'entrée sera un tableau imbriqué (par exemple [10,20,[[[10]]]]). Il ne contiendra que des entiers (à la fois négatifs et positifs), des chaînes et des tableaux. Vous pouvez prendre l’entrée comme argument de fonction, STDIN ou celle qui convient à votre langue. Vous pouvez supposer que le tableau d'entrée n'aura pas de tableau vide.

Sortie

La sortie sera un tableau unidimensionnel à plat comportant les mêmes éléments du même type que dans le tableau imbriqué et dans l'ordre SAME.

Cas de test

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

N'hésitez pas à demander des éclaircissements en utilisant les commentaires. C'est du code-golf , donc le code le plus court en octets gagne!

Remarque: Si votre langue contient une fonction intégrée pour cela, vous ne devez PAS l'utiliser.

Veuillez également inclure un lien vers un site Web sur lequel votre code peut être exécuté.

K, 3 octets

,//

C'est un idiome assez commun. "Joindre sur converger".

essayez-le ici avec oK .

Comment ça marche:

Join ( ,) fusionne des atomes ou des listes pour produire une liste. Over ( /) prend un verbe (dans ce cas join) et l'applique entre chaque élément d'une liste, de gauche à droite. Ainsi, le composé ,/aplatira tous les éléments de niveau supérieur de la liste. Le symbole a en /réalité différentes significations selon la valence (nombre d'arguments) du verbe avec lequel il est composé. Lorsque nous fournissons ,/un verbe, la dernière /agit comme un "convergent" - elle s'applique de manière répétée ,/à l'entrée jusqu'à ce qu'elle cesse de changer. Certaines autres langues appellent une fonctionnalité comme celle-ci un "combinateur à point fixe". En fusionnant de manière répétée les listes de niveau inférieur, vous obtiendrez éventuellement une liste simple et aucune des opérations ne perturbera l'ordre des éléments. Cela semble résoudre le problème.

JavaScript (ES6), 35 octets

Inspiré par la réponse de @ user81655 :

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

Mathematica, 16 à 14 octets

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

Une fonction non nommée qui prend et retourne une liste, par exemple:

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

Explication

Fête du sucre syntaxique!

Pour comprendre comment cela fonctionne, notez que chaque expression dans Mathematica est soit un atome (par exemple , des nombres, des chaînes, des symboles) ou une expression composé de la forme f[a, b, c, ...], où f, a, b, csont eux - mêmes expressions arbitraires. Ici, fon appelle la tête de l'expression. Tout le reste est juste du sucre syntaxique. Par exemple, {a, b, c}c'est juste List[a, b, c].

Nous commençons avec //@quelles cartes a fonctionne sur tous les niveaux d'une liste. Par exemple:

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

Notez que cela mappe fles atomes ainsi que les expressions composées. Ce que nous recherchons maintenant, c'est un moyen de supprimer les en-têtes de liste et de tout conserver.

La Applyfonction est normalement utilisée pour alimenter les éléments d'une liste sous forme d'arguments distincts, mais sa définition est plus générale et remplace simplement la tête d'une expression. Par exemple Apply[g, f[a, b]]donne g[a, b].

Maintenant, il y a une "tête" spéciale appelée Sequencequi disparaît tout simplement. Par exemple, {a, Sequence[b, c], d}évalue à {a, b, c, d}. L'idée de mettre à plat la liste est de remplacer les têtes de toutes les listes intérieures par des Sequencenoms afin qu'elles soient superposées. Donc, ce que nous voulons, c'est en Applytête Sequencedes listes. De manière pratique, si nous Applylions quelque chose à un atome, l’atome reste inchangé, nous n’avons donc pas à distinguer entre les types d’expressions.

Enfin, il y a un petit problème: fest également appliqué au niveau le plus externe, de sorte qu'il supprime également le niveau le plus externe List, ce que nous ne voulons pas. Le moyen le plus rapide de contrer ce problème consiste simplement à envelopper le résultat dans une nouvelle liste, de sorte que les environs Sequencepuissent disparaître en toute sécurité.

Notez qu'il n'y a ni Applyni Sequencedans le code. @@est une forme d'opérateur de Applyet ##&est une astuce de golf standard pour raccourcir le long nom intégré Sequence. Donc, ungolfant tout un peu, nous obtenons quelque chose comme:

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

Pour plus de détails sur les méthodes et les raisons ##&, consultez la section "Séquence d'arguments" de ma réponse pour connaître les astuces de Mathematica .

Python 2, 43 octets

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

Sur une liste, rechute sur les éléments et concatène les résultats. Sur une chaîne ou un nombre, encapsule dans une liste de singleton.

Malheureusement, Python 2 commande pour les types int < list < stringsandwichs listentre les autres, ce qui nécessite deux inégalités à vérifier. Donc, au lieu de cela, l*0est vérifié par rapport à la liste vide [], sinon donner 0ou "".

Ruby, 43 42 34 octets

Solution récursive Maintenant, avec une gestion d'exception! (On peut aussi remercier @akostadinov pour avoir inspiré le changement)

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

Lien IDEOne

JavaScript (ES6), 41 octets

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 octets

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

Explication:

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

Tester:

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

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

Haskell n'a ni listes imbriquées avec des profondeurs différentes des sous-listes ni types mixtes pour les éléments de liste. Pour imbriquer je définis un type de données personnalisé Dqui est soit une feuille Lqui contient un élément, soit un nœud Nqui est une liste de Ds. Pour les éléments mixtes, j'utilise le type de données prédéfini Eitherqui combine deux types en un, ici Either String Integer. Le nouveau type Det la fonction aplatir fsont totalement polymorphes dans le type des éléments leaf, je ne dois donc pas faire très attention à rien Either.

Exemple d'utilisation: 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 octets

us+]Y

Essayez-le en ligne: démonstration ou suite de tests

Mais bien sûr, il existe également une fonction intégrée, qui gère la tâche en seulement 2 octets: .n( Suite de tests )

JavaScript (Firefox 30-57), 43 octets

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

Juste parce que je pouvais même éviter d'utiliser concat.

Perl, 34 29 octets

Les fonctions.

Si besoin est d'aplatir my @a = f(@a), 29 octets:

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

Testez-le sur Ideone

Si besoin d'être mis à plat pour un tableau comme my $a = f($a)34 octets:

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

Testez-le sur Ideone .

Perl 5.22.0+, 27 octets

Merci à Hobbs .

Si besoin d'aplatir pour lister comme my @a = f(@a), 27 octets:

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

Testez-le sur JDoodle

Si besoin est d'aplatir pour avoir un tableau de type my $a = f($a)32 octets:

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

Testez-le sur JDoodle .

Julia, 29 octets

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

Il s'agit d'une éclaboussure récursive dans une fonction de concaténation jusqu'à atteindre un point fixe. Exemple

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

Rétine , 30 octets

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

Essayez-le en ligne! (La première ligne est uniquement utilisée pour exécuter plusieurs tests en même temps.)

Retina n'a aucun concept de tableaux, de littéraux de chaîne ou de nombres, j'ai donc décidé de choisir un format d'entrée «commun» [...,...], "composé de tableaux de styles et de chaînes délimitées, qui \peut être utilisé à l'intérieur des chaînes pour échapper à tout caractère (en particulier "et \lui - même).

Le programme lui-même correspond simplement à une chaîne complète ou à un crochet, et les remplace par $1ce qui garde les chaînes et supprime les crochets. La limite 1>saute le premier match pour ne pas enlever le premier [. Cependant, cela supprime la fin ], nous la rajoutons dans une étape séparée.

Pyke, 11 octets

.F~]+=])K~]

Essayez-le ici!

Explication:

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

Ou 7 octets après un correctif

M?+]K~]

Essayez-le ici!

Explication:

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

Ou même 2 octets si l’impression sur la sortie standard est autorisée (cela peut entrer dans les fonctions intégrées)

M
<newline required>

Essayez-le ici!

Cela applique profondément la print_newlinefonction à chaque élément non séquentiel de l'entrée et se répète pour les éléments séquentiels.

Java (v8) 390 276 octets

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

Juste pour être complet et tout ça. :) Je ne peux pas dire que le code est efficace en Java.

Python, 57 octets

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

Essayez-le en ligne: Python 2 , Python 3

Merci à Kevin Lau pour le list==type(x)tour.

Rubis

il y a flattenméthode intégrée .

Vous pouvez exécuter ici: http://www.tutorialspoint.com/execute_ruby_online.php

Un 43 octets, mais pensé pour partager:

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

Un 45 octets plus efficace que le précédent et l'autre ruby ​​répondent:

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

voici le repère:

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

résultat:

       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 ( -pdrapeau) 35 octets

Bon mot. Inspiré par Martin Büttner .

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

Testez-le sur Ideone .

Clojure, 68 octets

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

mapcatapplique d’abord une fonction à chaque élément puis concatole les résultats. Ainsi, chaque fois qu’il indique un niveau de nidification, il est perdu. La concatte ne fonctionne pas sur les séquences, donc les éléments doivent être intégrés au vecteur s'ils ne sont pas vectoriels.

Vous pouvez l'essayer ici: http://www.tryclj.com

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

ANSI C, 193 octets

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

:-/, Aucune suggestion? Au fait, j'ai essayé de trouver une source en ligne pour compiler cela, mais le WL est strict pour que ce code soit compilé. Sinon, cela fonctionnera pour VS et gcc.

JavaScript 20 octets

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

Le tableau + tableau est égal à tableau.toString

C #, 48 octets

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

Je pensais le poster aussi puisque personne n’a encore donné de solution C #. Suggestions bienvenues!

Raquette, 63 octets

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

Java 8 165 caractères

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

Cette réponse est basée sur l'approche de Jeremy Harton . Je l'ai utilisé a changé à certains endroits et créé une version plus semblable au golf.

JavaScript, 17 octets

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

Enfin, les conversions de types JavaScript peuvent être utilisées à bon escient! Veuillez noter que ceci produira en réalité un tableau, mais la conversion de chaîne (le placer dans HTML) le transformera en une liste séparée par des virgules.

Si les listes séparées par des virgules sont acceptables, les éléments suivants sont valides:

7 octets

a=>""+a

REMARQUE: l'extrait est cassé pour une raison quelconque

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 octets

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

Attaché , 14 octets

{Reap[Sow@>_]}

Essayez-le en ligne!

Heureusement, Attache a un opérateur de "vectorisation", qui applique une fonction aux atomes d'une liste. Dans ce cas, il suffit de configurer une faucheuse avec Reapet Sowtous les atomes de l’entrée _avec @>. Je pense que c'est assez élégant.

Des alternatives

15 octets: Fixpoint{`'^^_}

16 octets: Fixpoint!&Concat

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

17 octets: Fixpoint[&Concat]

Elixir , 74 octets

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

Première réponse de Elixir, peut donc probablement être joué un peu au golf.

Essayez-le en ligne.

Explication:

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

Bien sûr, si les modifications étaient autorisées, cela aurait pu être 25 octets à la place:

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

Essayez-le en ligne.

Gelée , 4 octets

;/ÐL

Essayez-le en ligne!

Explication

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

Intégré Fserait un octet si autorisé.

Wolfram Language (Mathematica) , 13 octets

#~Level~{-1}&

Essayez-le en ligne!

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

sélectionne les éléments de la structure au dernier niveau de son arborescence . Je ne suis pas sûr que cela compte comme "en évitant le construit" (ce qui serait Flatten).