#include <bits/stdc++.h>
using namespace std;
 
int N, L, D;
vector<int> arr;
unordered_map<int, bool> dp; // memo for global DFS (key = used indices mask)
 
// Global DFS: try to partition the sorted array (of size N) into groups of size L with common difference D.
// mask: bitmask of indices already used.
bool dfs(int mask);
 
// Helper: given a fixed "base" (the smallest unused index in the current DFS call)
// and a candidate list (indices > base and unused), recursively choose L-1 indices 
// to form a block with min = arr[base] and max = arr[base] + D.
// pos: current index in candidate vector to consider
// r: how many indices still need to be chosen
// found: whether we have already chosen an element equal to arr[base] + D
// currentSet: bitmask (with respect to global indices) of the candidates chosen so far.
bool chooseCombination(const vector<int> &candidates, int pos, int r, bool found, int currentSet, int base, int curMask) {
    // If we have chosen enough indices, check that the block has the required max and try DFS on the new mask.
    if(r == 0) {
        if(!found) return false; // must have at least one candidate equal to arr[base] + D
        int newMask = curMask | (1 << base) | currentSet;
        if(dfs(newMask))
            return true;
        return false;
    }
    // Prune: if there are not enough remaining candidates
    if(pos >= (int)candidates.size())
        return false;
    // Also, if we haven't found an element equal to arr[base]+D, check if any candidate in the remaining list can supply that.
    bool canFindMax = found;
    for (int i = pos; i < (int)candidates.size(); i++) {
        if(arr[candidates[i]] == arr[base] + D) { canFindMax = true; break; }
    }
    if(!canFindMax) return false;
    
    // Option 1: pick the candidate at pos.
    int idx = candidates[pos];
    bool newFound = found || (arr[idx] == arr[base] + D);
    if(chooseCombination(candidates, pos + 1, r - 1, newFound, currentSet | (1 << idx), base, curMask))
        return true;
    // Option 2: skip the candidate at pos.
    if(chooseCombination(candidates, pos + 1, r, found, currentSet, base, curMask))
        return true;
    
    return false;
}
 
bool dfs(int mask) {
    if(mask == (1 << N) - 1) return true; // all indices used
    if(dp.count(mask))
        return dp[mask];
    
    // Choose the smallest unused index as the base for the next block.
    int base = 0;
    while(mask & (1 << base)) base++;
    
    // Gather candidate indices (all unused indices > base).
    vector<int> candidates;
    for (int i = base + 1; i < N; i++) {
        if(!(mask & (1 << i)))
            candidates.push_back(i);
    }
    
    bool possible = false;
    if(L == 2) {
        // For blocks of size 2, simply try pairing base with some candidate j that gives the required diff.
        for (int j : candidates) {
            if(arr[j] - arr[base] == D) {
                int newMask = mask | (1 << base) | (1 << j);
                if(dfs(newMask)) {
                    possible = true;
                    break;
                }
            }
        }
    } else {
        // For blocks of size > 2, choose L-1 candidates from "candidates" such that one of them equals arr[base]+D.
        possible = chooseCombination(candidates, 0, L - 1, false, 0, base, mask);
    }
    
    dp[mask] = possible;
    return possible;
}
 
// Function to compute the maximum number of blocks into which the array can be partitioned.
int maxBlocks(vector<int>& inputArr) {
    N = inputArr.size();
    arr = inputArr;
    sort(arr.begin(), arr.end());
    
    // Precompute candidate differences D (from any pair) plus 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; // worst-case: entire array is one block.
    // Try candidate k (number of blocks) from highest possible (N/2) down to 2.
    for (int k = N/2; k >= 2; k--) {
        if(N % k != 0) continue; // blocks must be of equal length
        L = N / k;
        // For each candidate difference, attempt to partition.
        for (int d : diffs) {
            D = d;
            dp.clear();
            if(dfs(0)) {
                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;
}