# Original solution

import itertools
import math
import copy

N, A, B, C = list(map(int, input().rstrip().split()))

pattern = [list(itertools.combinations(list(range(x)), 3)) for x in range(3, N+1)]

def stretch_shortening(sticks, A, B, C):
    min_cost = 1e10
    
    for i1, i2, i3 in pattern[len(sticks) - 3]:
        cost = abs(sticks[i1] - A) + abs(sticks[i2] - B) + abs(sticks[i3] - C)
        if min_cost > cost:
            min_cost = cost
    return min_cost

def connect(sticks, A, B, C):
    
    min_cost = stretch_shortening(sticks, A, B, C) + (N - len(sticks)) * 10
    
    if len(sticks) <= 3:
        return min_cost
    
    for i1, i2 in itertools.combinations(list(range(len(sticks))), 2):
        if sticks[i1] + sticks[i2] > sticks[-1] and sticks[-1] >= C:
            continue
        if sticks[i1] <= 10 or sticks[i2] <= 10:
            continue
        '''
        copied_sticks = copy.copy(sticks)
        copied_sticks[i1] += copied_sticks[i2]
        copied_sticks.pop(i2)
        copied_sticks = sorted(copied_sticks)
        '''
        i1_value = sticks[i1]
        i2_value = sticks[i2]
        total_i1_i2 = i1_value + i2_value
        flag = False
        for i, v in enumerate(sticks):
            if total_i1_i2 < v:
                insert_index = i
                sticks.insert(i, total_i1_i2)
                sticks.pop(i2)
                sticks.pop(i1)
                flag = True
                #print(0, sticks)
                break
        if flag == False:
            insert_index = -1
            sticks.insert(len(sticks), total_i1_i2)
            sticks.pop(i2)
            sticks.pop(i1)
            #print(1, sticks[-1], sticks)
        
                
        
        min_cost_connect = connect(sticks, A, B, C)
        sticks.insert(i1, i1_value)
        sticks.insert(i2, i2_value)
        sticks.pop(insert_index)
        if min_cost_connect < min_cost:
            min_cost = min_cost_connect
    
    return min_cost
'''
def connect(sticks, A, B, C, min_cost):
    
    new_min_cost = stretch_shortening(sticks, A, B, C) + (N - len(sticks)) * 10
    
    if len(sticks) <= 3:
        return min_cost
    
    if len(sticks) <= 3:
        if min_cost > new_min_cost:
            return new_min_cost
        else:
            return min_cost
    
    if min_cost < new_min_cost:
        return min_cost
    else:
        min_cost = new_min_cost
    
    
    min_copied_sticks = None
    for i1, i2 in itertools.combinations(range(len(sticks)), 2):
        if sticks[i1] + sticks[i2] > sticks[-1] and sticks[-1] > C:
            continue
        copied_sticks = copy.copy(sticks)
        copied_sticks[i1] += copied_sticks[i2]
        copied_sticks.pop(i2)
        copied_sticks = sorted(copied_sticks)
        #min_cost_connect = connect(copied_sticks, A, B, C, min_cost)
        min_cost_connect = stretch_shortening(copied_sticks, A, B, C) + (N - len(copied_sticks)) * 10
        if min_cost_connect < min_cost:
            min_cost = min_cost_connect
            min_copied_sticks = copied_sticks
    
    if min_copied_sticks is not None:
        min_cost_connect = connect(min_copied_sticks, A, B, C, min_cost)
        if min_cost_connect < min_cost:
            min_cost = min_cost_connect
    
    return min_cost
'''
sticks = []
for _ in range(N):
    sticks.append(int(eval(input())))
sticks = sorted(sticks)

min_cost = connect(sticks, C, B, A) #, 1e10)
#min_cost = stretch_shortening(sticks, A, B, C)
#print(pattern)

print(min_cost)



# Optimized solution

import itertools
import math
import copy

N, A, B, C = list(map(int, input().rstrip().split()))

pattern = [list(itertools.combinations(list(range(x)), 3)) for x in range(3, N+1)]

def stretch_shortening(sticks, A, B, C):
    min_cost = 1e10
    
    for i1, i2, i3 in pattern[len(sticks) - 3]:
        cost = abs(sticks[i1] - A) + abs(sticks[i2] - B) + abs(sticks[i3] - C)
        if min_cost > cost:
            min_cost = cost
    return min_cost

temp_set = set()
def connect(sticks, A, B, C):
    
    min_cost = stretch_shortening(sticks, A, B, C) + (N - len(sticks)) * 10
    
    if len(sticks) <= 3:
        return min_cost
    
    for i1, i2 in itertools.combinations(list(range(len(sticks))), 2):
        if sticks[i1] + sticks[i2] > sticks[-1] and sticks[-1] >= C:
            continue
        if sticks[i1] <= 10 or sticks[i2] <= 10:
            continue
        
        copied_sticks = copy.copy(sticks)
        copied_sticks[i1] += copied_sticks[i2]
        copied_sticks.pop(i2)
        copied_sticks = sorted(copied_sticks)
        
        len_set = len(temp_set)
        temp_set.add(''.join(["{:05d}".format(x) for x in copied_sticks]))
        if len_set == len(temp_set):
            continue
        
        min_cost_connect = connect(copied_sticks, A, B, C)

        if min_cost_connect < min_cost:
            min_cost = min_cost_connect
    
    return min_cost

sticks = []
for _ in range(N):
    sticks.append(int(eval(input())))
sticks = sorted(sticks)

min_cost = connect(sticks, C, B, A) #, 1e10)
#min_cost = stretch_shortening(sticks, A, B, C)
#print(pattern)

print(min_cost)