Problem: 2050C - Uninteresting Number
Language: c++17 

Solution 1 (runtime: 77 ms):
/**
 *    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;
}

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 

    string S; cin >> S;
    ll sum(0), two(0) ,three(0);

    for(char &ch : S){
        if(ch == '2')
            two++;
        if(ch == '3')
            three++;
        sum += (ch - '0');
    }
    if(sum%9==0){
        cout<<"yes"<<"\n";
        return; 
    }
   for(int i=0;i<=min(9ll,two);i++){
        for(int j=0;j<=min(3ll,three);j++){
            ll x=sum;
            x+=2*i+6*j;
            if(x % 9 == 0){
                cout << "Yes" <<endl;
                return;
            }
        }
    }
    cout << "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

Solution 2 (runtime: 77 ms):
#include<bits/stdc++.h>
using namespace std;
int main(){
    int t; cin>>t;
    while(t--){
        string s; cin>>s;
        int c_2=0,c_3=0,sum=0;

        for(int i=0; i<s.size(); i++){
            if(s[i]=='2') c_2++;
            else if(s[i]=='3') c_3++;
            sum+=(s[i]-'0');
        }
        // cout<<sum<<" ";
        sum=sum%9;
        if(sum) sum=9-sum;
        // cout<<sum<<" "<<s.size()<<" "<<c_2<<" "<<c_3<<endl;
        int f=0;
        if(!sum) f=1;

        for(int i=0; i<=c_2; i++){
            for (int j=0; j<=c_3; j++){
                int temp=(i*2+j*6)%9;
                if(temp==sum){f=1; break;}
            }
            if(f) break;
        }

        if(f) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
}