将列表列表解析为悲伤列表


12

在此挑战中,您必须将列表列表解析为更简单的列表格式。

这项挑战基于我的sadflak解析器。在我的sadflak解析器中,它删除了所有(),并在列表的开头替换为()的总和,以使程序运行更快。

要解析为悲伤列表,您必须执行以下操作(Python实现的事情,使用一个元组的元组):

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

这是一个递归函数。对于列表,请从列表输入中的()数量开始创建一个新列表,然后该列表的其余部分依次是每个列表的悲伤列表版本,而不是列表输入中的()。返回列表。

输入:

您可以采用几种不同的格式输入:

  • 您可以将其作为列表
  • 你可以把它当成元组
  • 你可以把它当作一个字符串

如果将其作为字符串使用,则应使用一些括号,如出现在脑筋急转弯中的括号。您不能使用字符1和2

只是合理

输入将始终在一个列表内,但是您的程序可能会在输入之外假设一个隐式列表层,即()()()=(()()()),或者可能选择不包含。示例将带有明确的外部列表

输出:

可以是列表,元组或字符串,或其他任何形式。您可以使用任何合理的输出格式,例如元共识。

例:

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

请注意,输入内容并不严格。这些输入可以是:

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

或其他一些合理的格式

解释的测试用例:

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

为了“满足”,首先我们计算()的数量

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

3.然后我们将其删除,并在开头添加3

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

此列表中只有一个列表。我们对此感到遗憾

((())())

多少 ()?

     ()
((())  )

1.我们删除并在开头添加1

(1,(()))

这个里面有一个清单

(())

计数

 ()
(  )

删除并添加计数

(1)

然后我们将其放回清单

(1,(1))

然后我们将其放回清单

(3,(1,(1)))

做完了

这是,所以越短越好


请注意,在实际的悲伤分析器中,()的数量实际上是列表的第二项,而第一项是命令的索引
Destructible Lemon

很好的JavaScript for... in,让我记住了您为什么从不使用它:Fiddle
Stephen

我想((((())())())(())()) = [1, [1, [1, [1]], [1]]应该是((((())())())(())()) = [1, [1, [1, [1]]], [1]]
Renzo

Answers:


4

Pyth,13个字节

L+]/bYyM-b]Yy

测试套件

怎么运行的

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




2

Mathematica,42个字节

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

通过使用//@MapAll)避免显式递归,该方法将函数映射到树中的每个节点上。这也意味着功能是从叶向上执行的。然而,它也将被应用到{}其中获得变成{0}在这个过程中。这就是为什么我们数和删除{0}代替{}



2

Clojure,59个字节

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

CommonLisp答案没有太大区别。它countremove似乎接受更好一点的构建,在这里我不得不使用套。


2

实际上,12个字节

;[]@c@;░Q£Mo

在线尝试!

将输入作为带有逗号分隔的方括号列表,并带有明确的外部括号。

说明:

;[]@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字节

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

在线尝试!


我认为您需要添加f=到字节数,因为您正在使用函数f,否则将其命名会破坏您的解决方案
Leo

@Leo你是对的。
ovs

1

果冻,10字节

Tị߀;@ċ“”$

在线尝试!

将输入作为列表列表...

当然,它使用其他答案使用的算法。;)


那不是10个字节。这是10个字符。字节数将取决于您使用的编码。
萨马迪

2
@Samadi否,Jelly具有专用的字符集,它是默认字符集,它可以将这些字符表示为一个字节。看这里
亚当

我知道了。感谢您的澄清!
萨马迪

1

Haskell,102字节

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

在线尝试!

因为Haskell是严格类型的,所以没有任意嵌套的列表。作为一种补救措施data L=I Int|T[L]deriving Show,可以将具有Ints或空列表的树状嵌套列表声明为叶子。

输入类似于第二个示例格式,T在每个大括号之前添加了一个额外的构造函数T[T[T[]],T[],T[T[]]]。输出也是如此,每个数字前面都有一个构造函数I。功能f执行令人难过的

测试用例的输出:

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个字节

打高尔夫球:

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

取消高尔夫:

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

演示版

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.