Question

我有一个数组。我需要对每个元素执行不同的计算。我以为我可以做以下事情：

def calc(a, b, c)
    arr = [a, b, c]
    arr.map { |i| (i[0] * 600), (i[1] * 800), (i[2] * 1000) }
end

calc(5, 8, 15)

但这不起作用。如何对单个数组的每个元素执行不同的计算？

Answer 1

以下是一些可能有用的其他实现。通过将乘数放入数组，我们可以使用zip将输入数组中的元素与适当的乘数值相连接。此外，通过从乘法逻辑中移除乘数值（multiply_arrays和transform_arrays），可以更简单地抽象逻辑。

#!/usr/bin/env ruby

VALUES = [1, 1, 1]
MULTIPLIERS = [600, 800, 1000]

def transform(*values)
  values.zip(MULTIPLIERS).map { |x, y| x * y }
end

def multiply_arrays(array1, array2)
  array1.zip(array2).map { |n1, n2| n1 * n2 }
end

def transform_arrays(array1, array2, method_name)
  array1.zip(array2).map { |n1, n2| n1.public_send(method_name, n2) }
end


p transform(*VALUES)                           # [600, 800, 1000]
p multiply_arrays(VALUES, MULTIPLIERS)         # [600, 800, 1000]
p transform_arrays(VALUES, MULTIPLIERS, :*)    # [600, 800, 1000]

如果计算需要大不相同（不同的运算符，值，更复杂的逻辑），那么我会考虑使用lambdas数组：

def transform_with_lambdas(values, transforms)
  values.zip(transforms).map do |value, transform|
    transform.(value)
  end
end

TRANSFORMS = [
  ->(x) { x *  600   },
  ->(x) { x +  100   },
  ->(x) { x /    3.0 },
]

p transform_with_lambdas(VALUES, TRANSFORMS)  # [600, 101, 0.3333333333333333]

Answer 2

这是一个解决方案，可以帮助您对两个不同的操作数应用不同的操作：

def calc(first_operand_arr, operator_arr, second_operand_arr)
  result_arr = []
  operator_arr.each_with_index do |o, i|
    result_arr << (first_operand_arr[i]).method(o).(second_operand_arr[i])
  end
  result_arr
end

calc([5, 8, 15], ['+', '-', '*'], [5, 3, 2])

Answer 3

def calc *arr
    ops = [600, 800, 1000]
    arr.map { |x| x * ops.shift }
end

calc(5, 8, 15)
  #=> [3000, 6400, 15000]

您可以按如下方式概括：

def calc(*arr)
  arr.map { |op1, op2, m| op1.send(m, op2) }
end

calc [5, 6, :*], [2, 3, :+], [10, 8, :-]
  #=> [30, 5, 2]

Answer 4

这是一个使用第二个lambda数组的选项，它可以是主数组中每个条目的任意函数。

operands = [1.0,2.0,3.0]

operations = [
              ->(e) { e * 10} ,
              ->(e) { e + 10 },
              ->(e) { e * e }
            ]

results = operands.each_with_index.map { |operand, index| operations[index].call(operand) }
puts results

修改我刚刚注意到这是Keith Bennett上面回答的一个变种，我将把它留在这里，因为从数组中检索lambda的方式不同。

对数组的每个元素执行不同的计算

4 个答案: