Ordina vettore con indici pari e dispari. C++

Question

Esiste una soluzione (o una semplice soluzione loop-free) per ordinare un vettore in base agli indici pari e dispari? Esempio:

long entries[] = {0,1,2,10,11}; // indices 0 1 2 3 4 
std::vector<long> vExample(entries, entries + sizeof(entries)/sizeof(long)); 

vExample.sortEvenOdd(vExample.begin(),vExample.end()); // magic one liner I wish existed... 

for (int i = 0; i < vExample.size(); i++) 
{ 
    std::cout << vExample[i] << " "; 
} 

Ora mi piacerebbe avere il seguente output:

0 2 11 1 10 // corresponding to indices 0 2 4 1 3 

Answer 1

ho cercato di fare un vero e proprio uno di linea:

std::stable_partition(std::begin(input), std::end(input), 
         [&input](int const& a){return 0==((&a-&input[0])%2);}); 

Ed ecco il programma completo:

#include <algorithm> 
#include <iostream> 
#include <vector> 

int main() { 
    std::vector<int> input {0,1,2,10,11}; 

    std::stable_partition(std::begin(input), std::end(input), 
         [&input](int const& a){return 0==((&a-&input[0])%2);}); 

    for (auto v : input) 
    std::cout << v << " "; 
} 

Ok lo so, funziona per la sola ragione che usi vettore una serie contigua di elementi e l'intera faccenda è sporca ... Ma per quello è un one liner come richiesto dall'OP e non richiede nulla in più come boost ...

Answer 2

Quello che vi serve è stable_partition. Definisci un predicato che controlla se l'indice utilizza persino il modulo 2 e sei pronto per partire.

Answer 3

Questo non è uno di linea, ma abbastanza vicino:

long entries[] = {0,1,2,10,11}; // indices 0 1 2 3 4 
std::vector<long> vExample; 
for(bool flag : { true, false }) { 
    auto cond = [&flag](long) { flag = !flag; return !flag; }; 
    std::copy_if(std::begin(entries), std::end(entries), std::back_inserter(vExample), cond); 
} 

Answer 4

Se è possibile utilizzare Boost, questo è abbastanza conciso:

#include <boost/range/adaptor/strided.hpp> 
#include <boost/range/adaptor/sliced.hpp> 
#include <boost/range/algorithm_ext/push_back.hpp> 
#include <iostream> 
#include <vector> 

int main() { 
    using namespace boost::adaptors; 

    std::vector<int> input {0,1,2,10,11}; 
    std::vector<int> partitioned; 

    boost::push_back(partitioned, input | strided(2)); 
    boost::push_back(partitioned, input | sliced(1, input.size()) | strided(2)); 

    for (auto v : partitioned) 
     std::cout << v << " "; 
} 

Ovviamente si può avvolgere che in una funzione per ottenere un un liner nel codice di chiamata. Live