Phân tích một danh sách các danh sách thành một danh sách buồn


12

Trong thử thách này, bạn phải phân tích một danh sách các danh sách, thành một định dạng danh sách đơn giản hơn.

Thử thách này dựa trên trình phân tích cú pháp sadflak của tôi. Trong trình phân tích cú pháp sadflak của tôi, nó đã loại bỏ tất cả (), thay thế bằng tổng của () ở đầu danh sách, để làm cho chương trình chạy nhanh hơn.

Để phân tích thành một danh sách buồn, bạn phải thực hiện điều này (điều triển khai python, sử dụng một bộ dữ liệu):

def sadlistfunc(list):
    new-sadlist = [0]
    for i in list:
        if i == ():
            new-sadlist[0]+=1
        else:
            new-sadlist.append(sadlistfunc(i))

Đây là một hàm đệ quy. Đối với danh sách, hãy bắt đầu một danh sách mới, bắt đầu bằng số () từ đầu vào danh sách, sau đó phần còn lại của danh sách này là phiên bản danh sách buồn của mọi danh sách không phải là () từ đầu vào danh sách. trả lại danh sách

Đầu vào:

bạn có thể nhận đầu vào ở một vài định dạng khác nhau:

  • bạn có thể lấy nó làm danh sách
  • bạn có thể coi nó như một tuple
  • bạn có thể coi nó như một chuỗi

nếu bạn lấy nó dưới dạng một chuỗi, bạn nên sử dụng một số bộ dấu ngoặc, như xuất hiện trong bộ não. bạn không được sử dụng ký tự 1 và 2

chỉ cần hợp lý

Đầu vào sẽ luôn nằm trong một danh sách, nhưng chương trình của bạn có thể giả sử một lớp danh sách ẩn bên ngoài đầu vào, tức là () () () = (() () ()) hoặc có thể chọn không. Ví dụ sẽ có danh sách bên ngoài rõ ràng

đầu ra:

có thể là danh sách hoặc tuple hoặc chuỗi, hoặc bất cứ điều gì. bạn có thể sử dụng bất kỳ định dạng đầu ra hợp lý nào, như là sự đồng thuận meta.

Thí dụ:

(()()()) = [3]
(((()))) = [0,[0,[1]]]
((())()(())) = [1, [1], [1]]
() = invalid input, if the outside bracket is explicit.
((((())())())(())()) = [1, [1, [1, [1]]], [1]]

lưu ý rằng đầu vào không nghiêm ngặt. những đầu vào này có thể là:

[[],[],[]]
[[[[]]]]
[[[]],[],[[]]]
[]
[[[[[]],[]],[]],[[]],[]]

hoặc một số định dạng hợp lý khác

giải thích trường hợp thử nghiệm:

(()()((())())())

để "làm buồn" điều này, đầu tiên chúng ta đếm số lượng ()

 ()()        ()
(    ((())())  )

3. sau đó chúng tôi loại bỏ những thứ này và thêm 3 vào lúc bắt đầu

(3,((())()))

Có một danh sách trong danh sách này. chúng tôi buồn

((())())

bao nhiêu ()?

     ()
((())  )

1. chúng tôi loại bỏ và thêm 1 khi bắt đầu

(1,(()))

cái này có một danh sách

(())

đếm

 ()
(  )

loại bỏ và thêm số lượng

(1)

sau đó chúng tôi đưa nó trở lại vào danh sách của nó

(1,(1))

sau đó chúng tôi đưa nó trở lại vào danh sách của nó

(3,(1,(1)))

làm xong

Đây là , nên ngắn hơn thì tốt hơn


Lưu ý rằng trong trình phân tích cú pháp sad-flak thực tế, số lượng () thực sự là mục thứ hai của danh sách và mục đầu tiên là chỉ mục của lệnh
Lemon

Tốt ol 'JavaScript for... in, khiến tôi nhớ tại sao bạn không bao giờ sử dụng nó: Fiddle
Stephen

Tôi cho là ((((())())())(())()) = [1, [1, [1, [1]], [1]]nên ((((())())())(())()) = [1, [1, [1, [1]]], [1]].
Renzo

Câu trả lời:


4

Bình thường , 13 byte

L+]/bYyM-b]Yy

Bộ thử nghiệm .

Làm thế nào nó hoạt động

L+]/bYyM-b]Yy
L               define a function y with argument b:
   /bY              list 1: count how many [] can be found in b
  ]                         wrap into singleton
        -b]Y        list 2: filter out [] from b
      yM                    apply y (this function) to each
 +                  concatenate the two lists above
            y   apply y to the input

Bạn có thể loại bỏ đầu tiên ].
Erik the Outgolfer


2

Brachylog , 21 byte

;[[]]x{↰₀}ᵐA&{∋∅}ᶜg,A

Hãy thử trực tuyến!


Byte và ký tự không tương đương. Sử dụng UTF-8, sẽ mất 33 byte, mặc dù chỉ có 21 ký tự.
Samadi

1
@Samadi Brachylog sử dụng trang mã riêng , được phép theo câu trả lời meta này .
Rò rỉ Nun

Ah tôi thấy. Tôi đã nhầm lẫn một chút. Cảm ơn đã làm rõ!
Samadi

@Samadi Không có vấn đề, câu hỏi này được hỏi mọi lúc.
Nữ tu rò rỉ

2

Toán học, 42 byte

{#~Count~{0},##&@@#~DeleteCases~{0}}&//@#&

Tránh đệ quy rõ ràng bằng cách sử dụng //@( MapAll) ánh xạ một hàm trên mỗi nút trong cây. Điều này cũng có nghĩa là các chức năng được thực hiện từ các lá trở lên. Tuy nhiên, nó cũng sẽ được áp dụng để {}được chuyển thành {0}quy trình. Đó là lý do tại sao chúng tôi đếm và loại bỏ {0}thay thế {}.



2

Clojure, 59 byte

(fn f[i](conj(map f(remove #{[]}i))(count(filter #{[]}i))))

Không có nhiều khác biệt với câu trả lời CommonLisp . Nó countremovedường như chấp nhận một cấu trúc đẹp hơn một chút, ở đây tôi đã phải sử dụng các bộ.


2

Trên thực tế , 12 byte

;[]@c@;░Q£Mo

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng danh sách dấu ngoặc vuông được phân tách bằng dấu phẩy với các vùng nước lợ bên ngoài rõ ràng.

Giải trình:

;[]@c@;░Q£Mo
;[]@c         count the number of empty lists
     @;░      filter out empty lists
        Q£Mo  recurse with filtered list and append result

2

Python 2 , 69 46 45 byte

f=lambda l:[l.count([])]+map(f,filter(len,l))

Hãy thử trực tuyến!


Tôi nghĩ rằng bạn cần thêm f=vào số tiền của mình, vì bạn đang sử dụng hàm f và đặt tên cho nó nếu không sẽ phá vỡ giải pháp của bạn
Leo

@Leo Bạn nói đúng.
trứng

1

Thạch , 10 byte

Tị߀;@ċ“”$

Hãy thử trực tuyến!

Lấy đầu vào là danh sách các danh sách ...

Tất nhiên nó sử dụng thuật toán mà các câu trả lời khác sử dụng. ;)


Đó không phải là 10 byte. Đó là 10 ký tự . Số lượng byte sẽ phụ thuộc vào mã hóa bạn sử dụng.
Samadi

2
@Samadi Không, Jelly có một bộ ký tự chuyên dụng là mặc định của nó và nó có thể biểu thị các ký tự đó dưới dạng một byte mỗi ký tự. Xem ở đây .
Adám

Tôi hiểu rồi. Cảm ơn bạn đã làm rõ!
Samadi

1

Haskell , 102 byte

data L=I Int|T[L]deriving Show
(I n:r)#m=r#(n+m)
(x:r)#m=x:r#m
_#m=[I m]
f(T[])=I 1
f(T t)=T$map f t#0

Hãy thử trực tuyến!

Bởi vì Haskell được gõ đúng, không có danh sách lồng nhau tùy ý. Như một phương thuốcdata L=I Int|T[L]deriving Show khai báo các danh sách lồng nhau giống như cây với Ints hoặc danh sách trống dưới dạng lá.

Đầu vào giống như trong định dạng ví dụ thứ hai, với một hàm tạo bổ sung Ttrước mỗi dấu ngoặc mở : T[T[T[]],T[],T[T[]]]. Điều tương tự cũng xảy ra với đầu ra, với mỗi số được đặt trước bởi một hàm tạo I. Chức năng fthực hiện việc buồn .

Đầu ra cho các trường hợp thử nghiệm:

T [I 3]
T [T [T [I 1],I 0],I 0]
T [T [I 1],T [I 1],I 1]
T [T [T [T [I 1],I 1],I 1],T [I 1],I 1]

1

Javascript (ES6), 77 byte

Chơi gôn

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

Ung dung:

const traverse = arr => !arr.length || arr
    .map(traverse)
    .reduce(
        (accum, val) => (val.length ? accum.push(val) : accum[0]++, accum),
        [0]
    );

Bản giới thiệu

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.