Alkuluvut

#include <bits/stdc++.h>

constexpr auto L = 1e6;
using i128 = __int128_t;

std::unordered_map<int64_t, int64_t> SOLVED;

std::vector<int64_t> P = []() {
    std::vector<int64_t> p(L + 1, true);
    p[0] = p[1] = false;
    for (int64_t i = 2; i <= L; ++i) {
        if (p[i]) {
            for (int64_t j = i * i; j <= L; j += i) {
                p[j] = false;
            }
        }
    }
    return p;
}();
 
i128 m_pow(i128 b, i128 exp, i128 m) {
    i128 res = 1;
    b %= m;
    while (exp) {
        if (exp & 1) {
            (res *= b) %= m;
        }
        (b *= b) %= m;
        exp >>= 1;
    }
    return res;
}
 
bool mr_check(i128 n, i128 p, i128 d, int s) {
    auto x = m_pow(p, d, n);
    if (x == 1 || x == n - 1) {
        return false;
    }
    for (auto r = 1; r < s; ++r) {
        (x *= x) %= n;
        if (x == n - 1) {
            return false;
        }
    }
    return true;
}
 
bool is_prime(int64_t x) {
    if (x <= L) {
        return P[x];
    }
    for (const auto p : {3, 5, 7, 11, 13}) {
        if (x % p == 0) {
            return false;
        }
    }
    auto r = 0;
    auto d = x - 1;
    while ((d & 1) == 0) {
        d >>= 1;
        r++;
    }
    for (const auto p : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}) {
        if (mr_check(x, p, d, r)) {
            return false;
        }
    }
    return true;
}

void test2(const std::vector<int64_t>& N, int64_t x, std::size_t idx, std::size_t L, int64_t& x2, bool& ok) {
    if (idx >= L) {
        return;
    }
    static const std::vector<int64_t> POW = {
        1LL, 10LL, 100LL, 1000LL, 10000LL, 100000LL, 1000000LL, 10000000LL, 100000000LL, 1000000000LL, 10000000000LL,
        100000000000LL, 1000000000000LL, 10000000000000LL, 100000000000000LL, 1000000000000000LL, 10000000000000000LL
    };
    for (int64_t d : N) {
        for (std::size_t p = 1; !ok && p <= idx; ++p) {
            if (d == 0 && p == idx) {
                continue;
            }
            const i128 m = POW[p];
            const auto xn = (x / m) * (m * 10) + d * m + (x % m);
            if (is_prime(xn)) {
                ok = true;
                x2 = xn;
                return;
            }
            test2(N, xn, idx + 1, L, x2, ok);
        }
        if (ok) {
            return;
        }
    }
    return;
}

void test(const std::vector<int64_t>& N, std::vector<bool>& used, std::size_t idx, int64_t m, int64_t x, bool& ok) {
    if (idx == N.size()) {
        if (ok = is_prime(x); ok) {
            std::cout << "YES\n" << x << '\n';
        } else {
            for (auto idx2 = idx; idx2 <= 16; ++idx2) {
                int64_t x2{};
                test2(N, x, idx, idx2, x2, ok);
                if (ok) {
                    std::cout << "YES\n" << x2 << '\n';
                    return;
                }
            }
        }
        return;
    }
    for (std::size_t i = 0; i < N.size(); ++i) {
        if (m == 1 && (N[i] % 2 == 0 || N[i] == 5)) {
            continue;
        }
        if (!used[i]) {
            used[i] = true;
            test(N, used, idx + 1, m * 10, m * N[i] + x, ok);
            if (ok) return;
            used[i] = false;
        }
    }
}

bool check3(const std::vector<int64_t>& N) {
    static const std::set<int64_t> g{1, 2, 4, 5, 7, 8};
    for (const auto n : N) {
        if (g.count(n)) {
            return false;
        }
    }
    return true;
}

bool init_test(const std::vector<int64_t>& N) {
    if (N.size() == 1) {
        switch (N.back()) {
            case 1:
                std::cout << "YES\n11\n";
                break;
            case 2:
            case 3:
            case 5:
            case 7:
                std::cout << "YES\n" + std::to_string(N.back()) + "\n";
                break;
            default:
                std::cout << "NO\n";
        }
        return true;
    }
    if (check3(N)) {
        std::cout << "NO\n";
        return true;
    }
    static const std::set<int64_t> g{1, 3, 7, 9};
    for (const auto n : N) {
        if (g.count(n)) {
            return false;
        }
    }
    std::cout << "NO\n";
    return true;
}

int main() {
    int t;
    std::cin >> t;
    for (int i = 0, k; i < t; ++i) {
        std::cin >> k;
        std::vector<int64_t> N(k);
        for (auto& n : N) {
            std::cin >> n;
        }
        if (!init_test(N)) {
            std::vector<bool> used(N.size());
            if (bool ok = false; test(N, used, 0, 1, 0, ok), !ok) {
                std::cout << "NO\n";
            }
        }
    }
}

Test 1

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2

Group: 2, 3

Verdict: WRONG ANSWER

Test 3

Group: 3

Verdict: ACCEPTED