Go: package main

import "fmt"

func main() {
	ans := make([]int, 0)
	for {
		var n int
		fmt.Scan(&n)
		if n == 0 {
			break
		}
		a := make([]int, n)
		for i := range a {
			fmt.Scan(&a[i])
		}
		mind := int(1e9)
		for bits := 0; bits < (1 << uint(n)); bits++ {
			gsum, psum := 0, 0
			for j := 0; j < n; j++ {
				if (bits & (1 << uint(j))) != 0 {
					gsum += a[j]
				} else {
					psum += a[j]
				}
			}
			mind = min(mind, abs(gsum-psum))
		}
		ans = append(ans, mind)
	}
	for i := range ans {
		fmt.Println(ans[i])
	}
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

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

#define PI 4*atan(1)
#define INF 1e8

typedef long long ll;

int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};

int main(){
  int n;
  while(cin >> n, n){
    vector<ll> a(n);
    for(int i = 0; i < n; i++)cin >> a[i];
    sort(a.begin(), a.end(), greater<ll>());
    ll pon = 0, gon = 0;
    for(auto p : a){
      if(pon >= gon)gon += p;
      else pon += p;
    }
    cout << abs(pon - gon) << endl;
  }
}

C++: #define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>

using namespace std;

typedef long long ll;
typedef pair <int,int> P;

static const double EPS = 1e-8;

int main(){
	int n;
	while(~scanf("%d",&n)){
		if(n==0) break;

		int atk[20];
		for(int i=0;i<n;i++){
			scanf("%d",atk+i);
		}

		int diff=numeric_limits<int>::max();
		for(int S=0;S<=(1<<n)-1;S++){
			int sumA=0;
			int sumB=0;
			for(int i=0;i<n;i++){
				if(S & (1<<i)) sumA+=atk[i];
				else sumB+=atk[i];
			}
			diff = min(diff,abs(sumA-sumB));
		}

		printf("%d\n",diff);
	}
}

C++: //Name: Split Up!
//Level: 3
//Category: 全探索,DP
//Note:

/*
 * 全ての選び方を試す．
 * このとき，ある選び方が2進数 pat で与えられているとき，これに対する攻撃力の合計値は
 * patのビットをどれか1つ落としたときの合計値に，落としたビットに対応する攻撃力を加えたものとなる．
 * このとき，パターンを2進数で昇順に試していけばビットを1つ落としたパターンは必ず pat より前に試しているので，
 * これらの値を記憶しておくことで簡単に計算できるようになる．
 *
 * 落とすビットはどれでもよいが，最下位ビットが pat&(-pat) で得られるのでここではこれを使っている．
 *
 * オーダーは O(2^N)．
 * 愚直に各パターンについて合計値を求めると O(N*2^N) であるから高速化されている．
 */
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int arr[20];
int pos_of[1<<20];
int main() {
    cin.tie(0);
    ios::sync_with_stdio(0);
    for(int i = 0; i < 20; ++i) pos_of[1<<i] = i;
    while(true) {
        int N;
        cin >> N;
        if(!N) break;

        int sum = 0;
        for(int i = 0; i < N; ++i) {
            cin >> arr[i];
            sum += arr[i];
        }
        int ans = 100000000;
        vector<int> memo(1<<N, 0);
        for(int pat = 1; pat < (1<<N); ++pat) {
            const int prev = pat&~(pat&-pat);
            const int suma = memo[prev] + arr[pos_of[pat&-pat]];
            const int sumb = sum - suma;
            ans = min(ans, abs(suma-sumb));
            memo[pat] = suma;
        }
        cout << ans << endl;
    }
    return 0;
}

C++: #include <iostream>
#include <string>
#include <algorithm>
#include <set>
#include <vector>
#include <cstring>
#include <climits>
#include <queue>
#include <map>
#include <sstream>
using namespace std;

#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define EPS 1e-9

int main(){
	int n;
	int data[21];
	while(cin>>n,n){
		int ret = INT_MAX;
		rep(i,n)cin>>data[i];
		rep(i,(1<<n)/2+1){
			int a=0,b=0;
			for(int j=0; j<n; j++){
				if( i&(1<<j) ){
					a += data[j];
				}else{
					b += data[j];
				}
			}
			ret = min(ret, abs(a-b));
		}
		printf("%d\n",ret);
	}
	return 0;
}

C++: #include <iostream>
#include <queue>
#define abs(a) ((a)>0 ? (a) : -(a))

using namespace std;

long diffmin,n,p[20];
void dfs(int layer, long a, long b){
	if (layer < n){
		dfs(layer + 1, a + p[layer], b);
		dfs(layer + 1, a, b + p[layer]);
	} else {
		if (diffmin > abs(a - b)){
			diffmin = abs(a - b);
		}
		return;
	}
}
int main(){
	long all = 0, party0 = 0, party1 = 0;
	cin >> n;
	while (n){
		for (int i = 0; i < n; i++){
			long input;
			cin >> input;
			p[i] = input;
			all += input;
		}
		diffmin = all;
		dfs(0, 0, 0);
		cout << diffmin;
		cin >> n;
		party0 = party1 = 0;
		all = 0;
	}
	return 0;
}

C++: #include<iostream>
using namespace std;
void check(int x);
int a[20];
int b,c;
int n;
int least = 1000000;
int main(){

    while(cin>>n,n){
        least = 1000000;
        for(int i=0;i<n;i++){
            cin>>a[i];
        }
        check(0);
        cout<<least<<endl;
    }

    return 0;
}
void check(int x){
    if(x==n){
        int an = b - c;
        if(an<0)an*=-1;
        if(an<least)least = an;
        return;
    }
    b+=a[x];
    check(x+1);
    b-=a[x];
    c+=a[x];
    check(x+1);
    c-=a[x];

}

C++: #include<iostream>
#include<climits>
#include<cstdlib>
using namespace std;
int main()
{
  int n,a[20],sum,min,i,j;
  while(cin>>n,n){
    sum=0;
    for(i=0;i<n;i++){
      cin>>a[i];
      sum+=a[i];
    }
    min=INT_MAX;
    for(i=(1<<n)-1;i>=0;i--){
      int s=0;
      for(j=0;j<n;j++)if(i&(1<<j))s+=a[j];
      if(min>abs(sum-s-s))min=abs(sum-s-s);
    }
    cout<<min<<endl;
  }
}

C++: #include <iostream>
#include <algorithm>
#include <cassert>
#include <cctype>
#include <complex>
#include <cstdio>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;

int n,p[20],s[1<<20];

int main(){
	while(cin>>n){
		if(!n)return 0;
		fill(s,s+(1<<n),0);
		int sum=0;
		for(int i=0;i<n;i++){cin>>p[i];sum+=p[i];}
		for(int i=0;i<1<<n;i++){
			for(int j=0;j<n;j++)if((i/(1<<j))%2)s[i]+=p[j];
		}
		sort(s,s+(1<<n));
		int dif=1e+9;
		for(int i=0;i<1<<n;i++)dif=min(dif,abs(s[i]*2-sum));
		cout<<dif<<endl;
	}
}

C++: #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <functional>
#include <queue>
#include <set>
#include <map>
#include <numeric>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cctype>
#include <sstream>

#define rep(i, a) REP(i, 0, a)
#define REP(i, a, b) for(int i = a; i < b; ++i)
#define repll(i, a) REPLL(i, 0, a)
#define REPLL(i, a, b) for(ll i = a; i < b; ++i)

typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> P;
typedef std::pair<P, int> PP;
const double PI = 3.14159265358979323846;
const double esp = 1e-9;
const int infi = (int)1e+9 + 10;
const ll infll = (ll)1e+17 + 10;

int n, max, ans = infi;
int dat[20];

int main(){
	while (std::cin >> n, n){
		ans = infi;
		rep(i, n)std::cin >> dat[i];

		max = (1 << n);
		rep(i, max){
			int sumA = 0, sumB = 0;
			rep(j, n){
				if ((i >> j) & 1)sumA += dat[j];
				else sumB += dat[j];
			}
			ans = std::min(ans, std::abs(sumA - sumB));
		}
		std::cout << ans << std::endl;
	}
	return 0;
}

C++: #include<iostream>
#include<set>
#include<algorithm>
using namespace std;

int abs(int a){
  return (a>0)?a:-a;
}

int main(){
  int n,total;
  int a[20];
  set<int> prob;

  for(;;){
    cin>>n;
    if(!n) break;

    total=0;
    for(int i=0; i<n; i++)
      cin>>a[i],total+=a[i];

    prob.insert(0);

    set<int> c;
    for(int i=0;i<n;i++){
      copy(prob.begin(), prob.end(), insert_iterator<set<int> >(c, c.end()));
      for(set<int>::iterator it=c.begin();it!=c.end();++it){
	if((*it)+a[i] > total/2 + 1) continue;
	prob.insert((*it)+a[i]);
      }
    }

    cout<<abs (total - (*(--prob.end()))*2 )<<endl;

    prob.clear();
    c.clear();
    //cout<<"total: "<<total<<endl;
  }
}