递归向量中的最小正数

Smallest positive number in a vector recursively

本文关键字：递归向量      更新时间：2023-10-16

我正在编写一个函数，该函数应该递归地找到整数向量中的最小正数。

现在我的代码如下所示：

 #include <vector>
 using namespace std;
 int rec_min_pos(const vector<int> & nums, int size) {
    if (size < 1) {
    return -1;
    } else {
        int min = rec_min_pos(nums, size - 1);
        if(min < 0){
            if(nums[size - 1] <= 0){
                return -1;
            }else{
                return nums[size-1];
            }
        }else {
            if (min < nums[size - 1]) {
                return min;
            } else {
                return nums[size - 1];
            }
        }
    }
}
int main(){
    vector<int> nums = {2, -3, 6, -21, 10, -80, 8};
    cout << rec_min_post(nums, nums.size());
}

如果我运行这个，我会得到8，这可能是因为下一个元素是负数。

以前的版本：

#include <vector>
using namespace std;
int rec_min_pos(const vector<int> & nums, int size) {
    if (size < 1) {
        return -1;
    } else {
        int min = rec_min_pos(nums, size - 1);
        if (min < nums[size - 1]) {
            return min;
        } else {
            return nums[size - 1];
        }
    }
}
int main(){
    vector<int> nums = {2, -3, 6, -21, 10, -80, 8};
    cout << rec_min_post(nums, nums.size());
}

我会得到-80这实际上是最小的值，但我需要最小的正值。

如何从整数向量中获取最小的正值？

def SPN(nums, s):
  if s == 0:
    # Empty array
    return +∞
  if nums[s-1] > 0:
    # num[s] is admissible, recurse and keep the smallest
    return min(nums[s-1], SPN(nums, s-1))
  else:
    # Just recurse
    return SPN(nums, s-1)
print SPN(nums, len(nums)

c++ 版本： 

#include <vector>
using namespace std;
int rec_min_pos(const vector<int> & nums, int size) {
    if (size < 1) {
        return INT_MAX;
    }
    if(nums[size-1] > 0){
        return min(nums[size-1], rec_min_pos(nums, size-1));
    }
    else{
        return rec_min_pos(nums, size-1);
    }
}

更新：

假设不允许保留INT_MAX表示 +∞，我们可以改用负数，比如 -1 ，约定min(x,-1) = x 。

Infty= -1 # Conventional +∞
def Min(a, b):
  if b == Infty:
    return a
  else:
    return min(a, b)
def SPN(nums, s):
  if s == 0:
    # Empty array
    return Infty 
  if nums[s-1] > 0:
    # num[s] is admissible, recurse and keep the smallest
    return Min(nums[s-1], SPN(nums, s-1))
  else:
    # Just recurse
    return SPN(nums, s-1)

如果我们使用任何负值表示 +∞ 的约定，这将导致我们得到一个更优雅的版本：

def Min(a, b):
  if a < 0:
    return b
  if b < 0:
    return a
  return min(a, b)
def SPN(nums, s):
  if s == 1:
    return nums[0] # Assumes len(nums) > 0
  return Min(nums[s-1], SPN(nums, s-1))

C++优雅版本：

#include <vector>
using namespace std;
int minimum(int a, int b){
    if(a < 0){
        return b;
    }
    if(b < 0){
        return a;
    }
    return min(a, b);
}
int SPN(vector<int> nums, int size){
    if(size == 1){
        return nums[0];
    }
    return minimum(nums[size-1], SPN(nums, size-1));
}
相关文章：