An elegant and efficient solution to this problem can be achieved by breaking it down based on the properties of the numbers 0, 1, and values greater than 1. This approach uses dynamic programming with memoization for the core logic.

1.  **Handle `k <= 1`:** If `k` is 1 or less, a subsequence product can only be smaller than `k` if it is 0. This requires the subsequence to contain at least one zero. The number of non-empty subsequences containing at least one zero is calculated and returned directly.

2.  **Partition the Array:** For `k > 1`, the array elements are categorized:
    *   **Zeros:** Any non-empty subsequence containing a zero will have a product of 0, which is less than `k`. The number of such subsequences is calculated first.
    *   **Ones:** Ones do not change the product of a subsequence but increase the number of ways to form it. Their effect is handled combinatorially.
    *   **Numbers > 1:** These are the elements that actively increase the product. We use a recursive helper function with memoization to count the valid subsequences formed from these numbers.

3.  **Recursive Counting (`count_from_prime`):** A helper function is defined to count the number of subsequences from numbers greater than 1 whose product is less than `k`. It uses a standard include/exclude pattern for each element and memoizes the results for `(index, current_product)` states to avoid re-computation. This function counts valid subsequences including the empty one (product 1).

4.  **Combine Results:**
    *   The count of valid subsequences from numbers > 1 (including the empty one) is obtained from the recursive helper.
    *   This count is multiplied by `2^count_ones` to account for all possible subsequences of ones that can be combined with them.
    *   We subtract 1 to exclude the overall empty subsequence (formed by the empty subsequence of numbers > 1 and the empty subsequence of ones). This gives the total count of valid non-empty subsequences from non-zero elements.
    *   Finally, this result is added to the count of subsequences containing zeros to get the total number of valid subsequences.

This method correctly handles all non-negative integers and is efficient for typical constraints where the product of `n` and `k` is manageable.

```python
def no_of_subsequences(arr, k):
    n = len(arr)

    if k <= 1:
        count_zeros = 0
        for x in arr:
            if x == 0:
                count_zeros += 1
        
        if count_zeros == 0:
            return 0
        return (1 << n) - (1 << (n - count_zeros))

    count_zeros = 0
    count_ones = 0
    arr_prime = []
    for x in arr:
        if x == 0:
            count_zeros += 1
        elif x == 1:
            count_ones += 1
        elif x < k:
            arr_prime.append(x)

    res_with_zeros = (1 << n) - (1 << (n - count_zeros))

    memo = {}

    def count_from_prime(index, product):
        state = (index, product)
        if state in memo:
            return memo[state]

        if index == len(arr_prime):
            return 1

        # Exclude current element
        res = count_from_prime(index + 1, product)

        # Include current element
        new_product = product * arr_prime[index]
        if new_product < k:
            res += count_from_prime(index + 1, new_product)

        memo[state] = res
        return res

    count_valid_prime_incl_empty = count_from_prime(0, 1)
    
    res_from_non_zeros = count_valid_prime_incl_empty * (1 << count_ones) - 1

    return res_with_zeros + res_from_non_zeros
```