Question

因此，对于我的一项家庭作业，我们被要求创建一个hailstonesequence并且我完全卡住了。我很难弄清楚如何分解包含循环的函数段，然后尝试将其转换为递归函数。任何帮助将不胜感激。在下面我有原始的for-loop函数，然后是（Attempted）递归函数。

// startingValue function with For-Loop
// Takes in an int value n and returns the
// start value k from 1 to n, that has the longest length.

int startingValue (int n) {
    int length = 0;
    int k;

    for ( int i = 1; i <= n; i++ ) {
        int currentLength = largestHailstoneLength(i);

        if (currentLength > length) {
            length = currentLength;
            k = i;
        }
    }       

    return k;
}

这是我尝试上述函数的递归版本：

int startingValue (int n) {
    int length = 0;
    int n = 0;
    int currentLength = largestHailstoneLength(i);

    if (currentLength < length) {
        return 0;
    } else {
        length = currentLength;
        n = i;
    }

    return (startingValue(i));
}

Answer 1

这里有一些简单的，可能效率低下的东西应该让你开始：

int startingValue(int n) {

    if (n == 1) {
        return n;
    }

    int m = startingValue(n - 1);

    return largestHailstoneLength(n) > largestHailstoneLength(m) ? n : m;
}

Answer 2

我不打算做你的作业，但我会告诉你Ruby中的解决方案是什么样的，这种语言与伪代码一样可读。 #之后的任何内容都是评论。

# Ruby equivalent to your C++ loop version
def start(n)
  biggest = 0
  k = -1
  (1..n).each do |i|  # loop from 1 to n, inclusive...
    # don't have access to your largestHailstoneLength(i) function,
    # so I'm using a random number on the range [0,1000)
    current = rand(1000)
    biggest, k = current, i if current > biggest
  end
  return k
end

# Using default argument values.  Alternatively, you can build
# a single-argument front end function and a recursive back end
# with these args the state info.
def start_recursive(n, i = 1, biggest = 0, k = -1)
  current = rand(1000)  # same as above
  biggest, k = current, i if current > biggest
  return i < n ? start_recursive(n, i + 1, biggest, k) : k
end

srand 12345  # explicit seed to RNG for reproducibility of sequence
p start(1000)  # => 301
srand 12345  # reseed RNG sequence to show recursive version yields same result
p start_recursive(1000)  # => 301

附录

在考虑了一点，并且玩了更大的范围之后，我想出了以下变体，它不太可能遭受堆栈溢出 - 它使用分而治之的策略来划分候选范围。我还通过调用largestHailstoneLength(i)来替换随机数评估：

def start_recursive(upper_index, lower_index = 1)
  return lower_index if lower_index >= upper_index
  mid = (lower_index + upper_index) / 2
  lower_max = start_recursive(mid, lower_index)
  upper_max = start_recursive(upper_index, mid + 1)
  if largestHailstoneLength(lower_max) < largestHailstoneLength(upper_max)
    return upper_max
  else
    return lower_max
  end
end

Answer 3

您的代码中存在一些问题

您未在递归函数中定义>>> a=[1,4,5,2] >>> b=[4,3,1,5] >>> sorted(b, key=lambda x:a.index(x) if x in a else len(a)) [1, 4, 5, 3]
你似乎对递归的工作方式一无所知，我会给你一个线索：
- 每次调用函数时，都会保存一个状态。
- 您需要说明递归函数停止的位置，否则它将一直调用自身，直到它因堆栈溢出而崩溃。
- 您需要知道是否要使用该功能返回的内容，或者您是否想要使用您传递给它的内容（或两者）

如果我做对了，i应该返回startingValue()最大的值。

所以我们这里遵循的是归纳原则：

我有largestHailstoneLength()个值
如果n为n，我不必进行任何比较，只需返回1。

否则

如果n最大，则应该大于n和1之间的最大值。
现在我们需要看到n - 1和1之间的最大值。
如果n - 1最大，则应该大于n - 1和1之间的最大值
...

那么，最重要的是检查n - 2

我们在递归中需要做的是将当前 // Stop here, no need to go compare if (n == 1) return n;与从n到1的最大值进行比较。那就是：

n - 1

知道哪个是更大的，我们只需返回它。

为了更好地理解事物，请多读一点。您可以开始here。

C ++ |需要帮助从For循环功能转换 - ＆gt;递归函数

3 个答案:

附录