红宝石中的递归乘法器

Question

我正在尝试在 ruby​​ 中创建一个递归乘法器。

@j = 0

def multiplier(x, y, z)
    count = 0
    if x > 0
        if z > 0
            @j += y
            z -= 1
            count += 1
            multiplier(x, y, z)
        else
            x -= 1
            z = count
            p z
            multiplier(x, y, z)
        end
    else
        return @j
    end
end


def main
    puts "Calculation is: " + multiplier(3, 10, 4).to_s
end

main

X 是乘法发生的次数

Y 是我们要相乘的数字

Z 是我们乘以的数

代码应该输出120和那里的变量

我在让 Z 保持我需要的样子时遇到问题。另外，我更愿意在没有全局变量的情况下这样做

类似 x*(y*z) 但没有时间符号

Answer 1

您的代码的主要问题是count 是一个局部变量，它不会在递归调用之间保存。此外，如果您想避免使用全局变量，请将变量作为附加参数传递给函数。在 FP 中我们称之为累加器：

def multiplier(x, y, z, j = 0)
  if z > 0
    multiplier(x, y, z - 1, j + y)
  elsif z.zero? # done with z, jump to x × (y × z)
    # z = -1 to explicitly mark we are done with z
    multiplier(x, j, -1, 0)
  elsif y.zero? # yay, we are all set, reducing is done!
    j
  else
    # still doing x × result step
    multiplier(x, y - 1, -1, j + x)
  end
end

multiplier(3, 10, 4)
#⇒ 120

上面肯定缺少对输入有效性的必要检查，但我敢打赌你明白了。

Answer 2

在recursive answer above 的基础上，这里有一个更通用的函数，它可以获取一个任意长的正整数列表并将它们乘以递归加法：

def multiplier(*integers, accum: 0)
  if integers.size == 1
    # We are finished!
    integers[0]
  elsif integers[-1].positive?
    # "Multiply" the last two integers, by recursive addition
    integers[-1] -= 1
    multiplier(*integers, accum: accum + integers[-2])
  else
    # The above multiplication is complete; set the last integer to its result
    integers[-2] = accum
    multiplier(*integers[0..-2])
  end
end

Answer 3

我会说 ruby​​ 的惯用方式是使用迭代器而不是递归/循环

def multiplier(x, y, z)
  x.times.map do
    y.times.map do
      z
    end.reduce(:+)
  end.reduce(:+)
end

或

def multiplier(x, y, z)
  x.times.map do
    y.times.map do
      z
    end
  end.flatten.reduce(:+)
end

或者如果唯一的操作是inc

def multiplier(x, y, z)
  j = 0
  x.times do
    y.times do
      z.times do
        j += 1
      end
    end
  end
  j
end

输出是一样的

multiplier(3, 10, 4)
# 120

对于任意数量的参数，我们必须使用递归

def multiplier(*xs, res: 0)
  return res if xs.empty?
  xs[0].times do
    res += 1 if xs.size == 1
    res = multiplier(*xs.drop(1), res: res)
  end
  res
end

或

def multiplier(*xs, res: 0)
  head, *tail = xs
  head.to_i.times do
    res += 1 if tail.empty?
    res = multiplier(*tail, res: res)
  end
  res
end

Answer 4

我先写一个递归地乘以两个数字的方法：

def multiply_2(a, b)
  return 0 if a.zero?
  b + multiply_2(a - 1, b)
end

multiply_2(3, 4)
#=> 12

并在该方法的基础上乘以三个数字：

def multiply_3(a, b, c)
  multiply_2(multiply_2(a, b), c)
end

multiply_3(3, 4, 10)
#=> 3

并最终将其扩展到处理 n 个数字：

def multiply_n(a, b, *more)
  result = multiply_2(a, b)
  return result if more.empty?
  multiply_n(result, *more)
end

multiply_n(3, 4, 10, 2)
#=> 240

请注意，对于大量数字，您可能会遇到SystemStackError。这可以通过创建 multiply_2 tail-recursive 来避免（作为练习，这并不难）并启用 Ruby 的 :tailcall_optimization。

Answer 5

可以这样写。

def multiplier(*args)
  prod = recurse(*args.map(&:abs))
  args.count { |n| n < 0 }.even? ? prod : -prod
end

def recurse(first, *rest)
  first.zero? || rest.empty? ? first : ([recurse(*rest)]*first).sum
end

multiplier(3,  10,  4)        #=>  120
multiplier(3,  10,  4, 2, 3)  #=>  720
multiplier(3, -10,  4)        #=> -120
multiplier(3, -10, -4)        #=>  120
multiplier(3,   0,  4)        #=>    0
multiplier(3,   0, -4)        #=>    0

假设我们希望计算multiplier(3, -4)。 recurse(3, 4) 被调用，在哪里

first = 3
rest = [4]
first.zero? #=> false
rest.empty? #=> false

所以我们计算

([recurse(4)]*3).sum

在recurse(4)，

first = 4
rest = []

由于rest.empty #=> true，recurse 返回first #=> 4，所以

([recurse(4)]*3).sum]
  #=> ([4]*3).sum => [4,4,4].sum => 12

返回到multiplier。由于[3, -4] 包含奇数个负值，因此乘数返回-12。