F. Fairness minimum maximum difference pennies

F. Fairness

time limit per test

2.0 s

memory limit per test

64 MB

input

standard input

output

standard output

Dwik and his brother Samir both received scholarships from a famous university in India. Their father, Besher, wants to send some money with each of them.

Besher has n coins, the ith coin has a value of ai. He will distribute these coins between his two sons in n steps. In the ith step, he chooses whether to give the ith coin to Dwik or to Samir.

Let xi be the absolute difference between the sum of Dwik's and Samir's coins after the ith step. The unfairness factor of a distribution is max({x1, x2, ..., xn}). Besher wants to minimize the unfairness factor, can you help him?

Input

The first line of the input consists of a single integer t, the number of test cases. Each test case consists of 2 lines:

The first line contains an integer n (1 ≤ n ≤ 100).

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100).

Output

Print t lines, ith line containing a single integer, the answer to the ith test case.

Example

input

Copy

2
5
1 2 1 4 3
7
4 5 6 1 1 3 4

output

Copy

2
5

Note

In the first sample test, besher has 5 coins (1, 2, 1, 4, 3), he can distribute them in the following way:

Step 1: Give the first coin to dwik , d = 1, s = 0  x1 = |1 - 0| = 1

Step 2: Give the second coin to samir, d = 1, s = 2  x2 = |1 - 2| = 1

Step 3: Give the third coin to samir, d = 1, s = 3  x3 = |1 - 3| = 2

Step 4: Give the fourth coin to dwik, d = 5, s = 3  x4 = |5 - 3| = 2

Step 5: Give the fifth coin to samir, d = 5, s = 6  x5 = |5 - 6| = 1

max({x1, x2, x3, x4, x5}) = 2

 

The meaning of problems: n coins to the points a, b two people, one coin per minute for a, b as a difference between the current number of coins, after completion points, taking the maximum difference in the distribution process to the final value. Q. In all allocation method, the minimum value of the final number

 

Solution: the amount of data, search violence each allocation method, the biggest difference is determined for each allocation method, taking the minimum weight

 

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<vector>
#include<stack>
#include<math.h>
#define mod 998244353
#define ll long long
#define MAX 0x3f3f3f3f
using namespace std;
int p[105];
int n,t,mx;
void dfs(int a,int b,int k,int now)
{
    if(K> = n-) // target state, the maximum difference in partial update process coin 
    { 
        MX = now;
         return ; 
    } 
    IF (now> = MX) // if it is more than the maximum difference value of one kind of coin-points large, returns, for a points 
    {
         return ; 
    } 
    the else 
    { 
        IF (ABS (ab &)> now) // update the current difference 
            now = ABS (ab & ); 
        DFS (A + P [K], B, + K . 1 , now); 
        DFS (A, B + P [K], K + . 1 , now); 
    } 

} 
int main () 
{ 
    CIN >> T;
     the while(T-- ) 
    { 
        MX = 99999 ; 
        CIN >> n-;
         for ( int I = 0 ; I <n-; I ++ ) 
            CIN >> P [I]; 
        DFS (P [ 0 ], 0 , . 1 , 0 ); // the first to give poor who are the same 
        cout << MX << endl; 
    } 
}