# Solving Leetcode Interviews in Seconds with AI: Maximum Units on a Truck


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1710" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are assigned to put some amount of boxes onto one truck. You are given a 2D array boxTypes, where boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi]:  numberOfBoxesi is the number of boxes of type i. numberOfUnitsPerBoxi is the number of units in each box of the type i.  You are also given an integer truckSize, which is the maximum number of boxes that can be put on the truck. You can choose any boxes to put on the truck as long as the number of boxes does not exceed truckSize. Return the maximum total number of units that can be put on the truck.   Example 1:  Input: boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4 Output: 8 Explanation: There are: - 1 box of the first type that contains 3 units. - 2 boxes of the second type that contain 2 units each. - 3 boxes of the third type that contain 1 unit each. You can take all the boxes of the first and second types, and one box of the third type. The total number of units will be = (1 * 3) + (2 * 2) + (1 * 1) = 8.  Example 2:  Input: boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10 Output: 91    Constraints:  1 <= boxTypes.length <= 1000 1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000 1 <= truckSize <= 106  

	# Explanation
	Here's the breakdown of the solution:

*   **Greedy Approach:** Prioritize boxes with the highest number of units per box to maximize the total units carried.
*   **Sorting:** Sort the `boxTypes` array in descending order based on `numberOfUnitsPerBoxi`.
*   **Iterative Selection:** Iterate through the sorted `boxTypes`, adding as many boxes as possible from each type to the truck until `truckSize` is reached.

*   **Runtime Complexity:** O(n log n), where n is the number of box types due to sorting. **Storage Complexity:** O(1) (excluding the input array).

	
	# Code
	```python
	def maximumUnits(boxTypes, truckSize):
    """
    Calculates the maximum number of units that can be put on the truck.

    Args:
        boxTypes: A 2D array where boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi].
        truckSize: The maximum number of boxes that can be put on the truck.

    Returns:
        The maximum total number of units that can be put on the truck.
    """
    boxTypes.sort(key=lambda x: x[1], reverse=True)  # Sort by units per box in descending order
    total_units = 0
    boxes_taken = 0

    for num_boxes, units_per_box in boxTypes:
        if boxes_taken + num_boxes <= truckSize:
            total_units += num_boxes * units_per_box
            boxes_taken += num_boxes
        else:
            remaining_space = truckSize - boxes_taken
            total_units += remaining_space * units_per_box
            break  # Truck is full

    return total_units
	```