C++ Internals

Fix the Leaky Vector

Difficulty

Asked at DRW, Akuna Capital

Read the problem, hints and solution here. The editor needs a bigger screen: open this page on a laptop to write and run your code.

x xxxxxxxxx xxxx-xxxxxx xxxxxxxx, x xxxx xxxxxxxx xxx xxxxx, xxx x xxxxxxxxx xxxx xx xxx xxxxxxx xx xxxxx xxx::xxxxxx (xxxx xxxxx, xxxxxxxx xxxxxxxxxxx). xx xxxxxx xxx xxxx. xxxxx xxxxx xxxxx xxx xxxxxxxxx xxxxx xx xxxxxxxx xxxxxx xxx xxx xxxxxx xxxx xxxx xxxx xx xxx xxxxx -xxxxxx.

xxxx xx x xxx-xxx-xxx xxxxxxx: xxx xxxxxx xxxxxxxx xxx xxxxxxxx, xxxxxx xxxxx. xxxxxx xxx xxxxxxxxx xxxxxxxxx xxxxxxx xxxxxxxx xxx xxxxxx xxxxxxxxx xx xxx xxxxxxxxxxxxxxx xxxxx.

xxx xxx xxxxxx, xxxxxxxx:

x. "xxxxxx xx xxx xxxxxx xxxx xxxxxx. xxxxxxx xxxxxxx x xxxx xxxxxxxxx xxxxxxx xxx xxxxxxxx, xxx xxx xxxxxx xxxxxxx xxxxxxx x xxxxxx xxxxx xxxxx xxxxx xxxx xxxx xx xxx xx xxxxx." x. "xxxxxxxxx xxx xxxxxxxx xxxx xxxxxxx xxxxx x xxxxxx xxxxx xxxx. xxx xx xxx xxxx xxxx xxxxx x xxxxxx xxxx xxxxxxxx xx xxxxxx, xxx xxxxxxxx xxxx xxxx xx -xxxxxx." x. "xxxxxx xxxxx xxxxx xxxx xxxxx xxxxxxxxxxxx xxx xxxxx xxxxx xxxx, xxxx xxxxxx xxx xxxxxxxxxx xxxx."

xxxxxxxx xxxx xxxx xxx xxxxxxx xxxx xxx xxxxxxxx xxxxx_xxxxxx / xxxx_xxxxxx xxx (xx xxx xxxx xxx/xxxxxx xxxxxxxx). xxx xxxxxxxxxxxxxxx xxxxx xxx xxxx xxxxxxxxxx xxxxxxx xx xxxxxx: xxxxxxx xxxxxxxxx xxxxx xxxx xxxxx (-xxxxxx), xxxxx xxxxxxx xxx xxxxxxxx xx xxxxx (-xxxxxx) xxx xxxx xxxxxx xx xxxxx xxxxx xxx xxxxxxxxxxxxx, xxx x xxxxxxxx xxxx xx xxxxxxx xx xxxxxx_xxxxx() xxxxxx xxxx xxxxxxxx. xxx xxxxx xxxxxx xxx xxxxxxxx: xxxxx xxxxxxx xxxx xxxx xxx xx xxxxx, xxxxxx() == xxxxx() xxx xxxxxx_xxxxx() == x.

xxxxxxxx

[]{ xxxxx_xxxxxxxx(); xxx::xxxxxx<xxx> xxx; { xxxxxxxx x; x.xxxx_xxxx(xx); x.xxxx_xxxx(xx); xxxxxxxx x = x; x[x] = xx; xxx.xxxx_xxxx(x[x]); xxx.xxxx_xxxx(x[x]); xxx.xxxx_xxxx(xxxxxx_xxxx<xxx>(x.xxxx())); } xxx.xxxx_xxxx(xxxxxx_xxxx<xxx>(xxxxxx() - xxxxx())); xxx.xxxx_xxxx(xxxxxx_xxxx<xxx>(xxxxxx_xxxxx())); xxxxxx xxx; }()
// [xx, xx, x, x, x]  (xxxx xxxx: xxxxxxx x[x] xxxx xxx xxxxx x; xxxxxxx xxxxxxx)

[]{ xxxxx_xxxxxxxx(); xxx::xxxxxx<xxxx xxxx> xxx; { xxxxxxxx x; x.xxxx_xxxx(x); xxxxxxxx x; x.xxxx_xxxx(x); x.xxxx_xxxx(x); x = x; xxx.xxxx_xxxx(x[x]); xxx.xxxx_xxxx(xxxxxx_xxxx<xxxx xxxx>(x.xxxx())); } xxx.xxxx_xxxx(xxxxxx()); xxx.xxxx_xxxx(xxxxx()); xxx.xxxx_xxxx(xxxxxx_xxxxx()); xxxxxx xxx; }()
// [x, x, x, x, x]  (xxx xxxxxxxxxxxx + xxx xxxxxxxxxx xxxxxxxx x xxxxxxx; xxx x xxx xxxxx)

xxxxxxxxxxx

xx xxx xxxxxx xxx xxxxxxxx xxxxxxxxxxxxxxx xx xxx xxxxxx xxxxxxxxx xx xxxxxxxx (xxxxxxxxxxxx, xxxxxxxx=, xxxxxxxxxx, xxxx_xxxx, xxxxxxxx[], xxxx).
xxx xxxxxxx xxxx xxxx xxxx xxxxx_xxxxxx / xxxx_xxxxxx.
xxxx-xxxxxxxxxx (x = x;) xxxx xxxxx xxx xxxxxxxx xxxxxxxxx.
xxxxxxxxxx (xxxxx xxxx xxxx-xxxxxxxxxx) xxxxxx xxxxx x xxxxx xxxxxx xxxx xxxxx_xxxxxx, xxxxx xx xxx xxxxxx'x xxxxxxxx, xxx xxxxx xxx xxx xxx; xxxxxxx xxx xxxxxxxxxxx'x xxxxxxxx xxxxxxxx xx xxx xxxx xx xxxx xxxxxxxx. xxx xxxxx xxxxx xxxxx xxxxxxxxxxx xx xxxx xxxxx.
xxxxxx xxxx xx xxxx: xxxxx xxxxxxxx x = x;, xxxxxx xxxxxxx x xxxxx xxxxxx x.
xxxxx xxx xxxxxxxx xx xxxxxxxxxx xxxxx xxxxxxx xxxx xxx xxxx xxx xx xxxxx, xxxxxx() == xxxxx() xxx xxxxxx_xxxxx() == x.
xxx xxxxxx xxxxx xxxxxxxx xxxxxx xxxx xxxxxxx xxxxxxxxxxxxx xxx xxxxxxx xxxx + xxxxxx + xxxx xxxxxxxxx.

This problem is only available to subscribers.

Language: C++SmallVec

#include <cstddef>
#include <vector>

// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
// ...
namespace bufcheck {

constexpr int FRESH = -424242;
constexpr int FREED = -777777;

struct Slab {
    int* ptr;
    std::size_t n;
    bool live;
};

inline std::vector<Slab>& slabs() { static std::vector<Slab> s; return s; }
inline long long& alloc_counter() { static long long c = 0; return c; }
inline long long& free_counter() { static long long c = 0; return c; }
inline long long& double_free_counter() { static long long c = 0; return c; }

inline int* alloc_buffer(std::size_t n) {
    const std::size_t slots = n == 0 ? 1 : n;
    int* p = new int[slots];
    for (std::size_t i = 0; i < slots; ++i) p[i] = FRESH;
    slabs().push_back({p, slots, true});
    ++alloc_counter();
    return p;
}

inline void free_buffer(int* p) {
    if (p == nullptr) return;
    for (Slab& slab : slabs()) {
        if (slab.ptr != p) continue;
        if (slab.live) {
            slab.live = false;
            for (std::size_t i = 0; i < slab.n; ++i) slab.ptr[i] = FREED;
            ++free_counter();
        } else {
            ++double_free_counter();
        }
        return;
    }
    ++double_free_counter();
}

inline long long allocs() { return alloc_counter(); }
inline long long frees() { return free_counter(); }
inline long long double_frees() { return double_free_counter(); }
inline void reset_counters() {
    alloc_counter() = 0;
    free_counter() = 0;
    double_free_counter() = 0;
}

}  // ...

using bufcheck::alloc_buffer;
using bufcheck::allocs;
using bufcheck::double_frees;
using bufcheck::free_buffer;
using bufcheck::frees;
using bufcheck::reset_counters;

// ...
// ...
// ...
// ...
// ...
class SmallVec {
public:
    SmallVec() : data_(alloc_buffer(4)), size_(0), cap_(4) {}

    SmallVec(const SmallVec& other)
        : data_(other.data_), size_(other.size_), cap_(other.cap_) {}

    SmallVec& operator=(const SmallVec& other) {
        data_ = alloc_buffer(other.cap_);
        size_ = other.size_;
        cap_ = other.cap_;
        for (std::size_t i = 0; i < size_; ++i) data_[i] = other.data_[i];
        return *this;
    }

    ~SmallVec() { free_buffer(data_); }

    void push_back(int value) {
        if (size_ == cap_) grow();
        data_[size_++] = value;
    }

    int& operator[](std::size_t i) { return data_[i]; }
    const int& operator[](std::size_t i) const { return data_[i]; }
    std::size_t size() const { return size_; }

private:
    void grow() {
        const std::size_t new_cap = cap_ * 2;
        int* bigger = alloc_buffer(new_cap);
        for (std::size_t i = 0; i < size_; ++i) bigger[i] = data_[i];
        data_ = bigger;
        cap_ = new_cap;
    }

    int* data_;
    std::size_t size_;
    std::size_t cap_;
};

Unlock to runUpgrade

Sample tests

Unlock the problem to run it against the tests.

Next in Quant Dev 50std::move TrapsC++ Internals