ในความท้าทายนี้งานของคุณคือการสร้างโปรแกรมที่ใช้ในอาร์เรย์ซ้อนกันและส่งกลับอาร์เรย์แบบแบนมิติเดียว ตัวอย่างเช่นการส่งออกควร [10,20,[30,[40]],50][10,20,30,40,50]

อินพุตจะเป็นอาร์เรย์ซ้อนกัน (เช่น[10,20,[[[10]]]]) มันจะมีจำนวนเต็มเท่านั้น (ทั้งลบและบวก) สตริงและอาร์เรย์ คุณสามารถรับอินพุตเป็นอาร์กิวเมนต์ฟังก์ชัน STDIN หรืออะไรก็ได้ที่เหมาะกับภาษาของคุณ คุณสามารถสันนิษฐานได้ว่าอาร์เรย์อินพุตจะไม่มีอาร์เรย์ว่างเปล่า

เอาท์พุต

เอาต์พุตจะเป็นอาเรย์แบบมิติเดียวที่มีองค์ประกอบเดียวกับชนิดเดียวกันในอาร์เรย์ที่ซ้อนกันและในลำดับเดียวกัน

กรณีทดสอบ

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

รู้สึกฟรีเพื่อขอคำชี้แจงใด ๆ โดยใช้ความคิดเห็น นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดในหน่วยไบต์ชนะ!

หมายเหตุ: หากภาษาของคุณมีอยู่ในตัวสำหรับสิ่งนี้คุณจะต้องไม่ใช้มัน

โปรดระบุลิงก์ไปยังเว็บไซต์ที่สามารถใช้รหัสของคุณได้

K, 3 ไบต์

,//

นี่เป็นสำนวนที่ค่อนข้างธรรมดา "เข้าร่วมบรรจบกัน"

ลองนี่ตกลง

มันทำงานอย่างไร:

เข้าร่วมกับ ( ,) ฟิวส์อะตอมกันหรือรายการในการผลิตรายการ เกิน ( /) ใช้กริยา (ในกรณีนี้เข้าร่วม) และใช้มันระหว่างองค์ประกอบของรายการแต่ละรายการจากซ้ายไปขวา ดังนั้นสารประกอบ,/จะแบนองค์ประกอบระดับบนสุดของรายการทั้งหมด สัญลักษณ์/มีความหมายต่างกันจริงขึ้นอยู่กับวาเลนซ์ (จำนวนอาร์กิวเมนต์) ของคำกริยาที่ประกอบกัน เมื่อเราให้,/เป็นคำกริยาสุดท้าย/ทำหน้าที่เป็น "มาบรรจบ" - มันนำ,/ไปใช้ซ้ำกับอินพุตจนกว่ามันจะหยุดการเปลี่ยนแปลง ภาษาอื่นบางภาษาเรียกคุณสมบัติเช่นนี้ว่า "combinator จุดคงที่" ด้วยการหลอมรวมรายการระดับล่างซ้ำแล้วซ้ำอีกในที่สุดคุณจะมาถึงรายการแบนเดียวและไม่มีการดำเนินการใดที่จะรบกวนลำดับขององค์ประกอบ ดูเหมือนว่าจะแก้ปัญหาได้

JavaScript (ES6), 35 ไบต์

แรงบันดาลใจจากคำตอบของ @ user81655 :

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

Mathematica, 16 14 ไบต์

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

ฟังก์ชั่นที่ไม่มีชื่อซึ่งใช้และส่งกลับรายการเช่น:

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

คำอธิบาย

ปาร์ตี้น้ำตาลซินแทคติก!

เพื่อให้เข้าใจถึงวิธีการทำงานนี้ทราบว่าการแสดงออกในทุกมาติกาเป็นทั้งอะตอม (เช่นตัวเลข, สตริง, สัญลักษณ์) หรือการแสดงออกของสารประกอบของแบบฟอร์มf[a, b, c, ...]ที่f, a, b, cตัวเองโดยพลการแสดงออก ที่นี่fเรียกว่าส่วนหัวของการแสดงออก ทุกอย่างอื่นนอกเหนือจากนั้นเป็นเพียงน้ำตาลประโยค เช่นเป็นเพียง{a, b, c}List[a, b, c]

เราเริ่มต้นด้วยการ//@แมปฟังก์ชั่นในทุกระดับของรายการ ตัวอย่างเช่น

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

โปรดทราบว่าสิ่งนี้จะแม็พfกับอะตอมรวมถึงนิพจน์เชิงประกอบ สิ่งที่เรากำลังมองหาคือวิธีกำจัดหัวรายการและเก็บทุกอย่างไว้

โดยApplyปกติแล้วฟังก์ชันนี้ใช้เพื่อป้อนองค์ประกอบของรายการเป็นอาร์กิวเมนต์ที่แยกกันไปยังฟังก์ชัน แต่นิยามที่แท้จริงของมันนั้นกว้างกว่าและแทนที่หัวของนิพจน์ เช่นให้Apply[g, f[a, b]]g[a, b]

ตอนนี้มี "หัว" พิเศษที่เรียกSequenceว่าหายไป เช่นเพียงแค่ประเมิน{a, Sequence[b, c], d} {a, b, c, d}แนวคิดสำหรับการทำให้รายการแบนคือการแทนที่ส่วนหัวของรายการภายในทั้งหมดSequenceเพื่อให้ได้รับการแบ่งเป็นรายการโดยรอบ ดังนั้นสิ่งที่เราต้องการคือApplyมุ่งหน้าSequenceไปยังรายการ สะดวกถ้าเรามีApplyอะไรบางอย่างกับอะตอมมันแค่ปล่อยให้อะตอมไม่เปลี่ยนแปลงดังนั้นเราจึงไม่ต้องแยกแยะระหว่างประเภทของนิพจน์เลย

ในที่สุดก็มีปัญหาเล็ก ๆ น้อยหนึ่ง: fถูกนำไปใช้กับระดับนอกสุดเพื่อที่จะกำจัดสิ่งนอกสุดListที่เราไม่ต้องการ วิธีที่สั้นที่สุดในการตอบโต้คือเพียงห่อผลในรายการอีกครั้งเช่นว่าสภาพแวดล้อมโดยรอบSequenceจะหายไปได้อย่างปลอดภัย

โปรดทราบว่าไม่มีApplyหรือไม่มีSequenceในรหัส @@เป็นรูปแบบที่ผู้ประกอบการApplyและเป็นเคล็ดลับการเล่นกอล์ฟมาตรฐานที่จะลดลงในตัวชื่อยาว##& Sequenceดังนั้นทุกอย่างที่ไม่น่ารังเกียจเราได้รับ:

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

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับวิธีการและเหตุผลที่##&ผลงานให้ดูส่วนที่เกี่ยวกับ "ลำดับของการขัดแย้ง" ในคำตอบของฉันสำหรับเคล็ดลับ Mathematica

Python 2, 43 ไบต์

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

ในรายการให้เรียกองค์ประกอบซ้ำและเชื่อมผลลัพธ์เข้าด้วยกัน บนสตริงหรือตัวเลขให้เข้ารหัสในรายการซิงเกิล

น่าเสียดายที่ Python 2 สั่งให้ทำint < list < stringแซนด์วิชประเภทต่างๆlistระหว่างกันทำให้ต้องตรวจสอบความไม่เท่าเทียมกันสองอย่าง ดังนั้นแทนที่จะl*0ถูกตรวจสอบกับรายการที่ว่างเปล่า[]มิฉะนั้นให้หรือ0""

Ruby, 43 42 34 ไบต์

โซลูชันแบบเรียกซ้ำ ขณะนี้มีข้อยกเว้นการจัดการ! (อาจเป็นเครดิต @akostadinov สำหรับสร้างแรงบันดาลใจให้กับการเปลี่ยนแปลง)

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

ลิงก์ IDEOne

JavaScript (ES6), 41 ไบต์

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 ไบต์

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

คำอธิบาย:

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

ทดสอบ:

#! /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 ไบต์

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

Haskell ไม่มีรายการซ้อนกันที่มีความลึกแตกต่างกันของรายการย่อยหรือประเภทผสมสำหรับองค์ประกอบรายการ สำหรับการซ้อนฉันกำหนดชนิดข้อมูลที่กำหนดเองDซึ่งเป็นใบไม้Lที่มีองค์ประกอบบางอย่างหรือโหนดNซึ่งเป็นรายการของDs สำหรับองค์ประกอบที่ผสมผมใช้ชนิดข้อมูลที่กำหนดไว้ล่วงหน้าซึ่งรวมสองประเภทไว้ในที่เดียวที่นี่Either Either String Integerรูปแบบใหม่Dและฟังก์ชั่นการแบนfนั้นมีความหลากหลายในรูปแบบขององค์ประกอบของใบไม้ดังนั้นฉันจึงไม่จำเป็นต้องดูแลอะไรเป็นEitherพิเศษ

ตัวอย่างการใช้งาน: ->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 ไบต์

us+]Y

ลองใช้ออนไลน์: การสาธิตหรือชุดทดสอบ

แต่แน่นอนว่ายังมีฟังก์ชั่น build-in ที่จัดการงานด้วย 2 ไบต์: .n( Test Suite )

JavaScript (Firefox 30-57), 43 ไบต์

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

concatเพียงเพราะฉันยังสามารถหลีกเลี่ยงการใช้

Perl, 34 29 ไบต์

ฟังก์ชั่น.

หากต้องการให้แบนเหมือนรายการmy @a = f(@a)29 ไบต์:

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

ทดสอบบน Ideone

หากต้องการให้แบนเหมือนอาเรย์อ้างอิงเช่นmy $a = f($a)34 ไบต์:

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

ทดสอบบน Ideone

Perl 5.22.0+, 27 ไบต์

ขอขอบคุณที่ฮอบส์

หากต้องการย่อให้อยู่ในรายการเช่นmy @a = f(@a)27 ไบต์:

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

ทดสอบบน JDoodle

ถ้าต้องการให้แบนเหมือน array อ้างอิงmy $a = f($a)32 ไบต์:

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

ทดสอบบน JDoodle

Julia, 29 ไบต์

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

นี่คือการกระจายซ้ำในฟังก์ชันเชื่อมต่อจนกว่าจะถึงจุดแก้ไข ตัวอย่าง

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

เรติน่า 30 ไบต์

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

ลองออนไลน์! (บรรทัดแรกใช้เพื่อเรียกใช้หลายกรณีทดสอบพร้อมกัน)

Retina ไม่มีแนวคิดเกี่ยวกับอาร์เรย์ตัวอักษรสตริงหรือตัวเลขดังนั้นฉันจึงตัดสินใจที่จะใช้รูปแบบอินพุต "ทั่วไป" ของ[...,...]อาร์เรย์สไตล์และ"สตริงที่ จำกัด ซึ่ง\สามารถใช้ภายในสตริงเพื่อหลีกเลี่ยงอักขระใด ๆ (โดยเฉพาะ"และ\ตัวมันเอง)

ตัวโปรแกรมนั้นตรงกับสตริงเต็มหรือวงเล็บเหลี่ยมและแทนที่มันด้วย$1ซึ่งเก็บสตริงและลบวงเล็บเหลี่ยม ขีด จำกัด การข้ามนัดแรกเพื่อที่เราจะไม่เอาชั้นนำ1> [อย่างไรก็ตามนี่จะเป็นการลบส่วนท้าย]ดังนั้นเราจึงเพิ่มกลับเข้าไปในสเตจแยกต่างหาก

Pyke 11 ไบต์

.F~]+=])K~]

ลองที่นี่!

คำอธิบาย:

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

หรือ 7 ไบต์หลังจากแก้ไขข้อผิดพลาด

M?+]K~]

ลองที่นี่!

คำอธิบาย:

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

หรือแม้กระทั่ง 2 ไบต์หากอนุญาตให้พิมพ์ไปยัง stdout (สิ่งนี้อาจมาพร้อมกับบิวด์อิน)

M
<newline required>

ลองที่นี่!

สิ่งนี้จะใช้print_newlineฟังก์ชั่นอย่างลึกซึ้งกับทุกรายการที่ไม่มีลำดับในอินพุตและเรียกซ้ำสำหรับรายการลำดับ

Java (v8) 390 276 ไบต์

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

เพียงเพื่อความสมบูรณ์และทุกสิ่งที่ :) ไม่สามารถพูดรหัสประสิทธิภาพของ Java

Python ขนาด 57 ไบต์

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

ลองใช้งานออนไลน์: Python 2 , Python 3

ขอบคุณ Kevin Lau สำหรับlist==type(x)เคล็ดลับ

ทับทิม

มีflattenวิธีการในตัว

คุณสามารถเรียกใช้ที่นี่: http://www.tutorialspoint.com/execute_ruby_online.php

43 ไบต์เดียว แต่คิดว่าจะแชร์:

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

45 ไบต์หนึ่งไบต์ที่มีประสิทธิภาพมากกว่าคำตอบทับทิมก่อนหน้าและคำตอบอื่น ๆ :

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

มาตรฐานที่นี่:

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

ผล:

       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ตั้งค่าสถานะ) 35 ไบต์

หนึ่งในสายการบิน. แรงบันดาลใจจากมาร์ตินBüttner

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

ทดสอบบน Ideone

Clojure, 68 ไบต์

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

mapcatก่อนใช้ฟังก์ชั่นกับแต่ละองค์ประกอบแล้ว concats ผลลัพธ์ ดังนั้นทุกครั้งที่มีการทำระดับ 'ซ้อน' จะหายไป Concat ไม่ทำงานบนลำดับไม่ดังนั้นองค์ประกอบจะต้องถูกห่อเป็นเวกเตอร์หากพวกเขาไม่ใช่เวกเตอร์

คุณสามารถลองได้ที่นี่: http://www.tryclj.com

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

ANSI C, 193 ไบต์

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

: - / ข้อเสนอแนะใด ๆ แต่ฉันพยายามค้นหาแหล่งข้อมูลออนไลน์เพื่อรวบรวมสิ่งนี้ แต่ WL นั้นเข้มงวดสำหรับการรวบรวมรหัสนี้ มันจะทำงานกับ VS และ gcc เป็นอย่างอื่น

JavaScript 20 ไบต์

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

อาร์เรย์ + อาร์เรย์เท่ากับ array.toString

C #, 48 ไบต์

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

คิดว่าฉันจะโพสต์มันเพราะยังไม่มีใครให้วิธีแก้ปัญหา C # ยินดีต้อนรับข้อเสนอแนะ!

แร็กเก็ต, 63 ไบต์

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

Java 8 165 ตัวอักษร

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 ในชั้นเรียน:

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

คำตอบนี้จะขึ้นอยู่กับวิธีการที่เจเรมี Harton ของ ฉันใช้มันเปลี่ยนไปในบางสถานที่และสร้างเวอร์ชันที่เหมือนกอล์ฟมากขึ้น

จาวาสคริปต์, 17 ไบต์

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

ในที่สุดการแปลงประเภทของ JavaScript สามารถนำไปใช้ประโยชน์ได้บ้าง! โปรดทราบว่าสิ่งนี้จะส่งออกอาร์เรย์จริงๆ แต่การแปลงสตริง (วางลงใน HTML) ทำให้มันกลายเป็นรายการที่คั่นด้วยเครื่องหมายจุลภาค

หากรายการที่คั่นด้วยเครื่องหมายจุลภาคเป็นเอาต์พุตที่ยอมรับได้ดังนั้นสิ่งต่อไปนี้ที่ถูกต้อง:

7 ไบต์

a=>""+a

หมายเหตุ: ตัวอย่างข้อมูลใช้งานไม่ได้ด้วยเหตุผลบางประการ

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 ไบต์

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

ทูตขนาด 14 ไบต์

{Reap[Sow@>_]}

ลองออนไลน์!

โชคดีที่ Attache มีโอเปอเรเตอร์ "vectorization" ซึ่งใช้ฟังก์ชั่นที่อะตอมของรายการ ในกรณีนี้เราทุกคนต้องทำคือการตั้งค่าที่เกี่ยวกับReapและSowทุกอะตอมของท่านด้วย_ @>ฉันคิดว่ามันค่อนข้างหรูหรา

ทางเลือก

15 ไบต์: Fixpoint{`'^^_}

16 ไบต์: Fixpoint!&Concat

17 ไบต์: {q:=[]q&Push@>_q}

17 ไบต์: Fixpoint[&Concat]

Elixir , 74 ไบต์

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

คำตอบแรกของ Elixir ดังนั้นอาจเป็นเรื่องของกอล์ฟ

ลองออนไลน์

คำอธิบาย:

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

แน่นอนว่าถ้าอนุญาตบิวอินแล้วอาจเป็น25 ไบต์แทน:

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

ลองออนไลน์

เยลลี่ขนาด 4 ไบต์

;/ÐL

ลองออนไลน์!

คำอธิบาย

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

บิวด์อินFจะเป็นหนึ่งไบต์ถ้าอนุญาต

ภาษา Wolfram (Mathematica)ขนาด 13 ไบต์

#~Level~{-1}&

ลองออนไลน์!

ยกเลิกแข็งแรงเล่นกอล์ฟ: F[x_] := Level[x, {-1}]

หยิบออกองค์ประกอบของโครงสร้างในระดับสุดท้ายของรูปแบบต้นไม้ ผมไม่แน่ใจว่าข้อหานี้เป็น "การหลีกเลี่ยงในตัวว่า" (ซึ่งจะเป็นFlatten)