Comment sortir d'une boucle dans Scala?

Comment sortir une boucle?

var largest=0
for(i<-999 to 1 by -1) {
    for (j<-i to 1 by -1) {
        val product=i*j
        if (largest>product)
            // I want to break out here
        else
           if(product.toString.equals(product.toString.reverse))
              largest=largest max product
    }
}

Comment transformer des boucles imbriquées en récursivité de queue?

Extrait de Scala Talk au FOSDEM 2009 http://www.slideshare.net/Odersky/fosdem-2009-1013261 sur la 22e page:

Briser et continuer Scala n'en a pas. Pourquoi? Ils sont un peu impératifs; mieux utiliser de nombreuses fonctions plus petites Problème d'interaction avec les fermetures. Ils ne sont pas nécessaires!

Quelle est l'explication?

Vous avez trois (ou plus) options pour sortir des boucles.

Supposons que vous souhaitiez additionner des nombres jusqu'à ce que le total soit supérieur à 1000. Vous essayez

var sum = 0
for (i <- 0 to 1000) sum += i

sauf que vous voulez arrêter quand (somme> 1000).

Que faire? Il existe plusieurs options.

(1a) Utilisez une construction qui inclut un conditionnel que vous testez.

var sum = 0
(0 to 1000).iterator.takeWhile(_ => sum < 1000).foreach(i => sum+=i)

(avertissement - cela dépend des détails de la façon dont le test takeWhile et le foreach sont entrelacés pendant l'évaluation, et ne devraient probablement pas être utilisés dans la pratique!).

(1b) Utilisez la récursion de queue au lieu d'une boucle for, en profitant de la facilité d'écriture d'une nouvelle méthode dans Scala:

var sum = 0
def addTo(i: Int, max: Int) {
  sum += i; if (sum < max) addTo(i+1,max)
}
addTo(0,1000)

(1c) Revenez à l'utilisation d'une boucle while

var sum = 0
var i = 0
while (i <= 1000 && sum <= 1000) { sum += 1; i += 1 }

(2) Jetez une exception.

object AllDone extends Exception { }
var sum = 0
try {
  for (i <- 0 to 1000) { sum += i; if (sum>=1000) throw AllDone }
} catch {
  case AllDone =>
}

(2a) Dans Scala 2.8+, ceci est déjà pré-packagé en scala.util.control.Breaksutilisant une syntaxe qui ressemble beaucoup à votre ancienne rupture familière de C / Java:

import scala.util.control.Breaks._
var sum = 0
breakable { for (i <- 0 to 1000) {
  sum += i
  if (sum >= 1000) break
} }

(3) Mettez le code dans une méthode et utilisez return.

var sum = 0
def findSum { for (i <- 0 to 1000) { sum += i; if (sum>=1000) return } }
findSum

C'est intentionnellement rendu pas trop facile pour au moins trois raisons auxquelles je peux penser. Tout d'abord, dans les grands blocs de code, il est facile d'ignorer les instructions "continue" et "break", ou de penser que vous vous échappez de plus ou de moins que vous ne l'êtes réellement, ou d'avoir besoin de casser deux boucles que vous ne pouvez pas faire facilement de toute façon - donc l'utilisation standard, bien que pratique, a ses problèmes, et donc vous devriez essayer de structurer votre code d'une manière différente. Deuxièmement, Scala a toutes sortes d'imbrications que vous ne remarquerez probablement même pas, donc si vous pouviez vous échapper, vous seriez probablement surpris de la fin du flux de code (en particulier avec les fermetures). Troisièmement, la plupart des "boucles" de Scala ne sont pas en fait des boucles normales - ce sont des appels de méthode qui ont leur propre boucle,Looplike, il est difficile de trouver un moyen cohérent de savoir ce que la «rupture» et autres devraient faire. Donc, pour être cohérent, la chose la plus sage à faire est de ne pas avoir du tout de "pause".

Remarque : il existe des équivalents fonctionnels de tous ces éléments dans lesquels vous retournez la valeur de sumplutôt que de la muter en place. Ce sont des Scala plus idiomatiques. Cependant, la logique reste la même. ( returndevient return x, etc.).

Cela a changé dans Scala 2.8 qui a un mécanisme pour utiliser les pauses. Vous pouvez maintenant effectuer les opérations suivantes:

import scala.util.control.Breaks._
var largest = 0
// pass a function to the breakable method
breakable { 
    for (i<-999 to 1  by -1; j <- i to 1 by -1) {
        val product = i * j
        if (largest > product) {
            break  // BREAK!!
        }
        else if (product.toString.equals(product.toString.reverse)) {
            largest = largest max product
        }
    }
}

Ce n'est jamais une bonne idée de sortir d'une boucle for. Si vous utilisez une boucle for, cela signifie que vous savez combien de fois vous souhaitez répéter. Utilisez une boucle while avec 2 conditions.

par exemple

var done = false
while (i <= length && !done) {
  if (sum > 1000) {
     done = true
  }
}

Pour ajouter Rex Kerr, répondez d'une autre manière:

• (1c) Vous pouvez également utiliser un garde dans votre boucle:

   var sum = 0
   for (i <- 0 to 1000 ; if sum<1000) sum += i
  

Puisqu'il n'y en a pas encore breakdans Scala, vous pouvez essayer de résoudre ce problème en utilisant une returndéclaration. Par conséquent, vous devez mettre votre boucle intérieure dans une fonction, sinon le retour ignorerait la boucle entière.

Scala 2.8 comprend cependant un moyen de briser

http://www.scala-lang.org/api/rc/scala/util/control/Breaks.html

// import following package
import scala.util.control._

// create a Breaks object as follows
val loop = new Breaks;

// Keep the loop inside breakable as follows
loop.breakable{
// Loop will go here
for(...){
   ....
   // Break will go here
   loop.break;
   }
}

utilisez le module Break http://www.tutorialspoint.com/scala/scala_break_statement.htm

Utilisez simplement une boucle while:

var (i, sum) = (0, 0)
while (sum < 1000) {
  sum += i
  i += 1
}

Une approche qui génère les valeurs sur une plage au fur et à mesure que nous itérons, jusqu'à une condition de rupture, au lieu de générer d'abord une plage entière, puis d'itérer dessus, en utilisant Iterator, (inspiré de l'utilisation @RexKerr de Stream)

var sum = 0
for ( i <- Iterator.from(1).takeWhile( _ => sum < 1000) ) sum += i

Voici une version récursive de queue. Comparé aux for-comprehensions, c'est un peu cryptique, certes, mais je dirais que c'est fonctionnel :)

def run(start:Int) = {
  @tailrec
  def tr(i:Int, largest:Int):Int = tr1(i, i, largest) match {
    case x if i > 1 => tr(i-1, x)
    case _ => largest
  }

  @tailrec
  def tr1(i:Int,j:Int, largest:Int):Int = i*j match {
    case x if x < largest || j < 2 => largest
    case x if x.toString.equals(x.toString.reverse) => tr1(i, j-1, x)
    case _ => tr1(i, j-1, largest)
  }

  tr(start, 0)
}

Comme vous pouvez le voir, la fonction tr est la contrepartie des for-comprehensions externes et tr1 de la for-comprehensions interne. Vous êtes les bienvenus si vous connaissez un moyen d'optimiser ma version.

La solution la plus proche serait la suivante:

var largest = 0
for (i <- 999 to 1 by -1;
  j <- i to 1 by -1;
  product = i * j;
  if (largest <= product && product.toString.reverse.equals (product.toString.reverse.reverse)))
    largest = product

println (largest)

La j-itération est faite sans nouvelle portée, et la génération du produit ainsi que la condition sont effectuées dans l'instruction for (pas une bonne expression - je n'en trouve pas de meilleure). La condition est inversée, ce qui est assez rapide pour cette taille de problème - peut-être que vous gagnez quelque chose avec une pause pour les boucles plus grandes.

String.reverse se convertit implicitement en RichString, c'est pourquoi je fais 2 revers supplémentaires. :) Une approche plus mathématique pourrait être plus élégante.

Le breakablepackage tiers est une alternative possible

https://github.com/erikerlandson/breakable

Exemple de code:

scala> import com.manyangled.breakable._
import com.manyangled.breakable._

scala> val bkb2 = for {
     |   (x, xLab) <- Stream.from(0).breakable   // create breakable sequence with a method
     |   (y, yLab) <- breakable(Stream.from(0))  // create with a function
     |   if (x % 2 == 1) continue(xLab)          // continue to next in outer "x" loop
     |   if (y % 2 == 0) continue(yLab)          // continue to next in inner "y" loop
     |   if (x > 10) break(xLab)                 // break the outer "x" loop
     |   if (y > x) break(yLab)                  // break the inner "y" loop
     | } yield (x, y)
bkb2: com.manyangled.breakable.Breakable[(Int, Int)] = com.manyangled.breakable.Breakable@34dc53d2

scala> bkb2.toVector
res0: Vector[(Int, Int)] = Vector((2,1), (4,1), (4,3), (6,1), (6,3), (6,5), (8,1), (8,3), (8,5), (8,7), (10,1), (10,3), (10,5), (10,7), (10,9))

import scala.util.control._

object demo_brk_963 
{
   def main(args: Array[String]) 
   {
      var a = 0;
      var b = 0;
      val numList1 = List(1,2,3,4,5,6,7,8,9,10);
      val numList2 = List(11,12,13);

      val outer = new Breaks; //object for break
      val inner = new Breaks; //object for break

      outer.breakable // Outer Block
      {
         for( a <- numList1)
         {
            println( "Value of a: " + a);

            inner.breakable // Inner Block
            {
               for( b <- numList2)
               {
                  println( "Value of b: " + b);

                  if( b == 12 )
                  {
                      println( "break-INNER;");
                       inner.break;
                  }
               }
            } // inner breakable
            if( a == 6 )
            {
                println( "break-OUTER;");
                outer.break;
            }
         }
      } // outer breakable.
   }
}

Méthode de base pour rompre la boucle, en utilisant la classe Breaks. En déclarant la boucle cassable.

Tout simplement, nous pouvons faire en scala est

scala> import util.control.Breaks._

scala> object TestBreak{
       def main(args : Array[String]){
       breakable {
       for (i <- 1 to 10){
       println(i)
       if (i == 5){
       break;
       } } } } }

production :

scala> TestBreak.main(Array())
1
2
3
4
5

Ironiquement, l'effraction de Scala scala.util.control.Breaksest une exception:

def break(): Nothing = { throw breakException }

Le meilleur conseil est: NE PAS utiliser break, continue et goto! OMI, ce sont les mêmes, les mauvaises pratiques et une source perverse de toutes sortes de problèmes (et de discussions brûlantes) et finalement "considérées comme nuisibles". Le bloc de code est structuré, également dans cet exemple les ruptures sont superflues. Notre Edsger W. Dijkstra † a écrit:

La qualité des programmeurs est une fonction décroissante de la densité des instructions go to dans les programmes qu'ils produisent.

J'ai une situation comme le code ci-dessous

 for(id<-0 to 99) {
    try {
      var symbol = ctx.read("$.stocks[" + id + "].symbol").toString
      var name = ctx.read("$.stocks[" + id + "].name").toString
      stocklist(symbol) = name
    }catch {
      case ex: com.jayway.jsonpath.PathNotFoundException=>{break}
    }
  }

J'utilise une bibliothèque java et le mécanisme est que ctx.read lève une exception quand il ne trouve rien. J'étais coincé dans la situation suivante: je dois rompre la boucle lorsqu'une exception a été levée, mais scala.util.control.Breaks.break utilise Exception pour rompre la boucle, et il était dans le bloc catch donc il a été intercepté.

J'ai eu laide façon de résoudre ce problème: faites la boucle pour la première fois et obtenez le compte de la longueur réelle. et l'utiliser pour la deuxième boucle.

retirer une pause de Scala n'est pas si bon, quand vous utilisez des bibliothèques java.

Je suis nouveau sur Scala, mais que diriez-vous pour éviter de lever des exceptions et de répéter les méthodes:

object awhile {
def apply(condition: () => Boolean, action: () => breakwhen): Unit = {
    while (condition()) {
        action() match {
            case breakwhen(true)    => return ;
            case _                  => { };
        }
    }
}
case class breakwhen(break:Boolean);

utilisez-le comme ceci:

var i = 0
awhile(() => i < 20, () => {
    i = i + 1
    breakwhen(i == 5)
});
println(i)

si vous ne voulez pas casser:

awhile(() => i < 20, () => {
    i = i + 1
    breakwhen(false)
});

Une utilisation intelligente de la findméthode de collecte fera l'affaire pour vous.

var largest = 0
lazy val ij =
  for (i <- 999 to 1 by -1; j <- i to 1 by -1) yield (i, j)

val largest_ij = ij.find { case(i,j) =>
  val product = i * j
  if (product.toString == product.toString.reverse)
    largest = largest max product
  largest > product
}

println(largest_ij.get)
println(largest)

Ci-dessous, le code pour rompre une boucle d'une manière simple

import scala.util.control.Breaks.break

object RecurringCharacter {
  def main(args: Array[String]) {
    val str = "nileshshinde";

    for (i <- 0 to str.length() - 1) {
      for (j <- i + 1 to str.length() - 1) {

        if (str(i) == str(j)) {
          println("First Repeted Character " + str(i))
          break()     //break method will exit the loop with an Exception "Exception in thread "main" scala.util.control.BreakControl"

        }
      }
    }
  }
}

Je ne sais pas à quel point le style Scala a changé au cours des 9 dernières années, mais j'ai trouvé intéressant que la plupart des réponses existantes utilisent vars, ou difficile à lire la récursivité. La clé pour sortir tôt est d'utiliser une collection paresseuse pour générer vos candidats potentiels, puis vérifiez la condition séparément. Pour générer les produits:

val products = for {
  i <- (999 to 1 by -1).view
  j <- (i to 1 by -1).view
} yield (i*j)

Ensuite, pour trouver le premier palindrome à partir de cette vue sans générer toutes les combinaisons:

val palindromes = products filter {p => p.toString == p.toString.reverse}
palindromes.head

Pour trouver le plus grand palindrome (bien que la paresse ne vous achète pas beaucoup car vous devez quand même consulter la liste entière):

palindromes.max

Votre code d'origine vérifie en fait le premier palindrome qui est plus grand qu'un produit suivant, ce qui revient à vérifier le premier palindrome, sauf dans une condition aux limites étrange que je ne pense pas que vous vouliez. Les produits ne diminuent pas strictement de façon monotone. Par exemple, 998*998est supérieur à 999*997, mais apparaît beaucoup plus tard dans les boucles.

Quoi qu'il en soit, l'avantage de la génération paresseuse séparée et de la vérification de l'état est que vous l'écrivez à peu près comme s'il utilisait la liste entière, mais il ne génère que ce dont vous avez besoin. Vous obtenez en quelque sorte le meilleur des deux mondes.