Come faccio a uscire da un ciclo in Scala?

Come faccio a interrompere un ciclo?

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

Come posso trasformare i nidificati per loop in ricorsione della coda?

Da Scala Talk al FOSDEM 2009 http://www.slideshare.net/Odersky/fosdem-2009-1013261 alla 22a pagina:

Rompere e continuare Scala non li ha. Perché? Sono un po 'imperativi; utilizzare meglio molte funzioni più piccole Emettere come interagire con le chiusure. Non sono necessari!

Qual è la spiegazione?

Hai tre (o giù di lì) opzioni per uscire dai loop.

Supponiamo di voler sommare i numeri fino a quando il totale è maggiore di 1000. Prova

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

tranne che si desidera interrompere quando (somma> 1000).

Cosa fare? Esistono diverse opzioni.

(1a) Utilizzare un costrutto che include un condizionale testato.

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

(attenzione - questo dipende dai dettagli di come il test takeWhile e il foreach sono interlacciati durante la valutazione e probabilmente non dovrebbero essere usati in pratica!).

(1b) Usa la ricorsione della coda invece di un ciclo for, approfittando di quanto sia facile scrivere un nuovo metodo in Scala:

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

(1c) Riporta all'utilizzo di un ciclo while

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

(2) Genera un'eccezione.

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

(2a) In Scala 2.8+ questo è già preconfezionato scala.util.control.Breaksnell'uso della sintassi che assomiglia molto alla tua vecchia pausa familiare da C / Java:

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

(3) Inserisci il codice in un metodo e usa return.

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

Questo è intenzionalmente reso non troppo facile per almeno tre motivi a cui riesco a pensare. Innanzitutto, in blocchi di codice di grandi dimensioni, è facile trascurare le istruzioni "continue" e "break", o pensare che stai uscendo da più o meno di quello che sei realmente, o devi interrompere due loop che non puoi fare facilmente comunque - quindi l'uso standard, sebbene utile, ha i suoi problemi, e quindi dovresti provare a strutturare il tuo codice in un modo diverso. In secondo luogo, Scala ha molti tipi di annidamenti che probabilmente non noterai nemmeno, quindi se potessi uscire dalle cose, probabilmente rimarrai sorpreso da dove finiva il flusso del codice (specialmente con le chiusure). Terzo, la maggior parte dei "loop" di Scala non sono in realtà loop normali: sono chiamate di metodo che hanno il loro loop,looplike, è difficile trovare un modo coerente per sapere cosa dovrebbe fare "break" e simili. Quindi, per essere coerenti, la cosa più saggia da fare è non avere affatto una "pausa".

Nota : ci sono equivalenti funzionali di tutti questi in cui si restituisce il valore sumpiuttosto che mutarlo in posizione. Questi sono Scala più idiomatica. Tuttavia, la logica rimane la stessa. ( returndiventa return x, ecc.).

Questo è cambiato in Scala 2.8 che ha un meccanismo per usare le pause. Ora puoi fare quanto segue:

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

Non è mai una buona idea uscire da un for-loop. Se stai usando un for-loop significa che sai quante volte vuoi iterare. Utilizzare un ciclo while con 2 condizioni.

per esempio

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

Per aggiungere la risposta di Rex Kerr in un altro modo:

• (1c) Puoi anche usare una guardia nel tuo loop:

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

Dato che non esiste ancora breakin Scala, potresti provare a risolvere questo problema usando una returndichiarazione. Pertanto è necessario inserire il proprio ciclo interno in una funzione, altrimenti il ​​ritorno salta l'intero ciclo.

Scala 2.8 tuttavia include un modo per rompere

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

usa il modulo Break http://www.tutorialspoint.com/scala/scala_break_statement.htm

Basta usare un ciclo while:

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

Un approccio che genera i valori su un intervallo mentre ripetiamo, fino a una condizione di rottura, invece di generare prima un intero intervallo e poi iterare su di esso, usando Iterator, (ispirato nell'uso di @RexKerr di Stream)

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

Ecco una versione ricorsiva della coda. Rispetto alla comprensione è un po 'enigmatico, devo dire, ma direi che è funzionale :)

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

Come puoi vedere, la funzione tr è la controparte delle comprensioni esterne e tr1 di quella interna. Sei il benvenuto se conosci un modo per ottimizzare la mia versione.

Vicino alla tua soluzione sarebbe questo:

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-iteration è fatta senza un nuovo ambito e la generazione del prodotto e la condizione sono fatte nella dichiarazione for (non una buona espressione - non ne trovo una migliore). La condizione è invertita, il che è abbastanza veloce per quella dimensione del problema - forse ottieni qualcosa con una pausa per loop più grandi.

String.reverse converte implicitamente in RichString, motivo per cui faccio 2 inversioni extra. :) Un approccio più matematico potrebbe essere più elegante.

Il breakablepacchetto di terze parti è una possibile alternativa

https://github.com/erikerlandson/breakable

Codice di esempio:

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

Metodo di base per interrompere il ciclo, utilizzando la classe Breaks. Dichiarando il loop come fragile.

Semplicemente possiamo fare in scala è

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

produzione :

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

Ironia della sorte, la rottura della Scala scala.util.control.Breaksè un'eccezione:

def break(): Nothing = { throw breakException }

Il miglior consiglio è: NON usare pausa, continua e vai! IMO sono la stessa, cattiva pratica e una fonte malvagia di ogni tipo di problema (e discussioni accese) e infine "considerati dannosi". Blocco di codice strutturato, anche in questo esempio le interruzioni sono superflue. Il nostro Edsger W. Dijkstra † ha scritto:

La qualità dei programmatori è una funzione decrescente della densità di andare alle istruzioni nei programmi che producono.

Ho una situazione come il codice qui sotto

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

Sto usando una libreria Java e il meccanismo è che ctx.read genera un'eccezione quando non riesce a trovare nulla. Sono rimasto intrappolato nella situazione che: devo interrompere il loop quando viene generata un'eccezione, ma scala.util.control.Breaks.break utilizza l'eccezione per interrompere il loop, ed era nel blocco catch quindi è stato catturato.

Ho un brutto modo di risolverlo: esegui il loop per la prima volta e ottieni il conteggio della lunghezza reale. e usalo per il secondo loop.

fare una pausa da Scala non è così buono, quando si usano alcune librerie Java.

Sono nuovo di Scala, ma che ne dici di evitare di gettare eccezioni e ripetere i metodi:

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

usalo così:

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

se non vuoi rompere:

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

L' uso intelligente del findmetodo di raccolta farà al caso tuo.

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)

Di seguito è riportato il codice per interrompere un loop in modo semplice

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"

        }
      }
    }
  }
}

Non so quanto sia cambiato lo stile alla Scala negli ultimi 9 anni, ma ho trovato interessante l'utilizzo della maggior parte delle risposte esistenti varso la ricorsione difficile da leggere. La chiave per uscire presto è utilizzare una collezione pigra per generare i tuoi possibili candidati, quindi verificare la condizione separatamente. Per generare i prodotti:

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

Quindi per trovare il primo palindromo da quella vista senza generare ogni combinazione:

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

Per trovare il più grande palindromo (anche se la pigrizia non ti compra molto perché devi comunque controllare l'intero elenco):

palindromes.max

Il tuo codice originale sta effettivamente controllando il primo palindromo che è più grande di un prodotto successivo, che è lo stesso del controllo del primo palindromo, tranne in una strana condizione al contorno che non penso tu abbia inteso. I prodotti non stanno diminuendo rigorosamente monotonicamente. Ad esempio, 998*998è maggiore di 999*997, ma appare molto più tardi nei loop.

Ad ogni modo, il vantaggio della generazione pigra separata e del controllo delle condizioni è che lo scrivi praticamente come se stesse usando l'intero elenco, ma genera solo tutto ciò di cui hai bisogno. In un certo senso ottieni il meglio da entrambi i mondi.