Programa para encontrar la media móvil simple | Conjunto-2

Promedio móvil simple

Dado un arr[] de tamaño N , que contiene solo números enteros positivos y un número entero K . La tarea es calcular el promedio móvil simple de K elementos anteriores. 

Ejemplos:

Entrada: { 1, 3, 5, 6, 8 }, K = 3
Salida: 0.33 1.33 3.00 4.67 6.33
Explicación: El nuevo número agregado es 1.0, SMA = 0.33
El nuevo número agregado es 3.0, SMA = 1.33
El nuevo número agregado es 5.0, SMA = 3.0
El nuevo número agregado es 6.0, SMA = 4.67
El nuevo número agregado es 8.0, SMA = 6.33        

Entrada: Array[]= {2, 5, 7, 3, 11, 9, 13, 12}, K = 2
Salida: 1,0 3,5 6 ​​5 7 10 11 12,5

Enfoque ingenuo: utiliza dos bucles anidados. El bucle exterior atraviesa la array de izquierda a derecha. El bucle interno calcula el promedio de K elementos anteriores, incluyéndose a sí mismo para cada índice. Finalmente, se imprimen los valores de la media móvil. El bucle exterior comienza a recorrer desde el índice K mismo. En lugar de almacenar el resultado, podemos mostrar directamente la salida para evitar el uso de espacios adicionales.

Complejidad temporal: O(N*K)
Complejidad espacial: O(1)

Enfoque eficiente: El enfoque eficiente se analiza en el Conjunto-1 de este problema.

Enfoque optimizado para el espacio: utiliza una ventana deslizante para mejorar la eficiencia del tiempo y la optimización del espacio. Una ventana de tamaño K comienza desde el índice K y el promedio móvil se imprime para cada índice a partir de entonces. 

A continuación se muestra la implementación del enfoque anterior. 

// 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 

Complejidad temporal: O(N)
Complejidad espacial: O(1)