Kyselyt

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

template <typename T>
int count_digits(T number)
{
    int digits = 0;
    while (number) {
        number /= 10;
        digits++;
    }
    return digits;
}

template <typename T>
char get_digit(T number, std::size_t digit)
{
    std::ostringstream oss;
    oss << number;
    return oss.str()[digit];
}

struct series_point {
    std::size_t member{1};
    std::size_t number{1};

    constexpr series_point() = default;

    series_point& get_point(std::size_t m)
    {
        while (true) {
            if (member >= m) {
                return *this;
            }
            member += count_digits(number++);
        }
    }

    series_point& get_prev()
    {
        member -= count_digits(number--);
        return *this;
    }

    char get_char(std::size_t m)
    {
        get_point(m);
        if (member > m) {
            get_prev();
        }
        return get_digit(number, m - member);
    }

    series_point copy() const
    {
        return *this;
    }
};

struct input {
    std::size_t i{0};
    std::size_t k{0};
    char result{0};
};

int main()
{
    series_point s;
    int q;
    std::cin >> q;

    std::vector<input> inputs(q);
    {
        std::size_t ix = 0;
        for (auto& i : inputs) {
            i.i = ix;
            std::cin >> i.k;
            ++ix;
        }
        std::sort(inputs.begin(), inputs.end(),
                  [](input a, input b) { return a.k < b.k; });
    }

    for (auto& i : inputs) {
        i.result = s.get_char(i.k);
    }

    std::sort(inputs.begin(), inputs.end(),
              [](input a, input b) { return a.i < b.i; });
    for (auto& i : inputs) {
        std::cout << i.result << '\n';
    }
}

Test 1

Group: 1

Verdict: WRONG ANSWER

Test 2

Group: 2

Verdict: ACCEPTED

Test 3

Group: 3

Verdict: TIME LIMIT EXCEEDED