 Open in App
Not now

# Program to find simple moving average | Set-2

• Difficulty Level : Hard
• Last Updated : 11 Jan, 2022

Simple Moving Average is the average obtained from the data for some t period of time . In normal mean, its value get changed with the changing data but in this type of mean it also changes with the time interval. We get the mean for some period t and then we remove some previous data. Again we get new mean and this process continues. This is why it is moving average. This has a great application in the financial market. OR this can be simply visualized as follows.

Given an arr[] of size N, containing only positive integers and an integer K. The task is to compute the simple moving average of previous K elements.

Examples:

Input: { 1, 3, 5, 6, 8 }, K = 3
Output: 0.33 1.33 3.00 4.67 6.33
Explanation: New number added is 1.0, SMA = 0.33
New number added is 3.0, SMA = 1.33
New number added is 5.0, SMA = 3.0
New number added is 6.0, SMA = 4.67
New number added is 8.0, SMA = 6.33

Input: Array[]= {2, 5, 7, 3, 11, 9, 13, 12}, K = 2
Output: 1.0 3.5 6 5 7 10 11 12.5

Naive Approach: This uses two nested loops. Outer loop traverses the array from left to right. Inner loop computes the average of K previous elements including itself for each index. Finally, the moving average values are printed. The outer loop starts traversal from index K itself. Instead of storing the result, we can directly display the output to avoid using extra spaces.

Time complexity: O(N*K)
Space complexity: O(1)

Efficient Approach: The efficient approach is discussed in the Set-1 of this problem.

Space Optimized approach: This uses sliding window for better time efficiency and space optimization. A window of size K starts from index K and the moving average is printed for each index thereafter.

Below is the implementation of the above approach.

## C++

 `// C++ code to find the simple moving average``#include ``#include ``using` `namespace` `std;` `// Function to compute moving average``// of previous K elements``void` `ComputeMovingAverage(``int` `arr[], ``int` `N,``                          ``int` `K)``{``    ``int` `i;``    ``float` `sum = 0;` `    ``// Initial sum of K elements.``    ``for` `(i = 0; i < K; i++) {``        ``sum += arr[i];``        ``cout << setprecision(2) << std::fixed;``        ``cout << sum / K << ``" "``;``    ``}` `    ``// Compute MA from index K``    ``float` `avg;``    ``for` `(i = K; i < N; i++) {``        ``sum -= arr[i - K];``        ``sum += arr[i];``        ``avg = sum / K;``        ``cout << setprecision(2) << std::fixed;``        ``cout << avg << ``" "``;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 3, 5, 6, 8 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `K = 3;``    ``ComputeMovingAverage(arr, N, K);``    ``return` `0;``}`

## Java

 `// Java code to find the simple moving average``import` `java.util.*;``class` `GFG{` `  ``// Function to compute moving average``  ``// of previous K elements``  ``static` `void` `ComputeMovingAverage(``int` `arr[], ``int` `N,``                                   ``int` `K)``  ``{``    ``int` `i;``    ``float` `sum = ``0``;` `    ``// Initial sum of K elements.``    ``for` `(i = ``0``; i < K; i++) {``      ``sum += arr[i];``      ``System.out.printf(``"%.2f "``,sum / K);``    ``}` `    ``// Compute MA from index K``    ``for` `(i = K; i < N; i++) {``      ``sum -= arr[i - K];``      ``sum += arr[i];``      ``System.out.printf(``"%.2f "``,sum / K);``    ``}``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = { ``1``, ``3``, ``5``, ``6``, ``8` `};``    ``int` `N = arr.length;``    ``int` `K = ``3``;``    ``ComputeMovingAverage(arr, N, K);``  ``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python code for the above approach` `# Function to compute moving average``# of previous K elements``def` `ComputeMovingAverage(arr, N, K):``    ``i ``=` `None``    ``sum` `=` `0` `    ``# Initial sum of K elements.``    ``for` `i ``in` `range``(K):``        ``sum` `+``=` `arr[i]``        ``print``(``"%.2f"``%``(``sum` `/` `K), end``=` `" "``)` `    ``# Compute MA from index K``    ``for` `i ``in` `range``(K, N):``        ``sum` `-``=` `arr[i ``-` `K]``        ``sum` `+``=` `arr[i]``        ``avg ``=` `sum` `/` `K``        ``print``(``"%.2f"``%``(avg), end ``=``" "``)` `# Driver code``arr ``=` `[``1``, ``3``, ``5``, ``6``, ``8``]``N ``=` `len``(arr)``K ``=` `3``ComputeMovingAverage(arr, N, K)` `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# code to find the simple moving average``using` `System;` `class` `GFG {` `  ``// Function to compute moving average``  ``// of previous K elements``  ``static` `void` `ComputeMovingAverage(``int``[] arr, ``int` `N,``                                   ``int` `K)``  ``{``    ``int` `i;``    ``float` `sum = 0;` `    ``// Initial sum of K elements.``    ``for` `(i = 0; i < K; i++) {``      ``sum += arr[i];``      ``Console.Write(Math.Round((sum / K),2) + ``" "``);``    ``}` `    ``// Compute MA from index K``    ``for` `(i = K; i < N; i++) {``      ``sum -= arr[i - K];``      ``sum += arr[i];``      ``Console.Write(Math.Round(sum / K, 2) + ``" "``);``    ``}``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[] arr = { 1, 3, 5, 6, 8 };``    ``int` `N = arr.Length;``    ``int` `K = 3;``    ``ComputeMovingAverage(arr, N, K);``  ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``

Output

`0.33 1.33 3.00 4.67 6.33 `

Time complexity: O(N)
Space complexity: O(1)

My Personal Notes arrow_drop_up