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

int N, L, D;
vector<int> arr;
int fullMask;
unordered_map<int, bool> dp; // memoization for DFS by used-indices mask

// DFS: given a bitmask 'mask' (with bits=1 for used indices),
// try to partition the remaining indices into blocks (each of size L and with max-min == D).
bool dfs(int mask) {
    if(mask == fullMask) return true;
    if(dp.count(mask)) return dp[mask];
    
    // Find the smallest unused index: this will serve as the block's minimum.
    int base = 0;
    while(mask & (1 << base)) base++;
    
    // Gather candidates (unused indices greater than base)
    vector<int> cand;
    for (int i = base + 1; i < N; i++) {
        if(!(mask & (1 << i)))
            cand.push_back(i);
    }
    // If we cannot choose enough indices to form a block, fail.
    if(cand.size() < (size_t)(L - 1)) {
        dp[mask] = false;
        return false;
    }
    
    // For a valid block, one of the chosen indices must hold the value: arr[base] + D.
    bool hasNeeded = false;
    for (int idx : cand) {
        if(arr[idx] == arr[base] + D) { hasNeeded = true; break; }
    }
    if(!hasNeeded) {
        dp[mask] = false;
        return false;
    }
    
    // If block size is 2, we just need one partner such that diff equals D.
    if(L == 2) {
        for (int idx : cand) {
            if(arr[idx] - arr[base] == D) {
                int newMask = mask | (1 << base) | (1 << idx);
                if(dfs(newMask))
                {
                    dp[mask] = true;
                    return true;
                }
            }
        }
        dp[mask] = false;
        return false;
    }
    
    // For L > 2, we need to choose (L - 1) indices from cand.
    vector<int> comb; // store chosen indices (they will be in increasing order, and so are in non-decreasing order by value)
    
    // Recursive function to choose r indices from cand starting at position idx.
    function<bool(int, int)> rec = [&](int idx, int r) -> bool {
        if(r == 0) {
            // Check if the maximum in the block is exactly arr[base] + D.
            // Because cand (and comb) are in increasing order (and arr is sorted),
            // the last chosen index gives the block maximum.
            if(arr[comb.back()] == arr[base] + D) {
                int newMask = mask | (1 << base);
                for (int j : comb)
                    newMask |= (1 << j);
                if(dfs(newMask))
                    return true;
            }
            return false;
        }
        // Not enough candidates left.
        if((int)cand.size() - idx < r) return false;
        
        // Pruning: if the maximum available candidate in the remainder is less than arr[base] + D, no need to continue.
        if(arr[cand.back()] < arr[base] + D)
            return false;
        
        // Try picking some candidates.
        for (int i = idx; i < (int)cand.size(); i++) {
            comb.push_back(cand[i]);
            if(rec(i+1, r-1))
                return true;
            comb.pop_back();
        }
        return false;
    };
    
    bool possible = rec(0, L - 1);
    dp[mask] = possible;
    return possible;
}
 
// For a given candidate block count k (with L = N/k) and candidate difference D,
// try to partition the sorted array. Returns true if possible.
bool canPartition(int L_val, int diff) {
    L = L_val;
    D = diff;
    dp.clear();
    return dfs(0);
}
 
// Main function: try candidate k (number of blocks) from maximum down to 2.
// If none works, return 1 (the whole array as one block).
int maxBlocks(vector<int>& inputArr) {
    N = inputArr.size();
    arr = inputArr;
    sort(arr.begin(), arr.end());
    fullMask = (1 << N) - 1;
    
    // Precompute candidate differences from any pair (and add 0).
    set<int> diffs;
    for (int i = 0; i < N; i++){
        for (int j = i+1; j < N; j++){
            diffs.insert(arr[j] - arr[i]);
        }
    }
    diffs.insert(0);
    
    int best = 1; // at worst, the whole array is one block.
    // Try candidate k (number of blocks) from highest possible (i.e. when block size L is smallest) down to 2.
    for (int k = N/2; k >= 2; k--) {
        if(N % k != 0) continue;  // blocks must be of equal size
        int L_val = N / k;
        // Try each candidate difference.
        for (int d : diffs) {
            if(canPartition(L_val, d))
                return k;
        }
    }
    return best;
}
 
int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int T;
    cin >> T;
    while(T--){
        int n;
        cin >> n;
        vector<int> arrInput(n);
        for (int i = 0; i < n; i++){
            cin >> arrInput[i];
        }
        cout << maxBlocks(arrInput) << "\n";
    }
    
    return 0;
}