Question

我需要从仅包含字符0，1和V（通配符）的字符串构造所有可能的二进制表示。字符串可以是任意长度（超过1000个字符），但通配符的数量小于20。

例如，对于输入V1V，输出将为[010, 011, 110, 111]

我当前的实现工作正常，但是使用适量的通配符溢出堆栈。代码为running here，如下所示。

def permutts
permutts =
{
  if (!it.contains('V'))
    return [it]

  def target = it
  def res = []

  ['0', '1'].each
  {
    def s = target.replaceFirst(~/V/, it)
    if (s.contains('V'))
    {
      res += permutts(s)
    }
    else
    {
      res << s
    }
  }
  res
}
println permutts('V1V')

我试图遵循使用trampoline()的一些示例，但我甚至不确定这是否是正确的方法。 The API says，“......该函数应执行计算的一个步骤......”但每个步骤执行两个操作：在0和1中替换为{{1} }。

这是我的一次尝试，可以是run here。

输出结果为：

def permutts

permutts =
{ it, res = [] ->
  println "entering with " + it + ", res=" + res
  if (it.contains('V'))
  {
    def s = it.replaceFirst(~/V/, '1')
    permutts.trampoline(s, res)

    s = it.replaceFirst(~/V/, '0')
    permutts.trampoline(s, res)
  }
  else
  {
    res << it
  }
}.trampoline()
println permutts('VV')

至少它正在做某事，但我不明白为什么它不继续。任何人都可以解释我做错了什么或提出了解决这个问题的不同方法吗？

Answer 1

Groovy的trampoline()提供tail call optimization，因此它应该用于在最后执行的指令（尾部）中调用自己的闭包/方法。

因此，一个更好的解决方案是经典的＆＃34;头/尾＆＃34;处理（添加println以跟踪调用）：

def permutts
permutts = { s, res ->   
    if (s.length() == 0) {
        println "s = $s, res = $res"
        res
    } else {
        println "s = $s, res = $res"
        if (s[0] == 'V') { // s[0] ~ list.head()
            res = res.collect({ it = it + '0' }) + res.collect({ it = it + '1' })
        } else {
            res = res.collect({ it = it + s[0] })
        }

        permutts.trampoline(s.substring(1), res) // s.substring(1) ~  list.tail()
    }
}.trampoline()

示例：

permutts('VV', [''])     
  s = VV, res = []
  s = V, res = [0, 1]
  s = , res = [00, 10, 01, 11]
  Result: [00, 10, 01, 11]

permutts('0V0', ['']) 
  s = 0V0, res = []
  s = V0, res = [0]
  s = 0, res = [00, 01]
  s = , res = [000, 010]
  Result: [000, 010]

关于您的代码，来自TrampolineClosure javadoc：

TrampolineClosure包装需要在a上执行的闭包功能性蹦床。在调用时，TrampolineClosure将调用原始封闭等待其结果。如果通话的结果是 TrampolineClosure的另一个实例，可能是作为结果创建的调用TrampolineClosure.trampoline（）方法将再次调用TrampolineClosure。这种重复的调用返回的TrampolineClosure实例将继续，直到其他值为止比TrampolineClosure还原。这个价值将成为决赛蹦床的结果。

即，尾调用优化中的替换。在你的代码中，只要其中一个链没有返回TrampolineClosure，整个TrampolineClosure链就会返回。

从groovy 2.3中，您可以使用@TailRecursive AST转换进行尾调用优化：

import groovy.transform.TailRecursive

@TailRecursive
List permutts(String s, List res = ['']) {   
    if (s.length() == 0) {
        res
    } else {
        res = (s[0] == 'V') ? res.collect({ it = it + '0' }) + res.collect({ it = it + '1' }) : res.collect({ it = it + s[0] })       
        permutts(s.substring(1), res)
    }
}

编辑：

为了完成我的回答，上面的内容可以在functional fold的一行中完成，在Groovy中是inject（使用集合的头部作为初始值并迭代尾部）：

assert ['000', '010'] == ['0', 'V', '0'].inject([''], { res, value -> (value == 'V') ?  res.collect({ it = it + '0' }) + res.collect({ it = it + '1' }) : res.collect({ it = it + value }) })
assert ['00', '10', '01', '11'] == ['V', 'V'].inject([''], { res, value -> (value == 'V') ?  res.collect({ it = it + '0' }) + res.collect({ it = it + '1' }) : res.collect({ it = it + value }) })

在Groovy中将递归Closure更改为TrampolineClosure

1 个答案: