Encuentre la array resultante después de aplicar la convolución en la array dada usando la máscara dada

Dadas dos arrays arr[] que contienen N enteros y una máscara[] de tamaño impar. La tarea es reemplazar cada elemento de la array con el valor calculado al realizar la misma convolución en la array.

Ejemplos:

Entrada: arr[] = {9, 7, 3, 9, 1, 8, 11}, mask[]={1, 2, -1}
Salida: 11 20 4 20 3 6 30 
Explicación: Las siguientes son las operaciones realizadas en la array dada arr[]
Para el índice 0: 0*1 + 9*2 + 7*-1 = 11
Para el índice 1: 9*1 + 7*2 + 3*-1 = 20
Para el índice 2: 7*1 + 3*2 + 9*-1 = 4
Para índice 3: 3*1 + 9*2 + 1*-1 = 20
Para índice 4: 9*1 + 1*2 + 8*-1 = 3
Para índice 5 : 1*1 + 8*2 + 11*-1 = 6
Para índice 6: 8*1 + 11*2 + 0*-1 = 30

Entrada: arr[] = {13, 26, 35, 41, 23, 18, 38}, máscara[]={-1, 3, 5, -3, 1} 
Salida: 240 117 140 233 187 4 221 

Enfoque: El enfoque más simple para resolver este problema es usar bucles anidados . El bucle exterior atravesará la array de izquierda a derecha, es decir, desde i = 0 hasta i < N , y un bucle interior atravesará la máscara desde el índice i – K/2 hasta el índice i + K/2 y calculará la convolución de a ellos. Finalmente, imprima la salida.

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

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to perform same convolution
void ComputeSameConvolution(int arr[],
                            int mask[], int N,
                            int K)
{
    int i, j, k, sum;
 
    // Nested loops
    for (i = 0; i < N; i++) {
        sum = 0;
        k = 0;
        for (j = i - (K / 2); j <= i + (K / 2);
             j++) {
            if (j < 0 || j >= N)
                k++;
            else
                sum += arr[j] * mask[k++];
        }
 
        // Print the required sum
        cout << sum << ' ';
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 9, 7, 3, 9, 1, 8, 11 };
    int mask[] = { 1, 2, -1 };
 
    int K = sizeof(mask) / sizeof(mask[0]);
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    ComputeSameConvolution(arr, mask, N, K);
    return 0;
}

// Java program for the above approach
class GFG {
 
  // Function to perform same convolution
  static void ComputeSameConvolution(int[] arr,
                                     int[] mask, int N,
                                     int K)
  {
    int i, j, k, sum;
 
    // Nested loops
    for (i = 0; i < N; i++) {
      sum = 0;
      k = 0;
      for (j = i - (K / 2); j <= i + (K / 2); j++) {
        if (j < 0 || j >= N)
          k++;
        else
          sum += arr[j] * mask[k++];
      }
 
      // Print the required sum
      System.out.print(sum + " ");
    }
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    int[] arr = { 9, 7, 3, 9, 1, 8, 11 };
    int[] mask = { 1, 2, -1 };
 
    int K = mask.length;
    int N = arr.length;
 
    // Function Call
    ComputeSameConvolution(arr, mask, N, K);
  }
}
 
// This code is contributed by ukasp.

# Python code for the above approach
 
# Function to perform same convolution
def ComputeSameConvolution(arr, mask, N, K):
    i = None
    j = None
    k = None
    sum = None
 
    # Nested loops
    for i in range(N):
        sum = 0;
        k = 0;
        for j in range(i - (K // 2), i + (K // 2) + 1):
            if (j < 0 or j >= N):
                k += 1
            else:
                sum += arr[j] * mask[k];
                k += 1
 
        # Print the required sum
        print(sum, end=' ');
 
# Driver Code
arr = [9, 7, 3, 9, 1, 8, 11];
mask = [1, 2, -1];
 
K = len(mask)
N = len(arr)
 
# Function Call
ComputeSameConvolution(arr, mask, N, K);
 
# This code is contributed by gfgking

// C# program for the above approach
using System;
class GFG
{
 
// Function to perform same convolution
static void ComputeSameConvolution(int []arr,
                            int []mask, int N,
                            int K)
{
    int i, j, k, sum;
 
    // Nested loops
    for (i = 0; i < N; i++) {
        sum = 0;
        k = 0;
        for (j = i - (K / 2); j <= i + (K / 2);
             j++) {
            if (j < 0 || j >= N)
                k++;
            else
                sum += arr[j] * mask[k++];
        }
 
        // Print the required sum
        Console.Write(sum + " ");
    }
}
 
// Driver Code
public static void Main()
{
    int []arr = { 9, 7, 3, 9, 1, 8, 11 };
    int []mask = { 1, 2, -1 };
     
    int K = mask.Length;
    int N = arr.Length;
     
    // Function Call
    ComputeSameConvolution(arr, mask, N, K);
 
}
}
 
// This code is contributed by Samim Hossain Mondal.

<script>
        // JavaScript code for the above approach
 
        // Function to perform same convolution
        function ComputeSameConvolution(arr,
            mask, N, K)
        {
            let i, j, k, sum;
 
            // Nested loops
            for (i = 0; i < N; i++) {
                sum = 0;
                k = 0;
                for (j = i - Math.floor(K / 2); j <= i + Math.floor(K / 2);
                    j++) {
                    if (j < 0 || j >= N)
                        k++;
                    else
                        sum += arr[j] * mask[k++];
                }
 
                // Print the required sum
                document.write(sum + ' ');
            }
        }
 
        // Driver Code
        let arr = [9, 7, 3, 9, 1, 8, 11];
        let mask = [1, 2, -1];
 
        let K = mask.length;
        let N = arr.length;
 
        // Function Call
        ComputeSameConvolution(arr, mask, N, K);
 
  // This code is contributed by Potta Lokesh
    </script>

11 20 4 20 3 6 30 

Complejidad temporal: O(N*K)
Espacio auxiliar: O(1)