Maximum Number of Alloys - Practice Coding Problems

Maximum Number of Alloys - Problem

Maximum Number of Alloys

You are the owner of a metalworking company that creates special alloys using various types of metals. Your company has access to k different machines, each with its own unique recipe for creating alloys.

Here's what you have:
• n different types of metals available in the market
• k machines, each requiring specific amounts of each metal type
• Initial stock[i] units of metal type i
• Each unit of metal type i costs cost[i] coins
• A budget limit for purchasing additional metals

For machine i to create one alloy, it needs exactly composition[i][j] units of metal type j. The key constraint is that all alloys must be created using the same machine.

Your goal is to determine the maximum number of alloys you can produce while staying within your budget. You'll need to choose which machine to use and potentially purchase additional metals to maximize production.

Input & Output

example_1.py — Basic Example

$ Input: n = 3, k = 2, budget = 15 composition = [[1,1,1],[1,1,1]] stock = [0,0,0] cost = [1,2,3]

› Output: 2

💡 Note: Both machines have the same composition [1,1,1]. To make 2 alloys, we need 2 units of each metal. Cost = 2×1 + 2×2 + 2×3 = 12, which is within budget 15. We can't make 3 alloys as the cost would be 18 > 15.

example_2.py — Different Machines

$ Input: n = 3, k = 2, budget = 15 composition = [[1,1,1],[1,1,10]] stock = [0,0,0] cost = [1,2,3]

› Output: 5

💡 Note: Machine 1: [1,1,1] costs 6 per alloy, can make 2 alloys (cost 12). Machine 2: [1,1,10] costs 33 per alloy, can't make any. Choose machine 1.

example_3.py — With Initial Stock

$ Input: n = 2, k = 3, budget = 10 composition = [[2,1],[1,2],[1,1]] stock = [1,1] cost = [1,1]

› Output: 5

💡 Note: Machine 3 with composition [1,1] is most efficient. We have 1 unit of each metal. For 5 alloys we need 5 units each, so buy 4 more of each. Cost = 4×1 + 4×1 = 8 ≤ 10.

Constraints

1 ≤ n, k ≤ 100
0 ≤ budget ≤ 10⁸
composition.length == k
composition[i].length == n
1 ≤ composition[i][j] ≤ 100
stock.length == n
0 ≤ stock[i] ≤ 10⁸
cost.length == n
1 ≤ cost[i] ≤ 100
All values are positive integers except stock which can be 0

Visualization

Tap to expand

Understanding the Visualization

Choose Machine

Select one of k machines, each with different metal requirements

Calculate Needs

For X alloys, calculate total metals needed: composition[i][j] × X

Check Budget

Calculate cost to buy additional metals: (needed - stock) × cost

Binary Search

Use binary search to find maximum feasible alloys within budget

Key Takeaway

🎯 Key Insight: Binary search works because the cost function is monotonic - if you can afford X alloys, you can definitely afford any number ≤ X alloys with the same or smaller budget.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18 Apple 15

The optimal solution uses binary search on the answer with time complexity O(k × n × log(max_alloys)). For each machine, we binary search on the number of alloys we can make, checking if the required materials can be purchased within budget. The key insight is that the cost function is monotonic - if we can make X alloys, we can definitely make any number ≤ X alloys.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(k * max_alloys * n)	O(1)	Try every possible number of alloys from 0 to maximum possible
Binary Search (Optimal)	O(k * n * log(max_alloys))	O(1)	Binary search on the number of alloys to find the maximum feasible amount

Brute Force (Linear Search) — Algorithm Steps

For each machine, determine a reasonable upper bound for number of alloys
Try each possible number of alloys from 0 to the upper bound
For each candidate, calculate materials needed: composition[machine][metal] * numAlloys
Calculate additional materials to buy: max(0, needed - stock[metal])
Check if total cost is within budget
Return the maximum feasible number across all machines

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Machine 1

Test 0, 1, 2, 3... alloys until cost exceeds budget

Try Machine 2

Test 0, 1, 2, 3... alloys until cost exceeds budget

Continue for all machines

Find the maximum feasible number across all machines

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int max(int a, int b) {
    return a > b ? a : b;
}

int maxNumberOfAlloys(int n, int k, int budget, int** composition, int* stock, int* cost) {
    int maxAlloys = 0;
    
    // Find max stock for upper bound
    int maxStock = 0;
    for (int i = 0; i < n; i++) {
        if (stock[i] > maxStock) maxStock = stock[i];
    }
    
    // Try each machine
    for (int machine = 0; machine < k; machine++) {
        int upperBound = budget + maxStock + 1;
        
        for (int numAlloys = 0; numAlloys < upperBound; numAlloys++) {
            long long totalCost = 0;
            
            // Calculate cost for this number of alloys
            for (int metal = 0; metal < n; metal++) {
                long long needed = (long long)composition[machine][metal] * numAlloys;
                long long additional = max(0, needed - stock[metal]);
                totalCost += additional * cost[metal];
                
                if (totalCost > budget) break;
            }
            
            if (totalCost <= budget) {
                maxAlloys = max(maxAlloys, numAlloys);
            } else {
                break;
            }
        }
    }
    
    return maxAlloys;
}

Time & Space Complexity

Time Complexity

⏱️

O(k * max_alloys * n)

k machines, for each we try up to max_alloys possibilities, and for each we check n metal types

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

43.5K Views

Medium Frequency

~25 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler