class UserMainCode:
    @classmethod
    def minimumSum(cls, input1, input2):
        def array_sum(arr):
            return sum(arr)
        if len(input2) < 2:
            return array_sum(input2)
        initial_sum = array_sum(input2)
        sorted_arr = sorted(input2)
        largest = sorted_arr[-1]
        second_largest = sorted_arr[-2]
        avg = (largest + second_largest) / 2
        updated_arr = [0 if num < avg else num for num in input2]
        updated_sum = array_sum(updated_arr)
        return min(initial_sum, updated_sum)

def roundsWon(N, C):
    m = j = 0  
    for r in C:
        if m >= j:
            if r == 'W':
                m += 1
            else:
                j += 1
        else:
            if r == 'W':
                j += 1
            else:
                m += 1
    print(m, j)

#include <iostream>
#include <queue>
#include <unordered_set>
#include <cmath>
using namespace std;
int minTime(int p) {
    if (p == 0) return 0;
        queue<pair<int, int>> q; 
    q.push({0, 0});
    
    unordered_set<int> visited;
    visited.insert(0);
    
    while (!q.empty()) {
        int current_position = q.front().first;
        int time = q.front().second;
        q.pop();
        
        if (current_position == p) {
            return time;
        }
        
        int step = time + 1;
        
        int new_pos1 = current_position + step;
        int new_pos2 = current_position - step;
                if (visited.find(new_pos1) == visited.end()) {
            visited.insert(new_pos1);
            q.push({new_pos1, time + 1});
        }
        if (visited.find(new_pos2) == visited.end()) {
            visited.insert(new_pos2);
            q.push({new_pos2, time + 1});
        }
    }
    
    return -1;
}
int main() {
    int p;
    cin >> p;
    cout << minTime(p) << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    int n, a, b, c;
    cin >> n >> a >> b >> c;
    vector<int> dp(n + 1, -1);
    dp[0] = 0; 
    for (int i = 0; i <= n; ++i) {
        if (dp[i] == -1) continue; 
        if (i + a <= n) dp[i + a] = max(dp[i + a], dp[i] + 1);
        if (i + b <= n) dp[i + b] = max(dp[i + b], dp[i] + 1);
        if (i + c <= n) dp[i + c] = max(dp[i + c], dp[i] + 1);
    }
    cout << dp[n] << endl;

    return 0;
}