2012-03-29 12 views
8

Supponiamo che io ho il codice C al di sottocome saltare alcune iterazioni in un ciclo in 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 
    } 
} 

Come convertire a Ruby? So che possiamo saltare una iterazione usando next, ma devo saltare alcune iterazioni a seconda del valore condizionale e non so quante iterazioni saltare prima del runtime?


Ecco il codice che sto effettivamente lavorando (come detto da Coreyward):

cerco "retta" nella matrice che i valori differisce meno di 0,1 (meno di 0,1 sarà considerato come una "linea retta"). L'intervallo deve essere più lungo di 50 per essere considerato come una "linea" lunga. Dopo aver trovato l'intervallo di righe [a, b], voglio saltare le iterazioni al limite superiore b in modo che non ricomincia da un + 1, e inizierà a trovare una nuova "linea retta" da 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

Sarebbe molto più utile se hai fornito l'intento di ciò che si sta cercando di realizzare. Ci sono alcuni metodi molto utili nella classe Enumerator che ti permettono di impostare il valore per la successiva iterazione ('feed') e vedere il valore successivo (' peek'), e puoi anche usare un ciclo 'for' in Rubino. Sono sicuro che c'è un modo più pulito di scrivere questo, semplicemente non so cosa stia cercando di fare. – coreyward

+0

Stai per indicizzare la fine della tua matrice in C, probabilmente vuoi cambiare il limite a "arr.Length-50". Questo sembra un modo un po 'complicato per trovare corse di 50 o più i cui valori sono con epsilon del valore iniziale. – dbenhur

+0

Sembra che si assuma che i valori a un indice più grande non siano mai inferiori ai valori nell'indice inferiore. È vero? – dbenhur

risposta

2

Un altro modo è usare la classe 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 

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

Questo è carino, ma non un'equivalenza per far avanzare un indice direttamente. Se si sta iterando attraverso una matrice con i e si raggiunge una decisione in cui si desidera passare all'indice j, facendo '(j-i) .times {iter.next}' è più complesso e costoso dell'assegnazione di 'i = j'. – dbenhur

3

Il tuo caso non è facilmente coperto da iteratori tipici rubino, ma ha anche ruby ​​ordinaria cicli while che può completamente coprire c-per. il seguente è equivalente al tuo ciclo c per sopra.

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ì, funziona, ma esiste un modo per farlo con gli Enumeratori? Stavo pensando a 'drop', quindi lascerà cadere i valori tra 5 e a [3], ma è stato confuso e perso quando ho iniziato a scrivere codice. – texasbruce

Problemi correlati