Problem:
陣形
プログラマー養成校であるアカベ高校では、チーム戦の競技プログラマーの役割を以下の３タイプに分けています。
Ｃ：
コーダー
言語を熟知しており、コーディングを行う。
Ａ：
アルゴリズマー
論理的思考が得意であり、アルゴリズムを考える。
Ｎ：
ナビゲーター
読解力に長けており、問題の分析・デバッグをする。
この高校では以下のいずれかの陣形で３人一組のチームを構成しています。
ＣＣＡ：
バランスがとれている安定型
ＣＣＣ：
スピードを見込めるがリスクの高い速攻型
ＣＡＮ：
正確に問題を解く慎重型
競技プログラミング部のコーチであるあなたは、これらの部員をうまく組み合わせ、できるだけ多くのチームを結成できるよう、毎年気を配っています。そこで、コーダーの人数、アルゴリズマーの人数、ナビゲーターの人数が入力として与えられたとき、最大何チーム作れるかを出力するプログラムを作成してください。
入力
入力は1つのデータセットからなる。入力データは以下の形式で与えられる。
Q
c
1
a
1
n
1
c
2
a
2
n
2
:
c
Q
a
Q
n
Q
1行目の
Q
(0 ≤
Q
≤ 100)はチーム数を求めたい年数である。続く
Q
行に各年の役割別の人数が与えられる。各行にはコーダーの人数
c
i
(0 ≤
c
i
≤ 1000)、アルゴリズマーの人数
a
i
(0 ≤
a
i
≤ 1000)、ナビゲーターの人数
n
i
(0 ≤
n
i
≤ 1000)が与えられる。
出力
年ごとに、作成できる最大のチーム数を1行に出力する。
入力例
4
3 0 0
1 1 1
9 4 1
0 1 2
出力例
1
1
4
0

Submitted solutions:

code_snippet: #include<bits/stdc++.h>

#define ll long long
using namespace std;



int main() {
//#ifndef ONLINE_JUDGE
//    freopen("Input.txt", "r", stdin);
//    freopen("Output.txt", "w", stdout);
//#endif
    int t;
    cin >> t ;
    while (t--) {
int a , b , c;
cin >> a >> b >> c ;
int ans = 0;
        for (int i = 0; i <350 ; ++i) {
            int aa = a ;
            if(i > a / 3)break;
            for (int j = 0; j <= 1000; ++j) {
                int bb = b;
                if(j > (a - 3*i) / 2 || j > b)break;
                for (int k = 0; k <=1000 ; ++k) {
                    if(k > min({a - (3 * i) - (2 * j),b - j,c}))break;
                    ans = max(ans , i + j + k);
                  //  cout << i + j + k << endl;
                }
            }
        }
        cout << ans << endl;
    }
}
accuracy: 1
time_ms: 400
memory_kb: 3416
final_rank: 18

code_snippet: #include <iostream>

using namespace std;

int team(int c, int a, int n);

int main(void){
  int Q;
  cin>>Q;
  for(int i=0;i<Q;i++){
    int c,a,n;
    cin>>c>>a>>n;
    cout<<team(c,a,n)<<endl;
  }
  return 0;
}

int team(int c, int a, int n){
  int retval=0;
  for(int tc=0;tc<=n;tc++){
    for(int ta=0;ta<=a-tc;ta++){
      int tb=c-tc-2*ta;
      if(tb<0){continue;}
      tb=tb/3;
      retval=max(retval,ta+tb+tc);
    }
  }
  return retval;
}
accuracy: 1
time_ms: 10
memory_kb: 3092
final_rank: 7

code_snippet: #include <iostream>
#include <algorithm>
using namespace std;
using ll = long long;

int main()
{
    ll q;
    ll c, a, n;

    cin >> q;
    for (int i = 0; i < q; i++) {
        cin >> c >> a >> n;

        ll ans = 0;
        for (int j = 0; j <= 1000; j++) {
            for (int k = 0; k <= 1000; k++) {
                ll tmpc = c - j * 3 - k * 2;
                ll tmpa = a - k;

                if (tmpc < 0 || tmpa < 0) continue;
                ans = max(ans, j + k + min(tmpc, min(tmpa, n)));
            }
        }

        cout << ans << endl;
    }

    return 0;
}
accuracy: 1
time_ms: 90
memory_kb: 3096
final_rank: 13

code_snippet: #include "bits/stdc++.h"
// Custom Header {{{
#define ALL(x) x.begin(), x.end()
using namespace std;
using i64 = long long;
using pii = pair<i64, i64>;
template<class A, class B>inline bool chmax(A &a, const B &b){return b>a ? a=b,1 : 0;}
template<class A, class B>inline bool chmin(A &a, const B &b){return b<a ? a=b,1 : 0;}
constexpr int INF  = 0x3f3f3f3f;
constexpr i64 LINF = 0x3f3f3f3f3f3f3f3fLL;
// }}}

signed main()
{
    ios::sync_with_stdio(false); cin.tie(nullptr);
    int q;
    cin >> q;

    while(q--) {
        int c, a, n;
        cin >> c >> a >> n;

        int ans = 0;
        for (int x = 0; x <= 1000; ++x) {
            for (int z = 0; z <= 1000; ++z) {
                if (
                        2*x + z <= c &&
                        x + z <= a &&
                        z <= n) {
                    int y = (c - 2 * x - z) / 3;
                    chmax(ans, x + y + z);
                }

            }
        }

        cout << ans << "\n";
    }

    return 0;
}

// vim: set foldmethod=marker :
accuracy: 1
time_ms: 70
memory_kb: 3200
final_rank: 11

code_snippet: #include <stdio.h>

#define min(X, Y) ((X) < (Y) ? (X) : (Y))
#define max(X, Y) ((X) > (Y) ? (X) : (Y))

int main()
{
    int q;
    int c, a, n;
    int i, j;

    scanf("%d", &q);
    for (i = 0; i < q; i++) {
        int ans = 0;
        scanf("%d %d %d", &c, &a, &n);
        
        int speed, ant, sin;

        for (speed = 0; speed <= 333; speed++) {
            for (ant = 0; ant <= 500; ant++) {
                if (c >= (speed * 3 + ant * 2) &&
                    a >= ant) {
                    sin = min(c - (speed * 3 + ant * 2), min(a - ant, n));
                    ans = max(ans, sin + speed + ant);
                }
            }
        }
        printf("%d\n", ans);
    }


    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 2748
final_rank: 6

code_snippet: #include<bits/stdc++.h>
using namespace std;


int main(){
  
  int y,c[1000],a[1000],n[1000],p[1000];
  cin>>y;
  
  for(int i=0;i<y;i++){

   cin>>c[i]>>a[i]>>n[i];
   int cd,ad,nd;
   nd=min(c[i],a[i]);
   nd=min(nd,n[i]);
   ad=min(c[i]/2,a[i]);
   cd=c[i]/3;
   p[i]=cd;
   
   for(int t=0;t<=cd;t++){
     for(int h=0;h<=ad;h++){
       for(int j=0;j<=nd;j++){
	 if(t*3+h*2+j<=c[i] && h+j<=a[i] && j<=n[i]){p[i]=max(p[i],t+h+j);}
	 else{break;}
       }
     }
   }


  }

  for(int i=0;i<y;i++){
    cout<<p[i]<<endl;
  }
  
  return 0;
}
accuracy: 1
time_ms: 410
memory_kb: 3104
final_rank: 17

code_snippet: #include <bits/stdc++.h>
using namespace std;

using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;

#define ALL(a)  begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

#define FF first
#define SS second

#define DUMP(x) cout<<#x<<":"<<(x)<<endl
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
  return is >> p.FF >> p.SS;
}
template<class T>
istream& operator>>(istream& is, vector<T>& xs){
  for(auto& x: xs)
	is >> x;
  return is;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
  return os << p.FF << " " << p.SS;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T>& xs){
  for(unsigned int i=0;i<xs.size();++i)
	os << (i?" ":"") << xs[i];
  return os;
}
template<class T>
void maxi(T& x, T y){
  if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
  if(x > y) x = y;
}


const double EPS = 1e-10;
const double PI  = acos(-1.0);
const LL MOD = 1e9+7;

int main(){
  cin.tie(0);
  ios_base::sync_with_stdio(false);

  int Q;
  cin >> Q;
  while(Q--){
	int c, a, n;
	cin >> c >> a >> n;

	int ans = 0;
	REP(i1,1001) REP(i2,1001){
	  int cc = c - i1 * 2 - i2 * 3;
	  int aa = a - i1 * 1;
	  if(cc < 0 || aa < 0) continue;
	  maxi(ans, i1+i2+min({aa,cc,n}));
	}
	cout << ans << endl;
  }

  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3152
final_rank: 9

code_snippet: #include <map>
#include <set>
#include <list>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <numeric>
#include <utility>
#include <iostream>
#include <algorithm>
#include <functional>

using namespace std;

#define INF (1 << 30)
#define INFL (1LL << 62)
#define MOD7 1000000007
#define MOD9 1000000009
#define EPS 1e-10

#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pul pair<ull, ull>
#define all(a) (a).begin(), (a).end()
#define FOR(i,a,b) for (int i=(a);i<(b);++i)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);--i)
#define REP(i,n) for (int i=0;i<(n);++i)
#define RREP(i,n) for (int i=(n)-1;i>=0;--i)

void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void yes() { cout << "yes" << endl; }
void no() { cout << "no" << endl; }
void Taka() { cout << "Takahashi" << endl; }
void Aoki() { cout << "Aoki" << endl; }
void digit(int d) { cout << fixed << setprecision(d); }
void IOup() { cin.tie(0); ios::sync_with_stdio(false); }

int main() {
	int q;
	cin >> q;
	while (q--) {
		int c, a, n, ans = 0;
		cin >> c >> a >> n;
		for (int z = 0; z <= n; ++z) {
			for (int x = 0; x <= a - z; ++x) {
				int y = (c - 2 * x - z) / 3;
				if (y >= 0 && 2 * x + 3 * y + z <= c) {
					ans = max(ans, x + y + z);
				}
			}
		}
		cout << ans << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3104
final_rank: 8

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int n;
vector<char>c(100);
int main() {
	int q;
	cin >> q;
	for (int i = 0; i < q; i++) {
		int C, A, N, ans = 0;
		cin >> C >> A >> N;
		for (int i = 0; i <= 1000; i++) {
			for (int j = 0; j <= 1000; j++) {
				int c = C;
				int a = A;
				int n = N;
				c -= i; a -= i; n -= i;
				c -= j * 2; a -= j;
				if (c >= 0 && a >= 0 && n >= 0) {
					ans = max(ans,i + j + c / 3);
				}
			}
		}
		cout << ans << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 3120
final_rank: 12

code_snippet: #include <iostream>

using namespace std;

/*
 * 
 */
int main(int argc, char** argv) {
    int Q,c,a,n;
    cin >> Q;
    
    for(int i=0;i<Q;i++){
        cin >> c >> a >> n;
        int lim = (c+a+n)/3,res = 0;
        if(lim>c)lim = c;
        int j = 0,k = 0,l = 0;
        for(;(j+k+l<=lim&&j*3+k*2+l<=c)&&(k+l<=a&&l<=n);j++){
            for(;(j+k+l<=lim&&j*3+k*2+l<=c)&&(k+l<=a&&l<=n);k++){
                for(;(j+k+l<=lim&&j*3+k*2+l<=c)&&(k+l<=a&&l<=n);l++){
                    if(j+k+l>res)res = j+k+l;
                }
                l = 0;
            }
            k = 0;
        }
        j = 0;
        cout << res << endl;
    }
        
    return 0;
}
accuracy: 1
time_ms: 400
memory_kb: 3052
final_rank: 16

code_snippet: #include<iostream>
#include<vector>
#include<string>
#include<map>
#include<algorithm>
using namespace std;


int main() 
{  
	int a;
	cin >> a;
	for (int b = 0; b < a; b++) 
	{
		int c, d, e;
		cin >> c >> d >> e;
		int s = 0;
		for (int f = 0; f <=c / 3; f++) {
			for (int g = 0; g <= (c - f * 3) / 2 && g <= d;g++) {
				vector<int>h{ (c - f * 3 - g * 2),d - g,e };
				sort(h.begin(), h.end());
				if (s < h[0]+f+g)s = h[0]+f+g;
			}
		}
		cout << s << endl;
	}
}
accuracy: 1
time_ms: 70
memory_kb: 3144
final_rank: 10

code_snippet: #include<bits/stdc++.h>
using namespace std;
int Q;
int C,A,N;
int main()
{
    scanf("%d",&Q);
    for(int i=0;i<Q;i++){
        scanf("%d%d%d",&C,&A,&N);
        int ans=0;
        for(int te3=0;te3<=N;te3++){
        	int C1=C,A1=A,N1=N;
            int team=te3;
            C1-=te3;A1-=te3;N1-=te3;
            if(C1<0||A1<0)continue;
             
            for(int te2=0;te2<=A1;te2++){
                A1=A-te3;C1=C-te3;
                team=te3;
                team+=te2;
                A1-=te2;C1-=2*te2;
                if(C1<0)continue;
                team+=C1/3;
                ans=max(ans,team);
            }
             
            C1=C;A1=A;N1=N;
        }
        printf("%d\n",ans);
    }
    return 0;
}
accuracy: 0.375
time_ms: 10
memory_kb: 1188
final_rank: 19

code_snippet: #include<bits/stdc++.h>
using namespace std;
int ans,m,a,c,n,sa,sc,scc;

int main(){
    cin >> m;
    for(int i=0;i<m;i++){
        cin >> c >> a >> n;

        for(int i=0;i<=c/3;i++){
            sc=c-3*i;
            for(int j=0;j<=min(sc/2,a);j++){
                scc=sc-j*2;
                sa=a-j;
                for(int k=0;k<=min(scc,min(sa,n));k++){
                    ans=max(ans,i+j+k);
                }
            }
        }



        cout << ans << endl;
        c=0,a=0,n=0,ans=0;
    }

return 0;
}
accuracy: 1
time_ms: 430
memory_kb: 1160
final_rank: 14

code_snippet: #include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef complex<double> P;
const int MAX_CAN = 1002;

int dp[MAX_CAN][MAX_CAN];

int main() {
  memset(dp, -1, sizeof(dp));
  dp[0][0] = 0;
  REP(i, MAX_CAN){
    REP(j, MAX_CAN){
        if(i - 1 >= 0) dp[i][j] = max(dp[i][j], dp[i - 1][j]);
        if(j - 1 >= 0) dp[i][j] = max(dp[i][j], dp[i][j - 1]);
        if(dp[i][j] < 0) continue;
        if(i + 2 < MAX_CAN && j + 1 < MAX_CAN) dp[i + 2][j + 1] = max(dp[i + 2][j + 1], dp[i][j] + 1);
        if(i + 3 < MAX_CAN)                    dp[i + 3][j]     = max(dp[i + 3][j],     dp[i][j] + 1);
      } }
  int Q; cin >>Q;
  while(Q--){
    int C, A, N, ans = 0; cin >>C >>A >>N;
    REP(i, N + 1) if(C - i >= 0 && A - i >= 0) ans = max(ans, dp[C - i][A - i] + i);
    cout <<ans <<endl;
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 5092
final_rank: 14

code_snippet: #include <iostream>
using namespace std;

int main() {
    int Q;
    cin >> Q;
    int c, a, n;
    while (Q--) {
        cin >> c >> a >> n;
        int team = 0;
        for (int ccc=0; ccc<1001; ++ccc) {
            if (c < ccc * 3) break;
            for (int cca=0; cca<1001; ++cca) {
                if (c < ccc * 3 + cca * 2 || a < cca) break;
                team = max(team, ccc + cca + min(c - ccc * 3 - cca * 2, min(a - cca, n)));
            }
        }
        cout << team << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1164
final_rank: 2

code_snippet: #include<iostream>
#include<algorithm>

using namespace std;

int q, n, a, b, c;

int solve(int c, int a, int n){
	int res = 0;
	for(int i = 0;i <= 1080;i++){
		for(int j = 0;j <= 1080;j++){
			int tc = c - i - 2 * j;
			int ta = a - i - j;
			int tn = n - i;
			if(tc >= 0 && ta >= 0 && tn >= 0){
				res = max(res, i + j + tc / 3);
			}
		}
	}
	return res;
}

int main(){
	cin >> q;
	for(int i = 0;i < q;i++){
		cin >> c >> a >> n;
		cout << solve(c, a, n) << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 90
memory_kb: 1160
final_rank: 4

code_snippet: #include <string> 
#include <algorithm> 
#include <cfloat> 
#include <climits> 
#include <cmath> 
#include <complex> 
#include <cstdio> 
#include <cstdlib> 
#include <cstring> 
#include <functional> 
#include <iostream> 
#include <map> 
#include <memory> 
#include <queue> 
#include <set> 
#include <sstream> 
#include <stack> 
#include <utility> 
#include <vector> 

#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define ALL(x) (x).begin(),(x).end() 
using namespace std; 
typedef long long ll;
const double eps = 1e-10;

int main(){
    int Q;
    cin >> Q;
    for(int _=0;_<Q;++_){
        int c, a, n;
        cin >> c >> a >> n;
        int res = 0;
        for(int i = 0; i <= c / 3; ++i){
            for(int j = 0; j <= min((c - i * 3) / 2, a); ++j){
                res = max(res, i + j + min(c-i*3-j*2, min(a-j, n)));
            }
        }
        cout << res << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1160
final_rank: 1

code_snippet: #include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <complex>
#include <string>
#include <sstream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define SORT(x) sort((x).begin(),(x).end())
#define all(x) (x).begin(),(x).end()
#define EQ(a,b) (abs((a)-(b))<eps)
int cnt(int c,int a)
{
	int mx=0;
	for(int i=0;i<=min(a,c/2);i++)mx=max(mx,i+(c-2*i)/3);
	return mx;
}
void solve(int c,int a,int n)
{
	int ans=0;
	for(int i=0;i<=min(n,min(a,c));i++)ans=max(ans,i+cnt(c-i,a-i));
	printf("%d\n",ans);
	return;
}
int main()
{
	int Q;
	scanf("%d",&Q);
	for(int i=0;i<Q;i++)
	{
		int c,a,n;
		scanf("%d %d %d",&c,&a,&n);
		solve(c,a,n);
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1188
final_rank: 3

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>

using namespace std;

#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int*)a, (int*)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10

typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;

int Q;
int dp[64][64][64];

int dfs(int c, int a, int n){
  if(dp[c][a][n] >= 0) return dp[c][a][n];
  int res = 0;
  if(c > 0 && a > 0 && n > 0) res = max(res, dfs(c-1, a-1, n-1)+1);
  if(c > 1 && a > 0) res = max(res, dfs(c-2, a-1, n)+1);
  if(c > 2) res = max(res, dfs(c-3, a, n)+1);
  return dp[c][a][n] = res;
}

int main(){
  cin >> Q;
  rep(i, Q){
    memset(dp, -1, sizeof(dp));
    int c, a, n;
    cin >> c >> a >> n;
    int res = 0;
    while(c > 8 && a > 4 && n > 0){
      res++;
      c--;
      a--;
      n--;
    }

    while(c > 8 && a > 4){
      res++;
      c-=2;
      a--;
    }

    while(c > 8){
      res++;
      c-=3;
    }
    res += dfs(c, a, n);
    printf("%d\n", res);
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 2176
final_rank: 5

code_snippet: #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>

using namespace std;

#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int*)a, (int*)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10

typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;

int Q;
int dp[64][64][64];

int dfs(int c, int a, int n){
  if(dp[c][a][n] >= 0) return dp[c][a][n];
  int res = 0;
  if(c > 0 && a > 0 && n > 0) res = max(res, dfs(c-1, a-1, n-1)+1);
  if(c > 1 && a > 0) res = max(res, dfs(c-2, a-1, n)+1);
  if(c > 2) res = max(res, dfs(c-3, a, n)+1);
  return dp[c][a][n] = res;
}

int main(){
  cin >> Q;
  rep(i, Q){
    memset(dp, -1, sizeof(dp));
    int c, a, n;
    cin >> c >> a >> n;
    int res = 0;
    while(c > 5 && a > 3 && n > 0){
      res++;
      c--;
      a--;
      n--;
    }

    while(c > 5 && a > 3){
      res++;
      c-=2;
      a--;
    }

    while(c > 5){
      res++;
      c-=3;
    }
    res += dfs(c, a, n);
    printf("%d\n", res);
  }
  return 0;
}
accuracy: 0.375
time_ms: 10
memory_kb: 2176
final_rank: 20