Палиндромы с использованием Scala

делать обратное-не самая лучшая идея. Лучше начать с начала и конца строки и перебирать и сравнивать поэлементно. Вы тратите время на копирование всей строки и ее изменение даже в тех случаях, когда первый и последний элемент не совпадают. На что-то с миллионом цифр, это будет огромная потеря.

это на несколько порядков быстрее, чем обратный для больших чисел:

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;
    }
  }
}

Это самое общее и ясное решение, которое я могу достичь:
Edit: получил от 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
}   

в соответствии с вашей!--3--диапазон-меньше> предложение: то же самое, но с помощью 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)

и с итератором (и другим методом вызова, то же самое, что вы можете сделать с потоком, на самом деле):

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

но, как заявил @user unknown, это прямой bruteforce и не практично с большими числами.

чтобы проверить, является ли список любого типа палиндромом с помощью slice, без каких-либо циклов

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
      }

Вы можете просто использовать 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)

решение для проверки, является ли строка палиндромом

это решение не отменяет строку. Однако я не уверен, что это будет быстрее.

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

решение найти следующий палиндром строка

это решение не самое лучшее для scala (почти такое же, как Java-решение), но оно имеет дело только со строками и подходит для больших чисел

вы просто должны отразить первый половину числа, которое вы хотите, проверьте, выше ли оно начального числа, в противном случае увеличьте на одну последнюю цифру первой половины и повторите ее.

во-первых, функция для увеличения строкового представления 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"
}

затем функция для сравнения со строковым представлением ints: (функция '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
    }
  }
}