如何生成具有预定义*唯一性*的整数序列？答案

【问题标题】：How to generate a sequence of integers with predefined *uniqueness*?如何生成具有预定义*唯一性*的整数序列？
【发布时间】：2023-03-09 07:58:01
【问题描述】：

对于某些测试，我需要生成一个可能很长的非随机具有预定义唯一性的整数序列。我将唯一性定义为一个浮点数，等于“序列中唯一数的数量”除以“总序列长度”。此数字应在(0, 1] 半开区间内。

我可能需要这些长度不同的序列，这是事先未知的 - 所以我需要一种算法来生成这样一个序列，它的 any 前缀序列具有唯一性，接近预定义的序列.例如，具有唯一性max(m,n)/(m+n) 的序列1,2,...,m,1,2,...,n 对我不利。

问题看起来很简单，因为算法应该只生成一个序列——但是我写的函数next()（见下文）看起来出乎意料的复杂，而且它还大量使用核心内存：

typedef std::set<uint64_t> USet;
typedef std::map<unsigned, USet> CMap;

const double uniq = 0.25;    // --- the predefined uniqueness 
uint64_t totalSize = 0;      // --- current sequence length
uint64_t uniqSize = 0;       // --- current number of unique integers
uint64_t last = 0;           // --- last added integer
CMap m;                      // --- all numbers, grouped by their cardinality  

uint64_t next()
{
  if (totalSize > 0)
  {
    const double uniqCurrent = static_cast<double>(uniqSize) / totalSize;
    if (uniqCurrent <= uniq)
    {
      // ------ increase uniqueness by adding a new number to the sequence 
      const uint64_t k = ++last;
      m[1].insert(k);
      ++totalSize;
      ++uniqSize;
      return k;
    }
    else
    {
      // ------ decrease uniqueness by repeating an already used number
      CMap::iterator mIt = m.begin();
      while (true)
      {
        assert(mIt != m.cend());
        if (mIt->second.size() > 0) break;
        ++mIt;
      }
      USet& s = mIt->second;
      const USet::iterator sIt = s.cbegin();
      const uint64_t k = *sIt;
      m[mIt->first + 1].insert(k);
      s.erase(sIt);
      ++totalSize;
      return k;
    }
  }
  else
  {
    m[1].insert(0);
    ++totalSize;
    ++uniqSize;
    return 0;
  }
}

任何想法如何更简单地做到这一点？

【问题讨论】：

提前说长度未知，是指需要能够生成任意长度的固定序列，还是需要能够按需增加序列的长度?这些是非常不同的要求，因为后者需要维护某种有状态的对象，而前者可以使用纯函数来完成。
@ChrisHayden - 老实说，我看不出有什么不同。这个函数应该生成我想要的 any 长度和 any 唯一性的序列。我现在不知道如何在没有状态的情况下做到这一点，而且我的函数中的这个状态（上图）会占用大量内存，这可能会阻止它生成非常长的序列 - 这也是我关心的问题
生成具有动态属性的固定长度序列可以通过std::vector<int> generate(<properties>) 之类的方法完成，即序列一旦生成就不可变。这与必须能够动态地将新元素添加到现有序列中不同。如果我没有清楚地解释这一点，也许其他人可以做得更好？
@ChrisHayden - 我不明白......如果我需要一个包含数十亿个数字的序列，该函数会给我一个这个长度的向量，对吧？为什么比一个一个得到数字更好？

标签： c++ algorithm

【解决方案1】：

您没有说过要让每个数字都具有相同的基数。下面的代码大致做到了这一点，但在某些情况下，它会“不按顺序”选择一个数字（主要是在序列的早期）。希望简单性和恒定的空间使用可以弥补这一点。

#include <cassert>
#include <cstdio>

class Generator {
 public:
  explicit Generator(double uniqueness)
      : uniqueness_(uniqueness), count_(0), unique_count_(0),
        previous_non_unique_(0) {
    assert(uniqueness_ > 0.0);
  }

  int Next() {
    ++count_;
    if (static_cast<double>(unique_count_) / static_cast<double>(count_) <
        uniqueness_) {
      ++unique_count_;
      previous_non_unique_ = 1;
      return unique_count_;
    } else {
      --previous_non_unique_;
      if (previous_non_unique_ <= 0) {
        previous_non_unique_ = unique_count_;
      }
      return previous_non_unique_;
    }
  }

 private:
  const double uniqueness_;
  int count_;
  int unique_count_;
  int previous_non_unique_;
};

int main(void) {
  Generator generator(0.25);
  while (true) {
    std::printf("%d\n", generator.Next());
  }
}

【讨论】：