Question

我想知道是否有办法生成一个数组，例如，从0开始，增加1直到达到3，然后减少1直到它再次达到0，例如

[0,1,2,3,2,1,0]

如果我可以提前指定数组中的值的数量，那就太好了。例如，如果我可以设置下限（0），上限（3），增量（1）和数组长度（9）：

[] .surphlate（0,3,1,9）会给我这个：

[0,1,2,3,2,1,0,1,2]

截至目前，我能想出的最好的事情是：

values = []
  until values.count >= 9
    values.pop
    x=0
    values << x && x+=1 while x < 3
    values << x && x-=1 while x >= 0 

  end

Answer 1

有趣的运动！

您正在寻找triangle wave。维基百科上的公式是标准形状（介于-1和1之间），但这里是任何波浪位置，周期和幅度的改编版本：

def triangle_wave(min, max, increment, length, offset = 0)
  amplitude = max - min
  period = 2 * amplitude
  Array.new(length) do |i|
    min + ((increment * (i + offset) - amplitude) % period - amplitude).abs
  end
end

puts triangle_wave(0, 3, 1, 9) == [0, 1, 2, 3, 2, 1, 0, 1, 2]
# true

p triangle_wave(-3, 3, 1, 20)
# => [-3, -2, -1, 0, 1, 2, 3, 2, 1, 0, -1, -2, -3, -2, -1, 0, 1, 2, 3, 2]

p triangle_wave(5, 9, 2, 9)
# => [5, 7, 9, 7, 5, 7, 9, 7, 5]

p triangle_wave(0, 1, 0.25, 9)
# => [0.0, 0.25, 0.5, 0.75, 1.0, 0.75, 0.5, 0.25, 0.0]

p triangle_wave(-3, 0, 1, 9, 3)
# => [0, -1, -2, -3, -2, -1, 0, -1, -2]

p triangle_wave(0, 1, 1, 9)
# => [0, 1, 0, 1, 0, 1, 0, 1, 0]

min应低于max，increment应为正数，max-min应该可以被increment整除。这些是对输入的限制，但不是对输出的限制：可以生成任何波形。

Answer 2

这个问题可能是使用Ruby flip-flop operator的教科书示例。

由于只有steps这样的非负整数high = low + steps * increment时，问题才有意义，我已将high的方法steps替换为{ {1}}。

def oscillate(low, steps, increment, length)
  high = low + steps * increment 
  n = low
  length.times.each_with_object([]) do |_,a|
    a << n
    n += (n==low)..(n==high-increment) ? increment : -increment
  end
end

oscillate(0,3,1,9)
  #=> [0, 1, 2, 3, 2, 1, 0, 1, 2]

oscillate(-1, 4, 2, 16)    
  #=> [-1, 1, 3, 5, 7, 5, 3, 1, -1, 1, 3, 5, 7, 5, 3, 1]

要显示此处发生了什么，我会稍微修改一下代码并添加一些puts语句，然后使用第一个示例运行它。

def oscillate(low, steps, increment, length)
  high = low + steps * increment
  puts "high = #{high}" 
  n = low
  length.times.each_with_object([]) do |_,a|
    a << n
    diff = (n==low)..(n==high-increment) ? increment : -increment
    print "n=#{n}, a<<n=#{a}, diff=#{diff}, " 
    n += diff
    puts "n+=diff=#{n}" 
  end
end

oscillate(0,3,1,9)
high = 3
n=0, a<<n=[0],                         diff= 1, n+=diff=1
n=1, a<<n=[0, 1],                      diff= 1, n+=diff=2
n=2, a<<n=[0, 1, 2],                   diff= 1, n+=diff=3
n=3, a<<n=[0, 1, 2, 3],                diff=-1, n+=diff=2
n=2, a<<n=[0, 1, 2, 3, 2],             diff=-1, n+=diff=1
n=1, a<<n=[0, 1, 2, 3, 2, 1],          diff=-1, n+=diff=0
n=0, a<<n=[0, 1, 2, 3, 2, 1, 0],       diff= 1, n+=diff=1
n=1, a<<n=[0, 1, 2, 3, 2, 1, 0, 1],    diff= 1, n+=diff=2
n=2, a<<n=[0, 1, 2, 3, 2, 1, 0, 1, 2], diff= 1, n+=diff=3
  #=> [0, 1, 2, 3, 2, 1, 0, 1, 2]

Answer 3

试试这个

def oscillate(a, b, step, num)
  ramp_up = a.step(b, step).entries
  ramp_down = ramp_up.drop(1).reverse.drop(1)
  ramp_up.concat(ramp_down).cycle.take(num)
end

这是如何运作的？

创建ramp_up和ramp_down数组
连接两个数组
cycle返回一个不断重复的枚举器
take表示该枚举器中的num个元素。除了评论中的建议，这不会重新计算任何内容。它只是实现了枚举器中的条目。

创建一个包含在两个边界之间振荡的值的数组

3 个答案: