Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::prev_permutation — permutación lexicográfica anterior

std::prev_permutation reorganiza un rango en su permutación lexicográfica anterior. Devuelve bool; si no existe una permutación anterior, reorganiza el rango en la última permutación y devuelve false.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <algorithm>

template<class BidirectionalIterator>
constexpr bool prev_permutation(BidirectionalIterator first,
                                BidirectionalIterator last);

template<class BidirectionalIterator, class Compare>
constexpr bool prev_permutation(BidirectionalIterator first,
                                BidirectionalIterator last,
                                Compare comp);

std::prev_permutation, declarada en <algorithm>, modifica [first, last) en el propio rango para producir la disposición inmediatamente anterior en orden lexicográfico. El orden lo determina la primera posición en la que los valores no son equivalentes según el comparador. En C++23, el comparador predeterminado es std::less{}, que garantiza un orden total estricto para los punteros incluso cuando el operador incorporado < no lo garantiza. La sobrecarga que recibe comp permite proporcionar otro orden débil estricto.

Un valor de retorno true significa que se encontró una permutación anterior. Un valor de retorno false no significa que los datos hayan quedado sin cambios: el algoritmo produce la última permutación, en orden descendente según el orden elegido. Para un rango vacío o de un solo elemento, devuelve false y el contenido permanece igual.

El algoritmo requiere iteradores bidireccionales cuyos valores referenciados se puedan intercambiar. No es necesario ordenar los datos antes de dar un solo paso. Si el comparador distingue todos los pares de valores distintos del rango, empieza en orden descendente y usa un bucle do–while para recorrer cada disposición distinta de los valores exactamente una vez, de mayor a menor. Si el comparador considera equivalentes valores distintos, el algoritmo solo distingue las disposiciones de sus clases de equivalencia, por lo que puede omitir algunas disposiciones de los valores. Por ejemplo, si el rango solo contiene dos valores distintos que el comparador considera equivalentes, la primera llamada ya devuelve false.

El ejemplo muestra tanto las transiciones entre permutaciones como el retorno a la última permutación después de false. Esta entrada describe las sobrecargas de std::prev_permutation que devuelven bool, no la interfaz std::ranges.

Ejemplos

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

int main() {
    std::array<int, 3> values{2, 1, 1};
    std::cout << std::boolalpha;

    bool found;
    do {
        for (int value : values) {
            std::cout << value;
        }
        found = std::prev_permutation(values.begin(), values.end());
        std::cout << " -> " << found << '\n';
    } while (found);

    std::cout << "after wrap: ";
    for (int value : values) {
        std::cout << value;
    }
    std::cout << '\n';
}

Resultado

211 -> true
121 -> true
112 -> false
after wrap: 211

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes