Skip to content
Related Articles

Related Articles

Find resultant Array after applying Convolution on given array using given mask

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 21 Jan, 2022

Given two arrays arr[] containing N integers and a mask[] of an odd size. The task is to replace every array element with the value computed by performing the same convolution on the array.

Examples:

Input: arr[] = {9, 7, 3, 9, 1, 8, 11}, mask[]={1, 2, -1}
Output: 11 20 4 20 3 6 30 
Explanation: Following are the operations performed in the given array arr[]
For index 0: 0*1 + 9*2 + 7*-1 = 11
For index 1: 9*1 + 7*2 + 3*-1 = 20
For index 2: 7*1 + 3*2 + 9*-1 = 4
For index 3: 3*1 + 9*2 + 1*-1 = 20
For index 4: 9*1 + 1*2 + 8*-1 = 3
For index 5: 1*1 + 8*2 + 11*-1 = 6
For index 6: 8*1 + 11*2 + 0*-1 = 30

Input: arr[] = {13, 26, 35, 41, 23, 18, 38}, mask[]={-1, 3, 5, -3, 1} 
Output: 240 117 140 233 187 4 221 

 

Approach: The simplest approach to solve this problem is to use nested loops. The outer loop will traverse the array from left to right, i.e. from i = 0 to i < N, and an inner loop will traverse the mask from index i – K/2 to the index i + K/2 and calculate the convolution of them. Finally, print the output.

Below is the implementation of the above approach:

C++




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




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


Python3




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




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


Javascript




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


Output

11 20 4 20 3 6 30 

Time Complexity: O(N*K)
Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!