# Solving Leetcode Interviews in Seconds with AI: How Many Numbers Are Smaller Than the Current Number


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1365" 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
	> Given the array nums, for each nums[i] find out how many numbers in the array are smaller than it. That is, for each nums[i] you have to count the number of valid j's such that j != i and nums[j] < nums[i]. Return the answer in an array.   Example 1:  Input: nums = [8,1,2,2,3] Output: [4,0,1,1,3] Explanation:  For nums[0]=8 there exist four smaller numbers than it (1, 2, 2 and 3).  For nums[1]=1 does not exist any smaller number than it. For nums[2]=2 there exist one smaller number than it (1).  For nums[3]=2 there exist one smaller number than it (1).  For nums[4]=3 there exist three smaller numbers than it (1, 2 and 2).  Example 2:  Input: nums = [6,5,4,8] Output: [2,1,0,3]  Example 3:  Input: nums = [7,7,7,7] Output: [0,0,0,0]    Constraints:  2 <= nums.length <= 500 0 <= nums[i] <= 100  

	# Explanation
	Here's a breakdown of the approach, complexity, and the Python code:

*   **High-Level Approach:**
    *   Use a counting sort approach to efficiently determine the frequency of each number in the input array since the numbers are within a small range (0-100).
    *   Calculate a prefix sum of the frequency array to determine the number of elements less than a given value.
    *   Iterate through the original input array and use the prefix sum to retrieve the count of smaller numbers for each element.

*   **Complexity:**
    *   Runtime Complexity: O(n), where n is the length of the input array `nums`.
    *   Storage Complexity: O(1), because the size of the `counts` array is fixed (101), regardless of the input array size.

*   **Python Code:**

	
	# Code
	```python
	def smallerNumbersThanCurrent(nums):
    """
    Given the array nums, for each nums[i] find out how many numbers in the array
    are smaller than it. That is, for each nums[i] you have to count the
    number of valid j's such that j != i and nums[j] < nums[i].
    Return the answer in an array.

    Args:
        nums (List[int]): A list of integers.

    Returns:
        List[int]: A list of integers representing the count of smaller numbers for each element in nums.
    """
    counts = [0] * 101  # Initialize counts for numbers 0-100
    for num in nums:
        counts[num] += 1

    # Calculate prefix sum
    for i in range(1, 101):
        counts[i] += counts[i - 1]

    result = []
    for num in nums:
        if num == 0:
            result.append(0)
        else:
            result.append(counts[num - 1])

    return result
	```