Submission #67515141

Source Code Expand

#include <bits/stdc++.h>
#define FASTIO
using namespace std;

using ll = long long;
using ui = unsigned int;
using ull = unsigned long long;
using Vi = std::vector<int>;
using Vl = std::vector<ll>;
using Pii = std::pair<int, int>;
using Pll = std::pair<ll, ll>;
template <class T, class Greater = std::greater<T>>
using min_priority_queue = std::priority_queue<T, std::vector<T>, Greater>;
template <class T, class Less = std::less<T>>
using max_priority_queue = std::priority_queue<T, std::vector<T>, Less>;

constexpr int I_INF = std::numeric_limits<int>::max();
constexpr ll L_INF = std::numeric_limits<ll>::max();
constexpr double DUB_INF = std::numeric_limits<double>::infinity();

template <typename T1, typename T2>
inline bool chmin(T1& a, const T2& b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}
template <typename T1, typename T2>
inline bool chmax(T1& a, const T2& b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

constexpr bool is_in_rect(long long i, long long j, long long H, long long W) noexcept {
    return i >= 0 && i < H && j >= 0 && j < W;
}

template <typename T>
concept HasSize = requires(T a) {
    { a.size() } -> std::convertible_to<long long>;
};
template <HasSize T>
constexpr long long isize(const T& v) noexcept {
    return static_cast<long long>(v.size());
}

// 二項演算子(自分同士) concept
// std::pair や std::tuple の演算子定義に用いる
#define DEF_BINARY_OPERATOR_CONCEPT(name, op) \
    template <typename T>                     \
    concept name = requires(T a, T b) {       \
        { a op b } -> std::convertible_to<T>; \
    };
DEF_BINARY_OPERATOR_CONCEPT(Addable, +)
DEF_BINARY_OPERATOR_CONCEPT(Subtractable, -)
DEF_BINARY_OPERATOR_CONCEPT(Multipliable, *)
DEF_BINARY_OPERATOR_CONCEPT(Divisible, /)
DEF_BINARY_OPERATOR_CONCEPT(AddAssignable, +=)
DEF_BINARY_OPERATOR_CONCEPT(SubtractAssignable, -=)
DEF_BINARY_OPERATOR_CONCEPT(MultiplyAssignable, *=)
DEF_BINARY_OPERATOR_CONCEPT(DivideAssignable, /=)

// std::pair 二項演算子
#define DEF_PAIR_BINARY_OP(concept_name, op)                                                          \
    template <concept_name T1, concept_name T2>                                                       \
    constexpr std::pair<T1, T2> operator op(const std::pair<T1, T2>& a, const std::pair<T1, T2>& b) { \
        return {a.first op b.first, a.second op b.second};                                            \
    }
DEF_PAIR_BINARY_OP(Addable, +)
DEF_PAIR_BINARY_OP(Subtractable, -)
DEF_PAIR_BINARY_OP(Multipliable, *)
DEF_PAIR_BINARY_OP(Divisible, /)

// std::pair 複合代入演算子
#define DEF_PAIR_COMPOUND_ASSIGNMENT_OP(concept_name, op)                              \
    template <concept_name T1, concept_name T2>                                        \
    std::pair<T1, T2>& operator op(std::pair<T1, T2>& a, const std::pair<T1, T2>& b) { \
        a.first op b.first, a.second op b.second;                                      \
        return a;                                                                      \
    }
DEF_PAIR_COMPOUND_ASSIGNMENT_OP(AddAssignable, +=)
DEF_PAIR_COMPOUND_ASSIGNMENT_OP(SubtractAssignable, -=)
DEF_PAIR_COMPOUND_ASSIGNMENT_OP(MultiplyAssignable, *=)
DEF_PAIR_COMPOUND_ASSIGNMENT_OP(DivideAssignable, /=)

// std::tuple 二項演算子
#define DEF_TUPLE_BINARY_OP(concept_name, op_name, op)                                           \
    template <typename Tuple, std::size_t... Is>                                                 \
    Tuple __##op_name##_tuple_impl(const Tuple& a, const Tuple& b, std::index_sequence<Is...>) { \
        return std::make_tuple((std::get<Is>(a) op std::get<Is>(b))...);                         \
    }                                                                                            \
    template <concept_name... Ts>                                                                \
    std::tuple<Ts...> operator op(const std::tuple<Ts...>& a, const std::tuple<Ts...>& b) {      \
        return __##op_name##_tuple_impl(a, b, std::index_sequence_for<Ts...>{});                 \
    }
DEF_TUPLE_BINARY_OP(Addable, add, +)
DEF_TUPLE_BINARY_OP(Subtractable, sub, -)
DEF_TUPLE_BINARY_OP(Multipliable, mul, *)
DEF_TUPLE_BINARY_OP(Divisible, div, /)

// std::tuple 複合代入演算子
#define DEF_TUPLE_COMPOUND_ASSIGNMENT_OP(concept_name, op_name, op)                       \
    template <typename Tuple, std::size_t... Is>                                          \
    void __##op_name##_tuple_impl(Tuple& a, const Tuple& b, std::index_sequence<Is...>) { \
        ((std::get<Is>(a) op std::get<Is>(b)), ...);                                      \
    }                                                                                     \
    template <typename... Ts>                                                             \
    std::tuple<Ts...>& operator op(std::tuple<Ts...>& a, const std::tuple<Ts...>& b) {    \
        __##op_name##_tuple_impl(a, b, std::index_sequence_for<Ts...>{});                 \
        return a;                                                                         \
    }
DEF_TUPLE_COMPOUND_ASSIGNMENT_OP(AddAssignable, add_assign, +=)
DEF_TUPLE_COMPOUND_ASSIGNMENT_OP(SubtractAssignable, sub_assign, -=)
DEF_TUPLE_COMPOUND_ASSIGNMENT_OP(MultiplyAssignable, mul_assign, *=)
DEF_TUPLE_COMPOUND_ASSIGNMENT_OP(DivideAssignable, div_assign, /=)

// 出力ユーティリティ関数
template <typename T>
concept Streamable = requires(std::ostream& os, T value) {
    { os << value } -> std::convertible_to<std::ostream&>;
};
template <typename T>
concept StreamableArray = requires(T t, size_t i, std::ostream& os) {
    { os << t[i] } -> std::convertible_to<std::ostream&>;
};
template <typename T>
concept IntArray = requires(T t, size_t i) {
    { std::remove_reference_t<decltype(t[i])>(t[i]) } -> std::integral;
};
template <typename T>
concept StreamableIntArray = StreamableArray<T> && IntArray<T>;
template <typename T>
concept StreamableMatrix = requires(T t, size_t i, size_t j, std::ostream& os) {
    { os << t[i][j] } -> std::convertible_to<std::ostream&>;
};
template <typename T>
concept IntMatrix = requires(T t, size_t i, size_t j) {
    { std::remove_reference_t<decltype(t[i][j])>(t[i][j]) } -> std::integral;
};
template <typename T>
concept StreamableIntMatrix = StreamableMatrix<T> && IntMatrix<T>;

template <std::ostream& os>
class Prints {
private:
    class __Prints {
    public:
        __Prints(const char* sep, const char* term) : sep(sep), term(term) {}
        template <Streamable... Args>
        void operator()(const Args&... args) const {
            print(args...);
        }

    private:
        const char* sep;
        const char* term;
        void print(void) const {
            os << term;
        }
        void print_rest(void) const {
            os << term;
        }
        template <Streamable Head, Streamable... Tail>
        void print(Head head, Tail... tail) const {
            os << head, print_rest(tail...);
        }
        template <Streamable Head, Streamable... Tail>
        void print_rest(Head head, Tail... tail) const {
            os << sep << head, print_rest(tail...);
        }
    };

public:
    Prints() {}
    __Prints operator()(const char* sep = " ", const char* term = "\n") {
        return __Prints(sep, term);
    }
};
Prints<std::cout> prints;
Prints<std::cerr> eprints;

template <std::ostream& os>
class Vprints {
public:
    template <StreamableArray Arr>
    void h(const Arr& arr, size_t sz, const char* sep = " ") const {
        basic_print_vec(arr, sz, sep, "\n");
    }
    template <StreamableIntArray Arr>
    void h1(const Arr& arr, size_t sz, const char* sep = " ") const {
        basic_print_vec_add1(arr, sz, sep, "\n");
    }
    template <StreamableArray Arr>
    void v(const Arr& arr, size_t sz) const {
        basic_print_vec(arr, sz, "\n", "\n");
    }
    template <StreamableArray Arr>
    void v1(const Arr& arr, size_t sz) const {
        basic_print_vec_add1(arr, sz, "\n", "\n");
    }
    template <StreamableMatrix Mat>
    void mat(const Mat& mat, size_t h, size_t w, const char* sep = " ") const {
        for (size_t i = 0; i < h; i++) {
            for (size_t j = 0; j < w; j++) {
                os << mat[i][j] << (j == w - 1 ? "" : sep);
            }
            os << "\n";
        }
    }
    template <StreamableIntMatrix Mat>
    void mat1(const Mat& mat, size_t h, size_t w, const char* sep = " ") const {
        for (size_t i = 0; i < h; i++) {
            for (size_t j = 0; j < w; j++) {
                os << mat[i][j] + 1 << (j == w - 1 ? "" : sep);
            }
            os << "\n";
        }
    }

private:
    template <StreamableArray Arr>
    void basic_print_vec(const Arr& arr, size_t sz, const char* sep, const char* term) const {
        for (size_t i = 0; i < sz; i++) {
            os << arr[i] << (i == sz - 1 ? "" : sep);
        }
        os << term;
    }
    template <StreamableIntArray Arr>
    void basic_print_vec_add1(const Arr& arr, size_t sz, const char* sep, const char* term) const {
        for (size_t i = 0; i < sz; i++) {
            os << arr[i] + 1 << (i == sz - 1 ? "" : sep);
        }
        os << term;
    }
};
Vprints<std::cout> vprints;
Vprints<std::cerr> evprints;

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

void solve() {
    ll N;
    cin >> N;
    string ans;

    bool ok = true;

    for (ll i = 0; i < N; i++) {
        char c;
        ll len;
        cin >> c >> len;
        if (len > 100) {
            ok = false;
            break;
        }

        ans += string(len, c);
    }

    if (isize(ans) > 100) {
        ok = false;
    }

    if (ok) {
        prints()(ans);
    } else {
        prints()("Too Long");
    }
}

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

int main() {
#ifdef FASTIO
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    std::ios::sync_with_stdio(false);
#endif
#ifdef FILEINPUT
    std::ifstream ifs("./in_out/input.txt");
    std::streambuf* cin_origin = std::cin.rdbuf(ifs.rdbuf());
#endif
#ifdef FILEOUTPUT
    std::ofstream ofs("./in_out/output.txt");
    std::streambuf* cout_origin = std::cout.rdbuf(ofs.rdbuf());
#endif
    std::cout << std::setprecision(18) << std::fixed;
    solve();
    std::cout << std::flush;
#ifdef FILEINPUT
    std::cin.rdbuf(cin_origin);
#endif
#ifdef FILEOUTPUT
    std::cout.rdbuf(cout_origin);
#endif
    return 0;
}

Submission Info

Submission Time
Task B - String Too Long
User scol
Language C++ 23 (gcc 12.2)
Score 200
Code Size 10858 Byte
Status AC
Exec Time 1 ms
Memory 3604 KiB

Judge Result

Set Name Sample All
Score / Max Score 0 / 0 200 / 200
Status
AC × 4
AC × 22
Set Name Test Cases
Sample 00_sample_00.txt, 00_sample_01.txt, 00_sample_02.txt, 00_sample_03.txt
All 00_sample_00.txt, 00_sample_01.txt, 00_sample_02.txt, 00_sample_03.txt, 01_test_00.txt, 01_test_01.txt, 01_test_02.txt, 01_test_03.txt, 01_test_04.txt, 01_test_05.txt, 01_test_06.txt, 01_test_07.txt, 01_test_08.txt, 01_test_09.txt, 01_test_10.txt, 01_test_11.txt, 01_test_12.txt, 01_test_13.txt, 01_test_14.txt, 01_test_15.txt, 01_test_16.txt, 01_test_17.txt
Case Name Status Exec Time Memory
00_sample_00.txt AC 1 ms 3600 KiB
00_sample_01.txt AC 1 ms 3468 KiB
00_sample_02.txt AC 1 ms 3464 KiB
00_sample_03.txt AC 1 ms 3388 KiB
01_test_00.txt AC 1 ms 3416 KiB
01_test_01.txt AC 1 ms 3376 KiB
01_test_02.txt AC 1 ms 3388 KiB
01_test_03.txt AC 1 ms 3436 KiB
01_test_04.txt AC 1 ms 3464 KiB
01_test_05.txt AC 1 ms 3468 KiB
01_test_06.txt AC 1 ms 3464 KiB
01_test_07.txt AC 1 ms 3516 KiB
01_test_08.txt AC 1 ms 3480 KiB
01_test_09.txt AC 1 ms 3604 KiB
01_test_10.txt AC 1 ms 3396 KiB
01_test_11.txt AC 1 ms 3416 KiB
01_test_12.txt AC 1 ms 3320 KiB
01_test_13.txt AC 1 ms 3460 KiB
01_test_14.txt AC 1 ms 3484 KiB
01_test_15.txt AC 1 ms 3472 KiB
01_test_16.txt AC 1 ms 3468 KiB
01_test_17.txt AC 1 ms 3468 KiB