Linalg IHW 2 task 2

main.cpp

#include <iostream>
#include "permutation.h"

using namespace std;

int main() {

    vector<size_t> vect;
    for (size_t i = 18; i < 324; ++i)
        vect.push_back(i);
    for (size_t i = 1; i < 18; ++i)
        vect.push_back(i);
    Permutation P(vect);
    if (P.get_sign() == 1)
        cout << "even";
    else
        cout << "odd";
    cout << endl;
    cout << "Number of inversions: " << P.get_inversions() << endl;

}

permutation.h

#pragma once

#include <iostream>
#include <vector>

class Permutation {
    std::vector<size_t> perm;

public:

    Permutation() {}

    Permutation(size_t n) {
        perm.reserve(n);
        for (size_t i = 0; i < n; ++i)
            perm.push_back(i);
    }

    Permutation(std::vector<size_t> _perm): perm(_perm) {
        if (std::find(perm.begin(), perm.end(), 0) == perm.end())
            for (size_t i = 0; i < perm.size(); ++i)
                --perm[i];
    }

    bool next() {
        if (perm.size() < 2)
            return false;
        size_t cur = perm.size() - 1;
        while (perm[cur - 1] > perm[cur]) {
            --cur;
            if (cur == 0)
                return false;
        }

        size_t nxt = perm.size() - 1;
        while (nxt > cur && perm[nxt] < perm[cur - 1])
            --nxt;

        std::swap(perm[nxt], perm[cur - 1]);

        std::reverse(perm.begin() + cur, perm.end());
        return true;
    }

    size_t size() const {
        return perm.size();
    }

    size_t operator[](size_t p) const {
        return perm[p];
    }

    size_t& operator[](size_t p) {
        return perm[p];
    }

    friend std::ostream& operator<<(std::ostream &os, const Permutation& P) {
        for (size_t i = 0; i < P.size(); ++i)
            os << i + 1 << '\t';
        os << std::endl;
        for (size_t i = 0; i < P.size(); ++i)
            os << P.perm[i] + 1 << '\t';
        return os;
    }

    Permutation& operator*=(const Permutation& other) {
        std::vector<size_t> tmp(size());
        for (size_t i = 0; i < size(); ++i) {
            tmp[i] = other[perm[i]];
        }
        perm = std::move(tmp);
        return *this;
    }

    friend Permutation operator*(const Permutation& P1, const Permutation& P2) {
        Permutation tmp(P1);
        tmp *= P2;
        return tmp;
    }

    Permutation inversed() const {
        Permutation tmp(size());
        for (size_t i = 0; i < size(); ++i)
            tmp[perm[i]] = i;
        return tmp;
    }

    bool operator==(const Permutation& P) const {
        return perm == P.perm;
    }

    size_t get_inversions() const {
        size_t res = 0;
        for (size_t i = 0; i < size(); ++i) {
            for (size_t j = i + 1; j < size(); ++j) {
                if (perm[j] < perm[i])
                    ++res;
            }
        }
        return res;
    }

    int get_sign() const {
        size_t res = get_inversions();
        if (res % 2 == 0)
            return 1;
        else
            return -1;
    }

};