用于创建 1 到 20 之间的 5 个唯一整数数组的算法 [重复]

Question

我的目标是创建一个由 5 个介于 1 到 20 之间的唯一整数组成的数组。有没有比我下面使用的算法更好的算法？

它有效，我认为它具有恒定的时间复杂度，因为循环不依赖于可变输入，但我想知道是否有更高效、更简洁或更简单的方法来编写它。

int * getRandom( ) {

  static int choices[5] = {};
  srand((unsigned)time(NULL));
   
  for (int i = 0; i < 5; i++) {

    int generated = 1 + rand() % 20;
    for (int j = 0; j < 5; j++){
      if(choices[j] == generated){
        i--;
      }
    }
    
    choices[i] = generated;
    cout << choices[i] << endl;
  }

  return choices;
}

非常感谢您的任何反馈。我是算法新手。

Answer 1

我能想到的最简单的方法就是用choices[i] = i+1 创建所有20 个数字的数组，用std::random_shuffle 将它们随机排列并取5 个第一个元素。可能会更慢，但很难引入错误，并且给定较小的固定大小 - 可能没问题。

顺便说一句，您的版本有错误。即使找到生成的 - 也可能会执行 choices[i] = generated; 行，这可能会创建 generated 值的副本。比如说，i = 3，生成的元素等于 j = 0 处的元素，现在你递减 i 并分配 choices[2] - 等于 choices[0]。

Answer 2

C++17 代码，解释了原因和内容。 如果您还有任何问题，请随时提出，我很乐意为您提供帮助

#include <iostream>
#include <array>
#include <string>
#include <random>
#include <type_traits>

// container for random numbers.
// by putting the random numbers + generator inside a class
// we get better control over the lifecycle.
// e.g. what gets called when.
// Now we know the generation gets called at constructor time.
class integer_random_numbers
{
public:
    // use std::size_t for things used in loops and must be >= 0
    integer_random_numbers(std::size_t number, int minimum, int maximum)
    {
        // initialize the random generator to be trully random
        // look at documentation for <random>, it is the C++ way for random numbers
        std::mt19937 generator(std::random_device{}());

        // make sure all numbers have an equal chance. range is inclusive 
        std::uniform_int_distribution<int> distribution(minimum, maximum);

        // m_values is a std::vector, which is an array of which
        // the length be resized at runtime.  
        for (auto n = 0; n < number; ++n)
        {
            int new_random_value{};

            // generate unique number
            do
            {
                new_random_value = distribution(generator);
            } while (std::find(m_values.begin(), m_values.end(), new_random_value) != m_values.end());
        
            m_values.push_back(new_random_value);
        }
    }

    // give the class an array index operator
    // so we can use it as an array later
    int& operator[](const std::size_t index)
    {
        // use bounds checking from std::vector
        return m_values.at(index);
    }

    // reutnr the number of numbers we generated
    std::size_t size() const noexcept
    {
        return m_values.size();
    }

private:
    // use a vector, since we specify the size at runtime.
    std::vector<int> m_values;
};

// Create a static instance of the class, this will
// run the constructor only once (at start of program)
static integer_random_numbers my_random_numbers{ 5, 1, 20 };

int main()
{
    // And now we can use my_random_numbers as an array
    for (auto n = 0; n < my_random_numbers.size(); ++n)
    {
        std::cout << my_random_numbers[n] << std::endl;
    }
}

Answer 3

1. 从 1 到 16 生成 5 个随机数，允许重复
2. 对它们进行排序
3. 第 2 个数字加 1，第 3 个数字加 2，第 4 个数字加 3，第 5 个数字加 4。

最后一步通过将具有重复项的可能序列重新映射为具有唯一整数的序列，将范围从 [1,16] 转换为 [1,20]。例如，[1,2,10,10,16] 变为 [1,3,12,13,20]。转换是完全双射的，因此您永远不需要丢弃和重新采样。