Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::shuffle — reorganizar elementos aleatoriamente

std::shuffle reorganiza os elementos de um intervalo no próprio intervalo, usando um gerador de números aleatórios fornecido. Requer iteradores de acesso aleatório; uma semente fixa não garante a mesma ordem em diferentes implementações da biblioteca padrão.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

template<class RandomAccessIterator, class UniformRandomBitGenerator>
void std::shuffle(RandomAccessIterator first, RandomAccessIterator last,
                  UniformRandomBitGenerator&& g);

std::shuffle, declarada em <algorithm>, reorganiza aleatoriamente os elementos do intervalo semiaberto [first, last). Não acrescenta nem remove elementos e devolve void. O contrato exige igual probabilidade para cada permutação, pelo que o resultado pode manter a ordem original.

Os iteradores têm de permitir acesso aleatório e os elementos referenciados têm de poder ser trocados. Por exemplo, std::array e std::vector modificáveis são adequados, mas std::list não. O argumento g tem de cumprir os requisitos de uniform random bit generator, como std::mt19937 de <random>; não é simplesmente uma semente nem uma função qualquer que devolve números.

O custo é linear em relação ao número de elementos. O gerador fornece a aleatoriedade e o seu estado pode mudar. Uma semente fixa facilita a repetição de testes na mesma implementação, mas a norma não determina uma ordem resultante específica entre diferentes implementações da biblioteca padrão.

O exemplo verifica a preservação dos elementos com std::is_permutation, em vez de esperar uma ordem específica ou exigir que a ordem mude. Assim, o resultado esperado é sempre true quando a execução é correta.

Exemplos

#include <algorithm>
#include <array>
#include <iostream>
#include <random>

int main() {
    const std::array<int, 5> original{1, 2, 3, 4, 5};
    auto values = original;
    std::mt19937 engine{42};

    std::shuffle(values.begin(), values.end(), engine);

    std::cout << std::boolalpha
              << std::is_permutation(original.begin(), original.end(),
                                     values.begin(), values.end())
              << '\n';
}

Resultado

true

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes