//
// Created by Barichek on 22.07.2023 11:22:46
//

#include <bits/stdc++.h>

#define F first
#define S second
#define MP make_pair
#define PB push_back

#define all(a) a.begin(), a.end()
#define len(a) (int) (a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

#ifdef Energy_is_not_over
#define DEBUG for (bool ____DEBUG = true; ____DEBUG; ____DEBUG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl

template<class ...Ts>
auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }

#else
#define DEBUG while (false)
#define LOG(...)
#endif

const int max_n = 1e5+10, inf = 1000111222;

struct segment_tree {
    struct node{
        int node_size;
        bool can_merge_with_right;
        array<array<int,2>,2> dp;
    };

    int rem_a[max_n];
    node mx[4*max_n];

    node merge(node l,node r,int mid)
    {
        node res;
        res.node_size=l.node_size+r.node_size;
        res.can_merge_with_right=r.can_merge_with_right;
        for (int i=0;i<2;i++){
            for (int j=0;j<2;j++){
                res.dp[i][j]=2*inf;
            }
        }
        for (int l_i=0;l_i<2;l_i++){
            for (int l_j=0;l_j<2;l_j++){
//                LOG(l_i,l_j);
                if (l.dp[l_i][l_j]==2*inf){
                    continue;
                }
                for (int r_i=0;r_i<2;r_i++){
                    for (int r_j=0;r_j<2;r_j++){
                        if (r.dp[r_i][r_j]==2*inf){
                            continue;
                        }
//                        LOG(r_i,r_j);
                        if (l.node_size==1 || r.node_size==1){
                            for (int is_merge=0;is_merge<=1;is_merge++){
                                if (!l.can_merge_with_right && is_merge){
                                    continue;
                                }
                                if (l.node_size!=1 && l_j==0 && !is_merge){
                                    continue;
                                }
                                if (r.node_size!=1 && r_i==0 && !is_merge){
                                    continue;
                                }
                                if ((l_j==1 || r_i==1) && is_merge){
                                    continue;
                                }

                                int cur_value = max({l.dp[l_i][l_j],r.dp[r_i][r_j],is_merge==0?-2*inf:rem_a[mid]+rem_a[mid+1]});
                                int new_L=l_i,new_R=r_j;
                                if (is_merge && l.node_size==1){
                                    new_L=1;
                                }
                                if (is_merge && r.node_size==1){
                                    new_R=1;
                                }

                                LOG(new_L,new_R,cur_value,l_i,l_j,r_i,r_j,is_merge);
                                res.dp[new_L][new_R]=min(res.dp[new_L][new_R],cur_value);
                            }
                        }
                        else{
                            if (l_j==0 && !l.can_merge_with_right){
                                continue;
                            }
                            if (l_j!=r_i){
                                continue;
                            }

                            int cur_value = max({l.dp[l_i][l_j],r.dp[r_i][r_j],l_j==1?-2*inf:rem_a[mid]+rem_a[mid+1]});
                            int new_L=l_i,new_R=r_j;

//                            LOG(new_L,new_R);
                            res.dp[new_L][new_R]=min(res.dp[new_L][new_R],cur_value);
                        }
                    }
                }
            }
        }
        return res;
    }

    void build(int v, int l, int r, int a[]) {
        if (l == r) {
            rem_a[l]=a[l];

            mx[v].node_size=1;
            mx[v].can_merge_with_right=1;
            for (int i=0;i<2;i++){
                for (int j=0;j<2;j++){
                    mx[v].dp[i][j]=2*inf;
                }
            }
            mx[v].dp[0][0]=-2*inf;
            mx[v].dp[1][1]=a[l];
            return;
        }
        int mid = (l + r) / 2;
        build(2 * v, l, mid, a);
        build(2 * v + 1, mid + 1, r, a);
        mx[v] = merge(mx[2 * v], mx[2 * v + 1], mid);
    }

    void forbit_one_element(int v, int l, int r, int pos) {
        if (l == r) {
            mx[v].dp[1][1]=2*inf;
            return;
        }
        int mid = (l + r) / 2;
        LOG("previously",l,r,mx[v].dp[1][1]);
        if (pos <= mid) {
            forbit_one_element(2 * v, l, mid, pos);
        } else {
            forbit_one_element(2 * v + 1, mid + 1, r, pos);
        }
        mx[v] = merge(mx[2 * v], mx[2 * v + 1], mid);
        LOG("currently",l,r,mx[v].dp[1][1]);
    }

    void forbit_two_elements(int v, int l, int r, int pos) {
        if (l == r) {
            mx[v].can_merge_with_right=0;
            return;
        }
        int mid = (l + r) / 2;
        LOG("previously",l,r,mx[v].dp[1][1]);
        if (pos <= mid) {
            forbit_two_elements(2 * v, l, mid, pos);
        } else {
            forbit_two_elements(2 * v + 1, mid + 1, r, pos);
        }
        mx[v] = merge(mx[2 * v], mx[2 * v + 1], mid);
        LOG("currently",l,r,mx[v].dp[1][1]);
    }

    node get_max(int v, int tl, int tr, int l, int r) {
        if (tl == l && tr == r) {
            return mx[v];
        }
        int mid = (tl + tr) / 2;
        if (r <= mid) {
            return get_max(2 * v, tl, mid, l, r);
        } else if (l > mid) {
            return get_max(2 * v + 1, mid + 1, tr, l, r);
        }
        return merge(get_max(2 * v, tl, mid, l, mid), get_max(2 * v + 1, mid + 1, tr, mid + 1, r), mid);
    }
};

segment_tree st;

int a[max_n];

const bool gen=0;
mt19937 rnd(4747474);

void solve()
{
    int n;
    if (gen){
        n=1e5;
        for (int i=0;i<n;i++){
            a[i]=rnd()%(int(1e9));
        }
    }
    else{
        cin>>n;
        for (int i=0;i<n;i++){
            cin>>a[i];
        }
    }
    vector<pair<int,pair<int,bool>>> vh;
    for (int i=0;i<n;i++){
        vh.pb(mp(a[i],mp(i,0)));
        if (i+1<n){
            vh.pb(mp(a[i]+a[i+1],mp(i,1)));
        }
    }
    sort(all(vh));

    st.build(1,0,n-1,a);
    ll answer=1e18;
    for (auto qq:vh){
        LOG(qq.fir,qq.sec.fir,qq.sec.sec);
        if (qq.sec.sec==0){
            LOG("st.forbit_one_element",qq.sec.fir);
            st.forbit_one_element(1,0,n-1,qq.sec.fir);
        }
        else{
            LOG("st.forbit_two_elements",qq.sec.fir);
            st.forbit_two_elements(1,0,n-1,qq.sec.fir);
        }

        LOG("forbids finished");

        int base_sum=a[qq.sec.fir]+(qq.sec.sec?a[qq.sec.fir+1]:0);
        int ans=base_sum;
        int L=qq.sec.fir,R=qq.sec.fir+(qq.sec.sec?1:0);
        if (L!=0){
            LOG("st.get_max L");
            ans=max(ans,st.get_max(1,0,n-1,0,L-1).dp[1][1]);
            LOG("st.get_max L finished");
        }
        if (R!=n-1){
            LOG("st.get_max R");
            ans=max(ans,st.get_max(1,0,n-1,R+1,n-1).dp[1][1]);
            LOG("st.get_max R finished");
        }
        LOG(ans,base_sum);
        if (ans!=2*inf){
            answer=min(answer,ll(ans)-ll(base_sum));
        }
    }

    cout<<answer<<"\n";
}

int main() {
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int tests;
    if (gen){
        tests=10;
    }
    else{
        cin>>tests;
    }
    while (tests--){
        solve();
    }
    return 0;
}