# Solving Leetcode Interviews in Seconds with AI: Minimum Cost to Make Array Equal


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2448" 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 given two 0-indexed arrays nums and cost consisting each of n positive integers. You can do the following operation any number of times:  Increase or decrease any element of the array nums by 1.  The cost of doing one operation on the ith element is cost[i]. Return the minimum total cost such that all the elements of the array nums become equal.   Example 1:  Input: nums = [1,3,5,2], cost = [2,3,1,14] Output: 8 Explanation: We can make all the elements equal to 2 in the following way: - Increase the 0th element one time. The cost is 2. - Decrease the 1st element one time. The cost is 3. - Decrease the 2nd element three times. The cost is 1 + 1 + 1 = 3. The total cost is 2 + 3 + 3 = 8. It can be shown that we cannot make the array equal with a smaller cost.  Example 2:  Input: nums = [2,2,2,2,2], cost = [4,2,8,1,3] Output: 0 Explanation: All the elements are already equal, so no operations are needed.    Constraints:  n == nums.length == cost.length 1 <= n <= 105 1 <= nums[i], cost[i] <= 106 Test cases are generated in a way that the output doesn't exceed 253-1  

	# Explanation
	Here's the breakdown of the solution:

*   **Minimize Cost Function:** The problem asks to find a single value `x` such that the sum of `cost[i] * abs(nums[i] - x)` is minimized. This is a weighted L1 minimization problem.
*   **Median as Optimal Point:** The optimal value for `x` is the weighted median of the `nums` array, where the weights are given by the `cost` array.
*   **Efficiently Find Weighted Median:** Instead of sorting, we can iterate through the sorted unique elements of `nums` and keep track of the cumulative weighted sum until we reach or exceed half the total cost.

*   **Runtime Complexity:** O(n log n) due to sorting the unique elements in nums.
*   **Storage Complexity:** O(n) in the worst case (when all elements in `nums` are unique).

	
	# Code
	```python
	def minCost(nums, cost):
    """
    Calculates the minimum cost to make all elements in nums equal.

    Args:
        nums: A list of integers.
        cost: A list of integers representing the cost of operations.

    Returns:
        The minimum total cost.
    """

    n = len(nums)
    pairs = sorted(zip(nums, cost))
    nums_sorted = [p[0] for p in pairs]
    cost_sorted = [p[1] for p in pairs]

    total_cost = sum(cost)
    cumulative_cost = 0
    median = 0

    for i in range(n):
        cumulative_cost += cost_sorted[i]
        if cumulative_cost * 2 >= total_cost:
            median = nums_sorted[i]
            break

    min_total_cost = 0
    for i in range(n):
        min_total_cost += abs(nums[i] - median) * cost[i]

    return min_total_cost
	```