Given an array of `n` integers `nums` and an integer `target`, find the number of index triplets `i`, `j`, `k` with `0 <= i < j < k < n` that satisfy the condition `nums[i] + nums[j] + nums[k] < target`.

**Example 1:**

**Input:** nums = \[-2,0,1,3\], target = 2
**Output:** 2
**Explanation:** Because there are two triplets which sums are less than 2:
\[-2,0,1\]
\[-2,0,3\]

**Example 2:**

**Input:** nums = \[\], target = 0
**Output:** 0

**Example 3:**

**Input:** nums = \[0\], target = 0
**Output:** 0

**Constraints:**

*   `n == nums.length`
*   `0 <= n <= 3500`
*   `-100 <= nums[i] <= 100`
*   `-100 <= target <= 100`
```python
def threeSumSmaller(nums, target):
    count = 0
    nums.sort()
    for i in range(len(nums)):
        j, k = i + 1, len(nums) - 1
        while j < k:
            if nums[i] + nums[j] + nums[k] < target:
                count += k - j
                j += 1
            else:
                k -= 1
    return count
```
explanation
To solve this problem, we first sort the input array. Then we loop through each element in the array and use two pointers, `j` and `k`, initialized to the following element and the last element in the sorted array, respectively. We repeat the process until `j` is less than `k`. Inside the loop, we check if the sum of `nums[i]`, `nums[j]`, and `nums[k]` is less than the target. If it is, we add the difference `k - j` to the count and increment `j`. Otherwise, we decrement `k`. Finally, we return the count.