Question

我遇到了这个problem from CodeChef。问题表明如下：

如果正整数表示为正整数，则称为回文结构从左到右和从右读取时，十进制系统是相同的向左。对于给定的正整数K不大于1000000 数字，写出大于K的最小回文的值输出

我可以按如下方式定义isPalindrome方法：

def isPalindrome(someNumber:String):Boolean = someNumber.reverse.mkString == someNumber

我面临的问题是，当整数满足isPalindrome方法时，如何从初始给定数字循环并中断并返回第一个回文？另外，是否有更好（有效）的方法来编写isPalindrome方法？

在这里获得一些指导会很棒

Answer 1

如果您有一个类似123xxx的数字，您知道xxx必须低于321 - 那么下一个回文是123321.

或者xxx在上面，然后3不能保留，124421必须是下一个。

这里有一些没有保证的代码，不是很优雅，但中间的（多个）Nines的情况有点毛茸茸（19992）：

object Palindrome extends App {

def nextPalindrome (inNumber: String): String = {
  val len = inNumber.length ()
  if (len == 1 && inNumber (0) != '9') 
    "" + (inNumber.toInt + 1) else {
    val head = inNumber.substring (0, len/2)
    val tail = inNumber.reverse.substring (0, len/2)
    val h = if (head.length > 0) BigInt (head) else BigInt (0)
    val t = if (tail.length > 0) BigInt (tail) else BigInt (0)

    if (t < h) {
      if (len % 2 == 0) head + (head.reverse)
      else inNumber.substring (0, len/2 + 1) + (head.reverse)
    } else {
     if (len % 2 == 1) {
       val s2 = inNumber.substring (0, len/2 + 1) // 4=> 4
       val h2 = BigInt (s2) + 1  // 5 
       nextPalindrome (h2 + (List.fill (len/2) ('0').mkString)) // 5 + "" 
     } else {
       val h = BigInt (head) + 1
       h.toString + (h.toString.reverse)
     }
    }
  }
}

def check (in: String, expected: String) = {
  if (nextPalindrome (in) == expected) 
    println ("ok: " + in) else 
    println (" - fail: " + nextPalindrome (in) + " != " + expected + " for: " + in)
}
//
val nums = List (("12345", "12421"), // f
  ("123456", "124421"), 
  ("54321", "54345"), 
  ("654321", "654456"), 
  ("19992", "20002"),
  ("29991", "29992"),
  ("999", "1001"),
  ("31", "33"),
  ("13", "22"),
  ("9", "11"),
  ("99", "101"),
  ("131", "141"),
  ("3", "4")
)
nums.foreach (n => check (n._1, n._2))
println (nextPalindrome ("123456678901234564579898989891254392051039410809512345667890123456457989898989125439205103941080951234566789012345645798989898912543920510394108095"))

}

我猜它也会处理一百万位Int的情况。

Answer 2

做反向并不是最好的主意。最好从字符串的开头和结尾开始，然后逐个元素地迭代和比较。即使在第一个和最后一个元素不匹配的情况下，您也浪费时间复制整个String并将其反转。在百万位数的东西上，这将是一个巨大的浪费。

对于更大的数字，这比反向快几个数量级：

def isPalindrome2(someNumber:String):Boolean = {
  val len = someNumber.length;
  for(i <- 0 until len/2) {
    if(someNumber(i) != someNumber(len-i-1)) return false; 
  }
  return true;
}

甚至可能有一种更快的方法，基于镜像字符串的前半部分。我会看看我现在能不能得到它......

更新所以这应该在几乎恒定的时间内找到下一个回文。没有循环。我只是把它划掉了，所以我确信它可以清理干净。

def nextPalindrome(someNumber:String):String = {
  val len = someNumber.length;
  if(len==1) return "11";
  val half = scala.math.floor(len/2).toInt;
  var firstHalf = someNumber.substring(0,half);
  var secondHalf = if(len % 2 == 1) {
    someNumber.substring(half+1,len);
  } else {
    someNumber.substring(half,len);
  }

  if(BigInt(secondHalf) > BigInt(firstHalf.reverse)) {
    if(len % 2 == 1) {
      firstHalf += someNumber.substring(half, half+1);
      firstHalf = (BigInt(firstHalf)+1).toString;
      firstHalf + firstHalf.substring(0,firstHalf.length-1).reverse
    } else {
      firstHalf = (BigInt(firstHalf)+1).toString;
      firstHalf + firstHalf.reverse;
    }
  } else {
    if(len % 2 == 1) {
      firstHalf + someNumber.substring(half,half+1) + firstHalf.reverse;
    } else {
      firstHalf + firstHalf.reverse;
    }
  }
}

Answer 3

这是我能达到的最普遍，最明确的解决方案：
修改：摆脱了BigInt，现在只需不到一秒的时间来计算百万位数。

def incStr(num: String) = {  // helper method to increment number as String
  val idx = num.lastIndexWhere('9'!=, num.length-1)
  num.take(idx) + (num.charAt(idx)+1).toChar + "0"*(num.length-idx-1)
}

def palindromeAfter(num: String) = {
  val lengthIsOdd = num.length % 2 
  val halfLength  = num.length / 2 + lengthIsOdd
  val leftHalf  = num.take(halfLength)               // first half of number (including central digit)
  val rightHalf = num.drop(halfLength - lengthIsOdd) // second half of number (also including central digit)      

  val (newLeftHalf, newLengthIsOdd) =  // we need to calculate first half of new palindrome and whether it's length is odd or even
    if (rightHalf.compareTo(leftHalf.reverse) < 0) // simplest case - input number is like 123xxx and xxx < 321
      (leftHalf, lengthIsOdd) 
    else if (leftHalf forall ('9'==))              // special case - if number is like '999...', then next palindrome will be like '10...01' and one digit longer
      ("1" + "0" * (halfLength - lengthIsOdd), 1 - lengthIsOdd)
    else                                           // other cases - increment first half of input number before making palindrome
      (incStr(leftHalf), lengthIsOdd)

  // now we can create palindrome itself
  newLeftHalf + newLeftHalf.dropRight(newLengthIsOdd).reverse
}

Answer 4

根据您的无范围提案：同样的事情，但使用Stream：

def isPalindrome(n:Int):Boolean = n.toString.reverse == n.toString
def ints(n: Int): Stream[Int] = Stream.cons(n, ints(n+1))
val result = ints(100).find(isPalindrome)

使用迭代器（和不同的调用方法，实际上你可以用Stream做同样的事情）：

val result = Iterator.from(100).find(isPalindrome)

但正如@user未知所述，这是直接的暴力行为，对大数字而言并不实用。

Answer 5

使用切片检查任何类型的列表是否为回文，没有任何循环

def palindrome[T](list: List[T]): Boolean = {
if(list.length==1 || list.length==0 ){
  false
}else {
  val leftSlice: List[T] = list.slice(0, list.length / 2)
  var rightSlice :List[T]=Nil
  if (list.length % 2 != 0) {
    rightSlice = list.slice(list.length / 2 + 1, list.length).reverse
  } else {
    rightSlice = list.slice(list.length / 2, list.length).reverse
  }
  leftSlice ==rightSlice
}

}

虽然最简单的解决方案是

     def palindrome[T](list: List[T]): Boolean = {
      list == list.reverse
      }

Answer 6

您可以在集合上使用find方法来查找与给定谓词匹配的第一个元素：

  def isPalindrome(n:Int):Boolean = n.toString.reverse == n.toString
  val (start, end) = (100, 1000)
  val result: Option[Int] = (start to end).find(isPalindrome)
  result foreach println

  >Some(101)

Answer 7

验证字符串是否为回文的解决方案

此解决方案不会反转String。但是我不确定它会更快。

def isPalindrome(s:String):Boolean = { 
  s.isEmpty ||   
  ((s.last == s.head) && isPalindrome(s.tail.dropRight(1)))
}

在给定字符串的情况下找到下一个回文的解决方案

此解决方案不适用于scala（与Java解决方案非常相似），但它只处理字符串，适用于大数

你只需要镜像你想要的数字的前半部分，检查它是否高于开始数字，否则，将前半部分的最后一位数增加1并再次镜像。

首先，将int的字符串表示形式递增1：

的函数

def incrementString(s:String):String = {
  if(s.nonEmpty){
    if (s.last == '9')
      incrementString(s.dropRight(1))+'0'
    else
      s.dropRight(1) + (s.last.toInt +1).toChar
  }else
    "1"
}

然后，一个函数与int的字符串表示进行比较:(函数'compare'不适用于该情况）

/* is less that 0 if x<y, is more than 0 if x<y, is equal to 0 if x==y */
def compareInts(x:String, y:String):Int = {
  if (x.length !=y.length)
    (x.length).compare(y.length)
  else
    x.compare(y)
}

现在计算下一个回文的功能：

def nextPalindrome(origin_ :String):String = {
  /*Comment if you want to have a strictly bigger number, even if you already have a palindrome as input */
  val origin = origin_
  /* Uncomment if you want to have a strictly bigger number, even if you already have a palindrome as input */
  //val origin = incrementString(origin_)

  val length = origin.length
  if(length % 2 == 0){
    val (first, last) = origin.splitAt(length/2); 
    val reversed = first.reverse
    if (compareInts(reversed,last) > -1)
      first ++ reversed
    else{
      val firstIncr = incrementString(first)
      firstIncr ++ firstIncr.reverse
    }
  } else {
    val (first,last) = origin.splitAt((length+1)/2)
    val reversed = first.dropRight(1).reverse
    if (compareInts(reversed,last) != -1)
      first ++ reversed
    else{
      val firstIncr = incrementString(first)
      firstIncr ++ firstIncr.dropRight(1).reverse
    }
  }
}

Answer 8

您可以尝试这样的操作，我正在使用基本的递归：

 object Palindromo {
  def main(args: Array[String]): Unit = {

    var s: String = "arara"
    println(verificaPalindromo(s))
  }

  def verificaPalindromo(s: String): String = {
    if (s.length == 0 || s.length == 1)
      "true" 
    else
      if (s.charAt(0).toLower == s.charAt(s.length - 1).toLower)
        verificaPalindromo(s.substring(1, s.length - 1))
      else
        "false"
  }
}

Answer 9

  @tailrec
  def palindrome(str: String, start: Int, end: Int): Boolean = {
    if (start == end)
      true
    else if (str(start) != str(end))
      false
    else
      pali(str, start + 1, end - 1)
  }

  println(palindrome("arora", 0, str.length - 1))

Palindromes使用Scala

9 个答案: