将第n次出现替换为反向

Question

Scala provides out of the box methods to work either with first or with all occurrences of the pattern.

What is the best (or canonical way) to replace only nth occurrence?

I can think of a couple of solutions but I do not really like any of them.

First one uses mutable var to track occurrences.

  def f1(str: String, pattern: String, occurrence: Int) = {
    pattern.r.replaceAllIn(str, {var c = 0
      m: Match => {
      c = c + 1
      if (c == occurrence) m.group(1).reverse else m.group(1)
      }
    })
  }

  println(f1("aaa bbb123, ccc456, ddd789, qqq1010 206z", """(\d+)""", 3))

Second one finds all matches, picks up the required and applies patch method for the String.

  def f2(str: String, pattern: String, occurrence: Int) = {
    val m = pattern.r.findAllMatchIn(str).toList.lift(occurrence-1)
    m match {
      case Some(m) => str.patch(m.start(1), m.group(1).reverse, m.group(1).length)
      case None => str
    }
  }

  println(f2("aaa bbb123, ccc456, ddd789, qqq1010 206z", """(\d+)""", 3))

Is there more concise/preferable or better way?

Update

Yet another approach with zipAll.

  def f5(str: String, pattern: String, occurrence: Int) = {
    val m = pattern.r.findAllIn(str).toArray
    val x = str.split(pattern)
    if (x.size>occurrence) m(occurrence-1) = m(occurrence-1).reverse
    x.zipAll(m, "", "").flatMap(t => List(t._1, t._2)).mkString
  }

Results of the performance test for functions f1...f5 with 1 000 000 executions and below function to measure elapsed time

  def time[R](block: => R): R = {
    val t0 = System.nanoTime()
    val result = block    // call-by-name
    val t1 = System.nanoTime()
    println("Elapsed time: " + (t1 - t0) + "ns")
    result
  }

Elapsed time: 6352446800ns
Elapsed time: 4832129400ns
Elapsed time: 3153650800ns
Elapsed time: 3501623300ns
Elapsed time: 6276521500ns

f3 seems to be the best (which is expected).

Answer 1

I think your 2nd approach is a good one but I wouldn't bother with the List manipulations.

def f3(str: String, pattern: String, occurrence: Int) = {
  val mi = pattern.r.findAllMatchIn(str).drop(occurrence - 1)
  if (mi.hasNext) {
    val m = mi.next()
    val s = m.group(0)
    str.patch(m.start, s.reverse, s.length)
  } else str
}

---

update : You could also try this slight modification.

def f4(str: String, pattern: String, occurrence: Int) =
  util.Try{pattern.r.findAllMatchIn(str).drop(occurrence - 1).next()
  }.fold(_=>str, m=>str.patch(m.start, m.group(0).reverse, m.group(0).length))


f4("aaa bbb123, ccc456, ddd789, qqq1010 206z", "\\d+", 3)

It's a bit more concise (a single line) and somewhat safer (won't throw if pattern can't be compiled to a regex), but I'm not sure it's actually preferable.