2012-03-29 16 views
8

Supongamos que tengo el código C por debajo decómo saltear algunas iteraciones en un bucle en Ruby?

for(i = 0; i < 10; i++){ 
    printf("Hello"); 
    if(i == 5){ 
     a[3] = a[2] * 2; 
     if(a[3] == b) 
      i = a[3];   //Skip to index = a[3]; depends on runtime value 
    } 
} 

Cómo convertir a Ruby? Sé que podemos omitir una iteración usando next, pero tengo que omitir algunas iteraciones dependiendo del valor condicional y no sé cuántas iteraciones saltear antes del tiempo de ejecución.


Aquí está el código que estoy realmente trabajando en (según lo mencionado por Coreyward):

Busco "línea recta" de la matriz que los valores difiere menos del 0,1 (menos de 0,1 se considerado como una "línea recta"). El rango debe ser mayor a 50 para ser considerado como una "línea" larga. Después de encontrar el rango de línea [a, b], quiero omitir las iteraciones al límite superior b para que no comience de nuevo desde a + 1, y comenzará a buscar una nueva "línea recta" desde b + 1

for(i=0; i<arr.Length; i++){ 
    if(arr[i] - arr[i + 50] < 0.1){ 
    m = i;         //m is the starting point 
    for(j=i; j<arr.Length; j++){    //this loop makes sure all values differs less than 0.1 
     if(arr[i] - arr[j] < 0.1){ 
     n = j; 
     }else{ 
     break; 
     } 
    } 
    if(n - m > 50){       //Found a line with range greater than 50, and store the starting point to line array 
     line[i] = m 
    } 
    i = n          //Start new search from n 
    } 

}

+2

Sería mucho más útil si se ha proporcionado la intención de lo que estamos tratando de lograr. Hay algunos métodos muy prácticos en la clase Enumerator que le permiten establecer el valor de la siguiente iteración ('feed') y ver el siguiente valor (' peek'), y también puede usar un ciclo 'for' en Rubí. Estoy seguro de que hay una manera más clara de escribir esto, simplemente no sé lo que está tratando de hacer. – coreyward

+0

Vas a indexar el final de tu matriz en C, probablemente quieras cambiar el límite a 'arr.Length-50'. Esto parece una forma algo intrincada de encontrar ejecuciones de 50 o más cuyos valores son con épsilon del valor inicial. – dbenhur

+0

Parece que está asumiendo que los valores con un índice mayor nunca son menores que los valores con un índice más bajo. ¿Es esto cierto? – dbenhur

Respuesta

2

Otra forma es utilizar la clase enumerator:

iter = (1..10).to_enum 
while true 
    value = iter.next 
    puts "value is #{value.inspect}" 
    if value == 5 
    3.times {value = iter.next} 
    end 
end 

da

value is 1 
value is 2 
value is 3 
value is 4 
value is 5 
value is 9 
value is 10 
StopIteration: iteration reached at end 
     from (irb):15:in `next' 
     from (irb):15 
     from C:/Ruby19/bin/irb:12:in `<main>' 
+0

Esto es lindo, pero no es una equivalencia para avanzar un índice directamente. Si uno está iterando a través de una matriz con i y llega a una decisión donde uno quiere avanzar al índice j, hacer '(j-i) .times {iter.next}' es más complejo y costoso que simplemente asignar 'i = j' – dbenhur

3

Su caso no está cubierto fácilmente por los iteradores típicos rubí, rubí, pero también tiene ordinaria, mientras que los bucles que pueden cubrir por completo c-para. lo siguiente es equivalente a tu c para el ciclo de arriba.

i = 0; 
while i < 10 
    puts "Hello" 
    if i == 5 
    a[3] = a[2] * 2 
    i = a[3] if a[3] == b 
    end 
    # in your code above, the for increment i++ will execute after assigning new i, 
    # though the comment "Skip to index = a[3]" indicates that may not be your intent 
    i += 1 
end 
+0

Sí, esto funciona, pero ¿hay alguna forma de hacerlo con enumeradores? Estaba pensando en 'drop', por lo que soltaré los valores entre 5 y a [3], pero me confundí y perdí cuando comencé a codificar. – texasbruce

Cuestiones relacionadas