Ruby imbriqué chaque boucle

Question

J'essaie de comprendre les boucles imbriquées en faisant fonctionner ce programme. Je voudrais utiliser la méthode de bouclage "à faire", si possible. En ce moment la boucle exécute toute la 1ère boucle, puis la 2ème ... etc ... Je voudrais faire, exécuter la 1ère boucle 1 fois, puis tomber à la 2ème boucle une fois ... etc. Voici mon code (ci-dessous collé)

souhaité sortie serait quelque chose comme ceci:

index      3.0     3.0 
+-------------------------------------------------------+ 
0       -23.4    -23.4 
1      -2226.74    -2226.74 
2     -1.93464e+07   -1.93464e+07 

code

class LogisticsFunction 
    puts "Enter two numbers, both between 0 and 1 (example: .25 .55)." 
    puts "After entering the two numbers tell us how many times you" 
    puts "want the program to iterate the values (example: 1)." 

    puts "Please enter the first number: " 
    num1 = gets.chomp 

    puts "Enter your second number: " 
    num2 = gets.chomp 

    puts "Enter the number of times you want the program to iterate: " 
    iter = gets.chomp 

    print "index".rjust(1) 
    print num1.rjust(20) 
    puts num2.rjust(30) 
    puts "+-------------------------------------------------------+" 

    (1..iter.to_i).each do |i| 
    print i 
    end 
    (1..iter.to_i).each do |i| 
     num1 = (3.9) * num1.to_f * (1-num1.to_f) 
     print num1 
    end 
     (1..iter.to_i).each do |i| 
     num2 = (3.9) * num2.to_f * (1-num2.to_f) 
      print num2 
     end 
end 

Answer 1

Je pense que vous ne devez pas courir avec trois boucles, suivant donnera la sortie du désir

(1..iter.to_i).each do |i| 
    print i 
    num1 = (3.9) * num1.to_f * (1-num1.to_f) 
    print num1.to_s.rjust(20) 
    num2 = (3.9) * num2.to_f * (1-num2.to_f) 
    print num2.to_s.rjust(30) 
end 

Answer 2

wouldnt quelque chose comme ça résoudre votre problème?

(1..iter.to_i).each do |i| 
    num1 = (3.9) * num1.to_f * (1-num1.to_f) 
    print num1 
    num2 = (3.9) * num2.to_f * (1-num2.to_f) 
    print num2 
end 

D'après ce que je peux vous voir même utiliser DonT la variable i. Donc, en théorie, vous pouvez simplement faire

iter.to_i.times do 
    # stuff 
end 

Answer 3

Vos boucles ne sont pas réellement imbriquées. Ils sont en fait l'un après l'autre. C'est pourquoi ils courent les uns après les autres. Pour les imbriquer - vous devez les mettre l'un dans l'autre. par exemple:

Non niché

(1..iter.to_i).each do |i| 
    # stuff for loop 1 is done here 
end # this closes the first loop - the entire first loop will run now 

(1..iter.to_i).each do |j| 
    # stuff for loop 2 is done here 
end # this closes the second loop - the entire second loop will run now 

Nested:

(1..iter.to_i).each do |i| 
    # stuff for loop 1 is done here 
    (1..iter.to_i) .each do |j| 
    # stuff for loop 2 is done here 
    end # this closes the second loop - the second loop will run again now 
    # it will run each time the first loop is run 
end # this closes the first loop - it will run i times