#include "bits/stdc++.h"
using namespace std;
typedef long long lint;
#define rep(i,n) for(int i=0;i<n;++i)
#define MAXN 100010
#define MAXM 1100000
#define all(v) v.begin(),v.end()
#define inf 2147483647
#define linf 1152921504606846976
typedef vector<lint> LIV;

string next(int n,string s){//000=>001=>002=>003=>010(gyaku)
	++s[0];
	rep(i,n){
		if(s[i]>='4'){
			if(i==n-1)return "unko";
			++s[i+1],s[i]='0';
		}
	}
	return s;
}

int main(){

	lint n,a[3];cin>>n>>a[0]>>a[1]>>a[2];
	vector<lint> l(n);rep(i,n)cin>>l[i];
	int ans=inf;
	for(string b="00000000";"unko"!=(b=next(n,b));){
		int s[4]={},c[4]={};
		rep(i,n){
			s[b[i]-'0']+=l[i];
			c[b[i]-'0']++;
		}int tmp=0;
		if(!c[0]||!c[1]||!c[2])continue;
		rep(i,3){
			tmp+=(c[i]-1)*10+abs(a[i]-s[i]);
		}ans=min(ans,tmp);
	}cout<<ans<<endl;
}



////現代的な屋敷 maxn=400040
////d,edge,g,P,q;
//lint d[MAXN];
//struct edge{
//	int to;
//	lint cost;
//};
//vector<edge> g[MAXN];
//vector<pair<int,int> >xl[100010],yl[100010];//zahyou, 頂点番号
//typedef pair<lint,int> P;
//priority_queue<P,vector<P>,greater<P> >q;
//void pfs(int s){
//	d[s]=0;q.push({0,s});
//	lint cd,cv;
//	while(q.size()){
//		cd=q.top().first,cv=q.top().second;q.pop();
//		if(cd>d[cv])continue;
//		for(edge &e:g[cv])if(d[e.to]>cd+e.cost){
//			d[e.to]=cd+e.cost;
//			q.push({d[e.to],e.to});
//		}
//	}
//}
//
//int main(){
//	lint m,n,k;cin>>m>>n>>k;
//	vector<int> xi(k),yi(k);
//	int x,y;
//	if(k<=2000){
//		fill(d,d+2*k+4,linf);
//		rep(i,k+2){
//			if(!i)x=1,y=1;
//			else if(i==k+1)x=m,y=n;
//			else x=xi[i-1],y=yi[y-1];
//			xl[y].push_back({x,i});
//			yl[x].push_back({y,i});
//			g[2*i].push_back({2*i+1,1});
//			g[2*i+1].push_back({2*i,1});
//			rep(j,xl[y].size()-1){
//				g[2*xl[y][j].second].push_back({2*i,x-xl[y][j].first});
//				g[2*i].push_back({2*xl[y][j].second,x-xl[y][j].first});
//			}rep(j,yl[x].size()-1){
//				g[2*yl[x][j].second+1].push_back({2*i+1,y-yl[x][j].first});
//				g[2*i+1].push_back({2*yl[x][j].second+1,y-yl[x][j].first});
//			}
//		}pfs(1);
//		cout<<(d[2*k+2]==linf?-1:min(d[2*k+2],d[2*k+3]))<<endl;
//	} else{
//
//	}
//	getchar();
//	getchar();
//}


//
//pair<int,int> dp[MAXN][MAXN];
//typedef pair<int,int> P;
//int main(){
//	lint n,k;cin>>n>>k;
//	vector<P>a(n);rep(i,n)cin>>a[i].second>>a[i].first;
//	sort(all(a),[](P a,P b){return a.first==b.first?(a.second>b.second):a.first<b.first;});
//	vector<int>c(n);
//	for(int i=1;i<n;++i)c[i]=(a[i].first==a[i-1].first)?c[i-1]+1:0;
//	rep(i,n)a[i].second+=c[i]*2;
//	rep(i,n+1)rep(j,k+1)dp[i][j].first=-inf;dp[0][0].first=0;
//	rep(j,k+1){
//		rep(i,n){
//			dp[i+1][j]=max(dp[i+1][j],P(dp[i][j].first,0));
//			if(!c[i]||(c[i]<=j&&dp[i][j].second)){
//				if(dp[i+1][j+1].first<=dp[i][j].first+a[i].second){
//					dp[i+1][j+1].first=dp[i][j].first+a[i].second;
//					dp[i+1][j+1].second=1;
//				}
//			}
//		}
//	}
//	cout<<dp[n][k].first<<endl;
//	getchar();
//	getchar();
//}


//danjon
//lint n,h;
//vector<lint>a,b;
//
//bool fulfill(int ix){//ix回泉を使ってn階まで行けるか
//	priority_queue<lint>q;
//	lint cur=h;
//	rep(i,n){
//		q.push(b[i]);
//		cur-=a[i];
//		while(cur<0){
//			--ix;
//			cur=min(h,cur+q.top());
//		}
//		if(ix<0)return 0;
//	}return 1;
//}
//
//int left(){
//	lint ng=-1,ok=inf,mid;
//	while(abs(ok-ng)>1){
//		mid=(ok+ng)/2;
//		if(fulfill(mid))ok=mid;
//		else ng=mid;
//	}return ok;
//}
//
//int main(){
//	cin>>n>>h;
//	a.resize(n),b.resize(n);
//	rep(i,n-1)cin>>a[i]>>b[i];
//	cout<<left()<<endl;
//	getchar();
//	getchar();
//}

//遺産相続
//class Unionfind{
//public://par,rank,init,uf,uf,root,same,unite
//	lint par[MAXN],rank[MAXN];
//	void init(int n){
//		rep(i,n)par[i]=i,rank[i]=0;
//	}Unionfind(int n){ init(n); }
//	Unionfind(){}
//	int root(int x){
//		return x==par[x]?x:par[x]=root(par[x]);
//	}bool same(int x,int y){
//		return root(x)==root(y);
//	}void unite(int x,int y){
//		x=root(x),y=root(y);
//		if(x==y)return;
//		if(rank[x]<rank[y])par[x]=y;
//		else{
//			par[y]=x;
//			if(rank[x]==rank[y])++rank[x];
//		}
//	}
//};
//
//struct edge{
//	lint cost;int from,to,i;
//};
//vector<edge>g;
//bool used[MAXM];
//
//int main(){
//	ios::sync_with_stdio(0);cin.tie(0);
//	lint n,m,k;cin>>n>>m>>k;g.resize(m);
//	int a,b;lint c;
//	rep(i,m){
//		cin>>a>>b>>c;--a;--b;
//		g[i]={c,a,b,i};
//	}sort(all(g),[](edge a,edge b){return a.cost>b.cost;});
//	vector<Unionfind>t(k);
//	vector<int> ans(m);
//	rep(i,k)t[i].init(n);
//	lint ctr=0,j;
//	rep(i,m){
//		j=0;
//		while(j<k&&t[j].same(g[i].from,g[i].to))++j;
//		if(j==k)j=-1;
//		else t[j].unite(g[i].from,g[i].to);
//		ans[g[i].i]=j+1;
//	}
//	rep(i,k){
//
//	}
//	
//	rep(i,m)cout<<ans[i]<<endl;
//}

//int dp[MAXN][MAXS][MAXM];
//
//int main(){
//	lint n,m,s;cin>>n>>m>>s;n*=n;
//	dp[0][0][0]=1;
//	rep(i,n){
//		rep(j,s){
//			for(int k=1;k<=m;++k){
//				for(int p=k;p<=m;++p){
//					dp[i+1][j+p][p]+=dp[i][j][k];
//				}
//			}
//		}
//	}
//	lint ans=0;
//	rep(i,m)ans+=dp[n][m][i];cout<<ans<<endl;
//}

//int main(){
//	lint n,m=1;cin>>n;
//	lint i=1,ans=2;
//	while(++i&&n>1){
//		if(n%i==0||i%n==0){
//			n/=i;
//			ans=max(ans,i);
//		}
//	}cout<<ans<<endl;
//}

//map<lint,lint>xzip,yzip;
//lint xunz[MAXN],yunz[MAXN];
//
//lint compress(vector<lint>&v,map<lint,lint>&z,lint u[]){
//	sort(all(v));v.erase(unique(all(v)),v.end());v.shrink_to_fit();
//	rep(i,v.size()){
//		z[v[i]]=i;
//		u[i]=v[i];
//	}return v.size();
//}
//
//
//
//int main(){
//	lint n,m;cin>>n>>m;
//	vector<lint> x(m),y(m),xt(m),yt(m);
//	rep(i,m){
//		cin>>x[i]>>y[i];
//		xt[i]=x[i];yt[i]=y[i];
//	}lint xs=compress(xt,xzip,xunz),ys=compress(yt,yzip,yunz);
//	lint xans=xunz[xs-1]-xunz[0],yans=yunz[ys-1]-yunz[0];
//	vector<lint>cx,cy;
//	rep(i,xs-1)cx.push_back(xunz[i+1]-xunz[i]);
//	rep(i,ys-1)cy.push_back(yunz[i+1]-yunz[i]);
//
//	getchar();
//	getchar();
//}


//int main(){
//	cin>>n;
//	p.resize(n);
//	q.resize(n);
//	r.resize(n);
//	b.resize(n);
//	lint g;
//	rep(i,n){
//		cin>>q[i]>>p[i]>>r[i]>>b[i];--r[i];--b[i];
//		g=gcd(p[i],q[i]);
//		p[i]/=g;q[i]/=g;
//	}lint ans=0;
//	rep(i,n)ans=max(ans,rec(i));
//	cout<<ans<<endl;
//}

//segtree
//class Segtree{
//public://n,sz,node,f,e,segtree,updete,query
//	int n,sz;
//	vector<lint> node;
//
//	lint f(lint x,lint y){ return min(x,y); }
//	lint e=inf;
//
//	Segtree(vector<lint> v){
//		sz=v.size();n=1;
//		while(n<sz)n<<=1;
//		node.resize(2*n,e);
//		rep(i,sz)node[n+i]=v[i];
//		for(int i=n-1;i>0;--i)node[i]=f(node[2*i],node[2*i+1]);
//	}
//	void update(int i,lint x){
//		node[n+i]=x;
//		while(i>>=1)node[i]=f(node[2*i],node[2*i+1]);
//	}
//	lint query(int a,int b,int k=1,int l=0,int r=-1){
//		if(r<0)r=n;
//		if(r<=a||b<=l)return e;
//		if(a<=l&&r<=b)return node[k];
//		return f(query(a,b,2*k,l,(l+r)/2),query(a,b,2*k+1,(l+r)/2,r));
//	}
//};
//
//int main(){
//	lint n,q;cin>>n>>q;
//	lint com,x,y;
//	vector<lint> a(n,inf);
//	Segtree t(a);
//	rep(i,q){
//		cin>>com>>x>>y;
//		if(com)cout<<t.query(x,y+1)<<endl;
//		else t.update(x,y);
//	}getchar();getchar();
//}


//int n;
//vector<int> a;
//int dp[10010][5010];
//
//int rec(int l,int k){
//	if(dp[l][k]!=inf)return dp[l][k];
//	dp[l][k]=min(dp[l][k],a[l+k]);
//	for(int i=1;i<k;++i){
//		dp[l][k]=min(dp[l][k],a[l+i]+rec(l+i,n-l-k));
//	}return dp[l][k];
//}
//
//int main(){
//	cin>>n;a.resize(n);
//	rep(i,n-1)cin>>a[i+1];
//	rep(i,n+1)rep(j,n/2+1)dp[i][j]=inf;
//	cout<<rec(0,n/2)<<endl;
//}


//
//
//#include "bits/stdc++.h"
//using namespace std;
//
//typedef long long lint;
//#define INF INT_MAX
//#define rep(i,n) for(int i=0;i<(n);++i)
//
//struct LazySegTree{
//	int n,sz;
//	vector<lint> node,lazy;
//
//	inline lint f(lint a,lint b){//この問題はqueryもupdateも+
//		return a+b;
//	}lint M1 = 0;
//
//	LazySegTree(vector<lint> v){
//		sz=v.size(); n=1;
//		while(n<sz)n<<=2;
//		node.resize(2*n,M1);
//		lazy.resize(2*n,M1);
//		rep(i,sz)node[n+i]=v[i];
//		for(int i=n-1;i>0;--i)node[i]=f(node[i*2],node[i*2+1]);
//	}
//	void eval(int k,int l,int r){
//		if(lazy[k])node[k]=f(node[k],lazy[k]);
//		if(r-l>1){
//			lazy[2*k]=f(lazy[2*k],lazy[k]/2);
//			lazy[2*k+1]=f(lazy[2*k+1],lazy[k]/2);
//		}lazy[k]=M1;
//	}
//	void update(int a,int b,lint x,int k=1,int l=0,int r=-1){
//		if(r<0)r=n;
//		eval(k,l,r);
//
//		if(b<=l||r<=a)return;
//		if(a<=l&&r<=b){
//			lazy[k]=f(lazy[k],(r-l)*x);
//			eval(k,l,r);
//		} else{
//			update(a,b,x,2*k,l,(l+r)/2);
//			update(a,b,x,2*k+1,(l+r)/2,r);
//			node[k]=f(node[2*k],node[2*k+1]);
//		}
//	}
//	void update(int k,lint x){
//		k+=n;
//		node[k]=x;
//		while(k>>=1){
//			node[k]=f(node[k*2],node[k*2+1]);
//		}
//	}
//	lint query(int a,int b,int k=1,int l=0,int r=-1){
//		if(r<0)r=n;
//		if(r<=a||b<=l)return M1;
//		if(a<=l&&r<=b)return node[k];
//		return f(query(a,b,2*k,l,(l+r)/2),query(a,b,2*k+1,(l+r)/2,r));
//	}
//};
//
//int main(){
//	int n,q;cin>>n>>q;
//
//	vector<lint> v(n,0);
//	LazySegTree seg(v);
//	rep(i,q){
//		int com,s,t;cin>>com;
//		lint x;
//
//		if(!com){
//			cin>>s>>t>>x;
//			seg.update(s,t+1,x);
//		}
//		else{
//			cin>>s>>t;
//			cout<<seg.query(s,t+1)<<endl;
//		}
//	}getchar();getchar();
//}

//lint n,q,nearest;
//LIV a,x,s,sa;
//bool fulfill(int ix,int key){//条件を満たすか(butukatteru)
//	int k=n-ix;
//	if(ix-k-1<0)return 1;
//	if(k<ix-nearest)return 0;
//	int r=sa[ix]-sa[ix-k]-x[key]*k,l=sa[ix-1]-sa[ix-k-1];
//	return (l>r);
//}
//
//int mid;
//int right(int n,int key){
//	int ok=-1,ng=n;//okが左に寄ってるイメージ=>その範囲の一番右を求める
//	while(abs(ok-ng)>1){
//		mid=(ok+ng)/2;
//		if(fulfill(mid,key))ok=mid;
//		else ng=mid;
//	}return ng;
//}
//
//int main(){
//	setc;
//
//	cin>>n>>q;
//	a.resize(n),x.resize(q),s.resize(n),sa.resize(n+1);
//	bool ki=(n&1);
//	rep(i,n){
//		cin>>a[i];
//		if((i&1)^ki)s[i/2+1]=s[i/2]+a[i];
//		sa[i+1]=sa[i]+a[i];
//	}lint ans=0;
//	rep(i,q){
//		cin>>x[i];
//		int p=right(n,i);
//		ans=sa[n]-sa[p];
//		ans+=s[n-p];
//	}
//	co(ans);
//
//	gc();
//}

//#include "bits/stdc++.h"
//using namespace std;
//typedef long long lint;
//#define rep(i,n) for(int i=0;i<(n);++i)
//#define MAXN 410
//#define linf 4223372036854775808
//#define inf 1073741824
//int main(){
//	int n,maxlen=0,len=0,start=0,ans=inf;
//	string s;
//	cin>>n>>s;s+=s;
//	char last=s[0],maxchar;
//	rep(i,2*n){
//		if(last!=s[i]){
//			last=s[i];
//			start=i;
//			len=0;
//		} ++len;
//		if(maxlen<=len){
//			maxlen=len;
//			if(abs(start-n)<ans){
//				ans=abs(start-n);
//				maxchar=last;
//			}
//		}
//	}cout<<ans+(maxchar=='0')<<endl;
//}


//lint dp[MAXN][MAXN];
//lint n;
//vector<lint> a,s;
//lint rec(int l,int r){
//	if(dp[l][r]!=-1)return dp[l][r];
//	if(r-l==1)return dp[l][r]=0;
//	lint tmp,res=linf;
//	for(int m=l+1;m<r;++m){
//		tmp=rec(l,m)+rec(m,r)+s[r]-s[l];
//		if(tmp<res)res=tmp;
//	}return dp[l][r]=res;
//}
//int main(){
//	cin.tie(0);cout.tie(0);
//	ios::sync_with_stdio(0);
//
//	cout<<31*1847<<1;
//	cin>>n;
//	rep(i,n+1)rep(j,n+1)dp[i][j]=-1;
//	a.resize(n);s.resize(n+1);
//	rep(i,n){
//		cin>>a[i];
//		s[i+1]=s[i]+a[i];
//	}cout<<rec(0,n)<<endl;
//	getchar();getchar();
//	return 0;
//}


//#include "bits/stdc++.h"
//using namespace std;
//typedef long long lint;
//#define rep(i,n) for(int i=0;i<(n);++i)
//#define MAXN 100010
//
//vector<int> a;
//lint n,c;
//
//bool fulfill(int ix){
//	lint ctr=1,prv=a[0];
//	for(int &i:a){
//		if(i-prv>=ix){
//			++ctr;
//			prv=i;
//		}
//	}return (ctr>=c);
//}
//
//int right(int max){
//	int ok=0,ng=n;
//	int mid;
//	for(int i=0;i<50;++i){
//		mid=(ok+ng)/2;
//		if(fulfill(mid))ok=mid;
//		else ng=mid;
//	}return ok;
//}
//
//int main(){
//	cin.tie(0);cout.tie(0);
//	ios::sync_with_stdio(0);
//
//	lint t;cin>>t;
//	rep(query,t){
//		cin>>n>>c;
//		a.resize(n);
//		rep(i,n){
//			cin>>a[i];
//		}sort(a.begin(),a.end());
//		cout<<right(a[n-1])<<endl;
//	}
//	return 0;
//}


Measured memory_bytes: 256