# Solving Leetcode Interviews in Seconds with AI: Count Number of Teams


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1395" 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
	> There are n soldiers standing in a line. Each soldier is assigned a unique rating value. You have to form a team of 3 soldiers amongst them under the following rules:  Choose 3 soldiers with index (i, j, k) with rating (rating[i], rating[j], rating[k]). A team is valid if: (rating[i] < rating[j] < rating[k]) or (rating[i] > rating[j] > rating[k]) where (0 <= i < j < k < n).  Return the number of teams you can form given the conditions. (soldiers can be part of multiple teams).   Example 1:  Input: rating = [2,5,3,4,1] Output: 3 Explanation: We can form three teams given the conditions. (2,3,4), (5,4,1), (5,3,1).   Example 2:  Input: rating = [2,1,3] Output: 0 Explanation: We can't form any team given the conditions.  Example 3:  Input: rating = [1,2,3,4] Output: 4    Constraints:  n == rating.length 3 <= n <= 1000 1 <= rating[i] <= 105 All the integers in rating are unique.  

	# Explanation
	Here's the breakdown of the problem and the solution:

*   **High-Level Approach:** The core idea is to iterate through each soldier as the potential middle soldier (`rating[j]`). For each `j`, we count how many soldiers to the left have a smaller rating (`less_left`) and how many have a larger rating (`greater_left`). Similarly, we count how many soldiers to the right have a smaller (`less_right`) and larger (`greater_right`) rating. Finally, we calculate the number of increasing teams (`less_left * greater_right`) and decreasing teams (`greater_left * less_right`) that can be formed with this soldier as the middle one.

*   **Complexity:**
    *   Runtime: O(n<sup>2</sup>) - due to nested loops.
    *   Storage: O(1) - constant extra space.

	
	# Code
	```python
	def numTeams(rating):
    n = len(rating)
    count = 0
    for j in range(1, n - 1):
        less_left = 0
        greater_left = 0
        less_right = 0
        greater_right = 0
        for i in range(j):
            if rating[i] < rating[j]:
                less_left += 1
            elif rating[i] > rating[j]:
                greater_left += 1
        for k in range(j + 1, n):
            if rating[k] < rating[j]:
                less_right += 1
            elif rating[k] > rating[j]:
                greater_right += 1
        count += (less_left * greater_right) + (greater_left * less_right)
    return count
	```