如何洗牌包括最后一个元素的数组？

Question

我试过使用 std::random_shuffle 和 std::shuffle，但它们只会随机播放第一个和介于第一个和最后一个之间的元素，而不是最后一个。有没有办法打乱包括最后一个元素的数组（向量）？

//NumberGenerator.h
#ifndef __NUMBERGENERATOR_H__
#define __NUMBERGENERATOR_H__
#pragma once
#include "Number.h" //regular numbers
#include "MegaNumber.h" //mega numbers
#include <vector> //<vector>
#include <string> //strings 
using std::to_string; //convert int to strings
#include <algorithm> //shuffle
//#include <random> //std::default_random_engine
#define NON_MEGA_COMBINATIONS 5
#define MEGA_COMBINATIONS 1

using std::vector; //<vectors>
using std::string; //string
using std::random_shuffle; //shuffles arrays

class NumberGenerator
{
public:
    NumberGenerator(vector<Number> numbers, vector<MegaNumber> megaNumbers); //constructor
    ~NumberGenerator();
    string pickNumbers(); //function that randomizes regularDraws and megaDraws
protected: 
    vector<Number> regularDraws; //contains number information
    vector<MegaNumber> megaDraws; //contains mega number information
};

#endif


//NumberGenerator.cpp
#include "NumberGenerator.h"


//constructor
NumberGenerator::NumberGenerator(vector<Number> numbers, vector<MegaNumber> megaNumbers)
{
    regularDraws = numbers;
    megaDraws = megaNumbers;
}

//destructor
NumberGenerator::~NumberGenerator()
{
}


string NumberGenerator::pickNumbers()
{
    srand(rand());
    random_shuffle(&regularDraws[1], &regularDraws[regularDraws.size() - 1]);
    random_shuffle(&megaDraws[1], &megaDraws[megaDraws.size() - 1]);
    string regular;
    string mega;
    string last = to_string(regularDraws[regularDraws.size() - 1].getID());

    for (int i = 1; i <= NON_MEGA_COMBINATIONS; i++)
    {
        regular = regular + " " + to_string(regularDraws[i].getID());
    }

    for (int i = 1; i <= MEGA_COMBINATIONS; i++)
    {
        mega = mega + " " + to_string(megaDraws[i].getID());
    }

    return regular + " " + mega + " " + last;
}



//Number.h
#ifndef __NUMBER_H_
#define __NUMBER_H__
#pragma once


class Number
{
public:
    Number(int id); //constructor
    ~Number(); //destructor


    int getID(); //returns the number ID



protected:
    int ID; //This is the number 
};

#endif 

//Number.cpp
#include "Number.h"


//constructor
Number::Number(int id)
{
    occurence = 0;
    occurencePct = 0;
    ID = id;
}

//destructor
Number::~Number()
{
}

//returns the number ID
int Number::getID() 
{
    return ID; 
}


//MegaNumber.h
#ifndef __MEGANUMBER_H__
#define __MEGANUMBER_H__
#pragma once
#include "Number.h"

//Subclass of Number
class MegaNumber :
    public Number
{
public:
    MegaNumber(int id); //Will be inheriting Number superclass
    ~MegaNumber();
};

#endif

//MegaNumber.cpp
#include "MegaNumber.h"


//constructor
MegaNumber::MegaNumber(int id) : Number::Number(id) //inherits the super class Number
{

}

//destructor
MegaNumber::~MegaNumber()
{
}

//Source.cpp
#include <iostream>
#include "NumberGenerator.h"
int main()
{
vector<Number> arg1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
vector<MegaNumber> arg2 = {0, 1, 2, 3, 4, 5, 6, 7 , 8, 9};
NumberGenerator game(arg1, arg2);
  for (int i = 0; i < 10; i++)
  {
      cout << game.pickNumbers() << endl;
  }
}

这是我的代码的精简版，因为它包含 10 个文件，我认为对于我正在做的事情来说已经足够了。无论如何，每次 pickNumbers() 是运行.

时，最后一个元素不会被洗牌

Answer 1

所有采用一对迭代器的标准库算法（和其他函数）都在半开范围 [first, last) 上运行。然而，这根本不是问题——所有标准库容器都被设计成 end()（和变体）返回的迭代器是一个 past-the-end 迭代器：它指向 容器中最后一个真实元素之后的一个。 所以这个调用：

std::vector<int> v = whatever();
std::random_shuffle(v.begin(), v.end());

实际上会打乱全部向量中的int。

鉴于此，您可以看到您错误地使用了该功能。对于 last 参数，您传递的是 &regularDraws[regularDraws.size() - 1]（和类似的）——向量中最后一个实际元素的地址。由于间隔是半开的，正如我在上面概述的那样，最后一个元素不是随机播放的一部分。

您根本不应该使用指向向量的指针⁽¹⁾，而应该使用迭代器：

random_shuffle(std::next(regularDraws.begin()), regularDraws.end());

std::next 在那里是因为你最初传递 [1] （向量中的第二个元素）作为 first 参数，所以我保留了那个（记住数组索引是在 C++ 中基于 0）。如果那不是你的意图，只需随机播放整个向量：

random_shuffle(regularDraws.begin(), regularDraws.end());

在任何地方使用半开范围实际上是非常有利的：

它允许空范围的简单表达式：begin == end
所有插入点都可以使用迭代器指定，如果我们将该迭代器表示为 "before the element pointed to." begin 则表示 "insert before the first element," 并且 end 转换为 "insert before the one-past-last` element," 即 "insert after the last element."

它允许简单 concatenation/splitting:

auto b = rng.begin();
auto e = rng.end();
auto m = std::next(b, std::distance(b, e) / 2);
processHalf(b, m);
processHalf(m, e);

⁽¹⁾ 您的代码之所以有效，是因为 std::vector 将其元素连续存储在内存中。使用迭代器，它将适用于任何容器。

如何洗牌包括最后一个元素的数组？

How to shuffle an array including the last element?

c++

arrays

random

shuffle

vector