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.33Input: 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++ code to find the simple moving average #include <bits/stdc++.h> #include <iomanip> 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[0]);
int K = 3;
ComputeMovingAverage(arr, N, K);
return 0;
} |
// 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 |
# 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# 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. |
<script> // JavaScript code for the above approach
// Function to compute moving average
// of previous K elements
function ComputeMovingAverage(arr, N,
K) {
let i;
let sum = 0;
// Initial sum of K elements.
for (i = 0; i < K; i++) {
sum += arr[i];
document.write((sum / K).toFixed(2) + " " );
}
// Compute MA from index K
for (i = K; i < N; i++) {
sum -= arr[i - K];
sum += arr[i];
avg = sum / K;
document.write((avg).toFixed(2) + " " );
}
}
// Driver code
let arr = [1, 3, 5, 6, 8];
let N = arr.length;
let K = 3;
ComputeMovingAverage(arr, N, K);
// This code is contributed by Potta Lokesh
</script>
|
0.33 1.33 3.00 4.67 6.33
Time complexity: O(N)
Space complexity: O(1)