Bu zorlu görevde, göreviniz iç içe geçmiş bir dizi alan ve tek boyutlu düzleştirilmiş bir dizi döndüren bir program oluşturmaktır. Örneğin [10,20,[30,[40]],50]çıktı vermeli [10,20,30,40,50].

Giriş iç içe geçmiş bir dizi olacaktır (örn. [10,20,[[[10]]]]). Yalnızca Tamsayılar (hem negatif hem de pozitif), Dizeler ve Diziler içerecektir. Girdiyi fonksiyon argümanı, STDIN veya dilinize uygun olanı olarak alabilirsiniz. Giriş dizisinin boş bir diziye sahip olmayacağını varsayabilirsiniz.

Çıktı

Çıktı, iç içe dizideki ve SAME sırasındaki ile aynı türde öğelere sahip düz boyutlu tek boyutlu bir dizi olacaktır.

Test Kılıfları

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

Yorumları kullanarak herhangi bir açıklama sormaktan çekinmeyin. Bu kod-golf , yani bayttaki en kısa kod kazanır!

Not: Eğer diliniz bunun için bir yerleşik içeriyorsa, kullanmamalısınız.

Lütfen ayrıca kodunuzun çalıştırılabileceği bir web sitesine bağlantı ekleyin.

K, 3 bayt

,//

Bu oldukça yaygın bir deyimdir. Msgstr "Yakınsamaya katıl".

burada OK ile deneyin .

Nasıl çalışır:

Join ( ,), bir liste oluşturmak için atomları veya listeleri bir araya getirir. Over ( /) bir fiili alır (bu durumda birleştirme) ve listenin her bir öğesi arasında soldan sağa uygular. Böylece, bileşik ,/listenin tüm üst düzey elemanlarını düzleştirir. Simge /aslında, birleştiği fiilin değerine (argüman sayısı) bağlı olarak farklı anlamlara gelir. ,/Fiil olarak verdiğimizde , final /"yakınsama" olarak hareket eder - ,/değişmeyi bırakana kadar girişe tekrar tekrar uygulanır . Diğer bazı diller buna "sabit nokta birleştirici" gibi bir özellik diyor. Alt seviye listelerini tekrar tekrar kaynaştırarak, sonunda tek bir düz listeye varacaksınız ve işlemlerin hiçbiri öğelerin sırasını bozmayacak. Bu sorunu çözmek gibi görünüyor.

JavaScript (ES6), 35 bayt

Esinlenerek user81655 cevabı @ :

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

Mathematica, 16 14 bayt

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

Bir liste alıp veren isimsiz bir işlev, örneğin:

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

açıklama

Sözdizimsel şeker partisi!

Anlamak için nasıl bu eserler, not Mathematica her ifade bir atom ya olduğu (örneğin sayılar, dizeleri, semboller) ya da formun bir bileşik ifadesi f[a, b, c, ...], f, a, b, ckeyfi ifadeler kendilerini bulunmaktadır. Burada ifadenin başıf denir . Bunun üzerine her şey sadece sözdizimsel şeker. Örneğin sadece .{a, b, c}List[a, b, c]

//@Hangi haritaların bir listenin tüm seviyelerinde işlediğiyle başlıyoruz . Örneğin:

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

Bunun f, bileşik ifadelerin yanı sıra atomlar üzerinde haritalandığına dikkat edin . Şu an aradığımız şey liste başlıklarından kurtulmanın ve her şeyi saklamanın bir yolu.

ApplyFonksiyonu normal olarak bir işleve ayrı bağımsız değişken olarak bir listesinin elemanları beslemek için kullanılır, ancak gerçek tanımı daha geneldir ve basit bir ifade baş yerine geçer. Örneğin Apply[g, f[a, b]]verir g[a, b].

Şimdi Sequenceise basitçe yok olan özel bir "kafa" var . Örneğin, {a, Sequence[b, c], d}sadece değerlendirir {a, b, c, d}. Listeyi düzleştirme fikri, tüm iç listelerin başlıklarını Sequenceçevreleyen listelerine sıçramaları için değiştirmektir . Yani istediğimiz şey listelerin Applybaşına Sequencegeçmek. Eğer Applybir atom için bir şey yaparsak , atomu değiştirmeden bırakır, bu yüzden ifade türlerini birbirinden ayırmak zorunda değiliz.

Son olarak, küçük bir sorun var: fen dış seviyeye de uygulandı, böylece Listbizim de istemediğimiz en uç noktayı da çıkardı . Buna karşı koymanın en kısa yolu, sonucu tekrar bir listeye sarmaktır, böylece çevre Sequencegüvenli bir şekilde ortadan kalkar.

Ne Applyde ne Sequencekodda olduğunu unutmayın. @@operatörün şeklidir Applyve ##&uzun dahili adı kısaltmak için standart bir golf oyunudur Sequence. Yani her şeyi biraz ungolfing, şöyle bir şey olsun:

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

##&İşlerin nasıl ve neden yapıldığı hakkında daha fazla bilgi için, Mathematica ipuçlarına cevabımdaki "Argüman dizileri" bölümüne bakın .

Python 2, 43 bayt

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

Bir listede, unsurları yeniden alır ve sonuçları birleştirir. Bir dize veya numarada, tekil bir listenin içine girer.

Ne yazık ki, Python 2'nin diğerleri arasındaki int < list < stringsandviçleri sipariş listetmesi, iki eşitsizliği kontrol etmeyi gerektiriyordu. Yani, bunun yerine l*0boş listeye göre kontrol edilir [], aksi halde 0veya verilir "".

Ruby, 43 42 34 bayt

Özyinelemeli çözüm. Şimdi istisna işleme! (Değişime ilham vermek için @akostadinov kredilerini de verebilir)

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

IDEOne bağlantısı

JavaScript (ES6), 41 bayt

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 bayt

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

Açıklama:

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

Ölçek:

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

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

Haskell'de alt listelerin farklı derinliklerine sahip iç içe geçmiş listeler veya liste öğeleri için karışık türler yoktur. Yuvalama için, bazı öğelerin bulunduğu Dbir yaprak Lolan veya bir s Nlistesi olan bir düğüm olan özel bir veri türü tanımlarım D. Karışık elemanlar için Eitherburada iki türü bir araya getiren önceden tanımlanmış veri tipini kullanıyorum Either String Integer. Yeni tip Dve düzleştirme işlevi f, yaprak elemanlarının tipinde tamamen polimorfiktir, bu nedenle ilgili hiçbir şeye daha fazla dikkat etmem gerekmez Either.

Kullanım örneği: 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 bayt

us+]Y

Çevrimiçi deneyin: Gösteri veya Test Paketi

Ancak elbette, görevi yalnızca 2 baytta halleden bir yerleşik işlevi de var: .n( Test Suite )

JavaScript (Firefox 30-57), 43 bayt

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

Sırf kullanmaktan kaçınabildiğim için concat.

Perl, 34 29 bayt

Fonksiyonlar.

my @a = f(@a)29 bayt gibi bir listenin düzleştirilmesi gerekiyorsa :

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

İdeone üzerinde test et

Ref gibi bir dizi düzleştirmek gerekirse my $a = f($a), 34 bayt:

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

İdeone üzerinde test et .

Perl 5.22.0+, 27 bayt

Hobbs için teşekkürler .

my @a = f(@a)27 bayt gibi bir listenin düzleştirilmesi gerekiyorsa :

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

JDoodle'ta test et

Ref gibi bir dizi düzleştirmek gerekirse my $a = f($a), 32 bayt:

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

JDoodle'ta test et .

Julia, 29 bayt

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

Bu, bir sabitleme noktasına ulaşana kadar bir birleştirme işlevinde özyinelemelidir. Örnek

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

Retina , 30 bayt

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

Çevrimiçi deneyin! (İlk satır yalnızca bir kerede birden fazla test senaryosunu çalıştırmak için kullanılır.)

Ben bir "ortak" Giriş formatı ile gitmeye karar Retina, diziler, dize hazır veya sayı kavramı yok [...,...]tarzı diziler ve "-delimited dizeleri, \(özellikle herhangi bir karakter kaçmak için dizge içinde kullanılabilir "ve \kendisi).

Programın kendisi sadece tam bir dize veya köşeli ayraçla eşleşir ve bunları $1dizeleri tutan ve köşeli ayraçları kaldıranlarla değiştirir. Sınır 1>, ilk eşleşmeyi atlar; böylece baştaki çizgiyi kaldırmayız [. Bununla birlikte, bu izlemeyi kaldırır ], bu yüzden ayrı bir aşamada ekleriz.

Pyke, 11 bayt

.F~]+=])K~]

Burada dene!

Açıklama:

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

Veya bir hatadan sonra 7 bayt

M?+]K~]

Burada dene!

Açıklama:

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

Stdout'a yazdırmaya izin verilirse hatta 2 bayt bile (Bu, yerleşiklerin altına girebilir)

M
<newline required>

Burada dene!

Bu, print_newlineişlevi girişteki her bir sıra dışı öğeye derinden uygular ve sıra öğeleri için özyinelemeler yapar.

Java (v8) 390 276 bayt

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

Sadece bütünlük ve hepsi için. :) Java'nın kod verimli olduğunu söyleyemem.

Python, 57 bayt

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

Çevrimiçi deneyin: Python 2 , Python 3

Numara için Kevin Lau'ya teşekkürler list==type(x).

Yakut

yerleşik bir flattenyöntem var.

Burada çalıştırabilirsiniz: http://www.tutorialspoint.com/execute_ruby_online.php

Bir 43 bayt, ancak paylaşmak için düşünülmüş:

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

Bir önceki ve diğer yakut cevabından daha verimli olan bir 45 bayt:

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

İşte kıyaslama:

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

sonuç:

       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 ( -pbayrak) 35 bayt

Oneliner. Martin Büttner'den ilham aldı .

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

İdeone üzerinde test et .

Clojure, 68 bayt

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

mapcatönce her bir öğeye işlev uygular, ardından sonuçları birleştirir. Bu yüzden her gizlendiğinde bir 'yuvalama seviyesini' kaybediyor. Concat diziler üzerinde çalışmaz, bu yüzden elementler vektör değillerse vektöre sarılmalıdır.

Burada deneyebilirsiniz: http://www.tryclj.com

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

ANSI C, 193 bayt

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

:-/, baska öneri? BTW, bunu derlemek için çevrimiçi bir kaynak bulmaya çalıştım ama WL bu kodun derlenmesi için çok katı. Aksi halde VS ve gcc için çalışacaktır.

JavaScript 20 bayt

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

Array + array array.toString'e eşittir

C #, 48 bayt

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

Henüz kimsenin C # çözümü vermediğinden de göndereceğimi düşündüm. Önerilerinizi bekliyoruz!

Raket, 63 bayt

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

Java 8 165 karakter

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

Bir sınıfa ungolfed:

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

Bu cevap Jeremy Harton'un yaklaşımına dayanıyor . Bazı yerlerde değiştirdim ve daha golf benzeri bir sürüm oluşturdum.

JavaScript, 17 Bayt

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

Son olarak, JavaScript'in tür dönüşümleri iyi bir kullanıma sokulabilir! Lütfen bunun bir dizi çıktısı alacağını unutmayın, ancak dize dönüşümü (HTML'ye koyarak) virgülle ayrılmış bir liste olmasına neden olur.

Virgülle ayrılmış listeler kabul edilebilir çıktıysa, aşağıdakiler geçerlidir:

7 Bayt

a=>""+a

NOT: Snippet bazı nedenlerden dolayı bozuldu

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 Bayt

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

Ataşesi , 14 bayt

{Reap[Sow@>_]}

Çevrimiçi deneyin!

Neyse ki, Attache bir listenin atomlarında bir fonksiyon uygulayan bir "vektörleştirme" işlecine sahiptir. Bu durumda, yapılacak tüm biz ihtiyacı olan bir orak kurmaktır Reapve Sowgirilecek tüm atomları _ile @>. Bence oldukça şık.

Alternatifler

15 bayt: Fixpoint{`'^^_}

16 bayt: Fixpoint!&Concat

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

17 bayt: Fixpoint[&Concat]

İksir , 74 bayt

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

İlk İksir cevabı, bu yüzden muhtemelen biraz golf olabilir.

Çevrimiçi deneyin.

Açıklama:

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

Elbette eğer yerleşiklere izin verilirse, bunun yerine 25 bayt olabilir :

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

Çevrimiçi deneyin.

Jöle , 4 bayt

;/ÐL

Çevrimiçi deneyin!

açıklama

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

Yerleşik Fizin verilirse bir bayt olur.

Wolfram Dili (Mathematica) , 13 bayt

#~Level~{-1}&

Çevrimiçi deneyin!

Un-golfed: F[x_] := Level[x, {-1}]

Yapının elemanlarını, ağaç formunun son seviyesinde ortaya çıkarır . Bunun "yerleşiklerden kaçınmak" olarak sayıldığından emin değilim (ki bu olurdu Flatten).