Disminuyendo el ciclo en Scala?

Question

Primer día y primer intento de usar Scala, ¡así que no me molestes! Estoy tratando de reescribir algún viejo código Java que tengo, que es simplemente una función que toma dos números e imprime los números de xa y. Por ejemplo, tengo la función de la subasta:

def increment(start: Int, finish: Int) = { 
     for (i <- start to finish) { 
     println("Current value (increasing from "+start+" to "+finish+") is "+i) 
     } 
    } 

Sin embargo, im luchando escribiendo una función de decremento correspondiente, que disminuirá de principio a fin? He leído Scala downwards or decreasing for loop? pero todavía no estoy seguro

Gracias

Answer 1

scala>def decrement(start: Int, finish: Int) = { 
    | for (i <- start to finish by -1) 
    | println("Current value (decreasing from "+start+" to "+finish+") is "+i); 
    | } 
decrement: (start: Int,finish: Int)Unit 

scala> decrement(10, 1) 
Current value (decreasing from 10 to 1) is 10 
Current value (decreasing from 10 to 1) is 9 
Current value (decreasing from 10 to 1) is 8 
Current value (decreasing from 10 to 1) is 7 
Current value (decreasing from 10 to 1) is 6 
Current value (decreasing from 10 to 1) is 5 
Current value (decreasing from 10 to 1) is 4 
Current value (decreasing from 10 to 1) is 3 
Current value (decreasing from 10 to 1) is 2 
Current value (decreasing from 10 to 1) is 1 

Answer 2

for (i <- (6 to 3 by -1)) {println ("i: " + i)} 
i: 6 
i: 5 
i: 4 
i: 3 

Si se olvida de by -1, puede moverse hacia arriba y utilizar una función, para revertir el resultado:

for (i <- (3 to 6)) {println ("i: " + ((6+3) - i))} 

Para excluir el segundo límite, use until:

for (i <- (6 until 3 by -1)) {println ("i: " + i)} 
i: 6 
i: 5 
i: 4 

Como alternativa, puede definir un iterador para su propósito. La extensión de un iterador es fácil; acaba de poner en práctica 'hasNext: Boolean' y 'siguiente: [L]', donde T es el tipo de manejar - en nuestro caso Int o tal vez a largo o Bigint:

class FromToIterator (start: Int, stop: Int) extends Iterator [Int] { 
    var current = start 
    //      3  6  3   6   6  3  6   3 
    def hasNext : Boolean = ((start < stop && current <= stop) || (start > stop && current >= stop)) 
    def next: Int = { 
    val res = current 
    if (start < stop) current += 1 else current -= 1 
    res 
    } 
} 
val it = new FromToIterator (3, 6) 
val ti = new FromToIterator (6, 3) 

for (i <-it) println (i) 
for (i <-ti) println (i) 

Answer 3

Aquí hay un incremento mundial/solución decremento inspirado por Scala downwards or decreasing for loop?:

def goThrough(start: Int, finish: Int) = {  
    val d = if(start<=finish) 1 else -1 
    for (i <- start to finish by d) { 
    println("Current value (increasing from "+start+" to "+finish+") is "+i) 
    } 
} 

Answer 4

highnum a lownum por -1 (interruptor con otro paso negativo o positivo para cambiar paso a paso)

def decrement(start: Int, finish: Int) = { 
    for (i <- start to finish by -1) { 
    println("Current value (decreasing from "+start+" to "+finish+") is "+i) 
    } 
} 

creo que esto es una víctima de Scala downwards or decreasing for loop?

Answer 5

object Test extends App{ 

    def decrement(start: Int, finish: Int,dec :Int) = { 
    for (i <- Range(start,finish,dec)) { 
     println("Current value (decreasing from "+start+" to "+finish+") is "+i) 
    } 
    } 

    decrement(5,0,-1) 
} 

Este es también un método.pero puede no ser la mejor llamada

Answer 6

def printInDecreasingOrder(start : Int, end : Int){ 
    if(start > end){ 
    for(i <- start to end by -1){ 
     println(s"Current value (decreasing from $start to $end) is $i") 
    } 
    }else{ 
    println("first num is smaller than second") 
    } 
} 

método:

printInDecreasingOrder(10, 2)

Resultado:

valor actual (disminución de 10 a 2) es de 10

valor actual (mayor a menor de 10 a 2) es 9

Valor actual (d ecreasing de 10 a 2) es 8

valor actual (disminuyendo de 10 a 2) es 7

valor actual (disminuyendo de 10 a 2) es 6

valor actual (disminuyendo de 10 a 2) es 5

valor actual (disminuyendo de 10 a 2) es 4

valor actual (disminuyendo de 10 a 2) es 3

valor actual (Disminuyendo de 10 a 2) es 2

printInDecreasingOrder(1, 10)

Resultado:

primera num es más pequeño que segundo

Answer 7

esta manera se puede utilizar decreciente para bucle en Scala.

object Example extends App { 


     for(i <- 20 to 2 by -2){ 


     println("Value of i = "+ i) 

     } 
    } 
------------------ 
O/P 
------------------ 
Value of i = 20 
Value of i = 18 
Value of i = 16 
Value of i = 14 
Value of i = 12 
Value of i = 10 
Value of i = 8 
Value of i = 6 
Value of i = 4 
Value of i = 2