Штуки

exam-queue-17/files/check.cpp

@@ -0,0 +1,57 @@
+#include "testlib.h"
+#include <sstream>
+
+using namespace std;
+
+int main(int argc, char * argv[])
+{
+    setName("compare ordered sequences of signed int%d numbers", 8 * int(sizeof(long long)));
+
+    registerTestlibCmd(argc, argv);
+
+    int n = 0;
+    string firstElems;
+
+    while (!ans.seekEof() && !ouf.seekEof())
+    {
+        n++;
+        long long j = ans.readLong();
+        long long p = ouf.readLong();
+        if (j != p)
+            quitf(_wa, "%d%s numbers differ - expected: '%s', found: '%s'", n, englishEnding(n).c_str(), vtos(j).c_str(), vtos(p).c_str());
+        else
+            if (n <= 5)
+            {
+                if (firstElems.length() > 0)
+                    firstElems += " ";
+                firstElems += vtos(j);
+            }
+    }
+
+    int extraInAnsCount = 0;
+
+    while (!ans.seekEof())
+    {
+        ans.readLong();
+        extraInAnsCount++;
+    }
+    
+    int extraInOufCount = 0;
+
+    while (!ouf.seekEof())
+    {
+        ouf.readLong();
+        extraInOufCount++;
+    }
+
+    if (extraInAnsCount > 0)
+        quitf(_wa, "Answer contains longer sequence [length = %d], but output contains %d elements", n + extraInAnsCount, n);
+    
+    if (extraInOufCount > 0)
+        quitf(_wa, "Output contains longer sequence [length = %d], but answer contains %d elements", n + extraInOufCount, n);
+    
+    if (n <= 5)
+        quitf(_ok, "%d number(s): \"%s\"", n, compress(firstElems).c_str());
+    else
+        quitf(_ok, "%d numbers", n);
+}

exam-queue-17/files/gen.cpp

@@ -0,0 +1,281 @@
+#include<bits/stdc++.h>
+
+#ifndef KRAKOZYABRA
+#include "testlib.h"
+#else
+#include "testliblochal.h"
+#endif // KRAKOZYABRA
+
+using namespace std;
+
+template <typename T>
+class ordered_set {
+private:
+    struct Node {
+        T data;
+        int weight; // Number of nodes in the subtree rooted at this node
+        std::unique_ptr<Node> left;
+        std::unique_ptr<Node> right;
+
+        Node(const T& data) : data(data), weight(1), left(nullptr), right(nullptr) {}
+    };
+
+    std::unique_ptr<Node> root;
+
+    // Helper function to update the weight of a node
+    void update_weight(Node* node) {
+        if (node) {
+            node->weight = 1;
+            if (node->left) node->weight += node->left->weight;
+            if (node->right) node->weight += node->right->weight;
+        }
+    }
+
+    // Helper function for insertion
+    Node* insert_recursive(Node* node, const T& data) {
+        if (!node) {
+            return new Node(data);
+        }
+
+        if (data < node->data) {
+            node->left.reset(insert_recursive(node->left.release(), data));  //Release ownership before recursive call
+        }
+        else {
+            node->right.reset(insert_recursive(node->right.release(), data)); //Release ownership before recursive call
+        }
+        update_weight(node);
+        return node;
+    }
+
+    // Helper function for deletion (find minimum in right subtree)
+    Node* find_min(Node* node) {
+        while (node->left) {
+            node = node->left.get(); // Access the raw pointer
+        }
+        return node;
+    }
+
+    // Helper function for deletion
+    Node* delete_recursive(Node* node, const T& data) {
+        if (!node) {
+            return nullptr; // Value not found
+        }
+
+        if (data < node->data) {
+            node->left.reset(delete_recursive(node->left.release(), data)); //Release ownership before recursive call
+        }
+        else if (data > node->data) {
+            node->right.reset(delete_recursive(node->right.release(), data)); //Release ownership before recursive call
+        }
+        else {
+            // Node to be deleted found
+
+            // Case 1: Node with no child or only one child
+            if (!node->left) {
+                Node* temp = node->right.release();
+                delete node;
+                return temp;
+            }
+            else if (!node->right) {
+                Node* temp = node->left.release();
+                delete node;
+                return temp;
+            }
+
+            // Case 2: Node with two children
+            Node* temp = find_min(node->right.get());
+            node->data = temp->data;
+            node->right.reset(delete_recursive(node->right.release(), temp->data));
+        }
+
+        update_weight(node);
+        return node;
+    }
+
+    //Helper for get_element_at_index (find the k-th smallest element).
+    T get_element_at_index_recursive(Node* node, int index) {
+        if (!node) {
+            throw std::out_of_range("Index out of range");
+        }
+
+        int left_subtree_size = (node->left) ? node->left->weight : 0;
+
+        if (index == left_subtree_size) {
+            return node->data;
+        }
+        else if (index < left_subtree_size) {
+            return get_element_at_index_recursive(node->left.get(), index);
+        }
+        else {
+            return get_element_at_index_recursive(node->right.get(), index - left_subtree_size - 1);
+        }
+    }
+
+    //Helper to perform inorder traversal
+    void inorder_traversal_recursive(Node* node, std::vector<T>& result) const {
+        if (node) {
+            inorder_traversal_recursive(node->left.get(), result);
+            result.push_back(node->data);
+            inorder_traversal_recursive(node->right.get(), result);
+        }
+    }
+
+    //Helper to find index of an element.
+    int get_index_of_element_recursive(Node* node, const T& target, int current_rank) const {
+        if (!node) {
+            return -1; // Element not found
+        }
+
+        int left_subtree_size = (node->left) ? node->left->weight : 0;
+
+        if (target == node->data) {
+            return current_rank + left_subtree_size;
+        }
+        else if (target < node->data) {
+            return get_index_of_element_recursive(node->left.get(), target, current_rank);
+        }
+        else {
+            return get_index_of_element_recursive(node->right.get(), target, current_rank + left_subtree_size + 1);
+        }
+    }
+
+
+public:
+    ordered_set() : root(nullptr) {}
+
+    void insert(const T& data) {
+        if (!root) {
+            root = std::make_unique<Node>(data);
+        }
+        else {
+            root.reset(insert_recursive(root.release(), data)); //Release ownership before recursive call
+        }
+    }
+
+    void erase(const T& data) {
+        root.reset(delete_recursive(root.release(), data)); //Release ownership before recursive call
+    }
+
+    T get_element(int index) {
+        if (index < 0 || index >= size()) {
+            throw std::out_of_range("Index out of range");
+        }
+        return get_element_at_index_recursive(root.get(), index);
+    }
+
+    int size() const {
+        return (root) ? root->weight : 0;
+    }
+
+    bool empty() const {
+        return root == nullptr;
+    }
+
+    void clear() {
+        root.reset(); // Effectively deletes the entire tree
+    }
+
+    // Returns a vector of the elements in sorted order (inorder traversal)
+    std::vector<T> inorder_traversal() const {
+        std::vector<T> result;
+        inorder_traversal_recursive(root.get(), result);
+        return result;
+    }
+
+    // Added function to get the index of an element
+    int get_index(const T target) const {
+        return get_index_of_element_recursive(root.get(), target, 0);
+    }
+};
+
+int main(int argc, char* argv[]) {
+#ifndef KRAKOZYABRA
+    registerGen(argc, argv, 1);
+#endif // KRAKOZYABRA
+
+
+    int minN = opt<int>(2), maxN = opt<int>(3);
+    int minM = opt<int>(4), maxM = opt<int>(5);
+    int minA = opt<int>(6), maxA = opt<int>(7);
+    int n = rnd.next(minN, maxN);
+    int m = rnd.next(minM, maxM);
+    cout << n << ' ' << m << '\n';
+    ordered_set<int> st;
+    vector<int> a;
+    while (a.size() < n) {
+        int aa = rnd.next(minA, maxA);
+        if (st.get_index(aa) == -1) {
+            a.push_back(aa);
+            st.insert(aa);
+        }
+    }
+
+    auto getrndin = [&]() {
+        if (st.size() == 0)
+            return -1;
+        int sz = st.size();
+        int i = rnd.next(0, sz - 1);
+        return st.get_element(i);
+        };
+    auto getrndnew = [&]() {
+        int aa = rnd.next(minA, maxA);
+        while (st.get_index(aa) != -1)
+            aa = rnd.next(minA, maxA);
+        return aa;
+        };
+
+    for (int i = 0; i < n; i++)
+        cout << a[i] << " \n"[i == n - 1];
+    for (int i = 0; i < m; i++) {
+        int t = 0;
+        if (st.size() == 0)
+            t = 2;
+        else
+            t = rnd.next(1, 3);
+        if (t == 1) {
+            int x = getrndnew();
+            int y = getrndin();
+            st.insert(x);
+            cout << t << ' ' << x << ' ' << y << '\n';
+        }
+        if (t == 2) {
+            int x = getrndnew();
+            st.insert(x);
+            cout << t << ' ' << x << '\n';
+        }
+        if (t == 3) {
+            int x = getrndin();
+            st.erase(x);
+            cout << t << ' ' << x << '\n';
+        }
+    }
+}
+
+//#pragma once
+//#include <bits/stdc++.h>
+//#include <random>
+//#include <optional>
+//
+//using namespace std;
+//
+//random_device rd;
+//mt19937 gen(rd());
+//
+//template <typename T>
+//T opt(T value) {
+//    FILE* stream;
+//    freopen_s(&stream, "params.txt", "r", stdin);
+//    T res;
+//    for (int i = 0; i < value; i++)
+//        cin >> res;
+//    return res;
+//}
+//
+//class Random {
+//public:
+//    long long next(long long a, long long b) {
+//        return a + gen() % (b - a + 1);
+//    };
+//};
+//
+//Random rnd;

exam-queue-17/files/gen1.cpp

@@ -0,0 +1,280 @@
+#include<bits/stdc++.h>
+
+#ifndef KRAKOZYABRA
+#include "testlib.h"
+#else
+#include "testliblochal.h"
+#endif // KRAKOZYABRA
+
+using namespace std;
+
+template <typename T>
+class ordered_set {
+private:
+    struct Node {
+        T data;
+        int weight; // Number of nodes in the subtree rooted at this node
+        std::unique_ptr<Node> left;
+        std::unique_ptr<Node> right;
+
+        Node(const T& data) : data(data), weight(1), left(nullptr), right(nullptr) {}
+    };
+
+    std::unique_ptr<Node> root;
+
+    // Helper function to update the weight of a node
+    void update_weight(Node* node) {
+        if (node) {
+            node->weight = 1;
+            if (node->left) node->weight += node->left->weight;
+            if (node->right) node->weight += node->right->weight;
+        }
+    }
+
+    // Helper function for insertion
+    Node* insert_recursive(Node* node, const T& data) {
+        if (!node) {
+            return new Node(data);
+        }
+
+        if (data < node->data) {
+            node->left.reset(insert_recursive(node->left.release(), data));  //Release ownership before recursive call
+        }
+        else {
+            node->right.reset(insert_recursive(node->right.release(), data)); //Release ownership before recursive call
+        }
+        update_weight(node);
+        return node;
+    }
+
+    // Helper function for deletion (find minimum in right subtree)
+    Node* find_min(Node* node) {
+        while (node->left) {
+            node = node->left.get(); // Access the raw pointer
+        }
+        return node;
+    }
+
+    // Helper function for deletion
+    Node* delete_recursive(Node* node, const T& data) {
+        if (!node) {
+            return nullptr; // Value not found
+        }
+
+        if (data < node->data) {
+            node->left.reset(delete_recursive(node->left.release(), data)); //Release ownership before recursive call
+        }
+        else if (data > node->data) {
+            node->right.reset(delete_recursive(node->right.release(), data)); //Release ownership before recursive call
+        }
+        else {
+            // Node to be deleted found
+
+            // Case 1: Node with no child or only one child
+            if (!node->left) {
+                Node* temp = node->right.release();
+                delete node;
+                return temp;
+            }
+            else if (!node->right) {
+                Node* temp = node->left.release();
+                delete node;
+                return temp;
+            }
+
+            // Case 2: Node with two children
+            Node* temp = find_min(node->right.get());
+            node->data = temp->data;
+            node->right.reset(delete_recursive(node->right.release(), temp->data));
+        }
+
+        update_weight(node);
+        return node;
+    }
+
+    //Helper for get_element_at_index (find the k-th smallest element).
+    T get_element_at_index_recursive(Node* node, int index) {
+        if (!node) {
+            throw std::out_of_range("Index out of range");
+        }
+
+        int left_subtree_size = (node->left) ? node->left->weight : 0;
+
+        if (index == left_subtree_size) {
+            return node->data;
+        }
+        else if (index < left_subtree_size) {
+            return get_element_at_index_recursive(node->left.get(), index);
+        }
+        else {
+            return get_element_at_index_recursive(node->right.get(), index - left_subtree_size - 1);
+        }
+    }
+
+    //Helper to perform inorder traversal
+    void inorder_traversal_recursive(Node* node, std::vector<T>& result) const {
+        if (node) {
+            inorder_traversal_recursive(node->left.get(), result);
+            result.push_back(node->data);
+            inorder_traversal_recursive(node->right.get(), result);
+        }
+    }
+
+    //Helper to find index of an element.
+    int get_index_of_element_recursive(Node* node, const T& target, int current_rank) const {
+        if (!node) {
+            return -1; // Element not found
+        }
+
+        int left_subtree_size = (node->left) ? node->left->weight : 0;
+
+        if (target == node->data) {
+            return current_rank + left_subtree_size;
+        }
+        else if (target < node->data) {
+            return get_index_of_element_recursive(node->left.get(), target, current_rank);
+        }
+        else {
+            return get_index_of_element_recursive(node->right.get(), target, current_rank + left_subtree_size + 1);
+        }
+    }
+
+
+public:
+    ordered_set() : root(nullptr) {}
+
+    void insert(const T& data) {
+        if (!root) {
+            root = std::make_unique<Node>(data);
+        }
+        else {
+            root.reset(insert_recursive(root.release(), data)); //Release ownership before recursive call
+        }
+    }
+
+    void erase(const T& data) {
+        root.reset(delete_recursive(root.release(), data)); //Release ownership before recursive call
+    }
+
+    T get_element(int index) {
+        if (index < 0 || index >= size()) {
+            throw std::out_of_range("Index out of range");
+        }
+        return get_element_at_index_recursive(root.get(), index);
+    }
+
+    int size() const {
+        return (root) ? root->weight : 0;
+    }
+
+    bool empty() const {
+        return root == nullptr;
+    }
+
+    void clear() {
+        root.reset(); // Effectively deletes the entire tree
+    }
+
+    // Returns a vector of the elements in sorted order (inorder traversal)
+    std::vector<T> inorder_traversal() const {
+        std::vector<T> result;
+        inorder_traversal_recursive(root.get(), result);
+        return result;
+    }
+
+    // Added function to get the index of an element
+    int get_index(const T target) const {
+        return get_index_of_element_recursive(root.get(), target, 0);
+    }
+};
+
+int main(int argc, char* argv[]) {
+#ifndef KRAKOZYABRA
+    registerGen(argc, argv, 1);
+#endif // KRAKOZYABRA
+
+
+    int minN = opt<int>(2), maxN = opt<int>(3);
+    int minM = opt<int>(4), maxM = opt<int>(5);
+    int minA = opt<int>(6), maxA = opt<int>(7);
+    int n = rnd.next(minN, maxN);
+    int m = rnd.next(minM, maxM);
+    cout << n << ' ' << m << '\n';
+    ordered_set<int> st;
+    vector<int> a;
+    while (a.size() < n) {
+        int aa = rnd.next(minA, maxA);
+        if (st.get_index(aa) == -1) {
+            a.push_back(aa);
+            st.insert(aa);
+        }
+    }
+
+    auto getrndin = [&]() {
+        if (st.size() == 0)
+            return -1;
+        int sz = st.size();
+        int i = rnd.next(0, sz - 1);
+        return st.get_element(i);
+        };
+    auto getrndnew = [&]() {
+        int aa = rnd.next(minA, maxA);
+        while (st.get_index(aa) != -1)
+            aa = rnd.next(minA, maxA);
+        return aa;
+        };
+
+    for (int i = 0; i < n; i++)
+        cout << a[i] << " \n"[i == n - 1];
+    for (int i = 0; i < m; i++) {
+        int t = 1;
+        //if (st.size() == 0)
+        //    t = 2;
+        //else
+        //    t = rnd.next(1, 3);
+        if (t == 1) {
+            int x = getrndnew();
+            int y = getrndin();
+            st.insert(x);
+            cout << t << ' ' << x << ' ' << y << '\n';
+        }
+        if (t == 2) {
+            int x = getrndnew();
+            st.insert(x);
+            cout << t << ' ' << x << '\n';
+        }
+        if (t == 3) {
+            int x = getrndin();
+            st.erase(x);
+            cout << t << ' ' << x << '\n';
+        }
+    }
+}
+
+//#pragma once
+//#include <bits/stdc++.h>
+//#include <random>
+//
+//using namespace std;
+//
+//random_device rd;
+//mt19937 gen(rd());
+//
+//template <typename T>
+//T opt(T value) {
+//    FILE* stream;
+//    freopen_s(&stream, "params.txt", "r", stdin);
+//    T res;
+//    for (int i = 0; i < value; i++)
+//        cin >> res;
+//    return res;
+//}
+//
+//class Random {
+//public:
+//    long long next(long long a, long long b) {
+//        return a + gen() % (b - a + 1);
+//    };
+//};
+//
+//Random rnd;

exam-queue-17/files/gen2.cpp

@@ -0,0 +1,276 @@
+#include<bits/stdc++.h>
+
+#ifndef KRAKOZYABRA
+#include "testlib.h"
+#else
+#include "testliblochal.h"
+#endif // KRAKOZYABRA
+
+using namespace std;
+
+template <typename T>
+class ordered_set {
+private:
+    struct Node {
+        T data;
+        int weight; // Number of nodes in the subtree rooted at this node
+        std::unique_ptr<Node> left;
+        std::unique_ptr<Node> right;
+
+        Node(const T& data) : data(data), weight(1), left(nullptr), right(nullptr) {}
+    };
+
+    std::unique_ptr<Node> root;
+
+    // Helper function to update the weight of a node
+    void update_weight(Node* node) {
+        if (node) {
+            node->weight = 1;
+            if (node->left) node->weight += node->left->weight;
+            if (node->right) node->weight += node->right->weight;
+        }
+    }
+
+    // Helper function for insertion
+    Node* insert_recursive(Node* node, const T& data) {
+        if (!node) {
+            return new Node(data);
+        }
+
+        if (data < node->data) {
+            node->left.reset(insert_recursive(node->left.release(), data));  //Release ownership before recursive call
+        }
+        else {
+            node->right.reset(insert_recursive(node->right.release(), data)); //Release ownership before recursive call
+        }
+        update_weight(node);
+        return node;
+    }
+
+    // Helper function for deletion (find minimum in right subtree)
+    Node* find_min(Node* node) {
+        while (node->left) {
+            node = node->left.get(); // Access the raw pointer
+        }
+        return node;
+    }
+
+    // Helper function for deletion
+    Node* delete_recursive(Node* node, const T& data) {
+        if (!node) {
+            return nullptr; // Value not found
+        }
+
+        if (data < node->data) {
+            node->left.reset(delete_recursive(node->left.release(), data)); //Release ownership before recursive call
+        }
+        else if (data > node->data) {
+            node->right.reset(delete_recursive(node->right.release(), data)); //Release ownership before recursive call
+        }
+        else {
+            // Node to be deleted found
+
+            // Case 1: Node with no child or only one child
+            if (!node->left) {
+                Node* temp = node->right.release();
+                delete node;
+                return temp;
+            }
+            else if (!node->right) {
+                Node* temp = node->left.release();
+                delete node;
+                return temp;
+            }
+
+            // Case 2: Node with two children
+            Node* temp = find_min(node->right.get());
+            node->data = temp->data;
+            node->right.reset(delete_recursive(node->right.release(), temp->data));
+        }
+
+        update_weight(node);
+        return node;
+    }
+
+    //Helper for get_element_at_index (find the k-th smallest element).
+    T get_element_at_index_recursive(Node* node, int index) {
+        if (!node) {
+            throw std::out_of_range("Index out of range");
+        }
+
+        int left_subtree_size = (node->left) ? node->left->weight : 0;
+
+        if (index == left_subtree_size) {
+            return node->data;
+        }
+        else if (index < left_subtree_size) {
+            return get_element_at_index_recursive(node->left.get(), index);
+        }
+        else {
+            return get_element_at_index_recursive(node->right.get(), index - left_subtree_size - 1);
+        }
+    }
+
+    //Helper to perform inorder traversal
+    void inorder_traversal_recursive(Node* node, std::vector<T>& result) const {
+        if (node) {
+            inorder_traversal_recursive(node->left.get(), result);
+            result.push_back(node->data);
+            inorder_traversal_recursive(node->right.get(), result);
+        }
+    }
+
+    //Helper to find index of an element.
+    int get_index_of_element_recursive(Node* node, const T& target, int current_rank) const {
+        if (!node) {
+            return -1; // Element not found
+        }
+
+        int left_subtree_size = (node->left) ? node->left->weight : 0;
+
+        if (target == node->data) {
+            return current_rank + left_subtree_size;
+        }
+        else if (target < node->data) {
+            return get_index_of_element_recursive(node->left.get(), target, current_rank);
+        }
+        else {
+            return get_index_of_element_recursive(node->right.get(), target, current_rank + left_subtree_size + 1);
+        }
+    }
+
+
+public:
+    ordered_set() : root(nullptr) {}
+
+    void insert(const T& data) {
+        if (!root) {
+            root = std::make_unique<Node>(data);
+        }
+        else {
+            root.reset(insert_recursive(root.release(), data)); //Release ownership before recursive call
+        }
+    }
+
+    void erase(const T& data) {
+        root.reset(delete_recursive(root.release(), data)); //Release ownership before recursive call
+    }
+
+    T get_element(int index) {
+        if (index < 0 || index >= size()) {
+            throw std::out_of_range("Index out of range");
+        }
+        return get_element_at_index_recursive(root.get(), index);
+    }
+
+    int size() const {
+        return (root) ? root->weight : 0;
+    }
+
+    bool empty() const {
+        return root == nullptr;
+    }
+
+    void clear() {
+        root.reset(); // Effectively deletes the entire tree
+    }
+
+    // Returns a vector of the elements in sorted order (inorder traversal)
+    std::vector<T> inorder_traversal() const {
+        std::vector<T> result;
+        inorder_traversal_recursive(root.get(), result);
+        return result;
+    }
+
+    // Added function to get the index of an element
+    int get_index(const T target) const {
+        return get_index_of_element_recursive(root.get(), target, 0);
+    }
+};
+
+int main(int argc, char* argv[]) {
+#ifndef KRAKOZYABRA
+    registerGen(argc, argv, 1);
+#endif // KRAKOZYABRA
+
+
+    int minN = opt<int>(2), maxN = opt<int>(3);
+    int minM = opt<int>(4), maxM = opt<int>(5);
+    int minA = opt<int>(6), maxA = opt<int>(7);
+    int n = rnd.next(minN, maxN);
+    int m = rnd.next(minM, maxM);
+    cout << n << ' ' << m << '\n';
+    ordered_set<int> st;
+    vector<int> a;
+    while (a.size() < n) {
+        int aa = rnd.next(minA, maxA);
+        if (st.get_index(aa) == -1) {
+            a.push_back(aa);
+            st.insert(aa);
+        }
+    }
+
+    auto getrndin = [&]() {
+        if (st.size() == 0)
+            return -1;
+        int sz = st.size();
+        int i = rnd.next(0, sz - 1);
+        return st.get_element(i);
+        };
+    auto getrndnew = [&]() {
+        int aa = rnd.next(minA, maxA);
+        while (st.get_index(aa) != -1)
+            aa = rnd.next(minA, maxA);
+        return aa;
+        };
+
+    for (int i = 0; i < n; i++)
+        cout << a[i] << " \n"[i == n - 1];
+    for (int i = 0; i < m; i++) {
+        int t = rnd.next(1, 2);
+        if (t == 1) {
+            int x = getrndnew();
+            int y = getrndin();
+            st.insert(x);
+            cout << t << ' ' << x << ' ' << y << '\n';
+        }
+        if (t == 2) {
+            int x = getrndnew();
+            st.insert(x);
+            cout << t << ' ' << x << '\n';
+        }
+        if (t == 3) {
+            int x = getrndin();
+            st.erase(x);
+            cout << t << ' ' << x << '\n';
+        }
+    }
+}
+
+//#pragma once
+//#include <bits/stdc++.h>
+//#include <random>
+//
+//using namespace std;
+//
+//random_device rd;
+//mt19937 gen(rd());
+//
+//template <typename T>
+//T opt(T value) {
+//    FILE* stream;
+//    freopen_s(&stream, "params.txt", "r", stdin);
+//    T res;
+//    for (int i = 0; i < value; i++)
+//        cin >> res;
+//    return res;
+//}
+//
+//class Random {
+//public:
+//    long long next(long long a, long long b) {
+//        return a + gen() % (b - a + 1);
+//    };
+//};
+//
+//Random rnd;

exam-queue-17/files/olymp.sty

@@ -0,0 +1,788 @@
+%
+% Macros for the contest problems
+% for MikTeX: use latex.exe
+% License: https://github.com/GassaFM/olymp.sty/blob/master/LICENSE
+% Authors: https://github.com/GassaFM/olymp.sty/blob/master/AUTHORS
+%
+
+\ProvidesPackage{olymp}
+
+\usepackage{verbatim}
+
+
+\newif\if@landscape\@landscapefalse
+\newif\if@russian\@russianfalse
+\newif\if@ukrainian\@ukrainianfalse
+\newif\if@arabic\@arabicfalse
+
+\DeclareOption{landscape}{
+    \@landscapetrue
+}
+\DeclareOption{russian}{
+    \@russiantrue
+}
+\DeclareOption{ukrainian}{
+    \@ukrainiantrue
+}
+\DeclareOption{arabic}{
+    \@arabictrue
+}
+\ProcessOptions\relax
+
+
+% -- Setup margins --
+%
+% Tex defines to large margins for our purposes. 
+% So we redefine this to use paper more efficiently
+%
+
+\newlength{\thelinewidth}
+
+\if@landscape
+    \if@twocolumn
+    \else
+        \error Landscape is only supported for two column mode
+    \fi
+
+    \ifcase\@ptsize % 10 pt
+        \hoffset=-15mm
+        \voffset=-35mm
+        \textheight=165mm
+        \textwidth=272mm
+    \or % 11 pt
+        \hoffset=-13mm
+        \voffset=-36mm
+        \textheight=166mm
+        \textwidth=272mm
+    \or % 12 pt
+        \hoffset=-12mm
+        \voffset=-35mm
+        \textheight=162mm
+        \textwidth=268mm
+    \fi
+\else
+    \ifcase\@ptsize % 10 pt
+        \hoffset=-26.5mm
+        \voffset=-35mm
+        \textheight=250mm
+        \textwidth=175mm
+    \or % 11 pt
+        \hoffset=-25mm
+        \voffset=-37.5mm
+        \textheight=255mm
+        \textwidth=175mm
+    \or % 12 pt
+        \hoffset=-20mm
+        \voffset=-35mm
+        \textheight=245mm
+        \textwidth=175mm
+    \fi
+
+    \if@twocolumn
+        \hoffset=-14.3mm
+        \voffset=-38mm
+        \textheight=255mm
+        \textwidth=188mm
+    \fi
+\fi
+
+\if@twocolumn
+    \thelinewidth=0.47\textwidth
+\else
+    \thelinewidth=\textwidth
+\fi
+
+% -- End of setup margins --
+
+%---------- From package "lastpage" ------------------
+\def\lastpage@putlabel{\addtocounter{page}{-1}%
+   \immediate\write\@auxout{\string\newlabel{LastPage}{{}{\thepage}}}%
+   \addtocounter{page}{1}}
+\AtEndDocument{\clearpage\lastpage@putlabel}%
+%---------- end of "lastpage" ------------------
+
+% -- Setup sizes --
+\newlength{\exmpwidinf}
+\newlength{\exmpwidouf}
+\newlength{\exmpwidewid}
+\newlength{\exmpthreewidinf}
+\newlength{\exmpthreewidouf}
+\newlength{\exmpthreewidnote}
+
+\newif\ifintentionallyblankpages
+
+\exmpwidinf=0.43\thelinewidth
+\exmpwidouf=0.43\thelinewidth
+\exmpwidewid=0.9\thelinewidth
+\exmpthreewidinf=0.28\thelinewidth
+\exmpthreewidouf=0.28\thelinewidth
+\exmpthreewidnote=0.30\thelinewidth
+
+\newlength{\afterproblemhead}
+\newlength{\afterconstraints}
+
+\renewcommand{\t}[1]{\ifmmode{\mathtt{#1}}\else{\texttt{#1}}\fi}
+\if@russian
+\renewcommand{\le}{\leqslant}
+\renewcommand{\ge}{\geqslant}
+\renewcommand{\leq}{\leqslant}
+\renewcommand{\geq}{\geqslant}
+\else
+\if@ukrainian
+\renewcommand{\le}{\leqslant}
+\renewcommand{\ge}{\geqslant}
+\renewcommand{\leq}{\leqslant}
+\renewcommand{\geq}{\geqslant}
+\else
+\parindent=0mm
+\parskip=1ex
+\fi
+\fi
+
+% -- End of setup sizes --
+
+% -- Setup keywords --
+
+\if@russian
+\def\kw@ProblemTutorial{Разбор задачи}
+\def\kw@Problem{Задача}
+\def\kw@ProblemAuthor{Автор:}
+\def\kw@ProblemDeveloper{Разработчик:}
+\def\kw@ProblemOrigin{Источник:}
+\def\kw@InputFileName{Имя входного файла:}
+\def\kw@OutputFileName{Имя выходного файла:}
+\def\kw@TimeLimit{Ограничение по времени:}
+\def\kw@MemoryLimit{Ограничение по памяти:}
+\def\kw@Feedback{Отображение результатов:}
+\def\kw@stdin{стандартный поток ввода}
+\def\kw@stdout{стандартный поток вывода}
+\def\kw@Specification{Спецификация}
+\def\kw@Interaction{Протокол взаимодействия}
+\def\kw@Input{Формат входных данных}
+\def\kw@Output{Формат выходных данных}
+\def\kw@Example{Пример}
+\def\kw@Examples{Примеры}
+\def\kwExampleNotes{Пояснение}
+\def\kw@Explanation{Пояснение к примеру}
+\def\kw@Explanations{Пояснения к примерам}
+\def\kw@Illustration{Иллюстрация}
+\def\kw@Scoring{Система оценки}
+\def\kw@Note{Замечание}
+\def\kw@Notes{Замечания}
+\def\kw@Constraints{Ограничения}
+\def\kw@version{версия}
+\def\kw@revision{ревизия}
+\def\kw@SubtaskOne{Подзадача 1}
+\def\kw@SubtaskTwo{Подзадача 2}
+\def\kw@SubtaskThree{Подзадача 3}
+\def\kw@SubtaskFour{Подзадача 4}
+\def\kw@SubtaskFive{Подзадача 5}
+\def\kw@SubtaskSix{Подзадача 6}
+\def\kw@Subtask{Подзадача}
+\def\kw@points{баллы}
+\def\kw@Page{Страница}
+\def\kw@of{из}
+\def\kw@notstated{не указан}
+\def\kw@IntentionallyBlankPage{Эта страница специально оставлена пустой}
+\def\kw@defaultinputname{тест}
+\def\kw@defaultoutputname{ответ}
+\else
+\if@ukrainian
+\def\kw@ProblemTutorial{Розбір задачі}
+\def\kw@Problem{Задача}
+\def\kw@ProblemAuthor{Автор:}
+\def\kw@ProblemDeveloper{Розробник:}
+\def\kw@ProblemOrigin{Джерело:}
+\def\kw@InputFileName{Назва вхідного файлу:}
+\def\kw@OutputFileName{Назва вихідного файлу:}
+\def\kw@TimeLimit{Ліміт часу:}
+\def\kw@MemoryLimit{Ліміт використання пам'яті:}
+\def\kw@Feedback{Відображення результатів:}
+\def\kw@stdin{стандартний потік вводу}
+\def\kw@stdout{стандартний потік виводу}
+\def\kw@Specification{Специфікація}
+\def\kw@Interaction{Протокол взаємодії}
+\def\kw@Input{Формат вхідних даних}
+\def\kw@Output{Формат вихідних даних}
+\def\kw@Example{Приклад}
+\def\kw@Examples{Приклади}
+\def\kwExampleNotes{Пояснення}
+\def\kw@Explanation{Пояснення до прикладу}
+\def\kw@Explanations{Пояснения до прикладів}
+\def\kw@Illustration{Ілюстрація}
+\def\kw@Scoring{Система оцінювання}
+\def\kw@Note{Зауваження}
+\def\kw@Notes{Зауваження}
+\def\kw@Constraints{Обмеження}
+\def\kw@version{версія}
+\def\kw@revision{ревізія}
+\def\kw@SubtaskOne{Підзадача 1}
+\def\kw@SubtaskTwo{Підзадача 2}
+\def\kw@SubtaskThree{Підзадача 3}
+\def\kw@SubtaskFour{Підзадача 4}
+\def\kw@SubtaskFive{Підзадача 5}
+\def\kw@SubtaskSix{Підзадача 6}
+\def\kw@Subtask{Підзадача}
+\def\kw@points{бали}
+\def\kw@Page{Сторінка}
+\def\kw@of{з}
+\def\kw@notstated{не вказано}
+\def\kw@IntentionallyBlankPage{Ця сторінка спеціально залишена порожньою}
+\def\kw@defaultinputname{тест}
+\def\kw@defaultoutputname{відповідь}
+\else
+\def\kw@ProblemTutorial{Problem Tutorial}
+\def\kw@Problem{Problem}
+\def\kw@ProblemAuthor{Author:}
+\def\kw@ProblemDeveloper{Developer:}
+\def\kw@ProblemOrigin{Origin:}
+\def\kw@InputFileName{Input file:}
+\def\kw@OutputFileName{Output file:}
+\def\kw@TimeLimit{Time limit:}
+\def\kw@MemoryLimit{Memory limit:}
+\def\kw@Feedback{Feedback:}
+\def\kw@stdin{standard input}
+\def\kw@stdout{standard output}
+\def\kw@Specification{Specification}
+\def\kw@Interaction{Interaction Protocol}
+\def\kw@Input{Input}
+\def\kw@Output{Output}
+\def\kw@Example{Example}
+\def\kw@Examples{Examples}
+\def\kwExampleNotes{Notes}
+\def\kw@Explanation{Explanation}
+\def\kw@Explanations{Explanations}
+\def\kw@Illustration{Illustration}
+\def\kw@Scoring{Scoring}
+\def\kw@Note{Note}
+\def\kw@Notes{Notes}
+\def\kw@Constraints{Constraints}
+\def\kw@version{version}
+\def\kw@revision{revision}
+\def\kw@SubtaskOne{Subtask 1}
+\def\kw@SubtaskTwo{Subtask 2}
+\def\kw@SubtaskThree{Subtask 3}
+\def\kw@SubtaskFour{Subtask 4}
+\def\kw@SubtaskFive{Subtask 5}
+\def\kw@SubtaskSix{Subtask 6}
+\def\kw@Subtask{Subtask}
+\def\kw@points{points}
+\def\kw@Page{Page}
+\def\kw@of{of}
+\def\kw@notstated{not stated}
+\def\kw@IntentionallyBlankPage{This page is intentionally left blank}
+\def\kw@defaultinputname{test}
+\def\kw@defaultoutputname{answer}
+\fi
+\fi
+
+\afterproblemhead=3mm
+\afterconstraints=2mm
+
+\newcommand{\problemheadfont}{\LARGE}
+\newcommand{\problemsectionfont}{\Large}
+\newcommand{\problemend}{
+\clearpage
+\ifintentionallyblankpages
+  \ifodd\value{page}
+  \else
+     \vspace*{\fill}
+     \begin{center}
+     \problemheadfont\kw@IntentionallyBlankPage
+     \end{center}
+     \vspace*{\fill}
+     \clearpage
+  \fi
+\fi
+}
+\newcommand{\problemtextfont}{\normalsize}
+\newcommand{\beforeproblemsectioncaption}{\smallbreak\smallskip}
+\newcommand{\afterproblemsectioncaption}{\smallskip}
+
+\if@twocolumn
+    \afterproblemhead=1mm
+    \afterconstraints=1mm
+    \renewcommand{\problemheadfont}{\large}
+    \renewcommand{\problemsectionfont}{\normalsize}
+    \renewcommand{\problemend}{\par\medskip}
+    \renewcommand{\problemtextfont}{\footnotesize}
+    \renewcommand{\beforeproblemsectioncaption}{\smallbreak\smallskip}
+    \renewcommand{\afterproblemsectioncaption}{}
+\fi
+
+% -- End of setup keywords --
+
+
+% -- Problem sections --
+
+\newcommand{\createsection}{\@newsection}
+
+\def\@newsection#1#2{\DeclareRobustCommand{#1}{
+{\beforeproblemsectioncaption\noindent\bf\problemsectionfont
+\textsf{#2}}
+\nopagebreak\par\afterproblemsectioncaption}
+}
+
+\newcommand{\createsectionexample}{\@newsectionexample}
+
+\def\@newsectionexample#1#2{\DeclareRobustCommand{#1}{
+\ifdefined\NoExamples\else%
+{\beforeproblemsectioncaption\noindent\bf\problemsectionfont
+\textsf{#2}}
+\nopagebreak\par\afterproblemsectioncaption%
+\fi%
+}
+}
+
+\newcommand{\createsectionpar}{\@newsectionpar}
+
+\def\@newsectionpar#1#2{\DeclareRobustCommand{#1}[1]{
+{\beforeproblemsectioncaption\noindent\bf\problemsectionfont
+\textsf{#2~##1}}
+\nopagebreak\par\afterproblemsectioncaption}
+}
+
+\newcommand{\createsectionpartwo}{\@newsectionpartwo}
+
+\def\@newsectionpartwo#1#2#3{\DeclareRobustCommand{#1}[2]{
+{\beforeproblemsectioncaption\noindent\problemsectionfont
+\textsf{\textbf{#2}~\textbf{##1}~(##2~#3)}}
+\nopagebreak\par\afterproblemsectioncaption}
+}
+
+\createsection{\Specification}{\kw@Specification}
+\createsection{\Interaction}{\kw@Interaction}
+\createsection{\InputFile}{\kw@Input}
+\createsection{\OutputFile}{\kw@Output}
+\createsectionexample{\Example}{\kw@Example}
+\createsectionexample{\Examples}{\kw@Examples}
+\createsection{\Explanation}{\kw@Explanation}
+\createsection{\Explanations}{\kw@Explanations}
+\createsection{\Illustration}{\kw@Illustration}
+\createsection{\Scoring}{\kw@Scoring}
+\createsection{\Note}{\kw@Note}
+\createsection{\Notes}{\kw@Notes}
+\createsection{\Constraints}{\kw@Constraints}
+\createsection{\SubtaskOne}{\kw@SubtaskOne}
+\createsection{\SubtaskTwo}{\kw@SubtaskTwo}
+\createsection{\SubtaskThree}{\kw@SubtaskThree}
+\createsection{\SubtaskFour}{\kw@SubtaskFour}
+\createsection{\SubtaskFive}{\kw@SubtaskFive}
+\createsection{\SubtaskSix}{\kw@SubtaskSix}
+\createsectionpar{\Subtask}{\kw@Subtask}
+\createsectionpartwo{\SubtaskWithCost}{\kw@Subtask}{\kw@points}
+
+% -- End of problem sections
+
+% -- Default limits definition --
+
+\if@russian
+\def\defaulttimelimit{2 секунды}
+\else
+\if@ukrainian
+\def\defaulttimelimit{2 секунди}
+\else
+\def\defaulttimelimit{2 seconds}
+\fi
+\fi
+
+
+
+\if@russian
+\def\defaultmemorylimit{256 мебибайт}
+\else
+\if@ukrainian
+\def\defaulttimelimit{256 мебібайт}
+\else
+\def\defaultmemorylimit{256 mebibytes}
+\fi
+\fi
+
+% -- End of default limits definition --
+
+% -- Problem environment --
+
+\def\defaultproblemauthor{\textit{\kw@notstated}}
+\gdef\thisproblemauthor{\defaultproblemauthor}
+\def\defaultproblemdeveloper{\textit{\kw@notstated}}
+\gdef\thisproblemdeveloper{\defaultproblemdeveloper}
+\def\defaultproblemorigin{\textit{\kw@notstated}}
+\gdef\thisproblemorigin{\defaultproblemorigin}
+
+\newif\ifdisplayauthor
+\newif\ifdisplaydeveloper
+\newif\ifdisplayorigin
+\newif\ifrevisionsignature
+\newif\ifdisplayauthorinfooter
+\newif\ifdisplaydeveloperinfooter
+
+\newcounter{problem}
+\newcounter{subtasknum}[problem]
+
+\newcommand{\SubtaskWithScore}[1]{%
+{\addtocounter{subtasknum}{1}%
+\beforeproblemsectioncaption\noindent\problemsectionfont%
+\textsf{\textbf{\kw@Subtask~\arabic{subtasknum}}}%
+\textsf{~(\kw@points:~#1)}%
+\nopagebreak\par\afterproblemsectioncaption}%
+}%
+
+\newenvironment{tutorial}[1]{%
+    \bigskip%
+    \noindent%
+    \refstepcounter{problem}
+    \textbf{\problemheadfont\textsf{\ifdefined\ShortProblemTitle\ifdefined\ProblemIndex\ProblemIndex. \fi\else\kw@Problem\ \ifdefined\ProblemIndex\ProblemIndex\else\if@arabic\arabic{problem}\else\Alph{problem}\fi\fi. \fi #1}}%
+    \nopagebreak%
+    \problemtextfont%
+}
+
+\newenvironment{@problem}[6]{
+\global\let\lastproblemauthor\thisproblemauthor
+\global\let\lastproblemdeveloper\thisproblemdeveloper
+\global\let\lastproblemorigin\thisproblemorigin
+
+% Hotfix
+%\def\@memorylimit{#5}
+
+%% -- Default memory limit --
+%% :FIXME:
+%\def\@t{#5}
+%
+%\ifx\@t\empty
+%    \def\@memorylimit{\defaultmemorylimit}
+%\else
+%%\ifcat\par\@t
+%%    \def\@memorylimit{\defaultmemorylimit}
+%%\else
+%    \def\@memorylimit{#5}
+%%\fi
+%\fi
+%% -- End of default memory limit --
+
+% -- No feedback case --
+% :FIXME:
+\def\@t{#6}
+
+\ifx\@t\empty
+    \def\@feedback{}
+\else
+%\ifcat\par\@t
+%    \def\@feedback{}
+%\else
+    \def\@feedback{\kw@Feedback & #6 \\}
+\fi
+%\fi
+% -- End of no feedback case --
+
+    {
+        \ifdefined\NoProblemHead\else%
+        \noindent
+        \refstepcounter{problem}
+        \textbf{\problemheadfont\textsf{%
+        		\ifdefined\ShortProblemTitle\ifdefined\ProblemIndex\ProblemIndex. \fi\else\kw@Problem\ \ifdefined\ProblemIndex\ProblemIndex\else\if@arabic\arabic{problem}\else\Alph{problem}\fi\fi. \fi%
+        		#1%
+                \ifdefined\DivisionNumber%
+                \if\DivisionNumber2%
+                {\ \textit{(Division\ \DivisionNumber)}}%
+                \fi%
+                \fi%
+                }}%
+        \nopagebreak%
+        \par\vspace{\afterproblemhead}%
+        \problemtextfont\parindent=6.5mm%
+        \vbox{
+            \begin{tabular}{l@{\extracolsep{1cm}}l}
+            \ifdisplayauthor%
+            \kw@ProblemAuthor & \thisproblemauthor \\
+            \fi%
+            \ifdisplaydeveloper%
+            \kw@ProblemDeveloper & \thisproblemdeveloper \\
+            \fi%
+            \ifdisplayorigin%
+            \kw@ProblemOrigin & \thisproblemorigin \\
+            \fi%
+            \ifdefined\NoInputFileName\else%
+            \ifx&#2&%
+            \else%
+            \kw@InputFileName & \texttt{#2} \\
+            \fi\fi%
+            \ifdefined\NoOutputFileName\else%
+            \ifx&#3&%
+            \else%
+            \kw@OutputFileName & \texttt{#3} \\
+            \fi\fi%
+            \ifdefined\NoTimeLimit\else%
+            \ifx&#4&%
+            \else%
+            \kw@TimeLimit & #4 \\
+            \fi\fi%
+            \ifdefined\NoMemoryLimit\else%
+            \ifx&#5&%
+            \else%
+            \kw@MemoryLimit & #5 \\
+            \fi\fi%
+%            \kw@MemoryLimit & \@memorylimit \\
+            \@feedback
+            \end{tabular}
+        }
+        \nopagebreak
+        \par\vspace{\afterconstraints}
+        \fi%
+    }
+    \problemtextfont
+
+    \newcommand{\InputFileName}{\ifx\relax#2\relax{\kw@defaultinputname}\else{#2}\fi}
+    \newcommand{\OutputFileName}{\ifx\relax#3\relax{\kw@defaultoutputname}\else{#3}\fi}
+}{%
+    \global\let\lastproblemauthor\thisproblemauthor%
+    \global\let\lastproblemdeveloper\thisproblemdeveloper%
+    \global\let\lastproblemdorigin\thisproblemorigin%
+    \gdef\thisproblemauthor{\defaultproblemauthor}%
+    \gdef\thisproblemdeveloper{\defaultproblemdeveloper}%
+    \gdef\thisproblemorigin{\defaultproblemorigin}%
+    \problemend%
+}
+
+\def\s@tm@cr@s{
+    \def\widthin##1{\exmpwidinf=##1\relax}
+    \def\widthout##1{\exmpwidouf=##1\relax}
+    \def\stretchin##1{\advance\exmpwidinf by ##1\relax}
+    \def\stretchout##1{\advance\exmpwidouf by ##1\relax}
+    \@ifstar{
+        \error Star must not be used in example environment any more
+    }
+}
+
+% This is magic, which delete space after verbatiminput
+\addto@hook{\every@verbatim}{\topsep=0pt\relax}
+
+% :FIXME:
+\newenvironment{example}[1][]{
+    \s@tm@cr@s#1
+    \ttfamily\obeylines\obeyspaces\frenchspacing
+    \newcommand{\exmp}[2]{
+    \ifdefined\NoExamples\else%
+        \begin{minipage}[t]{\exmpwidinf}\rightskip=0pt plus 1fill\relax##1\medskip\end{minipage}&
+        \begin{minipage}[t]{\exmpwidouf}\rightskip=0pt plus 1fill\relax##2\medskip\end{minipage}\\
+        \hline
+    \fi%
+    }
+
+    \newcommand{\exmpfile}[2]{
+    \ifdefined\NoExamples\else%
+       \exmp{
+          \verbatiminput{##1}
+       }{
+          \verbatiminput{##2}
+       }%
+    \fi%
+    }
+
+
+    \ifdefined\NoExamples\else%
+    \begin{tabular}{|l|l|}
+        \hline
+        \multicolumn{1}{|c|}{\bf\texttt{\InputFileName}}&
+        \multicolumn{1}{c|}{\bf\texttt{\OutputFileName}}\\
+        \hline
+    \fi%
+}{
+    \ifdefined\NoExamples\else%
+    \end{tabular}
+    \fi%
+}
+
+\newenvironment{examplewide}[1][]{%
+    \s@tm@cr@s#1
+    \ttfamily\obeylines\obeyspaces\frenchspacing
+    \newcommand{\exmp}[2]{
+        \ifdefined\NoExamples\else%
+        \begin{tabular}{|c|}
+        \hline
+        \multicolumn{1}{|c|}{\bf\texttt{\InputFileName}}\\
+        \hline
+        \begin{minipage}[t]{\exmpwidewid}\rightskip=0pt plus 1fill\relax
+        ##1
+        \medskip\end{minipage}\\
+        \hline
+        \multicolumn{1}{|c|}{\bf\texttt{\OutputFileName}}\\%
+        \hline
+        \begin{minipage}[t]{\exmpwidewid}\rightskip=0pt plus 1fill\relax
+        ##2    
+        \medskip\end{minipage}\\%
+        \hline
+        \end{tabular}
+        \fi%
+    }
+    \newcommand{\exmpfile}[2]{
+        \ifdefined\NoExamples\else%
+       \exmp{
+          \verbatiminput{##1}
+       }{
+          \verbatiminput{##2}
+       }%
+        \fi%
+    }
+}{
+}
+
+\newenvironment{examplethree}[1][]{
+    \s@tm@cr@s#1
+    \ttfamily\obeylines\obeyspaces\frenchspacing
+    \newcommand{\exmp}[3]{
+        \ifdefined\NoExamples\else%
+        \begin{minipage}[t]{\exmpthreewidinf}\rightskip=0pt plus 1fill\relax##1\medskip\end{minipage}&
+        \begin{minipage}[t]{\exmpthreewidouf}\rightskip=0pt plus 1fill\relax##2\medskip\end{minipage}&
+        \begin{minipage}[t]{\exmpthreewidnote}\rightskip=0pt plus 1fill\relax##3\medskip\end{minipage}\\
+        \hline
+        \fi%
+    }
+
+    \newcommand{\exmpfile}[3]{
+    \ifdefined\NoExamples\else%
+       \exmp{
+          \verbatiminput{##1}
+       }{
+          \verbatiminput{##2}
+       }{
+          ##3
+       }%
+    \fi%
+    }
+
+
+    \ifdefined\NoExamples\else%
+    \begin{tabular}{|l|l|l|}
+        \hline
+        \multicolumn{1}{|c|}{\bf\texttt{\InputFileName}}&
+        \multicolumn{1}{|c|}{\bf\texttt{\OutputFileName}}&
+        \multicolumn{1}{|c|}{\bf\texttt{\expandafter\unexpanded{\expandafter\kwExampleNotes}}}\\
+        \hline
+    \fi%
+}{
+    \ifdefined\NoExamples\else%
+    \end{tabular}
+    \fi%
+}
+
+% -- This is hack to make feedback argument optional
+
+\newenvironment{problem}[5]{%
+\def\@ProblemCommon{\begin{@problem}{#1}{#2}{#3}{#4}{#5}}%
+\newcommand\@problemSix[1]{\@ProblemCommon{##1}}%
+\newcommand\@problemFive{\@ProblemCommon{}}%
+\@ifnextchar\bgroup\@problemSix\@problemFive%
+}{%
+\end{@problem}%
+}
+
+
+% -- End of problem environment --
+
+
+% -- Declare "shortitems" and "shortnums" environment: it's a "compact itemize" --
+\if@twocolumn
+    \def\shortitems{\vspace{-1mmplus6mm}\itemize\itemsep-0.618mmplus0.5mm\relax}%
+    \def\endshortitems{\vspace{-1mmplus6mm}\enditemize}%
+    \def\shortnums{\vspace{-1mmplus6mm}\enumerate\itemsep-0.618mmplus0.5mm\relax}%
+    \def\endshortnums{\vspace{-1mmplus6mm}\endenumerate}%
+\else
+    \def\shortitems{\vspace{-3mmplus2mm}\itemize\itemsep-1.618mmplus0.5mm\relax}%
+    \def\endshortitems{\vspace{-3mmplus2mm}\enditemize}%
+    \def\shortnums{\vspace{-3mmplus2mm}\enumerate\itemsep-1.618mmplus0.5mm\relax}%
+    \def\endshortnums{\vspace{-3mmplus2mm}\endenumerate}%
+\fi
+% -- end of "shortitems" and "shortnums" declaration --
+
+\newcommand{\thecontestname}{Olympiad in Informatics}
+\newcommand{\thecontestlocation}{Somewhere}
+\newcommand{\thecontestdate}{Once upon a time}
+\newcommand{\therevision}{undefined}
+
+\DeclareRobustCommand{\contestname}{\thecontestname\par\thecontestlocation\unskip, \thecontestdate}
+
+\DeclareRobustCommand{\contest}[3]{
+    \renewcommand{\thecontestname}{#1}
+    \renewcommand{\thecontestlocation}{#2}
+    \renewcommand{\thecontestdate}{#3}
+
+    \def\temp{#1}\ifx\temp\empty
+       \def\temp{#2}\ifx\temp\empty
+          \def\temp{#3}\ifx\temp\empty
+            \let\thecontestname\undefined%
+            \let\thecontestlocation\undefined%
+            \let\thecontestdate\undefined%
+          \fi
+       \fi
+    \fi
+}
+
+\DeclareRobustCommand{\revision}[1]{
+    \renewcommand{\therevision}{#1}
+}
+
+\makeatletter
+
+\renewcommand{\@oddhead}{
+    \ifdefined\thecontestname
+        \parbox{\textwidth}{
+            \sffamily
+            \begin{center}
+                \protect\contestname
+                \\[2pt]
+                \hrule
+            \end{center}
+        }
+    \fi
+}
+
+\renewcommand{\@oddfoot}{
+\gdef\problemletter{\if@arabic\arabic{problem}\else\Alph{problem}\fi}
+
+% Revision signature
+\ifrevisionsignature%
+%\if@revsign%
+	{\gdef\rsigfooter{, \kw@revision\ \therevision}}%
+\else%
+	{\gdef\rsigfooter{}}%
+\fi%
+
+\ifdisplayauthorinfooter%
+%\if@newfooter%
+	{\gdef\thefooter%
+        {~\quad{\kw@Problem\ \problemletter%
+        \ifdefined\DivisionNumber{ (Div.~\DivisionNumber)}\fi}%
+        {\hfill}%
+        {\kw@ProblemAuthor~\lastproblemauthor}%
+        {\hfill}%
+        {\kw@Page\ \thepage\ \kw@of\ \pageref{LastPage}\rsigfooter}\quad~}}%
+\else%
+\ifdisplaydeveloperinfooter%
+	{\gdef\thefooter%
+        {~\quad{\kw@Problem\ \problemletter}%
+        {\hfill}%
+        {\kw@ProblemDeveloper~\lastproblemdeveloper}%
+        {\hfill}%
+        {\kw@Page\ \thepage\ \kw@of\ \pageref{LastPage}\rsigfooter}\quad~}}%
+\else%
+	{\gdef\thefooter%
+        {{\hfil}\kw@Page\ \thepage\ \kw@of\ \pageref{LastPage}\rsigfooter\hfil}}%
+\fi%
+\fi%
+
+    \parbox{\textwidth}{
+        \hrule
+        \vspace{6pt}
+        \sffamily
+        \thefooter
+    }
+}
+
+\makeatother
+
+\headheight=2cm
+\headsep=6mm
+
+\hfuzz=0.5pt
+
+\sloppy

exam-queue-17/files/print.cpp

@@ -0,0 +1,86 @@
+#define _CRT_SECURE_NO_WARNINGS
+#include<bits/stdc++.h>
+#include "testlib.h"
+
+using namespace std;
+
+int main(int argc, char* argv[]) {
+	registerGen(argc, argv, 1);
+	int t = opt<int>(1);
+	vector<int> a;
+	vector<vector<int>> b;
+
+	if (t == 1) {
+		a.push_back(1);
+		b.push_back({ 1, 2, 1 });
+	}
+	if (t == 2) {
+		a.push_back(1);
+		for (int i = 0; i < 100000; i += 2) {
+			b.push_back({ 1, 2, 1 });
+			b.push_back({ 3, 2 });
+		}
+	}
+	if (t == 3) {
+		a.push_back(1e9);
+		for (int i = 0; i < 50000; i++)
+			b.push_back({ 2, i + 1 });
+		for (int i = 0; i < 50000; i++)
+			b.push_back({ 3, i + 1 });
+	}
+	if (t == 4) {
+		for (int i = 0; i < 100000; i++)
+			a.push_back(i + 1);
+		for (int i = 0; i < 100000; i++)
+			b.push_back({ 3, i + 1 });
+	}
+	if (t == 5) {
+		for (int i = 0; i < 100000; i++)
+			a.push_back(i + 1);
+		for (int i = 0; i < 100000; i++)
+			b.push_back({ 1, 100000 + i + 1, i + 1 });
+	}
+	if (t == 6) {
+		for (int i = 0; i < 100000; i++)
+			a.push_back(1e9 - i);
+		for (int i = 0; i < 50000; i++) {
+			b.push_back({ 1, i + 1, (int)1e9 - i });
+			b.push_back({ 3, (int)1e9 - i });
+		}
+	}
+	if (t == 7) {
+		for (int i = 0; i < 100000; i++)
+			a.push_back(1e9 - i);
+		for (int i = 0; i < 100000; i++)
+			b.push_back({ 3, (int)1e9 - i });
+	}
+	if (t == 8) {
+		for (int i = 0; i < 100000 && b.size() < 100000; i++)
+			a.push_back(i + 1);
+		for (int i = 0; i < 100000 && b.size() < 100000; i++)
+			b.push_back({ 3, (int)1e5 - i });
+	}
+	if (t == 9) {
+		for (int i = 0; i < 100000; i++)
+			a.push_back(i + 1);
+		for (int i = 0; i < 100000 && b.size() < 100000; i += 2)
+			b.push_back({ 3, i + 1 });
+		for (int i = 0; i < 100000 && b.size() < 100000; i += 2)
+			b.push_back({ 2, i + 1 });
+	}
+	if (t == 10) {
+		for (int i = 100000; i > 0; i--)
+			a.push_back(i);
+		for (int i = 0; i < 100000 && b.size() < 100000; i += 2)
+			b.push_back({ 3, i + 1 });
+		for (int i = 0; i < 100000 && b.size() < 100000; i += 2)
+			b.push_back({ 2, i + 1 });
+	}
+	cout << a.size() << ' ' << b.size() << '\n';
+	for (int i = 0; i < a.size(); i++)
+		cout << a[i] << " \n"[i + 1 == a.size()];
+	for (auto i : b) {
+		for (int j = 0; j < i.size(); j++)
+			cout << i[j] << " \n"[j + 1 == i.size()];
+	}
+}

exam-queue-17/files/problem.tex

@@ -0,0 +1,79 @@
+\begin{problem}{${problem.name}}<#--
+-->{<#if "stdin" == problem.inputFile><#--
+     --><#if "russian" == language>стандартный ввод<#--
+     --><#else>standard input<#--
+     --></#if><#else>${problem.inputFile}</#if>}<#--
+-->{<#if "stdout" == problem.outputFile><#--
+     --><#if "russian" == language>стандартный вывод<#--
+     --><#else>standard output<#--
+     --></#if><#else>${problem.outputFile}</#if>}<#--
+--><#assign timeLimit=problem.timeLimit/1000/><#--
+--><#if language="russian"><#--
+    --><#if problem.timeLimit%1000!=0||(10<=timeLimit%100&&timeLimit%100<20)||timeLimit%10=0||5<=timeLimit><#--
+        -->{${timeLimit?c} секунд}<#--
+    --><#else><#--
+        --><#if timeLimit%10=1><#--
+            -->{${timeLimit?c} секунда}<#--
+        --><#else><#--
+            -->{${timeLimit?c} секунды}<#--
+        --></#if><#--
+    --></#if><#--
+--><#else><#--
+    -->{${timeLimit?c} second<#if (timeLimit!=1)>s</#if>}<#--
+--></#if><#--
+--><#assign memoryLimit=problem.memoryLimit/1048576/><#--
+--><#if language="russian"><#--
+    --><#if problem.memoryLimit%1048576==0&&!(10<=memoryLimit%100&&memoryLimit%100<20)&&2<=memoryLimit%10&&memoryLimit%10<5><#--
+        -->{${memoryLimit?c} мегабайта}
+    <#else><#--
+        -->{${memoryLimit?c} мегабайт}
+    </#if>
+<#else><#--
+    -->{${memoryLimit?c} megabyte<#if (memoryLimit>1)>s</#if>}
+</#if>
+
+<#if providedStatementsCommands?? && providedStatementsCommands?size != 0><#--
+    --><#list providedStatementsCommands as command><#--
+        -->${command?string}
+</#list>
+
+</#if>
+${problem.legend}
+
+<#if problem.input?? && (problem.input?length>0)>
+\InputFile
+${problem.input}
+
+</#if>
+<#if problem.output?? && (problem.output?length>0)>
+\OutputFile
+${problem.output}
+
+</#if>
+<#if problem.interaction?? && (problem.interaction?length>0)>
+\Interaction
+${problem.interaction}
+
+</#if>
+<#if problem.scoring?? && (problem.scoring?length>0)>
+\Scoring
+${problem.scoring}
+
+</#if>
+<#if  (problem.sampleTests?size>0)>
+\Example<#if  (problem.sampleTests?size>1)>s</#if>
+
+\begin{example}
+<#list problem.sampleTests as test>
+\exmpfile{${test.inputFile}}{${test.outputFile}}%
+</#list>
+\end{example}
+</#if>
+
+<#if (problem.notes??) && (problem.notes?length > 0)>
+\Note
+${problem.notes}
+
+</#if>
+\end{problem}
+

exam-queue-17/files/statements.ftl

@@ -0,0 +1,53 @@
+\documentclass [11pt, a4paper, oneside] {article}
+
+\usepackage [T2A] {fontenc}
+\usepackage [utf8] {inputenc}
+\usepackage [english, russian] {babel}
+\usepackage {amsmath}
+\usepackage {amssymb}
+\usepackage <#if contest.language?? && contest.language="russian">[russian]<#elseif contest.language?? && contest.language="ukrainian">[ukrainian]</#if>{olymp}
+\usepackage {comment}
+\usepackage {epigraph}
+\usepackage {expdlist}
+\usepackage {graphicx}
+\usepackage {multirow}
+\usepackage {siunitx}
+\usepackage {ulem}
+%\usepackage {hyperref}
+\usepackage {import}
+\usepackage {ifpdf}
+\usepackage {xparse}
+\ifpdf
+  \DeclareGraphicsRule{*}{mps}{*}{}
+\fi
+
+\begin {document}
+
+\contest
+{${contest.name!}}%
+{${contest.location!}}%
+{${contest.date!}}%
+
+\binoppenalty=10000
+\relpenalty=10000
+
+\renewcommand{\t}{\texttt}
+\renewcommand{\thefootnote}{\fnsymbol{footnote}}
+
+<#if shortProblemTitle?? && shortProblemTitle>
+  \def\ShortProblemTitle{}
+</#if>
+
+<#list statements as statement>
+<#if statement.path??>
+\graphicspath{{${statement.path}}}
+<#if statement.index??>
+  \def\ProblemIndex{${statement.index}}
+</#if>
+\import{${statement.path}}{./${statement.file}}
+<#else>
+\input ${statement.file}
+</#if>
+</#list>
+
+\end {document}

exam-queue-17/files/tests/validator-tests/01

@@ -0,0 +1,8 @@
+7 6
+1 2 3 4 5 6 7
+1 8 3
+2 9
+3 3
+1 3 9
+2 10
+3 1

exam-queue-17/files/tests/validator-tests/02

@@ -0,0 +1,3 @@
+1 1
+1
+1 1 1

exam-queue-17/files/tests/validator-tests/03

@@ -0,0 +1,3 @@
+1 1
+1
+2 1

exam-queue-17/files/tests/validator-tests/04

@@ -0,0 +1,4 @@
+2 2
+1 2
+1 3 2
+3 4

exam-queue-17/files/tutorial.tex

@@ -0,0 +1,11 @@
+\begin{tutorial}{${problem.name}}
+
+<#if providedTutorialCommands?? && providedTutorialCommands?size != 0><#--
+    --><#list providedTutorialCommands as command><#--
+        -->${command?string}
+</#list>
+
+</#if>
+${problem.tutorial}
+
+\end{tutorial}

exam-queue-17/files/val.cpp

@@ -0,0 +1,52 @@
+#include <bits/stdc++.h>
+#include "testlib.h"
+
+using namespace std;
+
+int minN = 1, maxN = 1e5;
+int minM = 1, maxM = 1e5;
+int minA = 1, maxA = 1e9;
+
+int main(int argc, char* argv[]) {
+    registerValidation(argc, argv);
+    int n = inf.readInt(minN, maxN, "n");
+    inf.readSpace();
+    int m = inf.readInt(minM, maxM, "m");
+    inf.readEoln();
+    set<int> st;
+    for (int i = 0; i < n; i++) {
+        int a = inf.readInt(minA, maxA, "a");
+        if (i == n - 1)
+            inf.readEoln();
+        else
+            inf.readSpace();
+        st.insert(a);
+    }
+    inf.ensuref((int)st.size() == n, "a is unique");
+    for (int i = 0; i < m; i++) {
+        int t = inf.readInt(1, 3, "t");
+        inf.readSpace();
+        if (t == 1) {
+            int x = inf.readInt(minA, maxA, "x");
+            inf.readSpace();
+            int y = inf.readInt(minA, maxA, "y");
+            inf.ensuref(st.count(x) == 0, "x is already in list");
+            inf.ensuref(st.count(y) == 1, "y is not in list");
+            st.insert(x);
+            inf.readEoln();
+        }
+        if (t == 2) {
+            int x = inf.readInt(minA, maxA, "x");
+            inf.ensuref(st.count(x) == 0, "xx is already in list");
+            st.insert(x);
+            inf.readEoln();
+        }
+        if (t == 3) {
+            int x = inf.readInt(minA, maxA, "x");
+            inf.ensuref(st.count(x) == 1, "x is not in list");
+            st.erase(x);
+            inf.readEoln();
+        }
+    }
+    inf.readEof();
+}