library/sequence/ForString.hpp

• View this file on GitHub
• Last update: 2025-11-24 18:49:07+09:00
• Include: #include "library/sequence/ForString.hpp"
• Link: View error logs on GitHub Actions

Depends on

• build/pch/stdc++.hpp

Required by

• library/sequence/AhoCorasick.hpp
• library/sequence/RollingHash.hpp
• library/sequence/Trie.hpp

Verified with

• test/AOJ/2212.test.cpp
• test/AOJ/ALDS1_14_B.test.cpp
• test/yukicoder/430.test.cpp
• test/yukicoder/430_2.test.cpp

Code

#pragma once
template <char MARGIN> struct ForString {
    static constexpr char change(char c) { return c - MARGIN; }
    static constexpr char restore(char a) { return a + MARGIN; }

    static std::vector<char> change(const std::string &s) {
        std::vector<char> v(s.size());
        for (int i = 0; i < s.size(); i++)
            v[i] = change(s[i]);
        return v;
    }
    static std::string restore(const std::vector<char> &v) {
        std::string s(v.size(), '#');
        for (int i = 0; i < v.size(); i++)
            s[i] = restore(v[i]);
        return s;
    }
};
struct FSAa {
    static constexpr char change(char c) {
        return c <= 'Z' ? c - 'A' : 26 + c - 'a';
    }
    static constexpr char restore(char a) {
        return a < 26 ? 'A' : a - 26 + 'a';
    }
    static std::vector<char> change(const std::string &s) {
        std::vector<char> v(s.size());
        for (int i = 0; i < s.size(); i++)
            v[i] = change(s[i]);
        return v;
    }
    static std::string restore(const std::vector<char> &v) {
        std::string s(v.size(), '#');
        for (int i = 0; i < v.size(); i++)
            s[i] = restore(v[i]);
        return s;
    }
};
using FSA = ForString<'A'>;
using FSa = ForString<'a'>;
using FS0 = ForString<'0'>;

#ifdef STR
#define STRA(s)                                                                \
    STR(s##tomato);                                                            \
    auto s = FSA::change(s##tomato);
#define STRa(s)                                                                \
    STR(s##tomato);                                                            \
    auto s = FSa::change(s##tomato);
#define STR0(s)                                                                \
    STR(s##tomato);                                                            \
    auto s = FS0::change(s##tomato);
#endif

#line 2 "library/sequence/ForString.hpp"
template <char MARGIN> struct ForString {
    static constexpr char change(char c) { return c - MARGIN; }
    static constexpr char restore(char a) { return a + MARGIN; }

    static std::vector<char> change(const std::string &s) {
        std::vector<char> v(s.size());
        for (int i = 0; i < s.size(); i++)
            v[i] = change(s[i]);
        return v;
    }
    static std::string restore(const std::vector<char> &v) {
        std::string s(v.size(), '#');
        for (int i = 0; i < v.size(); i++)
            s[i] = restore(v[i]);
        return s;
    }
};
struct FSAa {
    static constexpr char change(char c) {
        return c <= 'Z' ? c - 'A' : 26 + c - 'a';
    }
    static constexpr char restore(char a) {
        return a < 26 ? 'A' : a - 26 + 'a';
    }
    static std::vector<char> change(const std::string &s) {
        std::vector<char> v(s.size());
        for (int i = 0; i < s.size(); i++)
            v[i] = change(s[i]);
        return v;
    }
    static std::string restore(const std::vector<char> &v) {
        std::string s(v.size(), '#');
        for (int i = 0; i < v.size(); i++)
            s[i] = restore(v[i]);
        return s;
    }
};
using FSA = ForString<'A'>;
using FSa = ForString<'a'>;
using FS0 = ForString<'0'>;

#ifdef STR
#define STRA(s)                                                                \
    STR(s##tomato);                                                            \
    auto s = FSA::change(s##tomato);
#define STRa(s)                                                                \
    STR(s##tomato);                                                            \
    auto s = FSa::change(s##tomato);
#define STR0(s)                                                                \
    STR(s##tomato);                                                            \
    auto s = FS0::change(s##tomato);
#endif

Back to top page