int* const pi1 = &i;
    int const *pi2 = &i;

1. правильные;
   
2. те, которые ожидает получить интервьюер;
   
3. те, которые даёт кандидат.

In the first alternative (delete object), if the static type of the object to be deleted is different from its dynamic type, the static type shall be a base class of the dynamic type of the object to be deleted and the static type shall have a virtual destructor or the behavior is undefined. In the second alternative (delete array) if the dynamic type of the object to be deleted differs from its static type, the behavior is undefined.

In a single-object delete expression, if the static type of the object to be deleted is different from its dynamic type and the selected deallocation function (see below) is not a destroying operator delete, the static type shall be a base class of the dynamic type of the object to be deleted and the static type shall have a virtual destructor or the behavior is undefined. In an array delete expression, if the dynamic type of the object to be deleted differs from its static type, the behavior is undefined.

    float __1 = 10000000;
    float __2 = 0.5;
    float sum_float = __2 +__2 + __1;
    float sum_float2 = __1 +__2 + __2;

// Требуется реализовать класс индекса, для хранения данных по 3-м вложенным текстовым ключам
//
//     index["key1"]["key2"]["key3"] = data;
//
// в последнем уровне индекса содержатся данные объект класса Data
//
// Пример заполнение данных по ключам выглядит так:
//
//  Data  data1, data2;
//  Index idx;
//  idx.set("key1").set("key2").set("key3").set(data1);
//  idx.set("key1.1").set("key2.1").set("key3.1").set(data2);
//
// Пример доступа к данным по ключам:
//
//  data1 = idx.get("key1").get("key2").get("key3").get();
//
// в реализации предусмотреть раcширение глубины индексов


class Data {
};

class Index {
};


int main()
{
    Data data1, data2, data3;
    Index idx;
    
    // добавление в индекс
    
    //idx.set("key1").set(data1);
    
    idx.set("key1").set("key2").set("key3").set(data1);
    idx.set("key1.1").set("key2.1").set("key3.1").set(data2);
    idx.set("key1.2").set("key2.2").set("key3.2").set(data3);
    
    // получение данных из индекса
    
    data1 = idx.get("key1").get("key2").get("key3").get();
    data2 = idx.get("key1.1").get("key2.1").get("key3.1").get();
    data3 = idx.get("key1.2").get("key2.2").get("key3.2").get();

    return 0;
}

struct MarketPolicy {};

struct LimitPolicy {
    double price;
    std::optional<double> stop;
};

Binder<MarketPolicy> binder("MarketPolicy");

Binder<LimitPolicy> binder("LimitPolicy");
binder.set("price", &LimitPolicy::price);
binder.set("stop", &LimitPolicy::stop);

class MarketPolicy {
};

class LimitPolicy {
    price: number;
    stop?: number;
};

class Order {
    symbol: string;
    quantity: number;
    isBuy: boolean;
    policy: MarketPolicy | LimitPolicy;
};

class Balance {
    free: number;
    locked: number;
};

make *.ts definitions according to the C++ classes in a simple way for the user of "your library".

К примеру, класс:
struct LimitPolicy {
double price;
std::optional<double> stop;
};

Метод:
template <typename Attribute>
void set(std::string name, Attribute attribute){
    // <----- получить std::string от Attribute
};
И вот как передают поле:
set("price", &LimitPolicy::price);

Base* b = (rand() % 2 == 0) ? new Derived1 : new Derived2;

report(typeid(*b));

// Требуется реализовать класс индекса, для хранения данных по 3-м вложенным текстовым ключам
//
//     index["key1"]["key2"]["key3"] = data;
//
// в последнем уровне индекса содержатся данные объект класса Data
//
// Пример заполнение данных по ключам выглядит так:
//
//  Data  data1, data2;
//  Index idx;
//  idx.set("key1").set("key2").set("key3").set(data1);
//  idx.set("key1.1").set("key2.1").set("key3.1").set(data2);
//
// Пример доступа к данным по ключам:
//
//  data1 = idx.get("key1").get("key2").get("key3").get();
//
// в реализации предусмотреть раcширение глубины индексов


class Data {
};

class Index {
};


int main()
{
    Data data1, data2, data3;
    Index idx;
    
    // добавление в индекс
    
    //idx.set("key1").set(data1);
    
    idx.set("key1").set("key2").set("key3").set(data1);
    idx.set("key1.1").set("key2.1").set("key3.1").set(data2);
    idx.set("key1.2").set("key2.2").set("key3.2").set(data3);
    
    // получение данных из индекса
    
    data1 = idx.get("key1").get("key2").get("key3").get();
    data2 = idx.get("key1.1").get("key2.1").get("key3.1").get();
    data3 = idx.get("key1.2").get("key2.2").get("key3.2").get();

    return 0;
}

1. Cколько запросов на выделение памяти из кучи будет сделано при вызове каждой из данных функций?

void f1() {
    std::string s = "hello world"; // const char* 12 байт // SSO < 16 байт
}

void f2() {
    char const* s = "hello world"; // 12 байт // только для чтения
}

void f3() {
    std::unique_ptr<int> i(new int); // int на куче - 4 байт
}

void f4() {
    std::shared_ptr<int> i(new int); // 2 указателя . 1 - на выделенный объект, 2ой на счетчик
}

void f5(std::vector<int>& v, int i) { // int - в хорошем случае. size < capacity. | size == capacity => нету места для нового int. 1. аллокация. 2. переместить. 3. создать новый объект. 4. деаллцировать старую память
    v.push_back(i);
}

void f6(std::list<int>& l, int i) { // new int
    l.push_back(i);
}

void f7(std::vector<int>& v1, const std::vector<int>& v2) {
    v1 = v2; // operator=. сравнить size(). 1. v1 size достаточно. 2. v1.clear() 
}

void f8(std::list<int>& l1, const std::list<int>& l2) {
    l1 = l2;
}

void f9(std::string& s1, const std::string& s2) {
    s1 = s2;
}

void f10(std::vector<int>& v1, std::vector<int>& v2) { // ни одноой аллок
    v1.swap(v2);
}

void f11(std::list<int>& l1, std::list<int>& l2) {
    l1.swap(l2);
}

void f12(std::map<std::string, int>& m, char const* k) {
    int i = m[k]; 1. constr
}

void f13() {
    struct S {
        const char const* s;
        S(char const* const s) : s(s) {}
    };
    char storage[2 * sizeof(S)];
    S* s = reinterpret_cast<S*>(storage);
    new(s) S("hello world");
}

// Как сделать чтобы робот шагал сначала левой, потом правой, левой, правой...?
// Обобщить до 40жки, чтобы каждая нога двигалась за предыдущей
===========

int main()
{
    std::thread first([]()
        {
            while(true)
            {
                std::cout << "First" << std::endl;
            }
        }
    );
    std::thread second([]()
        {
            while(true)
            {
                std::cout << "Second" << std::endl;
            }
        }
    );
    first.join();
    second.join();

    return 0;
}

int x, y, bombs;

//======================

vector<vector<int>> table;
table.resize(x);

for(auto & col: table)
    col.resize(y);

// 9 == bomba
// 0 == empty

for (int i = 0; i < bombs; ++i) {
    int row = srand(time_now()) % x;
    int col = srand(time_now()) % y;

    if(table[col][row] == 9) {
        --i;
        continue;
            }
    
    table[col][row] = 9;
}

//======================

for(int col = 0; col < x; ++col) {
    for(int row = 0; row < y; ++row) {
        
        if(table[col][row] == 9)
            continue;

        /*        
            col - 1, row
        col + 1, row
        col    , row - 1
        col    , row + 1
        col    , row
        col - 1, row - 1
        col + 1, row - 1
        col - 1, row + 1
        col + 1, row + 1            
        */
    
        int bombs_around = 0;    
        
        int cols[] = [col - 1, col, col + 1];
        int rows[] = [row - 1, row, row + 1];
                
        for(int l = 0; l < 3; ++l) {
            for(int k = 0; k < 3; ++k) {
                if(cols[l] < 0 || cols[l] > x - 1 || rows[k] < 0 || rows[k] > y - 1)
                    continue;
                    
                if(table[cols[l]][rows[k]] == 9)
                    bombs_around++;
            }
        }
        
        table[col][row] = bombs_around;
}

Требуется реализовать функцию zip, которая соединяет элементы двух слайсов в слайс пар

func main() {
    s1, s2 := []int{1, 2, 3}, []int{4, 5, 6, 7, 8}
    fmt.Println(zip(s1, s2)) // [[1 4] [2 5] [3 6]]
}

func zip(s1 []int, s2 []int) [][]int {
    //...
}
// Моё решение. Сделал объединение в пары:
std::vector<int> s1 {1, 2, 3};
std::vector<int> s2 {4, 5, 6, 7, 8};

std::vector<std::pair<int, int>> zip(std::vector<int> s1, std::vector<int> s2) {
    std::vector<std::pair<int, int>> res;
    int size = std::min(s1.size(), s2.size());
    res.reserve(size);

    for(int i = 0; i < size; ++i) {
        int el1 = s1[i];
        int el2 = s2[i];

        std::pair<int, int> pair = {s1[i], s2[i]};
        res.push_back(pair);
    }
    return res;
}

//----------------------

Есть база с такой схемой данных

// user
id | firstname | lastname | birth
1  | Ivan      | Petrov   | 1996-05-01
2  | Anna      | Petrova  | 1999-06-01      

// purchase
sku   | price | user_id | date
11111 | 5500  | 1       | 2021-02-15
22222 | 4000  | 1       | 2021-02-14
33333 | 8000  | 2       | 2021-03-01
44444 | 400   | 2       | 2021-03-02

// ban_list
user_id | date   
1       | 2021-03-08

Нужно вывести:
Список уникальных клиентов и купленных ими товаров в феврале

// написать функцию replace c 3-мя входными аргументами, возвращающую новую строку
//
// список аргументов:
// 1 - входная строка
// 2 - что ищем во входной строке
// 3 - чем заменяем
//
// примеры выполнения:
// replace("aabbcc", "b", "B")    -> "aaBBcc"
// replace("aabbcc", "bb", "B")   -> "aaBcc"
// replace("aabbbcc", "bb", "B")  -> "aaBbcc"
// replace("aabbcc", "b", "BB")   -> "aaBBBBcc"


std::string replace(std::string input, std::string substr, std::string replace_to) {
    std::string res;
    int idx_of_substr = 0;
    ind end_idx_copied = 0;

    for(int i = 0; i < input.size(); ++i) {
        idx_of_substr = input.find(substr, idx_of_substr);
        if(idx_of_substr != std::string::npos) {
            res.append(input.substr(end_idx_copied, idx_of_substr));
            res.append(replace_to);

            i = i + substr.size() - 1;
            end_idx_copied = i;
        }
    }

    res.append(input.substr(end_idx_copied, input.size() - 1));
}

Тестовое задание.
В данной задаче будут рассматриваться 13-ти значные числа в тринадцатиричной системе исчисления(цифры 0,1,2,3,4,5,6,7,8,9,A,B,C) с ведущими нулями.
Например, ABA98859978C0, 6789110551234, 0000007000000
Назовем число красивым, если сумма его первых шести цифр равна сумме шести последних цифр.
Пример:
Число 0055237050A00 — красивое, так как 0+0+5+5+2+3 = 0+5+0+A+0+0
Число 1234AB988BABA — некрасивое, так как 1+2+3+4+A+B != 8+8+B+A+B+A 
Задача:
написать программу на С/С++ печатающую в стандартный вывод количество 13-ти значных красивых чисел с ведущими нулями в тринадцатиричной системе исчисления.
В качестве решения должен быть предоставлено:
1) ответ — количество таких чисел. Ответ должен быть представлен в десятичной системе исчисления.
2) исходный код программы.

// pretty_numbers = 707972099625

#include <iostream>

#include <string>
#include <map>

using namespace std;

std::map<int, int> sum_numbers;
unsigned long long counter = 0;

void count_sums(const char str[], int sum, int n, int lenght) {
    if (lenght == 1) {
        for (int j = 0; j < n; j++) {
            int current = str[j] - 48;
            if(current >= 10)
                current = current - 7;

            sum_numbers[sum + current]++;
        }
    } else {
        for (int i = 0; i < n; i++) {
            int current = str[i] - 48;
            if(current >= 10)
                current = current - 7;

            count_sums(str, sum + current, n, lenght - 1);
        }
    }
}

void permutations(int n, int lenght) {
    if (lenght == 1) {
        for (int j = 0; j < n; j++)
            counter++;
    } else {
        for (int i = 0; i < n; i++)
            permutations(n, lenght - 1);
    }
}

int main() {
    int lenght = 6;
    char str[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C'};
    int n = sizeof str;
    count_sums(str, 0, n, lenght);

    /*
    for(auto [sum, unique_numbers] : sum_numbers)
        cout << sum << ":" << unique_numbers << endl;

    ...
    39:195042
    40:187803
    41:178878
    ...
    */

    unsigned long long pretty_numbers = 0;

    for(auto [sum, unique_numbers] : sum_numbers) {
        permutations(unique_numbers, 2);
        cout << "sum: " << sum << " : " << unique_numbers << " : " << counter << " : " << pretty_numbers << endl;
        pretty_numbers += counter;
        counter = 0;
    }

    pretty_numbers = pretty_numbers - 2;
    cout << "pretty_numbers = " << pretty_numbers;

    return 0;
}


/*
sum: 0 : 1 : 1 : 0
sum: 1 : 6 : 36 : 1
sum: 2 : 21 : 441 : 37
sum: 3 : 56 : 3136 : 478
sum: 4 : 126 : 15876 : 3614
sum: 5 : 252 : 63504 : 19490
sum: 6 : 462 : 213444 : 82994
sum: 7 : 792 : 627264 : 296438
sum: 8 : 1287 : 1656369 : 923702
sum: 9 : 2002 : 4008004 : 2580071
sum: 10 : 3003 : 9018009 : 6588075
sum: 11 : 4368 : 19079424 : 15606084
sum: 12 : 6188 : 38291344 : 34685508
sum: 13 : 8562 : 73307844 : 72976852
sum: 14 : 11592 : 134374464 : 146284696
sum: 15 : 15378 : 236482884 : 280659160
sum: 16 : 20013 : 400520169 : 517142044
sum: 17 : 25578 : 654234084 : 917662213
sum: 18 : 32137 : 1032786769 : 1571896297
sum: 19 : 39732 : 1578631824 : 2604683066
sum: 20 : 48378 : 2340430884 : 4183314890
sum: 21 : 58058 : 3370731364 : 6523745774
sum: 22 : 68718 : 4722163524 : 9894477138
sum: 23 : 80262 : 6441988644 : 14616640662
sum: 24 : 92547 : 8564947209 : 21058629306
sum: 25 : 105378 : 11104522884 : 29623576515
sum: 26 : 118518 : 14046516324 : 40728099399
sum: 27 : 131698 : 17344363204 : 54774615723
sum: 28 : 144627 : 20916969129 : 72118978927
sum: 29 : 157002 : 24649628004 : 93035948056
sum: 30 : 168518 : 28398316324 : 117685576060
sum: 31 : 178878 : 31997338884 : 146083892384
sum: 32 : 187803 : 35269966809 : 178081231268
sum: 33 : 195042 : 38041381764 : 213351198077
sum: 34 : 200382 : 40152945924 : 251392579841
sum: 35 : 203658 : 41476580964 : 291545525765
sum: 36 : 204763 : 41927886169 : 333022106729
sum: 37 : 203658 : 41476580964 : 374949992898
sum: 38 : 200382 : 40152945924 : 416426573862
sum: 39 : 195042 : 38041381764 : 456579519786
sum: 40 : 187803 : 35269966809 : 494620901550
sum: 41 : 178878 : 31997338884 : 529890868359
sum: 42 : 168518 : 28398316324 : 561888207243
sum: 43 : 157002 : 24649628004 : 590286523567
sum: 44 : 144627 : 20916969129 : 614936151571
sum: 45 : 131698 : 17344363204 : 635853120700
sum: 46 : 118518 : 14046516324 : 653197483904
sum: 47 : 105378 : 11104522884 : 667244000228
sum: 48 : 92547 : 8564947209 : 678348523112
sum: 49 : 80262 : 6441988644 : 686913470321
sum: 50 : 68718 : 4722163524 : 693355458965
sum: 51 : 58058 : 3370731364 : 698077622489
sum: 52 : 48378 : 2340430884 : 701448353853
sum: 53 : 39732 : 1578631824 : 703788784737
sum: 54 : 32137 : 1032786769 : 705367416561
sum: 55 : 25578 : 654234084 : 706400203330
sum: 56 : 20013 : 400520169 : 707054437414
sum: 57 : 15378 : 236482884 : 707454957583
sum: 58 : 11592 : 134374464 : 707691440467
sum: 59 : 8562 : 73307844 : 707825814931
sum: 60 : 6188 : 38291344 : 707899122775
sum: 61 : 4368 : 19079424 : 707937414119
sum: 62 : 3003 : 9018009 : 707956493543
sum: 63 : 2002 : 4008004 : 707965511552
sum: 64 : 1287 : 1656369 : 707969519556
sum: 65 : 792 : 627264 : 707971175925
sum: 66 : 462 : 213444 : 707971803189
sum: 67 : 252 : 63504 : 707972016633
sum: 68 : 126 : 15876 : 707972080137
sum: 69 : 56 : 3136 : 707972096013
sum: 70 : 21 : 441 : 707972099149
sum: 71 : 6 : 36 : 707972099590
sum: 72 : 1 : 1 : 707972099626
pretty_numbers = 707972099625
*/

A>Тестовое задание.
A>В данной задаче будут рассматриваться 13-ти значные числа в тринадцатиричной системе исчисления(цифры 0,1,2,3,4,5,6,7,8,9,A,B,C) с ведущими нулями.
A>Например, ABA98859978C0, 6789110551234, 0000007000000
A>Назовем число красивым, если сумма его первых шести цифр равна сумме шести последних цифр.

Глобальные переменные.

Безумный способ умножения чисел:

unsigned long long counter = 0;

void permutations(int n, int lenght) {
    if (lenght == 1) {
        for (int j = 0; j < n; j++)
            counter++;
    } else {
        for (int i = 0; i < n; i++)
            permutations(n, lenght - 1);
    }
}

///
{
      permutations(unique_numbers, 2);
      // ...
      pretty_numbers += counter;
      counter = 0;
}

    pretty_numbers += unique_numbers * unique_numbers;

Граничные условия и рекурсия

        for (int j = 0; j < n; j++) {
            int current = str[j] - 48;
            if(current >= 10)
                current = current - 7;

Копипаста.

Магические константы.

        for (int j = 0; j < n; j++) {
            int current = str[j] - 48;
            if(current >= 10)
                current = current - 7;
            sum_numbers[sum + current]++;
        }

        for (int j = 0; j < n; j++) {
            sum_numbers[sum + j]++;
        }

Универсальность

    char str[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C'};
    int n = sizeof str;

Алгоритм.

Тестирование и краевые случаи.

• В исходнике оставлен закоментированный код (и это не поясняющий пример из документации);
  
• В именах опечатки (lenght);
  
• Нет const для обозначения неизменяемых параметров;
  
• Просили вывести число — а программа зачем-то выводит портянку ещё чего-то непонятного;
  
• _{Для хранения плотного набора чисел c индексами от 0 для Length*Base прямо-таки напрашивается вектор, а не map. Но сойдёт, если сказать что это для экономии строчек кода (меньше кода — меньше мест для ошибки), да и будет работать не так уж медленно, если убрать из кода бесконечные инкременты}.

у MS компилятора были опции (может и сейчас есть) регулирующие время конструирования таблиц виртуальных методов: можно было сконструировать все таблицы виртуальных методов до создания объекта и тогда вызов виртуального метода в конструкторе приводил к вызову метода ещё несконструированного объекта, а в деструкторе к вызову метода уже разрушенного объекта.

#include <iostream>
#include <algorithm>
#include <tuple>
#include <iterator>
#include <ranges>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <utility>
#include <cassert>


template< typename T >
struct container_traits
{
    using iterator = decltype( std::begin( std::declval<T>() ) );
    using value_type  = typename std::iterator_traits< iterator >::value_type;
    using reference_type = typename std::iterator_traits< iterator >::reference;
    using container = T;
};

template< typename T >
struct container_traits< std::reference_wrapper<T> >
{
    using iterator = typename container_traits<T&>::iterator ;
    using value_type  = typename container_traits<T&>::reference_type;
    using reference_type = value_type;
    using container = T&;
};


template< typename T1, typename T2 >
class zip : std::pair< typename container_traits<T1>::container ,
                       typename container_traits<T2>::container >
{
    using  base = std::pair< typename container_traits<T1>::container ,
                             typename container_traits<T2>::container >;

    using _iterator_1 = typename container_traits<T1>::iterator;
    using _iterator_2 = typename container_traits<T2>::iterator;

    using _value_type_1 =  typename container_traits<T1>::value_type;
    using _value_type_2 =  typename container_traits<T2>::value_type;

public:
    using base::base;

    using value_type = std::pair< _value_type_1, _value_type_2 >;
    class iterator : public std::pair< _iterator_1, _iterator_2 >
            // for C++14 and older:
            // ,public std::iterator< std::input_iterator_tag, vlaue_type >
    {
        using base = std::pair< _iterator_1, _iterator_2 >;
public:
        using base::base;

        iterator operator++() { return { first++, second++ }; }
        iterator operator++(int) {return { ++first, ++second }; }

        bool operator == ( const iterator& r ) const { return static_cast<const base&>(*this) == r;  }
        bool operator != ( const iterator& r ) const { return static_cast<const base&>(*this) != r;  }

        vlaue_type operator*() const { return { *first, *second }; }
    };
    using const_iterator = iterator;

    size_t size() const  { return std::min( std::size(first), std::size(second) );    }
    value_type operator[]( size_t index ) const  {  return { first[index], second[index] };  }
    value_type at( size_t index ) const { return { first.at(index), second.at(index) };    }

    iterator begin() const  {   return { first.begin(), second.begin() }; }
    iterator end  () const  {   return { first.end  (), second.end  () }; }
};
template< typename T1, typename T2 >
zip(T1,T2) -> zip<T1,T2>;


using namespace std;

int main()
{
    auto i = zip( std::vector{1,2,3}, std::vector{"a"s, "b"s, "c"s} )[1];
    assert( ( i==std::pair{2,"b"s} ) );

    // support of conteiner with no 'operator[]'
    auto j= * std::begin( zip( std::list{1,2,3}, std::list{"a"s, "b"s, "c"s} ) );
    assert( ( j==std::pair{1,"a"s} ) );

    // TODO: support of std::initializer_list
    // auto p = * std::begin( zip( {1,2,3}, {"a"s, "b"s, "c"s} ) );
    // assert( ( p==std::pair{1,"a"s} ) );

    // test 'size'
    assert( zip( std::vector{1,2,3}, std::vector{"a"s, "b"s, "c"s, "d"s} ).size() == 3 );

    // test for-each loop
    for( auto i : zip( std::vector{1,2,3}, std::vector{"a"s, "b"s, "c"s} ) )
        std::cout << i.first << " " << i.second << std::endl;


    // modification via reference:
    std::vector<int> a={1,2,3,4,};
    std::vector<int> b={1,2,3,4,};
    zip(std::ref(a),std::ref(b))[1] = std::pair{ 5,6 };
    assert( a[1] == 5 );
    assert( b[1] == 6 );

    return 0;
}

select firstname.user, sku.purchase from user, purchase               // Показываю столбцы
where id.user=user_id.purchase                                        // объединенные кросс join'ом. Показываю лишь те строки, у которых id из этих столбцов равны
and 
purchase.date between 2021-02-01 and 2021-02-27                       // причем покажу только строки в которых значение даты купленного товара из интервала
and 
where not id.user in (select user_id.ban_list from ban_list)  // уберу такие, у которых id.user из списка, который получил вложенным подзапросом

from functools import cache

nums = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

@cache
def num_ways(n, depth, numbers):
    if n < 0:
        return 0
    if depth == 0:
        return 1 if n == 0 else 0
    ans = 0
    for number in numbers:
        ans += num_ways(n-number, depth-1, numbers)
    return ans

count = 0
for s in range(0, 73):
    cnt = num_ways(s, 6, nums)
    print(s,'     ', cnt)
    count += cnt*cnt
print(count)

0 1
1 6
2 21
3 56
4 126
5 252
6 462
7 792
8 1287
9 2002
10 3003
11 4368
12 6188
13 8562
14 11592
15 15378
16 20013
17 25578
18 32137
19 39732
20 48378
21 58058
22 68718
23 80262
24 92547
25 105378
26 118518
27 131698
28 144627
29 157002
30 168518
31 178878
32 187803
33 195042
34 200382
35 203658
36 204763
37 203658
38 200382
39 195042
40 187803
41 178878
42 168518
43 157002
44 144627
45 131698
46 118518
47 105378
48 92547
49 80262
50 68718
51 58058
52 48378
53 39732
54 32137
55 25578
56 20013
57 15378
58 11592
59 8562
60 6188
61 4368
62 3003
63 2002
64 1287
65 792
66 462
67 252
68 126
69 56
70 21
71 6
72 1
707972099627

A>int main()
A>{
A>    std::thread first([]()
A>        {
A>            while(true)
A>            {
A>                std::cout << "First" << std::endl;
A>            }
A>        }
A>    );
A>    std::thread second([]()
A>        {
A>            while(true)
A>            {
A>                std::cout << "Second" << std::endl;
A>            }
A>        }
A>    );
A>    first.join();
A>    second.join();
A>    return 0;
A>}
A>

int main()
{
  while(true)
  {
    std::cout << "First" << std::endl;
    std::cout << "Second" << std::endl;
    // ...
  }
  return 0;
}

count += cnt*cnt*13

static_assert(std::is_same<const int*, int const* >::value, "is not equal");

Дан отсортированный массив целых чисел, нужно вернуть отсортированный массив квадратов этих чисел.

vector<int> sortedSquares(vector<int>& A)
{
    vector<int> ret(A.size());
    int r=A.size()-1,l=0;
    for(int i=r;i>=0;i--)
    {
        if(abs(A[r])>abs(A[l]))
            ret[i]=A[r]*A[r--];
        else
            ret[i]=A[l]*A[l++];
    }
    return ret;
}

std::string replace_impl(std::string source, std::string_view from, std::string_view to, const std::string::size_type start_idx)
{
    const auto pos = source.find(from, start_idx);
    if(pos == std::string::npos) {
        return source;
    }
    else {
        source.replace(pos, from.size(), to);
        return replace_impl(std::move(source), from, to, pos + to.size());
    }
}

std::string replace_all(std::string source, std::string_view from, std::string_view to)
{
    return replace_impl(std::move(source), from, to, 0);
}

// Использование:
thread_pool->QueueJob([] { /* ... */ });

class ThreadPool {
public:
    void Start();
    void QueueJob(const std::function<void()>& job);
    void Stop();
    void busy();

private:
    void ThreadLoop();

    bool should_terminate = false;           // Tells threads to stop looking for jobs
    std::mutex queue_mutex;                  // Prevents data races to the job queue
    std::condition_variable mutex_condition; // Allows threads to wait on new jobs or termination 
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> jobs;
};

void ThreadPool::Start() {
    const uint32_t num_threads = std::thread::hardware_concurrency(); // Max # of threads the system supports
    threads.resize(num_threads);
    for (uint32_t i = 0; i < num_threads; i++) {
        threads.at(i) = std::thread(ThreadLoop);
    }
}

void ThreadPool::ThreadLoop() {
    while (true) {
        std::function<void()> job;
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            mutex_condition.wait(lock, [this] {
                return !jobs.empty() || should_terminate;
            });
            if (should_terminate) {
                return;
            }
            job = jobs.front();
            jobs.pop();
        }
        job();
    }
}

void ThreadPool::QueueJob(const std::function<void()>& job) {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        jobs.push(job);
    }
    mutex_condition.notify_one();
}

void ThreadPool::busy() {
    bool poolbusy;
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        poolbusy = jobs.empty();
    }
    return poolbusy;
}

void ThreadPool::Stop() {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        should_terminate = true;
    }
    mutex_condition.notify_all();
    for (std::thread& active_thread : threads) {
        active_thread.join();
    }
    threads.clear();
}

thread_pool->QueueJob([] { /* ... */ });

Самый понятный и простой на данный момент пул.
#pragma once

#include <future>
#include <thread>
#include <condition_variable>
#include <atomic>
#include <queue>
#include <vector>
#include <tuple>
#include <functional>
#include <utility>

class ThreadPool {
using Task = std::future<void>;
public:
    explicit ThreadPool(std::size_t threads_num);
    ~ThreadPool();

    template <typename F, typename ... Args>
    void addTask(F f, Args&& ... args) {
        {
            std::lock_guard<std::mutex> l(cv_m_);
            if (quit_) {
                throw std::runtime_error("adding task to stopped threadpool");
            }
            tasks_.emplace(std::async(std::launch::deferred, std::forward<F>(f), std::forward<Args>(args)...));
        }
        condition_.notify_one();
    }

private:
    std::mutex cv_m_;
    std::condition_variable condition_;
    std::atomic_bool quit_ = false;
    std::queue<Task> tasks_;
    std::vector<std::thread> workers_;
};

ThreadPool::ThreadPool(std::size_t threads_num)
{
    for (std::size_t i = 0; i < threads_num; ++i) {
        workers_.emplace_back(
                [this](){
                    while (true) {
                        std::unique_lock<std::mutex> lk(this->cv_m_);
                        condition_.wait(lk, [this](){
                            return !this->tasks_.empty() || this->quit_;
                        });
                        if (this->quit_ && this->tasks_.empty()) {
                            return;
                        }
                        if (!this->tasks_.empty()) {
                            auto f = std::move(this->tasks_.front());
                            this->tasks_.pop();
                            lk.unlock();
                            f.get();
                        }
                    }
                }
        );
    }
}

ThreadPool::~ThreadPool() {
    quit_ = true;
    condition_.notify_all();
    for (auto& worker : workers_) {
        worker.join();
    }
}