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

vector<vector<vector<int>>> generate_half(const vector<int>& R) {
    int n = R.size();
    vector<vector<vector<int>>> dp(21, vector<vector<int>>(21, vector<int>()));
    dp[0][0].push_back(0);
    
    for(auto r : R){
        for(int s_red = 20; s_red >=0; s_red--){
            for(int s_blue = 20; s_blue >=0; s_blue--){
                if(dp[s_red][s_blue].empty()) continue;
               
                if(s_red <20){
                    for(auto sum_diff : dp[s_red][s_blue]){
                        dp[s_red+1][s_blue].push_back(sum_diff + r);
                    }
                }
                
                if(s_blue <20){
                    for(auto sum_diff : dp[s_red][s_blue]){
                        dp[s_red][s_blue+1].push_back(sum_diff - r);
                    }
                }
            }
        }
    }
    
    for(int s_red=0; s_red<=20; s_red++){
        for(int s_blue=0; s_blue<=20; s_blue++){
            if(dp[s_red][s_blue].empty()) continue;
            sort(dp[s_red][s_blue].begin(), dp[s_red][s_blue].end());
            dp[s_red][s_blue].erase(unique(dp[s_red][s_blue].begin(), dp[s_red][s_blue].end()), dp[s_red][s_blue].end());
        }
    }
    
    return dp;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int N;
    cin >> N;
    vector<int> R(N);
    for(auto &x : R) cin >> x;
   
    int mid = N /2;
    vector<int> A(R.begin(), R.begin()+mid);
    vector<int> B(R.begin()+mid, R.end());
   
    vector<vector<vector<int>>> dp_A = generate_half(A);
    vector<vector<vector<int>>> dp_B = generate_half(B);
    
    int min_diff = INT32_MAX;
   
    for(int k=1; k <= min(20, N/2); k++){
        for(int s_red_a=0; s_red_a <=k; s_red_a++){
            int s_blue_a = k - s_red_a;
            if(s_blue_a <0 || s_blue_a > (int)A.size()) continue;
            
            int s_red_b = k - s_red_a;
            int s_blue_b = k - s_blue_a;
            if(s_red_b <0 || s_blue_b <0 || s_red_b > (int)B.size() || s_blue_b > (int)B.size()) continue;
           
            for(auto sum_diff_a : dp_A[s_red_a][s_blue_a]){
                const vector<int>& vec = dp_B[s_red_b][s_blue_b];
                if(vec.empty()) continue;
               
                int target = -sum_diff_a;
                auto it = lower_bound(vec.begin(), vec.end(), target);
                if(it != vec.end()){
                    int sum_diff_b = *it;
                    min_diff = min(min_diff, abs(sum_diff_a + sum_diff_b));
                }
                if(it != vec.begin()){
                    it--;
                    int sum_diff_b = *it;
                    min_diff = min(min_diff, abs(sum_diff_a + sum_diff_b));
                }
            }
        }
    }
    
    cout << min_diff << "\n";
}