1. Abridged Problem Statement  
Given integers P, M, C (available grams/ml of flour, milk, and cabbage) and K, R, V (grams/ml needed per patty), compute the maximum number of patties one can make. That is, output floor(min(P/K, M/R, C/V)).

2. Detailed Editorial  
We need to determine how many patties Petya can cook without running out of any one of the three key ingredients. Each ingredient imposes its own limit:  
- From the flour supply P, you can make at most ⌊P/K⌋ patties.  
- From the milk supply M, at most ⌊M/R⌋ patties.  
- From the cabbage supply C, at most ⌊C/V⌋ patties.  

Because you must have all three ingredients available to make each patty, the true maximum is the smallest of these three values.  

Steps to solve:  
1. Read P, M, C, K, R, V.  
2. Compute x1 = P / K, x2 = M / R, x3 = C / V using integer division (floor).  
3. The answer is min(x1, x2, x3).  
4. Print that minimum.  

Time complexity is O(1) and memory usage is negligible. Given 1 ≤ P, M, C, K, R, V ≤ 10000, divisions and comparisons fit easily into 32- or 64-bit integers.

3. C++ Solution

```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int64_t p, milk, c;
int64_t k, r, v;

void read() {
    cin >> p >> milk >> c;
    cin >> k >> r >> v;
}

void solve() {
    // Each patty needs k flour, r milk, v cabbage. The number of patties is
    // limited independently by each ingredient, so the answer is the minimum of
    // the integer divisions p / k, milk / r and c / v.

    int64_t answer = p / k;
    answer = min(answer, c / v);
    answer = min(answer, milk / r);
    cout << answer << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

4. Python Solution

```python
def main():
    # Read six integers from input: P, M, C, K, R, V
    import sys
    P, M, C, K, R, V = map(int, sys.stdin.read().split())

    # Compute maximum patties by each resource
    max_by_flour = P // K     # integer division
    max_by_milk  = M // R
    max_by_cabb  = C // V

    # The limiting factor is the minimum of the three
    answer = min(max_by_flour, max_by_milk, max_by_cabb)

    # Print the result
    print(answer)

if __name__ == "__main__":
    main()
```

5. Compressed Editorial  
Compute floor divisions P/K, M/R, C/V and output their minimum.
