如何在字符串中反向单词并保留标点符号和大写符号

Question

private def reverseHelper(word: String): String = {
  var result = new StringBuilder(word)
  if (word.head.isUpper) {
    result.setCharAt(0, word.head.toLower)
    result.setCharAt(word.length - 1, word.last.toUpper)
  }
  result.reverse.result()
}

val formatString = str
  .split("[.,!?: ]+")
  .map(result => str.replaceFirst(result, reverseHelper(result)))
  .foreach(println)

示例：输入：什么是句子？Ouput：Tahw ecnetnes吗？

但是我有Array [String]：Tahw是一个句子？，什么是句子？，什么是句子？，什么是ecnetnes？我如何用正确的格式写出来？

Answer 1

在单词边界上使用split的版本：

def reverseWords(string: String): String = {
  def revCap(s: String): String =
    s.headOption match {
      case Some(c) if c.isUpper =>
        (c.toLower +: s.drop(1)).reverse.capitalize
      case Some(c) if c.isLower =>
        s.reverse
      case _ => s
    }

  string
    .split("\\b")
    .map(revCap)
    .mkString("")
}

Answer 2

恢复原始大小写有点棘手。

def reverser(s:Seq[Char], idx:Int = 0) :String = {
  val strt = s.indexWhere(_.isLetter, idx)
  if (strt < 0) s.mkString
  else {
    val end = s.indexWhere(!_.isLetter, strt)
    val len = end - strt
    val rev = Range(0,len).map{ x =>
      if (s(strt+x).isUpper) s(end-1-x).toUpper
      else                   s(end-1-x).toLower
    }
    reverser(s.patch(strt,rev,len), end)
  }
}

测试：

reverser(       "What, is A sEntence?")
//res0: String = Tahw, si A eCnetnes?

Answer 3

您可以先在特殊字符列表中分割字符串，然后反转每个单词并将其存储在临时字符串中。之后，遍历原始字符串和临时字符串，并将与任何特殊字符匹配的单词替换为临时字符串中的当前字符。

private def reverseHelper(word: String): String = {
  var result = new StringBuilder(word)
  if (word.head.isUpper) {
    result.setCharAt(0, word.head.toLower)
    result.setCharAt(word.length - 1, word.last.toUpper)
  }
  result.reverse.result()
}

val tempStr = str
  .split("[.,!?: ]+")
  .map(result => reverseHelper(result))
  .mkString("")

val sList = "[.,!?: ]+".toList

var curr = 0

val formatString = str.map(c => {
          if(!sList.contains(c)) {
              curr = curr + 1
              tempStr(curr-1)
          }
          else c
      })

Answer 4

这是一种使用Regex模式生成Seq(word, nonWord)的成对字符串的列表，然后对word字符串进行反向和位置大写的方法：

def reverseWords(s: String): String = {
  val pattern = """(\w+)(\W*)""".r

  pattern.findAllMatchIn(s).flatMap(_.subgroups).grouped(2).
    map{ case Seq(word, nonWord) =>
      val caseList = word.map(_.isUpper)
      val newWord = (word.reverse zip caseList).map{
          case (c, true)  => c.toUpper
          case (c, false) => c.toLower
        }.mkString
      newWord + nonWord
    }.
    mkString
}

reverseWords("He likes McDonald's burgers. I prefer In-and-Out's.")
//res1: String = "Eh sekil DlAnodcm's sregrub. I referp Ni-dna-Tuo's."