Scala中的括号匹配---功能方法

时间:2012-04-04 11:35:17

标签: scala functional-programming

假设我想解析一个带有各种开始和结束括号的字符串(我在标题中使用了括号,因为我认为它更常见 - 但问题是相同的)所以我将所有更高级别分开一个清单。

鉴于:

[hello:=[notting],[hill]][3.4(4.56676|5.67787)][the[hill[is[high]]not]]

我想:

List("[hello:=[notting],[hill]]", "[3.4(4.56676|5.67787)]", "[the[hill[is[high]]not]]")

我这样做的方法是计算开始和结束括号,并在我将计数器设置为0时添加到列表中。但是,我有一个丑陋的命令性代码。您可以假设原始字符串格式正确。

我的问题是:这个问题的功能方法是什么?

注意:我已经考虑过使用for ... yield构造但是由于使用了计数器我无法得到一个简单的条件(我必须有条件只是为了更新计数器)而且我不知道我是怎么做的在这种情况下可以使用这个结构。

5 个答案:

答案 0 :(得分:7)

使用Scala解析器组合库的快速解决方案:

import util.parsing.combinator.RegexParsers

object Parser extends RegexParsers {
  lazy val t = "[^\\[\\]\\(\\)]+".r

  def paren: Parser[String] =
    ("(" ~ rep1(t | paren) ~ ")" |
     "[" ~ rep1(t | paren) ~ "]") ^^ {
      case o ~ l ~ c => (o :: l ::: c :: Nil) mkString ""
    }

  def all = rep(paren)

  def apply(s: String) = parseAll(all, s)
}

在REPL中检查:

scala> Parser("[hello:=[notting],[hill]][3.4(4.56676|5.67787)][the[hill[is[high]]not]]")
res0: Parser.ParseResult[List[String]] = [1.72] parsed: List([hello:=[notting],[hill]], [3.4(4.56676|5.67787)], [the[hill[is[high]]not]])

答案 1 :(得分:4)

怎么样:

def split(input: String): List[String] = {
  def loop(pos: Int, ends: List[Int], xs: List[String]): List[String] =
    if (pos >= 0)
      if ((input charAt pos) == ']') loop(pos-1, pos+1 :: ends, xs)
      else if ((input charAt pos) == '[')
        if (ends.size == 1) loop(pos-1, Nil, input.substring(pos, ends.head) :: xs)
        else loop(pos-1, ends.tail, xs)
      else loop(pos-1, ends, xs)
    else xs
  loop(input.length-1, Nil, Nil)
}

scala> val s1 = "[hello:=[notting],[hill]][3.4(4.56676|5.67787)][the[hill[is[high]]not]]"
s1: String = [hello:=[notting],[hill]][3.4(4.56676|5.67787)][the[hill[is[high]]not]]

scala> val s2 = "[f[sad][add]dir][er][p]"
s2: String = [f[sad][add]dir][er][p]

scala> split(s1) foreach println
[hello:=[notting],[hill]]
[3.4(4.56676|5.67787)]
[the[hill[is[high]]not]]

scala> split(s2) foreach println
[f[sad][add]dir]
[er]
[p]

答案 2 :(得分:2)

根据你的要求计算,括号似乎完全没问题。你会如何以功能的方式做到这一点?你可以明确传递状态。

首先我们定义我们的状态,它在blocks中累积结果或连接下一个block并跟踪深度:

case class Parsed(blocks: Vector[String], block: String, depth: Int)

然后我们编写一个处理的纯函数,返回下一个状态。希望我们可以仔细查看这一功能并确保它是正确的。

def nextChar(parsed: Parsed, c: Char): Parsed = {
  import parsed._
  c match {
    case '[' | '(' => parsed.copy(block = block + c,
                                  depth = depth + 1)
    case ']' | ')' if depth == 1 
                   => parsed.copy(blocks = blocks :+ (block + c),
                                  block = "",
                                  depth = depth - 1)
    case ']' | ')' => parsed.copy(block = block + c,
                                  depth = depth - 1)
    case _         => parsed.copy(block = block + c)
  }
}

然后我们只使用foldLeft来处理具有初始状态的数据:

val data = "[hello:=[notting],[hill]][3.4(4.56676|5.67787)][the[hill[is[high]]not]]"
val parsed = data.foldLeft(Parsed(Vector(), "", 0))(nextChar) 
parsed.blocks foreach println

返回:

[hello:=[notting],[hill]]
[3.4(4.56676|5.67787)]
[the[hill[is[high]]not]]

答案 3 :(得分:2)

你有一个丑陋的必要解决方案,那么为什么不做一个好看的解决方案呢? :)

这是对huynhjl解决方案的必要翻译,但只是张贴以表明有时必要的是简洁的,也许更容易理解。

  def parse(s: String) = {
    var res = Vector[String]()
    var depth = 0
    var block = ""
    for (c <- s) {
      block += c
      c match {
        case '[' => depth += 1
        case ']' => depth -= 1
                    if (depth == 0) {
                      res :+= block
                      block = ""
                    }
        case _   =>
      }
    }
    res
  }

答案 4 :(得分:0)

试试这个:

val s = "[hello:=[notting],[hill]][3.4(4.56676|5.67787)][the[hill[is[high]]not]]"
s.split("]\\[").toList

返回:

List[String](
  [hello:=[notting],[hill],
  3.4(4.56676|5.67787),
  the[hill[is[high]]not]]
)