Problem: 2050C - Uninteresting Number
Language: C++17 (GCC 7-32)


Submission (verdict: Runtime error on test 1):
/**
 *    Author:  Hemanshu Waghmare
 **/

#include <bits/stdc++.h>

#define ll long long int
#define ull unsigned ll
#define ld long double
#define vi vector<ll>
#define mod 1000000007
// #define mod 998244353
#define vpl vector<pair<ll, ll>>
#define pb push_back
using namespace std;
#define in6 int64_t 
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define MK make_pair
/***********fast pow*************/
// ll fastpow(ll a, ll p){
//     ll res = 1;
//     while (p){
//         if (p % 2 == 0){
//             a = a * 1ll * a % mod;
//            // a = a * 1ll * a;
//             p /= 2;
//         }
//         else{
//             res = res * 1ll * a % mod;
//             //res = res * 1ll * a;
//             p--;
//         }
//     }
//     return res;
// }

/***********factorial************/
// vi fac(1000005);
// void fact(ll n)
// {
//     ll res = 1;
//     fac[0]=1;
//     for (ll i = 1; i <= n; i++)
//     {
//         res = res * 1ll * i % mod;
//         fac[i]=res;
//     }
//     //return res;
// }

// /***********combination************/
// ll comb(ll n, ll k)
// {
//     if(k>n){
//         return 0;
//     }
//     return fac[n] * 1ll * fastpow(fac[k], mod - 2) % mod * 1ll * fastpow(fac[n - k], mod - 2) % mod;
// }

// /***********convert string to integer*********/
// ll to_integer(string &aa)
// {
//     ll res = 0;
//     for (auto x : aa)
//         res = (res * 10) + (x - '0');
//     return res;
// }

// /*************check no is prime or not**********/
// bool prime(ll n)
// {
//     if (n <= 1)
//         return false;
//     if (n <= 3)
//         return true;
//     if (n % 2 == 0 || n % 3 == 0)
//         return false;
//     for (ll i = 5; i * i <= n; i = i + 6)
//         if (n % i == 0 || n % (i + 2) == 0)
//             return false;
//     return true;
// }

// /**********sieve of erastosthenes****************/
// ll prime[1000001];
// void sieve(ll n)
// {
//     for (ll p = 2; p * p <= n; p++)
//     {
//         if (prime[p] == 1)
//         {
//             for (ll i = p * p; i <= n; i += p)
//                 prime[i]=0;
//         }
//     }
// }

/******* Modular arithmetics ***/
// ll mul(ll a, ll b)
// {
//     return ((a % mod) * (b % mod)) % mod;
// }

// ll add(ll a, ll b)
// {
//     return ((a % mod) + (b % mod)) % mod;
// }

// ll divi(ll a,ll b){
//     return mul(a,fastpow(b,mod-2));
// }

// ll sub(ll a, ll b)
// {
//     return (a - b + mod) % mod;
// }

// ll inv_modular(ll p,ll q){
//     ll expo;
//     expo=mod-2;

//     while (expo) {
//         if (expo & 1) {
//             p = (p * q) % mod;
//         }
//         q = (q * q) % mod;
//         expo >>= 1;
//     }
//     return p;
// }

/********Disjoint Set Union************/
// class DSU{
//     ll n;
//     vi a,s,mn;
//     public:
//         void init(ll N){
//             n=N;
//             a.resize(n+1),s.resize(n+1);
//             mn.resize(n+1);
//             for(ll i=1;i<=n;i++){
//                 a[i]=i;
//                 s[i]=1;
//                 mn[i]=1e9;
//             }
//         }
//         ll root(ll i){
//             return a[i]==i ? i : a[i]=root(a[i]);
//         }
//         void Union(ll i,ll j){
//             ll roota=root(i),rootb=root(j);
//             if(roota==rootb){
//                 return;
//             }
//             if(s[roota]<=s[rootb]){
//                 a[roota]=a[rootb];
//                 s[rootb]+=s[roota];
//             }
//             else{
//                 a[rootb]=a[roota];
//                 s[roota]+=s[rootb];
//             }
//        }
// };

// *** GCD of the two number****
// ll gcd(ll n1,ll n2)
// {
//   if (n2 != 0)
//     return gcd(n2, n1 % n2);
//   else
//     return n1;
// }


void print(vector<int> &a){
cout << "Array : ";
  for(auto x : a){
    cout << x << " ";
  }
  cout <<endl;
}

// Function to precompute greatest proper divisors for all numbers up to MAX_N
// void precomputeGPD() {
//     for (int d = 1; d <= MAX_N; ++d) {
//         // d is a divisor, update all multiples of d
//         for (int multiple = 2 * d; multiple <= MAX_N; multiple += d) {
//             gpd[multiple] = d;  // d is a proper divisor of 'multiple'
//         }
//     }
// }

// const int64_t INF = 1e18;
// the int64 take huge numbers bro 


// ///// Z function 

    // vector<int> calZ(vector<int>& nums) {
    //     int N = nums.size();
    //     vector<int> Z(N);
    //     int left = 0, right = 0;

    //     for (int k = 1; k < N; k++) {
    //         if (k > right) {
    //             left = right = k;
    //             while (right < N and nums[right] == nums[right - left]) {
    //                 right++;
    //             }
    //             Z[k] = right - left;
    //             right--;
    //         } else {
    //             int k1 = k - left;
    //             if (Z[k1] < right - k + 1) {
    //                 Z[k] = Z[k1];
    //             } else {
    //                 left = k;
    //                 while (right < N and nums[right] == nums[right - left]) {
    //                     right++;
    //                 }
    //                 Z[k] = right - left;
    //                 right--;
    //             }
    //         }
    //     }
    //     return Z;
    // }

int getMEX(set<int>& s) {
    int mex = 0;
    while (s.find(mex) != s.end()) {
        ++mex;
    }
    return mex;
}


bool Uninteresting(int i, string &S) {
    if (i == S.size()) {
        if (stol(S) % 9 == 0) {
            return true;
        } else {
            return false;
        }
    }
    // cout << stoi(S) <<endl;
    if (stol(S) % 9 == 0)
        return true;

    int currChar = S[i] - '0';
    bool ans = Uninteresting(i + 1, S);

    if (currChar == 2 || currChar == 3) {
        char newChar = '0' + (currChar * currChar);
        string temp = S;
        temp[i] = newChar;
        ans |= Uninteresting(i + 1, temp);
    }

    return ans;
}

void solve()
{
    // int N , M;
    // cin >> N >> M;

    // vector<int> A(N),B(N);

    // FOR(i,0,N) cin >> A[i];
    // FOR(i,0,N) cin >> B[i];

    // 0 1 2 0 1 
    // 0 1 0 2 
    // 0 1 0 1 2 1 
    // 0 1 0 1 0 1 2 
    // 0 1 2 
    // 0 1 0 1 2 
    // 0 1 0 1 0 1 

    ll N; cin >> N;
    string S = to_string(N);
    // cout << S <<endl;
    cout << (Uninteresting(0, S) ? "Yes" : "No") << endl;
}


int main()
{
    auto begin = std::chrono::high_resolution_clock::now();
   ios_base::sync_with_stdio(false);
   cin.tie(NULL);

#ifndef ONLINE_JUDGE

  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);

#endif
    


  int t = 1;
  cin >> t;

  while (t--)
  {
   solve(); 
  }
// cout.flush()
   auto end = std::chrono::high_resolution_clock::now();
   auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin);
   cerr << "Time measured: " << elapsed.count() * 1e-9 << " seconds.\n";
  return 0;
}
// 3 1 4 1 5 9 2 6