#include <filesystem>

int main()
{
  std::uintmax_t size = std::filesystem::file_size("file.txt");
}

#include <cassert>

void test(int x) {
    assert(x > 0 && "x must be positive");
    // остальной код функции
}

int main() {
    test(5);  // проходит проверку
    test(-3); // приводит к ошибке во время выполнения
    return 0;
}

#include <type_traits>

template <typename T>
void check() {
    static_assert(std::is_integral<T>::value, "T must be an integral type");
}

int main() {
    check<int>();   // проходит проверку
    check<float>(); // ошибка компиляции: T must be an integral type
    return 0;
}

#include <iostream>

#define DEBUG

#ifdef DEBUG
#define DEBUG_PRINT(x) std::cout << x << std::endl
#else
#define DEBUG_PRINT(x)
#endif

int main() {
    int value = 42;
    DEBUG_PRINT("Value: " << value);
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>

std::string convertToRanges(std::vector<int>& nums) {
    if (nums.empty()) {
        return "";
    }

    // Сортируем вектор
    std::sort(nums.begin(), nums.end());

    std::vector<std::string> ranges;
    int start = nums[0];
    int prev = start;

    for (size_t i = 1; i < nums.size(); ++i) {
        if (nums[i] != prev + 1) {
            // Если последовательность прервалась, добавляем диапазон
            if (start == prev) {
                ranges.push_back(std::to_string(start));
            }
            else {
                ranges.push_back(std::to_string(start) + "-" + std::to_string(prev));
            }
            start = nums[i];
        }
        prev = nums[i];
    }

    // Добавляем последний диапазон
    if (start == prev) {
        ranges.push_back(std::to_string(start));
    }
    else {
        ranges.push_back(std::to_string(start) + "-" + std::to_string(prev));
    }

    // Объединяем диапазоны в одну строку
    std::ostringstream result;
    for (size_t i = 0; i < ranges.size(); ++i) {
        if (i > 0) {
            result << ",";
        }
        result << ranges[i];
    }

    return result.str();
}

int main() {
    std::vector<int> nums1 = { 1, 4, 5, 2, 3, 9, 8, 11, 0 };
    std::cout << convertToRanges(nums1) << std::endl;  // Ожидаемый вывод: "0-5,8-9,11"

    std::vector<int> nums2 = { 1, 4, 3, 2 };
    std::cout << convertToRanges(nums2) << std::endl;  // Ожидаемый вывод: "1-4"

    std::vector<int> nums3 = { 1, 4 };
    std::cout << convertToRanges(nums3) << std::endl;  // Ожидаемый вывод: "1,4"

    return 0;
}

#include <iostream>
#include <chrono>

int main() {
    auto start = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < 10000; ++i) {
        std::cout << "Hello, World!" << std::endl; // Принудительный сброс после каждой строки
    }

    auto middle = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < 10000; ++i) {
        std::cout << "Hello, World!\n"; // Буферизация, меньше операций I/O
    }

    auto end = std::chrono::high_resolution_clock::now();

    std::cout << "Time with std::endl: "
              << std::chrono::duration_cast<std::chrono::milliseconds>(middle - start).count()
              << " ms\n";

    std::cout << "Time with \\n: "
              << std::chrono::duration_cast<std::chrono::milliseconds>(end - middle).count()
              << " ms\n";

    return 0;
}

#include <stdio.h>
#include <setjmp.h>

jmp_buf jump_buffer;

void risky_function() {
    printf("Готовимся к прыжку...\n");
    longjmp(jump_buffer, 42);  // Прыжок обратно в setjmp!
}

int main() {
    int ret = setjmp(jump_buffer);
    if (ret == 0) {
        printf("Первая инициализация...\n");
        risky_function();
    } else {
        printf("Вернулись с кодом: %d\n", ret);  // Выведет 42!
    }
    return 0;
}

#include <iostream>
#include <sstream>
#include <vector>
#include <string>

std::vector<std::string> parseCommand(const std::string& line) {
    // TODO: разбить строку на токены по пробелам
    // Учти: несколько пробелов подряд — не ошибка
}

void execute(const std::vector<std::string>& tokens) {
    if (tokens.empty()) return;
    
    if (tokens[0] == "echo") {
        // TODO: вывести все аргументы через пробел
    } else if (tokens[0] == "exit") {
        exit(0);
    } else {
        // TODO: вывести "Unknown command: <имя команды>"
    }
}

int main() {
    std::string line;
    while (true) {
        std::cout << "> ";
        if (!std::getline(std::cin, line)) break;
        execute(parseCommand(line));
    }
}