分离并打印出偶数和奇数随机数

Question

我已经生成了 100 个随机数，我必须在其中缩短随机数的偶数和奇数。所有的偶数或奇数都不能重复。

例如我将创建 100 个随机数

#include <iostream>   
#include <cstdlib>    

int main()
{
  for (int i=1; i <=100; ++i){

      //double p = rand();
      std::cout <<"random number is :" << rand()<<std::endl;


  }


}

由于我不知道 100 个随机数中的偶数和奇数是否相同，所以我想选择最少的偶数和奇数对。我也想知道总的奇数和偶数是分别生成的。需要注意的是，例如，如果任何偶数或奇数被打印多次，我想将其视为一个。

例如。假设我们从打印的随机数中有 60 个偶数和 40 个奇数。而且从 60 个偶数中，有 10 个偶数是重复的。所以我认为不同的事件编号是 50。打印出来的数字将是前 20 个偶数和前 20 个奇数。

我想这样做的原因是因为我想学习如何从随机生成器的 for 循环中过滤掉偶数和奇数。

更新：

我的目标是从生成的随机数中找到偶数和奇数。当我把偶数和奇数短路时，所有的偶数和奇数都会不同。这意味着，如果我发现偶数 2 打印了 5 次，我仍然会考虑那个。通过这种方式，我想找到偶数和奇数的最小数量。

举个例子：

生成的打印输出为：{1,2,2,3,4,5,6,8,9,3,2,4,6,10}

从列表中，偶数和奇数将是：

偶数 = {2,4,6,8} 奇数 = {1,3,5,9}

如果你仔细看，我将 10 排除在偶数短路之外。原因是，如果我在偶数列表中添加 10，我的偶数会多于奇数。

Answer 1

使用std::unorderd_set 创建奇数集和偶数集

检查数字是否为奇数 = (num&1) 奇数为 1，偶数为 0

std::unordered_set<int> set_odd;
std::unordered_set<int> set_even;
for (int num : nums) {
  if (num & 1) set_odd.insert(num);
  else set_even.insert(even);
}

Answer 2

这将执行您在示例中解释的操作。

#include <set>
#include <vector>

int main()
{
  std::vector<int> numbers = {1, 2, 2, 3, 4, 5, 6, 8, 9, 3, 2, 4, 6, 10};
  std::set<int> even, odd;

  // sort the numbers into even and odd sets
  for (auto const& n : numbers)
  {
    if (n % 2 == 0)
      even.insert(n);
    else
      odd.insert(n);
  }

  // figure out which set is smaller
  int min = std::min(even.size(), odd.size());

  // print out the evens
  std::cout << "even = ";
  auto it = even.begin();
  for(int i = 0; i < min; ++i)
  {
    std::cout << *(it++) << " ";
  }
  std::cout << std::endl;

  // print out the odds
  std::cout << "odd  = ";
  it = odd.begin();
  for(int i = 0; i < min; ++i)
  {
    std::cout << *(it++) << " ";
  }
  std::cout << std::endl;
}

Answer 3

如果您只想要 pairs 随机数（2 整数集合中的一对，一个偶数，一个奇数，而不是 std::pair），您需要一种生成数字的方法，提供存储对，并跟踪生成的奇数和偶数以及关联生成的数对的方法。

要生成随机数，std::random_device 会根据您选择的随机数引擎（例如 std::mersenne_twister_engine）为 int 生成随机数。您可以在std::uniform_int_distribution 中生成一个数字，只需声明设备，用设备播种生成器，然后在您选择的 min 和 max 之间创建一个分布。

要在int 的正数范围内设置和生成随机数，您可以这样做：

...
#include <random>

#define NMAX std::numeric_limits<int>::max()
...
    std::random_device rd;    /* delcare the randon number generator device */
    std::mt19937 gen(rd());   /* standard mrsene_twister engine seeded w/rd */
    std::uniform_int_distribution<int> dist(0, NMAX); /* create disribution */

要从分发中请求一个数字，只需：

        int r = dist(rd);                       /* generate rand */

如何存储生成的对取决于您如何协调将生成的偶数和奇数相加以协调将数字对存储在一起。您可以使用std::map 或std::unordered_map 或简单地使用偶数和奇数std::vector<int>。使用后者，您可以填充偶数向量和奇数向量，然后简单地输出两者中较小的.size()，以捕获从我们的 100 个随机整数中生成的奇偶对。

例如：

#define MAXRAND 100
...
    std::vector<int> even, odd;
    ...
    for (int i = 0; i < MAXRAND; i++) {         /* loop MAXRAND times */
        int r = dist(rd);                       /* generate rand */
        if (r % 2 == 0)                         /* if even */
            even.push_back(r);                  /* add to even vector */
        else    /* odd number */
            odd.push_back(r);                   /* add to odd vector */
    }

通过这种方式，您可以指定生成 100 个随机数，但最终会从这 100 个随机数中生成许多奇偶对 - 这听起来就像您要问的那样。

总之你可以做到：

#include <iostream>
#include <iomanip>
#include <random>
#include <vector>

#define NMAX std::numeric_limits<int>::max()
#define MAXRAND 100

int main (void) {

    std::vector<int> even, odd;
    std::random_device rd;    /* delcare the randon number generator device */
    std::mt19937 gen(rd());   /* standard mrsene_twister engine seeded w/rd */
    std::uniform_int_distribution<int> dist(0, NMAX); /* create disribution */
    size_t limit = 0;

    for (int i = 0; i < MAXRAND; i++) {         /* loop MAXRAND times */
        int r = dist(rd);                       /* generate rand */
        if (r % 2 == 0)                         /* if even */
            even.push_back(r);                  /* add to even vector */
        else    /* odd number */
            odd.push_back(r);                   /* add to odd vector */
    }
    /* output results */
    limit = (even.size() > odd.size()) ? odd.size() : even.size();
    std::cout << limit << " even-odd pairs (0 - " << NMAX << ")\n\n";
    for (size_t p = 0; p < limit; p++)
        std::cout << std::setw(12) << even.at(p) << 
                    "  " << odd.at(p) << '\n';
}

使用/输出示例

运行你通常会生成 40-50 对数字——随机分布相当好，例如

$ ./bin/evenoddpairs
48 even-odd pairs (0 - 2147483647)

  1513290664  712950177
  2014370968  990873219
   161619218  6719997
  2062410942  1965300831
  2072442520  938385103
   669324326  1957687455
  1201350414  2134189381
   217290372  1304388089
   726760634  232069103
  2086887656  1784024967
  1345123406  185879429
  1706842790  686104759
  1034648158  268926351
  1445724500  1996600823
  1303450734  1890287253
   763120758  1581912187
  1788401668  1537971261
  1542967608  1842999149
   377964104  1995119937
    87264498  644262155
   224210492  519040373
   692262016  372293591
   502458404  1867793795
   575578512  751306553
   373162704  170423471
  1502626218  152785903
   284546326  287967359
   388031960  1233214425
  1839930048  243652639
   465469190  1747259241
  1488469408  252779515
  2144753340  1992139979
  2010564888  298805387
   917820234  187798339
  1204892922  1454685783
   563347322  50283749
  1303887182  345841727
  1429521892  1668482773
   702286146  1191166889
  1490493310  963750729
   986716484  1522036479
  1107465502  1445768043
  1613852374  1307939505
  1584334086  1565159437
  1325156802  354726127
  1165679412  1618569419
  1192475084  1341169211
    71913214  1569003463

有很多方法可以将它们组合在一起，但考虑到生成 100 个随机数的限制，然后只收集从这 100 个数字中创建的奇偶对，偶数/奇数向量很容易确保您最终得到仅生成 100 对中的对。让我知道这是您要问的问题，还是您要问的问题略有不同。

如果您只需要强制唯一随机数，您可以从两个向量中填充一个std::unordered_map。