Перемешать массив

#include <iostream>
#include <algorithm>
#include <iterator>
#include <vector>
#include <utility>
 
std::ostream &operator<<(std::ostream &out, const std::vector<int> &vec) {
  std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(out, " "));
  return out;
}
 
std::pair<int, int> CreateNewNeibors(int first, int second) {
  return std::make_pair(first, second);
}
 
struct TrueFalse {
  TrueFalse(bool is_now_true) : is_now_true_(is_now_true) {}
 
  template <typename T>
  bool operator()(T) {
    return is_now_true_ = !is_now_true_;
  }
 
  bool is_now_true_ = false;
};
 
std::vector<int> ShuffledWithNoNeigbours(const std::vector<int> &vec) {
  std::vector<int> no_neigbours;
  std::copy_if(vec.begin(), vec.end(), std::back_inserter(no_neigbours),
               TrueFalse(true));
  std::copy_if(vec.begin(), vec.end(), std::back_inserter(no_neigbours),
               TrueFalse(false));
  return no_neigbours;
}
 
void SwapMiddleIfVectorSizeOdd(std::vector<int> &vec) {
  if (vec.size() % 2 == 1) {
    auto middle = vec.begin() + vec.size() / 2;
    std::swap(*middle, vec.back());
  }
}
 
std::vector<int> Rearrange(const std::vector<int> &vec) {
  std::vector<int> rearranged(vec);
  SwapMiddleIfVectorSizeOdd(rearranged);
  return ShuffledWithNoNeigbours(rearranged);
}
 
std::vector<int> MarkAtOldPosition(const std::vector<int> &old,
                                   const std::vector<int> &rearranged) {
  std::vector<int> at_old_position(old.size());
  for (size_t i = 0; i < old.size(); ++i) {
    if (old[i] == rearranged[i]) {
      at_old_position[i] = 1;
    }
  }
  return at_old_position;
}
 
std::vector<int> HasSameNeigbours(const std::vector<int> &old,
                                  const std::vector<int> &rearranged) {
  std::vector<int> has_old_neigbors(rearranged.size());
  for (size_t i = 0; i < old.size(); ++i) {
    auto rearranged_pos =
        std::find(rearranged.begin(), rearranged.end(), old[i]);
    if ((rearranged_pos != rearranged.begin() &&
         (old[i - 1] == *(rearranged_pos - 1))) ||
        (rearranged_pos + 1 != rearranged.end() &&
         old[i + 1] == *(rearranged_pos + 1))) {
 
      has_old_neigbors[std::distance(rearranged.begin(), rearranged_pos)] = 1;
    }
  }
  return has_old_neigbors;
}
 
struct EqualToZero {
  template <typename T>
  bool operator()(T element) {
    return element == 0;
  }
};
 
bool AllZero(const std::vector<int> vec) {
  return std::all_of(vec.begin(), vec.end(), EqualToZero());
}
 
void ShowDebug(const std::vector<int> &array,
               const std::vector<int> &rearranged,
               const std::vector<int> &old_pos_marks,
               const std::vector<int> &has_same_neigbours) {
  std::cout << "array      : " << array << '\n';
  std::cout << "rearranged : " << rearranged << '\n';
  std::cout << "old pos    : " << old_pos_marks << '\n';
  std::cout << "same_neigb : " << has_same_neigbours << '\n';
}
 
bool IsBrutForceTestPassed() {
  for (size_t i = 4; i < 20; ++i) {
    std::vector<int> array(i);
    std::generate_n(array.begin(), i, std::rand);
    auto rearranged = Rearrange(array);
    auto old_pos_marks = MarkAtOldPosition(array, rearranged);
    auto has_same_neigbours = HasSameNeigbours(array, rearranged);
    if (!AllZero(old_pos_marks) || !AllZero(has_same_neigbours)) {
      ShowDebug(array, rearranged, old_pos_marks, has_same_neigbours);
      return false;
    }
  }
  return true;
}
 
void ShowExample() {
  std::cout << "This is example:\n";
  std::vector<int> array = {7, 3, 2, 1, 4, 6, 9};
  auto rearranged = Rearrange(array);
  auto old_pos_marks = MarkAtOldPosition(array, rearranged);
  auto has_same_neigbours = HasSameNeigbours(array, rearranged);
  ShowDebug(array, rearranged, old_pos_marks, has_same_neigbours);
}
 
void ShowBurtFroceTestResults() {
  std::cout << "Is brut force test passed: " << std::boolalpha
            << IsBrutForceTestPassed() << '\n';
}
 
void ShowTestDoNotLie() {
  std::cout << "Test don't lie:\n";
  std::cout << MarkAtOldPosition({1}, {1}) << '\n';
  std::cout << MarkAtOldPosition({1, 2}, {1, 2}) << '\n';
  std::cout << MarkAtOldPosition({1, 2, 3}, {1, 2, 3}) << '\n';
  std::cout << MarkAtOldPosition({1, 2, 3}, {3, 2, 1}) << '\n';
  std::cout << HasSameNeigbours({1}, {1}) << '\n';
  std::cout << HasSameNeigbours({1, 2}, {1, 2}) << '\n';
  std::cout << HasSameNeigbours({1, 2, 3}, {1, 2, 3}) << '\n';
  std::cout << HasSameNeigbours({1, 2, 3}, {3, 2, 1}) << '\n';
}
 
int main() {
  ShowTestDoNotLie();
  ShowExample();
  ShowBurtFroceTestResults();
}

#include <algorithm>
#include <vector>
#include <iostream>
 
using namespace std;
 
auto my_shuffle = [](auto first, auto last)
{
    while (first + 1 != last)
    {
        rotate(first, first + 1, last);
        rotate(first, first + 1, --last);
    }
};
 
int main()
{
    vector<int> v{1, 2, 3, 4, 5, 6, 7};
    my_shuffle(std::begin(v), std::end(v));
}

#include <iostream>
 
using namespace std;
 
int lN, vn[100001];
 
int main()
{
    cin >> lN;
    if (lN < 4)
    {
        cout << "No solution";
        return 0;
    }
 
    for (int i = 0; i < lN; i++)
    {
        vn[i] = i + 1;
    }
 
    int tmp;
    for (int i = 0; i < lN - (lN % 2 == 0 ? 0 : 1); i += 2)
    {
        tmp = vn[i];
        vn[i] = vn[i + 1];
        vn[i + 1] = tmp;
    }
    for (int i = 1; i < lN - 1; i += 2)
    {
        tmp = vn[i];
        vn[i] = vn[i + 1];
        vn[i + 1] = tmp;
    }
 
 
    for (int i = 0; i < lN; i++)
    {
        cout << vn[i] << endl;
    }
    return 0;
}