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

int n;
vector<long long> weights;

// 递归函数：处理第index个苹果，返回最小重量差
ll recurse_apples(int index, ll sum1, ll sum2) {
    // 终止条件：所有苹果处理完毕
    if (index == n) {
        return abs(sum1 - sum2);
    }
    // 递归两种选择：当前苹果放入sum1或sum2，取最小值
    ll option1 = recurse_apples(index + 1, sum1 + weights[index], sum2);
    ll option2 = recurse_apples(index + 1, sum1, sum2 + weights[index]);
    return min(option1, option2);
}

int main() {
    cin >> n;
    weights.resize(n);
    for (ll &w : weights) {
        cin >> w;
    }
    // 初始调用：从第0个苹果开始，两组重量均为0
    cout << recurse_apples(0, 0, 0) << endl;
    return 0;
}

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

int main() {
    int n;
    cin >> n;
    vector<ll> weights(n);
    for (ll &w : weights) {
        cin >> w;
    }

    ll total = accumulate(weights.begin(), weights.end(), 0LL);
    ll min_diff = LLONG_MAX;

    // 遍历所有掩码（0到2^n - 1）
    for (int mask = 0; mask < (1 << n); ++mask) {
        ll sum1 = 0;
        // 计算当前掩码对应的s1重量和
        for (int i = 0; i < n; ++i) {
            if (mask & (1 << i)) {
                sum1 += weights[i];
            }
        }
        ll sum2 = total - sum1;
        min_diff = min(min_diff, abs(sum1 - sum2));
    }

    cout << min_diff << endl;
    return 0;
}

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

string s;
vector<string> perms;
int char_count[26] = {0}; // 记录每个字符的剩余数量

// 递归函数：构建当前排列curr
void search(const string &curr = "") {
    // 终止条件：当前排列完成
    if (curr.size() == s.size()) {
        perms.push_back(curr);
        return;
    }
    // 遍历所有可能的字符
    for (int c = 0; c < 26; ++c) {
        if (char_count[c] > 0) {
            // 选择当前字符
            char_count[c]--;
            search(curr + (char)('a' + c));
            // 回溯：恢复字符数量
            char_count[c]++;
        }
    }
}

int main() {
    cin >> s;
    // 初始化字符计数
    for (char ch : s) {
        char_count[ch - 'a']++;
    }
    // 递归生成所有排列
    search();
    // 输出结果（已按字典序，因递归时按a-z顺序选择字符）
    for (const string &p : perms) {
        cout << p << endl;
    }
    return 0;
}

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

int main() {
    string s;
    cin >> s;
    sort(s.begin(), s.end()); // 排序，确保从最小字典序开始
    vector<string> perms;

    do {
        perms.push_back(s); // 处理当前排列
    } while (next_permutation(s.begin(), s.end())); // 生成下一个排列

    // 输出所有排列（已去重，因next_permutation自动跳过重复）
    for (const string &p : perms) {
        cout << p << endl;
    }
    return 0;
}

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

const int DIM = 8;
vector<vector<bool>> blocked(DIM, vector<bool>(DIM)); // 标记障碍格子

// 检查排列是否合法（皇后不共对角线，且不在障碍格）
bool is_valid(const vector<int> &perm) {
    unordered_set<int> diag1, diag2; // 记录已使用的对角线
    for (int col = 0; col < DIM; ++col) {
        int row = perm[col];
        // 检查障碍
        if (blocked[row][col]) return false;
        // 检查对角线
        int d1 = row + col;
        int d2 = row - col;
        if (diag1.count(d1) || diag2.count(d2)) return false;
        diag1.insert(d1);
        diag2.insert(d2);
    }
    return true;
}

int main() {
    // 读取障碍格子（'*'表示障碍）
    for (int r = 0; r < DIM; ++r) {
        string row;
        cin >> row;
        for (int c = 0; c < DIM; ++c) {
            blocked[r][c] = (row[c] == '*');
        }
    }

    // 初始化排列：perm[col] = row（0~7）
    vector<int> perm(DIM);
    iota(perm.begin(), perm.end(), 0); // 初始为[0,1,2,...,7]

    int count = 0;
    // 遍历所有排列
    do {
        if (is_valid(perm)) {
            count++;
        }
    } while (next_permutation(perm.begin(), perm.end()));

    cout << count << endl;
    return 0;
}

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

const int DIM = 8;
vector<vector<bool>> blocked(DIM, vector<bool>(DIM));
vector<bool> rows_taken(DIM, false);          // 标记行是否被占用
vector<bool> diag1(2 * DIM - 1, false);       // 左下到右上对角线（row+col）
vector<bool> diag2(2 * DIM - 1, false);       // 右下到左上对角线（row-col + DIM-1）
int count = 0;                                 // 合法方案数

// 回溯函数：处理第col列
void backtrack(int col) {
    // 终止条件：所有列已处理
    if (col == DIM) {
        count++;
        return;
    }
    // 尝试在当前列的每一行放置皇后
    for (int row = 0; row < DIM; ++row) {
        // 检查合法性：不在障碍格、行未占、对角线未占
        if (blocked[row][col]) continue;
        int d1 = row + col;
        int d2 = row - col + DIM - 1; // 调整为非负索引
        if (rows_taken[row] || diag1[d1] || diag2[d2]) continue;

        // 放置皇后，更新状态
        rows_taken[row] = true;
        diag1[d1] = true;
        diag2[d2] = true;

        // 递归处理下一列
        backtrack(col + 1);

        // 回溯：恢复状态
        rows_taken[row] = false;
        diag1[d1] = false;
        diag2[d2] = false;
    }
}

int main() {
    // 读取障碍格子
    for (int r = 0; r < DIM; ++r) {
        string row;
        cin >> row;
        for (int c = 0; c < DIM; ++c) {
            blocked[r][c] = (row[c] == '*');
        }
    }
    // 从第0列开始回溯
    backtrack(0);
    cout << count << endl;
    return 0;
}