Open in App
Not now

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

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

 ``

Output

`11 20 4 20 3 6 30 `

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

My Personal Notes arrow_drop_up
Related Articles