如何在ruby中反转顺序

如何用Ruby编写一个代码段，以相反的顺序打印出1到200之间每3的倍数

这是我目前掌握的代码：

(1..200).each do | i | ##loop it then
  if i % 3 == 0

---

您可以尝试将值分配给变量a，然后可以：

a.reverse!
puts a

例如，这也可能有帮助：

def reverse_string(string) # method reverse_string with parameter 'string'
  loop = string.length       # int loop is equal to the string's length
  word = ''                  # this is what we will use to output the reversed word
  while loop > 0             # while loop is greater than 0, subtract loop by 1 and add the string's index of loop to 'word'
    loop -= 1                  # subtract 1 from loop
    word += string[loop]       # add the index with the int loop to word
  end                        # end while loop
  return word                # return the reversed word
end                        # end the method

---

您可以尝试将值分配给变量a，然后可以：

a.reverse!
puts a

例如，这也可能有帮助：

def reverse_string(string) # method reverse_string with parameter 'string'
  loop = string.length       # int loop is equal to the string's length
  word = ''                  # this is what we will use to output the reversed word
  while loop > 0             # while loop is greater than 0, subtract loop by 1 and add the string's index of loop to 'word'
    loop -= 1                  # subtract 1 from loop
    word += string[loop]       # add the index with the int loop to word
  end                        # end while loop
  return word                # return the reversed word
end                        # end the method

Range没有反向方法，但您可以调用_a以返回这些数字的数组，然后在该数组上分别调用reverse_以反向顺序迭代这些数字：

(1..200).to_a.reverse_each { |i| puts i if i % 3 == 0 }

有关详细信息，请参阅和的文档。

Range没有反向方法，但您可以调用a以返回这些数字的数组，然后在该数组上分别调用reverse\u以按相反顺序迭代这些数字：

(1..200).to_a.reverse_each { |i| puts i if i % 3 == 0 }

有关更多信息，请参阅和的文档。

您可能需要选择并反转

您可能需要选择并反转

这项工作：

(1..200).to_a.reverse.each do |number|
  if number % 3 == 0
  puts number
  end
end

在这里，您将指定一个从1到200的数字范围，将它们转换为数组，颠倒顺序并迭代每个元素，以查看它是否可以被3整除，即如果被3整除，它不应该有余数，如果是，则打印数字：

编辑：正如乔丹指出的，写作

reverse_each 

而不是

 reverse.each 

效率更高。

这样做：

(1..200).to_a.reverse.each do |number|
  if number % 3 == 0
  puts number
  end
end

在这里，您将指定一个从1到200的数字范围，将它们转换为数组，颠倒顺序并迭代每个元素，以查看它是否可以被3整除，即如果被3整除，它不应该有余数，如果是，则打印数字：

编辑：正如乔丹指出的，写作

reverse_each 

而不是

 reverse.each 

---

效率更高。

从200到1打印三的倍数的最简单方法是使用：

---

与其他答案不同，它不需要将一个范围转换为一个数组，也不需要创建一个数组并将其反转。

打印从200到1的三个倍数的最简单方法是使用：

---

与其他答案不同，它不需要将一个范围转换为数组，也不需要创建数组并将其反转。

OP希望打印范围的某些元素。当然，首先构造一个数组是低效的，但也不是必要的。我的答案和其他一些答案并不创建数组

假设范围的形式为first..last。要按相反顺序打印多个元素，您可以编写：

def rev_n_skip(first, last, multiple)
  (first..last).step(multiple).reverse_each { |i| print "#{i} " }
  puts
end

rev_n_skip(1, 19, 3) #-> 19 16 13 10 7 4 1 
rev_n_skip(1, 18, 3) #-> 16 13 10 7 4 1 
rev_n_skip(1, 17, 3) #-> 16 13 10 7 4 1 
rev_n_skip(1, 16, 3) #-> 16 13 10 7 4 1 
rev_n_skip(1, 15, 3) #-> 13 10 7 4 1 

rev_n_skip(2, 19, 3) #-> 17 14 11 8 5 2 
rev_n_skip(2, 18, 3) #-> 17 14 11 8 5 2 
rev_n_skip(2, 17, 3) #-> 17 14 11 8 5 2 
rev_n_skip(2, 16, 3) #-> 14 11 8 5 2 
rev_n_skip(2, 15, 3) #-> 14 11 8 5 2 

---

OP希望打印某个范围的某些元素。当然，首先构造一个数组是低效的，但也不是必要的。我的答案和其他一些答案并不创建数组

假设范围的形式为first..last。要按相反顺序打印多个元素，您可以编写：

def rev_n_skip(first, last, multiple)
  (first..last).step(multiple).reverse_each { |i| print "#{i} " }
  puts
end

rev_n_skip(1, 19, 3) #-> 19 16 13 10 7 4 1 
rev_n_skip(1, 18, 3) #-> 16 13 10 7 4 1 
rev_n_skip(1, 17, 3) #-> 16 13 10 7 4 1 
rev_n_skip(1, 16, 3) #-> 16 13 10 7 4 1 
rev_n_skip(1, 15, 3) #-> 13 10 7 4 1 

rev_n_skip(2, 19, 3) #-> 17 14 11 8 5 2 
rev_n_skip(2, 18, 3) #-> 17 14 11 8 5 2 
rev_n_skip(2, 17, 3) #-> 17 14 11 8 5 2 
rev_n_skip(2, 16, 3) #-> 14 11 8 5 2 
rev_n_skip(2, 15, 3) #-> 14 11 8 5 2 

---

其他三种不需要阵列的方式是：

(1..200).reverse_each { |i| puts i if i % 3 == 0 }

或：

以及：

---

其他三种不需要阵列的方式是：

(1..200).reverse_each { |i| puts i if i % 3 == 0 }

或：

以及：

---

我建议，而不是相反。each.Ruby总是让我惊讶不已。语法糖不保存单个字符，但仍然感觉更干净…这不是语法糖。它有不同的语义。reverse以相反的顺序初始化第二个数组，即第一个数组的副本，而reverse_每个数组都会从头到尾迭代原始数组。to_a是不必要的，也是不可取的，因为它创建了一个不需要的临时数组。我建议用reverse代替。each.Ruby永远不会停止让我感到惊讶。语法糖不保存单个字符，但仍然感觉更干净…这不是语法糖。它有不同的语义。reverse以相反的顺序初始化第二个数组，即第一个数组的副本，而reverse_每个数组从头到尾迭代原始数组。to_a是不必要的，也是不可取的，因为它创建了一个不需要的临时数组。我认为这不是副本，@theTinMan。链接的问题涉及下降范围，例如4..0，OP从未提及。重复的我不认为这是重复的，@theTinMan。链接问题涉及降序范围，例如4..0，OP从未提及。OP只想打印元素。这样做不需要创建数组。OP只想打印元素。这样做不需要创建数组。