Number of K-Spikes in Stock Price Array

Given the changes to stock price over a period of time as an array of distinct integers, count the number of spikes in the stock price which are counted as K-Spikes.

A K-Spike is an element that satisfies both the following conditions:

• There are at least K elements from indices (0, i-1) that are less than the price[i].
• There are at least K elements from indices (i+1, n-1) that are less than the price[i].

Examples:

Input: price = [1, 2, 8, 5, 3, 4], K = 2
Output: 2
Explanation: There are 2 K-Spikes:
• 8 at index 2 has (1, 2) to the left and (5, 3, 4) to the right that are less than 8.
• 5 at index 3 has (1, 2) to the left and (3, 4) to the right that are less than 5.

Input: price = [7, 2, 3, 9, 7, 4], K = 3
Output: 0
Explanation: There is no K-spike possible for any i. For element 9 there are at least 3 elements smaller than 9 on the left side but there are only 2 elements that are smaller than 9 on the right side.

Naive approach: The basic way to solve the problem is as follows:

The idea is to check for every element of the price array whether it is a K-spike or not.

• To check we calculate the number of elements that are smaller than prices[i] in the range [0 …… i-1]
• Calculate the number of elements that are smaller than the price[i] in the range[i+1 …… N] by again traversing using loops
• After that if the given condition is satisfied then the price[i] is K-spike then we increment our answer.

Time complexity: O(N²)
Auxillary space: O(1)

Efficient approach: To solve the problem follow the below idea:

In the naive approach we have traversed the array again for finding count of smaller elements till i-1 or from i+1, but how about precalculating the number of elements that are smaller than price[i] in range[0…… i-1] and also in range[i+1…..N) and storing them in an prefix and suffix array respectively.

Follow the steps to solve the problem:

• We construct two array’s prefix and suffix, prefix[i] denotes number of elements that are smaller than price[i] in [0……i-1] and suffix[i] denotes the number of elements that are smaller than price[i] in [i+1 …… N).
• To construct prefix array we maintain a ordered set(Policy based data structure) in which elements till index i-1 already present in set so we can find the position of price[i] in ordered set by using order_of_key function which gives number of items strictly smaller than price[i] then we just put this value at prefix[i] and at last we push price[i] in set.
• To construct suffix array we traverse the price array backwards and do the similar thing that we have done for prefix array.
• Now we have prefix and suffix array in our hand then we traverse the price aray and check if both prefix[i] and suffix[i] are at least K then we increment our answer.

Below is the implementation of the above approach:

C++

// C++ code for the above approach:
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

template <typename T>
using pbds = tree<T, null_type, less<T>, rb_tree_tag,
                  tree_order_statistics_node_update>;

// Function to calculate the number of
// spikes in price array
int CalculateNumberOfKSpikes(vector<int>& price, int k)
{
    int n = price.size();

    // Decalare ordered set
    pbds<int> st1, st2;

    // Initialize a variable for storing our
    // number of K-spikes
    int countOfKspikes = 0;

    // Declaring prefix and suffix array where
    // prefix[i] denotes number of elements
    // that are smaller than price[i] in
    // [0......i-1] and suffix[i] denotes the
    // number of elements that are smaller than
    // price[i] in [i+1 ...... N).
    vector<int> prefix(n + 1, 0), suffix(n + 1, 0);
    for (int i = 0; i < n; i++) {

        // Calculate the number of elements that
        // are smaller than price[i] using
        // order_of_key function
        prefix[i] = st1.order_of_key(price[i]);

        // Insert current price[i] to contribute in
        // next iteration
        st1.insert(price[i]);
    }

    for (int i = n - 1; i >= 0; i--) {

        // Calculate the number of elements that
        // are smaller than price[i] using
        // order_of_key function
        suffix[i] = st2.order_of_key(price[i]);

        // Insert current price[i] to contribute
        // in next iteration
        st2.insert(price[i]);
    }

    for (int i = 0; i < n; i++) {

        // If prefix and suffix are atleast K than
        // current element is k-spike
        if (prefix[i] >= k && suffix[i] >= k) {
            countOfKspikes++;
        }
    }
    return countOfKspikes;
}

// Drivers code
int main()
{
    vector<int> price = { 1, 2, 8, 5, 3, 4 };
    int k = 2;

    int countOfKspikes = CalculateNumberOfKSpikes(price, k);

    // Function Call
    cout << countOfKspikes;
    return 0;
}

Java

import java.util.TreeSet;

public class Main {
    // Function to calculate the number of spikes in price array
    static int calculateNumberOfKSpikes(int[] price, int k) {
        int n = price.length;

        // Declare ordered sets
        TreeSet<Integer> st1 = new TreeSet<>();
        TreeSet<Integer> st2 = new TreeSet<>();

        // Initialize a variable for storing our number of K-spikes
        int countOfKSpikes = 0;

        // Declaring prefix and suffix arrays where
        // prefix[i] denotes the number of elements
        // that are smaller than price[i] in
        // [0......i-1] and suffix[i] denotes the
        // number of elements that are smaller than
        // price[i] in [i+1 ...... N).
        int[] prefix = new int[n + 1];
        int[] suffix = new int[n + 1];

        for (int i = 0; i < n; i++) {
            // Calculate the number of elements that
            // are smaller than price[i] using
            // lower() function
            prefix[i] = st1.headSet(price[i]).size();

            // Insert current price[i] to contribute in
            // the next iteration
            st1.add(price[i]);
        }

        for (int i = n - 1; i >= 0; i--) {
            // Calculate the number of elements that
            // are smaller than price[i] using
            // lower() function
            suffix[i] = st2.headSet(price[i]).size();

            // Insert current price[i] to contribute
            // in the next iteration
            st2.add(price[i]);
        }

        for (int i = 0; i < n; i++) {
            // If prefix and suffix are at least K, then
            // the current element is a K-spike
            if (prefix[i] >= k && suffix[i] >= k) {
                countOfKSpikes++;
            }
        }

        return countOfKSpikes;
    }

    // Driver code
    public static void main(String[] args) {
        int[] price = {1, 2, 8, 5, 3, 4};
        int k = 2;

        int countOfKSpikes = calculateNumberOfKSpikes(price, k);

        // Function Call
        System.out.println(countOfKSpikes);
    }
}

Python3

def calculate_number_of_k_spikes(price, k):
    n = len(price)

    # Declare ordered sets
    st1 = set()
    st2 = set()

    # Initialize a variable for storing the number of K-spikes
    count_of_k_spikes = 0

    # Declaring prefix and suffix arrays where
    # prefix[i] denotes the number of elements
    # that are smaller than price[i] in
    # [0......i-1] and suffix[i] denotes the
    # number of elements that are smaller than
    # price[i] in [i+1 ...... N).
    prefix = [0] * (n + 1)
    suffix = [0] * (n + 1)

    for i in range(n):
        # Calculate the number of elements that
        # are smaller than price[i] using set operations
        prefix[i] = len([x for x in st1 if x < price[i]])

        # Insert current price[i] to contribute in
        # the next iteration
        st1.add(price[i])

    for i in range(n - 1, -1, -1):
        # Calculate the number of elements that
        # are smaller than price[i] using set operations
        suffix[i] = len([x for x in st2 if x < price[i]])

        # Insert current price[i] to contribute
        # in the next iteration
        st2.add(price[i])

    for i in range(n):
        # If prefix and suffix are at least K, then
        # the current element is a K-spike
        if prefix[i] >= k and suffix[i] >= k:
            count_of_k_spikes += 1

    return count_of_k_spikes

# Driver code
if __name__ == "__main__":
    price = [1, 2, 8, 5, 3, 4]
    k = 2

    count_of_k_spikes = calculate_number_of_k_spikes(price, k)

    # Function Call
    print(count_of_k_spikes)
#This Code is Contributed by chinmaya121221

C#

using System;
using System.Collections.Generic;

public class MainClass
{
    // Function to calculate the number of spikes in price array
    static int CalculateNumberOfKSpikes(int[] price, int k)
    {
        int n = price.Length;

        // Declare ordered sets
        SortedSet<int> st1 = new SortedSet<int>();
        SortedSet<int> st2 = new SortedSet<int>();

        // Initialize a variable for storing our number of K-spikes
        int countOfKSpikes = 0;

        // Declaring prefix and suffix arrays where
        // prefix[i] denotes the number of elements
        // that are smaller than price[i] in
        // [0......i-1] and suffix[i] denotes the
        // number of elements that are smaller than
        // price[i] in [i+1 ...... N).
        int[] prefix = new int[n + 1];
        int[] suffix = new int[n + 1];

        for (int i = 0; i < n; i++)
        {
            // Calculate the number of elements that
            // are smaller than price[i] using
            // headSet() function
            prefix[i] = st1.GetViewBetween(int.MinValue, price[i]).Count;

            // Insert current price[i] to contribute in
            // the next iteration
            st1.Add(price[i]);
        }

        for (int i = n - 1; i >= 0; i--)
        {
            // Calculate the number of elements that
            // are smaller than price[i] using
            // headSet() function
            suffix[i] = st2.GetViewBetween(int.MinValue, price[i]).Count;

            // Insert current price[i] to contribute
            // in the next iteration
            st2.Add(price[i]);
        }

        for (int i = 0; i < n; i++)
        {
            // If prefix and suffix are at least K, then
            // the current element is a K-spike
            if (prefix[i] >= k && suffix[i] >= k)
            {
                countOfKSpikes++;
            }
        }

        return countOfKSpikes;
    }

    // Driver code
    public static void Main(string[] args)
    {
        int[] price = { 1, 2, 8, 5, 3, 4 };
        int k = 2;

        int countOfKSpikes = CalculateNumberOfKSpikes(price, k);

        // Function Call
        Console.WriteLine(countOfKSpikes);
    }
}

// This code is contributed by akshitaguprzj3

Javascript

// Function to calculate the number of K-spikes in the given array
function calculateNumberOfKSpikes(price, k) {
    const n = price.length;

    // Declare sets for prefix and suffix
    const st1 = new Set();
    const st2 = new Set();

    // Initialize a variable for storing the number of K-spikes
    let countOfKSpikes = 0;

    // Arrays to store prefix and suffix counts
    const prefix = new Array(n + 1).fill(0);
    const suffix = new Array(n + 1).fill(0);

    // Calculate prefix counts
    for (let i = 0; i < n; i++) {
        prefix[i] = [...st1].filter(x => x < price[i]).length;

        // Insert current price[i] to contribute in the next iteration
        st1.add(price[i]);
    }

    // Clear sets for suffix calculation
    st1.clear();

    // Calculate suffix counts
    for (let i = n - 1; i >= 0; i--) {
        suffix[i] = [...st2].filter(x => x < price[i]).length;

        // Insert current price[i] to contribute in the next iteration
        st2.add(price[i]);
    }

    // Check for K-spikes
    for (let i = 0; i < n; i++) {
        // If prefix and suffix are at least K, then the current element is a K-spike
        if (prefix[i] >= k && suffix[i] >= k) {
            countOfKSpikes++;
        }
    }

    return countOfKSpikes;
}

// Driver code
const price = [1, 2, 8, 5, 3, 4];
const k = 2;

// Function Call
const countOfKSpikes = calculateNumberOfKSpikes(price, k);
console.log(countOfKSpikes);

Output

2

Time Complexity: O(N*logN)
Auxillary space: O(N), where N is the size of the array.