desperius

#include <utility>

class SinglyLinkedList
{
public:
    SinglyLinkedList() = default;
    SinglyLinkedList(const SinglyLinkedList& that)
    {
        if (Node* that_c = that.head)
        {

desperius

#include <thread>
#include <atomic>
#include <functional>
#include <vector>

#include "threadsafe_queue"

class join_threads
{
public:

desperius

#include <queue>
#include <mutex>
#include <memory>
#include <condition_variable>

template<class T>
class threadsafe_queue
{
public:
    threadsafe_queue() {}

desperius

#include <atomic>

class spinlock_mutex
{
    spinlock_mutex() : m_flag(ATOMIC_FLAG_INIT) {}

    void lock()
    {
        // Function returns true if flag was set before the call and false otherwice.
        while(m_flag.test_and_set(std::memory_order_acquire));

desperius

#include <exception>
#include <stack>
#include <mutex>
#include <memory>

struct empty_stack : std::exception
{
    const char* what() const noexcept override;
};

desperius

#include <exception>
#include <stack>
#include <mutex>
#include <memory>

struct empty_stack : std::exception
{
    const char* what() const noexcept;
};

desperius

#include <iostream>
#include <bitset>

struct bitarr
{
    bitarr(unsigned char v) : val(v) {}

    void print()
    {
        std::bitset<8 * sizeof(unsigned char)> bits(val);

desperius

#include <iostream>
#include <string>
#include <functional>

template <class T>
inline void hash_combined(std::size_t& res, const T& val)
{
    std::hash<T> h;
    res ^= h(val) + 0x9e3779b9 + (res << 6) + (res >> 2);
}

desperius

class Str
{
public:
    Str();
    Str(const char* src);
    ~Str();

    Str(const Str& that);
    Str& operator= (const Str& that);

desperius

#include <iostream>

int n = 0;
int m = 0;

int* arr;

void increse(int index)
{
    if (!(index < n))