1119

#include <vector>
#include <cstdio>

void test_mod() {
    unsigned long step = 5;
    unsigned long size = 7;
    unsigned long index = 4;

    if (index >= step) {
        index -= step;
    } else {
        index = size - (index + 1);
        printf("Index: %lu\n", index);

        index = (index + step - 1) % size;
        printf("Index: %lu\n", index);

        index = size - (index + 1);
        printf("Index: %lu\n", index);
    }

    printf("%lu\n", index);
}

void print_vec(std::vector<unsigned long>& vec) {
    printf("Vector: ");
    for (auto counter = 0; counter < vec.size(); ++counter) {
        printf("%lu ", vec[counter]);
    }

    printf("\n");
}

int main() {

    unsigned long N = 10;
    unsigned long step_right = 4;
    unsigned long step_left = 3;

    unsigned long index_right = (step_right - 1) % N;
    // printf("First right index: %lu\n", index_right);

    unsigned long index_left = (N - 1) - (step_left - 1);
    //printf("First left index: %lu\n", index_left);

    std::vector<unsigned long> vec;
    for (auto counter = 0; counter < N; ++counter) {
        vec.push_back(counter + 1);
    }

    // test_mod();

    bool flag_left = false, flag_right = false;
    while (!vec.empty()){
        printf("New values - R: %lu / L: %lu / S: %lu\n", index_right, index_left, vec.size());

        print_vec(vec);

        if (index_left == 0) flag_left = true;
        if (index_right == (vec.size() - 1)) flag_right = true;

        if (index_right == index_left) {
            printf(" %lu,\n", vec[index_right]);
            // printf("Both are removing the same value %lu (Index value: %lu - Vector size: %lu)\n", vec[index_right], index_right, vec.size());
            vec.erase(vec.begin() + index_right);
            --index_left;
        } else {
            // print_vec(vec);

            long unsigned out_right, out_left;
            if (index_right < index_left) {
                // printf(" %lu", vec[index_right]);
                // printf("Right movement - Removing value %lu (Index value: %lu - Vector size: %lu)\n", vec[index_right], index_right, vec.size());
                out_right = vec[index_right];
                vec.erase(vec.begin() + index_right);

                if (vec.empty()){
                    printf(" %lu\n", out_right);
                    break;
                }

                --index_left;
                // printf(" %lu", vec[index_left]);
                // printf("Left movement - Removing value %lu (Index value: %lu - Vector size: %lu)\n", vec[index_left], index_left, vec.size());
                out_left = vec[index_left];
                vec.erase(vec.begin() + index_left);
            } else {
                // printf("Left movement - Removing value %lu (Index value: %lu - Vector size: %lu)\n", vec[index_left], index_left, vec.size());
                out_left = vec[index_left];
                vec.erase(vec.begin() + index_left);

                if (vec.empty()){
                    printf(" %lu\n", out_left);
                    break;
                }

                --index_right;
                --index_left;

                out_right = vec[index_right];
                vec.erase(vec.begin() + index_right);
            }

            printf(" %lu %lu,\n", out_right, out_left);
            // print_vec(vec);
        }

        if (flag_left) {
          index_left = vec.size() - 1;
          flag_left = false;
        }

        if (flag_right) {
          index_right = 0;
          flag_right = false;
        }

        if (vec.empty()) break;

        // print_vec(vec);

        // printf("Previous values - R: %lu / L: %lu / S: %lu\n", index_right, index_left, vec.size());

        index_right = (index_right + step_right - 1) % vec.size(); // Ok

        if (index_left >= step_left) {
            index_left -= step_left;
        } else {
            long unsigned tmp = vec.size() - (index_left + 1);
            index_left = vec.size() - (((tmp + step_left - 1) % vec.size()) + 1);
        }

        // printf("New values - R: %lu / L: %lu / S: %lu\n", index_right, index_left, vec.size());
    }

    return 0;
}