_{หมายเหตุ: นี่คือ # 2 ในชุดของความท้าทายการจัดการอาร์เรย์ สำหรับความท้าทายก่อนหน้านี้คลิกที่นี่}

แยกรายการซ้อนกัน

หากต้องการแยกค่าในรายการที่ซ้อนให้ทำให้แบนแล้วห่อแต่ละค่าเพื่อให้อยู่ในระดับความลึกที่ซ้อนกันเหมือนเดิม

กล่าวคือรายการนี้:

[1, [2, 3], [4, 4, [5, 2], 1]]

จะกลายเป็น:

[1, [2], [3], [4], [4], [[5]], [[2]], [1]]

ความท้าทาย

งานของคุณคือการเขียนโปรแกรมที่รับรายการจำนวนเต็มบวก (ภายในขีด จำกัด ของภาษาของคุณ) และดำเนินการแยกนี้

คุณสามารถส่งฟังก์ชั่นที่รับรายการเป็นอาร์กิวเมนต์หรือโปรแกรมเต็มรูปแบบที่ดำเนินการ I / O

เนื่องจากนี่คือโค้ดกอล์ฟการส่งสั้นที่สุด (เป็นไบต์) ชนะ! *

_{* ช่องโหว่มาตรฐานการเล่นกอล์ฟถูกแบน คุณรู้จักสว่าน}

กรณีทดสอบ

รายการอินพุตจะมีจำนวนเต็มตามขนาดจำนวนเต็มมาตรฐานของภาษาของคุณเท่านั้น เพื่อหลีกเลี่ยงข้อ จำกัด ของภาษาที่ขัดขวางไม่ให้แข่งขันค่าจะไม่ซ้อนกันที่ระดับความลึกมากกว่า 10

คุณอาจคิดว่าการป้อนข้อมูลจะไม่มีรายการย่อยว่างเปล่าตัวอย่างเช่น - [[5, []]]จะไม่ได้รับ อย่างไรก็ตามรายการหลักอาจว่างเปล่า

[]            ->  []

[[1, 2]]      ->  [[1], [2]]
[3, [4, 5]]   ->  [3, [4], [5]]
[3, [3, [3]]] ->  [3, [3], [[3]]]
[[6, [[7]]]]  ->  [[6], [[[7]]]]
[[5, 10], 11] ->  [[5], [10], 11]

อย่าลังเลที่จะแสดงความคิดเห็นหากฉันพลาดกรณีมุม

ตัวอย่าง

ฉันได้รวมตัวอย่าง Python 3 อย่างรวดเร็ว (ungolfed) ไว้ด้วยกัน - คุณสามารถทดสอบบน repl.itได้

Brachylogขนาด 16 ไบต์

:{##:0&:ga|g}ac|

ลองออนไลน์!

คำอธิบาย

Example input: [1:[2:3]]

:{          }a     Apply the predicate below to each element of the list: [[1]:[[2]:[3]]]
              c    Concatenate: Output = [1:[2]:[3]]
               |   Or: Input = Output = []

  ##                 Input is a list: e.g. Input = [2:3]
    :0&              Call recursively the main predicate with this input: [2:3]
       :ga           Group each element in a list: Output = [[2]:[3]]
          |          Or (not a list): e.g. Input = 1
           g         Group into a list: Output = [1]

Mathematica, 24 21 ไบต์

##&@@List/@#0/@#&/@#&

หรืออย่างใดอย่างหนึ่งเหล่านี้:

##&@@List/@#&/@#0/@#&
##&@@List@*#0/@#&/@#&
##&@@List/@#&@*#0/@#&

คำอธิบาย

เหตุผลนี้สั้นมากก็คือมันเป็นการเรียกซ้ำที่ไม่จำเป็นต้องมีพื้นฐานชัดเจน

มีน้ำตาลซินแทกติกจำนวนมากที่นี่ดังนั้นเรามาเริ่มด้วยการแยกสิ่งนี้ออก หมายถึงฟังก์ชั่นที่ไม่มีชื่อด้านซ้ายของมันที่มีการโต้แย้งเขียนเป็น& #ภายในฟังก์ชั่นนี้#0หมายถึงฟังก์ชั่นของตัวเองซึ่งช่วยให้หนึ่งในการเขียนฟังก์ชั่นซ้ำที่ไม่มีชื่อ แต่ขอเริ่มด้วยการตั้งชื่อฟังก์ชั่นด้านในและดึงมันออกมา:

f[x_] := ##& @@ List /@ f /@ x
f /@ # &

อื่น ๆ น้ำตาลประโยคที่สำคัญคือf/@xที่สั้นสำหรับMap[f, x]คือมันเรียกร้องในองค์ประกอบของทุกf xเหตุผลf[x_] := ... f /@ xไม่ได้นำไปสู่การเรียกซ้ำแบบไม่สิ้นสุดคือการทำแผนที่บางสิ่งผ่านอะตอมทำให้อะตอมไม่เปลี่ยนแปลงโดยไม่ต้องเรียกใช้ฟังก์ชัน ดังนั้นเราไม่จำเป็นต้องตรวจสอบกรณีพื้นฐาน (องค์ประกอบปัจจุบันเป็นจำนวนเต็ม) อย่างชัดเจน

ดังนั้นฟังก์ชั่นจะfย้อนกลับไปยังรายการที่ลึกที่สุดภายในxจุดที่f/@กลายเป็นไม่ต้องเลือก จากนั้นเราก็เรียกใช้##& @@ List /@ในที่ การทำแผนที่Listมากกว่ารายการเพียง wraps องค์ประกอบในรายการแยกต่างหากในแต่ละดังนั้นจะกลายเป็น{1, 2, 3} {{1}, {2}, {3}}จากนั้นเราก็ใช้ ##&ไปซึ่งหมายความว่าหัว (เช่นรายการนอก) ได้รับการแทนที่ด้วยเพื่อให้ผลัดกันนี้ลงใน##& ##&[{1}, {2}, {3}]แต่##&เพียงคืนค่าเป็นอาร์กิวเมนต์เป็นSequence(ซึ่งคุณสามารถคิดว่าเป็นรายการที่ไม่ได้ห่อหุ้มหรือตัวดำเนินการ "เครื่องหมาย" ในภาษาอื่น)

ดังนั้น##& @@ List /@เปลี่ยนรายการ{1, 2, 3}ให้เป็น{1}, {2}, {3}(ชนิดของสิ่งสุดท้ายที่ถูกห่อหุ้มไว้ในหัวจริง ๆSequenceแต่จะหายไปทันทีที่เราใช้ค่าใดก็ได้)

นั่นทำให้เกิดคำถามว่าทำไมfตัวเองถึงไม่สามารถแก้ปัญหาได้ ปัญหาคือว่ารายการนอกสุดควรได้รับการปฏิบัติที่แตกต่างกัน ถ้าเรามีการป้อนข้อมูล{{1, 2}, {3, 4}}ที่เราต้องการ{{1}, {2}, {3}, {4}}และไม่ได้ {{1}}, {{2}}, {{3}}, {{4}}โซลูชันดั้งเดิมของฉันได้รับการแก้ไขโดยการส่งผลลัพธ์สุดท้ายเป็นรายการของอาร์กิวเมนต์Joinที่จะคืนค่ารายการระดับนอก แต่สิ่งนี้เพิ่งข้ามระดับภายนอกโดยใช้f ตัวเองในแผนที่บนผลลัพธ์ ดังนั้นfจะถูกนำไปใช้กับองค์ประกอบเฉพาะของรายการนอกสุดเท่านั้นและไม่เคยแตะต้องรายการนั้น

สำหรับอีกสามโซลูชั่นวิธีแรกใช้การเรียกซ้ำภายนอกfซึ่งทำงานได้ดีเช่นกัน อีกสองวิธีหลีกเลี่ยงการMapดำเนินการซ้ำซ้อนโดยการเขียนสองฟังก์ชั่นก่อนแล้วจึงทำการแมปผลลัพธ์เพียงครั้งเดียว

J , 19 18 ไบต์

(<@]/@,~>)S:0 1{::

นี่เป็นคำกริยาที่ไม่ระบุชื่อที่ใช้และส่งกลับอาร์เรย์ที่บรรจุอยู่ในกล่องซึ่งเป็นรุ่นที่ซ้อนกันของ J (ค่อนข้างยุ่งยาก) เห็นมันผ่านกรณีทดสอบทั้งหมด

คำอธิบาย

สิ่งนี้ใช้การดำเนินการที่ค่อนข้างแปลกใหม่{::( แผนที่ ) และS:(สเปรด ) ซึ่งทำงานบนอาร์เรย์แบบบรรจุกล่อง {::แทนที่ใบไม้แต่ละอันด้วยเส้นทางชนิดบรรจุกล่องไปยังใบไม้นั้น S:ใช้คำกริยาที่กำหนดกับความลึกการซ้อนที่กำหนดจากนั้นแบ่งผลลัพธ์เป็นอาร์เรย์

(<@]/@,~>)S:0 1{::  Input is y.
(        )          Let's look at this verb first.
        >           Open the right argument,
      ,~            append the left argument to it,
    /               then reduce by
 <@]                boxing. This puts the left argument into as many nested boxes
                    as the right argument is long.
                    This verb is applied to y
               {::  and its map
            0 1     at levels 0 and 1.
                    This means that each leaf of y is paired with its path,
                    whose length happens to be the nesting depth of y,
                    and the auxiliary verb is applied to them.
          S:        The results are spread into an array.

R, 199 ไบต์

function(l){y=unlist(l);f=function(x,d=0){lapply(x,function(y){if(class(y)=='list'){f(y,d=d+1)}else{d}})};d=unlist(f(l));lapply(1:length(d),function(w){q=y[w];if(d[w]){for(i in 1:d[w])q=list(q)};q})}

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

การแก้ปัญหาประกอบด้วยสองส่วนใหญ่ ฟังก์ชั่นวนซ้ำที่วนรอบรายการทั้งหมดและบันทึกความลึก:

  f=function(x,d=0){
    lapply(x,function(y){
      if(class(y)=='list'){
        f(y,d=d+1)
      } else {
        d
      }})
  }

เมื่อเรามีความลึกของทุก ๆ รายการของเวกเตอร์ที่unlist(l)เก็บไว้dเราจะสร้างรายการโดยนัยlapplyและเติมด้วยฟังก์ชันต่อไปนี้:

  lapply(1:length(d),function(w){
    q=y[w]
    if(d[w]){
      for(i in 1:d[w]){
        q=list(q)
      }
    }
    q
  })

ในการเรียกใช้นี้เราสร้างวัตถุที่qมีค่าของรายการในรายการตรวจสอบความลึกของมันและดูว่ามันไม่ใช่ศูนย์ ถ้ามันเป็นศูนย์เราก็สามารถปล่อยให้มันเป็นค่าตัวเลข หากไม่ใช่ศูนย์เราต้องซ้อนในจำนวนรายการนั้น ดังนั้นเราจึงเรียกร้องให้วงเวลาและโทรซ้ำแล้วซ้ำอีกdq=list(q)

lapplyจากนั้นใส่ค่าทั้งหมดเหล่านี้qในรายการสร้างผลลัพธ์ที่ต้องการ

จบโปรแกรมด้วยระยะห่างที่เหมาะสมและเช่น:

function(our.list){
  values <- unlist(our.list)
  f <- function(part.list, depth = 0){
    lapply(part.list, function(y){
      if(class(y)=='list'){
        f(y, depth <- depth + 1)
      } else {
        return(depth)
      }})
  }
  depths <- unlist(f(our.list))
  new.list <- lapply(1:length(depths), function(w){
    q <- values[w]
    if(depths[w] != 0){
      for(i in 1:depths[w]){
        q <- list(q)
      }
    }
    return(q)
  })
  return(new.list)
}

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

+`(.(?>()\[|(?<-2>)]|.)+)\2,
$1],[

ลองออนไลน์!

C (gcc), 147 ไบต์

d=0,l,i;
P(n,c){for(;n--;)putchar(c);}
main(c){for(;~(c=getchar());l=i)i=isdigit(c),P((l<i)*d,91),P(i,c),P((l>i)*d,93),P(l>i,32),d+=(92-c)*(c>90);}

อินพุตตัวอย่าง:

1 [23 3] [40 4 [5 2] 1]

ตัวอย่างผลลัพธ์:

1 [23] [3] [40] [4] [[5]] [[2]] [1]

เรียงซ้อน , ไม่ใช่การแข่งขัน, 25 ไบต์

{e d:e$wrap d 1-*}cellmap

นี่คือฟังก์ชั่นที่จะแก้ไขสมาชิกอันดับต้น ๆ ของสแต็ก หากคุณต้องการฟังก์ชั่น bonafide เพียงเพิ่ม[และ]ไปยังจุดเริ่มต้นและจุดสิ้นสุด ลองที่นี่!

นี่เป็นเวอร์ชันที่อ่านได้:

{ arr :
  arr { ele depth :
    ele   $wrap depth 1- * (* execute wrap n times, according to the depth *)
  } cellmap (* apply to each cell, then collect the results in an array *)
} @:a2
(1 (2 3) (4 4 (5 2) 1)) a2 out

กรณีทดสอบ:

(1 (2 3) (4 4 (5 2) 1))    (* arg on TOS *)
{e d:e$wrap d 1-*}cellmap
out                        (* display TOS *)

เอาต์พุตโดยไม่มีบรรทัดใหม่:

(1 (2) (3) (4) (4) ((5)) ((2)) (1))

PHP, 101 94 ไบต์

บันทึก 1 ไบต์ขอบคุณ @Christoph, บันทึกอีก 6 แรงบันดาลใจจากสิ่งนั้น

function s($a){foreach($a as$b)if($b[0])foreach(s($b)as$c)$r[]=[$c];else$r[]=$b;return$r?:[];}

ฟังก์ชั่นวนซ้ำตรงไปตรงมา

ทำให้พังถล่ม

function s($a)
{
    foreach($a as$b)                // loop through array
        if($b[0])                       // if element is array
            foreach(s($b)as$c)$r[]=[$c];    // append separated elements to result
        else$r[]=$b;                    // else append element to result
    return$r?:[];                   // return result, empty array for empty input
}

Python 2, 122 106 ไบต์

คะแนนแย่มากเพียงใช้งานง่าย

ขอบคุณ @ Zachary T ที่ช่วยประหยัด 16 ไบต์!

def x(l,a=[],d=0):
 n=lambda b:b and[n(b-1)]or l
 if'['in`l`:[x(e,a,d+1)for e in l];return a
 else:a+=n(d)

เรียกxด้วยอาร์กิวเมนต์เดียวเพื่อเรียกใช้ ด้วยเหตุผลบางอย่างมันสามารถทำงานได้เพียงครั้งเดียว

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

f=a=>[for(e of a)for(d of e.map?f(e):[e])e.map?[d]:d]

คำตอบ ES6 ที่ดีที่สุดที่ฉันมีอยู่คือ 76 ไบต์:

f=(a,r=[],d=0)=>a.map(e=>e.map?f(e,r,d+1):r.push((n=d=>d?[n(d-1)]:e)(d)))&&r

Pyth - 29 ไบต์

.b]FYt-F/LN`[)PsM._:`Q"\d"3.n

Test Suite

Perl 6 , 60 47 ไบต์

sub f{[$_~~List??|([$_] for .&f)!!$_ for |$^a]}

( ลองออนไลน์ )

คำอธิบาย:

1. [... for |$^a]: ทำซ้ำอาร์เรย์อินพุตและสร้างอาร์เรย์ใหม่จากมัน
2. $_ ~~ List ?? ... !! ...: สำหรับแต่ละองค์ประกอบตรวจสอบว่ามันเป็นตัวเองอาร์เรย์
3. |([$_] for .&f): ถ้าองค์ประกอบนั้นเป็นอาร์เรย์ให้ใช้ฟังก์ชันซ้ำอีกครั้งแล้ววนซ้ำองค์ประกอบของอาร์เรย์ใหม่ที่ส่งกลับจากการเรียกซ้ำนั้นซึ่งจะรวมองค์ประกอบแต่ละตัวในอาร์เรย์ของมันเองและส่งเข้าไปในรายการด้านนอก
4. $_: หากองค์ประกอบนั้นไม่ใช่อาร์เรย์ให้ส่งผ่านตามที่เป็นอยู่

Haskell, 71 ไบต์

data L=N Int|C[L] 
d#C l=((C .pure.d)#)=<<l
d#n=[d n]
f(C l)=C$(id#)=<<l

อีกครั้งฉันต้องกำหนดประเภทรายการของตัวเองเพราะรายชื่อพื้นเมืองของ Haskell ไม่สามารถซ้อนกันได้โดยพลการ ชนิดใหม่นี้Lสามารถส่งคืนจากฟังก์ชัน แต่ไม่สามารถพิมพ์ตามค่าเริ่มต้นดังนั้นเพื่อดูผลลัพธ์ที่ฉันกำหนดshowอินสแตนซ์สำหรับL:

instance Show L where
  show (N n)=show n
  show (C l)=show l

ตอนนี้เราสามารถทำการทดสอบใน REPL:

*Main> f $ C[N 1, C[N 2, N 3], C[N 4, N 4, C[N 5, N 2], N 1]]
[1,[2],[3],[4],[4],[[5]],[[2]],[1]]

*Main> f $ C[C[N 6, C[C[N 7]]]]
[[6],[[[7]]]]

วิธีการทำงาน: การเรียกซ้ำแบบง่ายซึ่งผ่านระดับการซ้อนเป็นฟังก์ชันของตัวCสร้าง เราเริ่มต้นด้วยฟังก์ชั่นเอกลักษณ์idและเมื่อใดก็ตามที่มีรายการ (-> จับคู่รูปแบบd#C l=) เราจะเพิ่มเลเยอร์อีกC(-> C .pure.d) ให้กับการเรียกซ้ำของ#องค์ประกอบทั้งหมดของรายการ หากเราพบตัวเลขเราเพียงใช้ฟังก์ชันการซ้อนข้อมูลdกับหมายเลข

APL (Dyalog) 44 ไบต์ *

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ รับรายการ APL ที่ซ้อนกันเป็นอาร์กิวเมนต์และส่งคืนอาร์เรย์ APL ที่ซ้อนกัน

∊{⊃⊂⍣⍵,⍺}¨{⊃¨(j∊⎕D)⊆+\-⌿'[]'∘.=j←⎕JSON⍵}

ลองออนไลน์!

{… } ใช้ฟังก์ชั่นที่ชัดเจนต่อไปนี้ที่มีการโต้แย้งโดย⍵:

 ⎕JSON⍵ แปลงอาร์กิวเมนต์เป็น JSON

 j← เก็บใน j

 '[]'∘.= ตารางที่jเท่ากับวงเล็บเปิด (แถวบน) และวงเล็บปิด (แถวล่าง)

 -⌿ แถวบนสุดลบแถวล่าง (ลดความแตกต่างในแนวตั้ง)

 +\ ยอดรวมสะสม (ซึ่งจะทำให้ระดับการซ้อนสำหรับอักขระแต่ละตัว)

 (… )⊆ partition เริ่มพาร์ติชั่นใหม่เมื่อใดก็ตามที่ 1 ไม่ได้นำหน้าด้วย 1 ใน ...

  j∊⎕D โดยที่อักขระแต่ละตัวของjเป็นสมาชิกของชุดของigits D

 ⊃¨ เลือกตัวแรกของแต่ละตัว (จะให้ระดับการซ้อนต่อหมายเลขหลายหลัก)

∊{... }¨ ใช้ฟังก์ชั่นต่อไปนี้เพื่อแต่ละระดับการทำรัง ( ⍵) โดยใช้องค์ประกอบที่สอดคล้องกันจากε nlisted (บี้) อาร์กิวเมนต์เป็นอาร์กิวเมนต์ซ้าย ( ⍺):

 ,⍺ ravel (ฟัง) หมายเลข (เพราะสเกลาร์ไม่สามารถใส่ได้)

 ⊂⍣⍵ ปิดล้อม⍵เวลา

 ⊃ เปิดเผย (เพราะรายชื่อที่อยู่ด้านในสุดนั้นเป็นสิ่งที่แนบมาด้วย)

^{* การใช้ Dyalog คลาสสิกกับ⎕ML←3(ค่าเริ่มต้นในระบบจำนวนมาก) แทน⊂สำหรับ⊆และสำหรับ↑ ติ้ว!⊃}