# Reduce all array elements to zero by performing given operations thrice

• Difficulty Level : Medium
• Last Updated : 21 Apr, 2021

Given an array arr[] of size N, the task is to convert every array element to 0 by applying the following operations exactly three times:

• Select a subarray.
• Increment every element of the subarray by the integer multiple of its length.

Finally, print the first and last indices of the subarray involved and the elements added to every index of the subarray in each step.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:

Input: arr[] = {1, 3, 2, 4}
Output:
Operation 1: 1 1
Operation 2: 3 4
Operation 3: 2 4
Explanation:
Step 1: Select subarray {arr} and add -1 to the only element in the subarray. Hence, the array arr[] modifies to {0, 3, 2, 4}.
Step 2: Select subarray {arr, arr} and add {4, 2} to the subarray elements respectively. Hence, the array arr[] modifies to {0, 3, 6, 6}.
Step 3: Select subarray {arr, arr} and add {-3, -6, -6} to the subarray elements respectively. Hence, the array arr[] modifies to {0, 0, 0, 0}

Input: arr[] = { 5 }
Output:
Operation 1 : 1 1
Operation 2 : 1 1
Operation 3 : 1 1

Approach: The given problem can be solved based on the following observations:

Operation 1: Select subarray {arr, .., arr[N]}. Set A[i] = A[i] – N * A[i] = (N – 1) * (-A[i]).
After operation 1, each element is a multiple of (N – 1).
Operation 2: Select subarray {arr, .. arr[N – 1]}. Add / Subtract a multiple of (N – 1) to all values of the subarray till they reduce to 0.
Operation 3: Select subarray {arr[N]}, of size 1. Add / Subtract a multiple of 1 to make A[N] = 0.

Follow the steps below to solve the problem:

• If N is equal to 1, then print -arr, +arr, -arr respectively in three moves.
• Otherwise, perform the following operations:
• Print 1 N. Subtract N * arr[i] from each element of the array print the subtracted elements.
• Print 1 N – 1. Subtract (N – 1) * arr[i] from each element of the subarray and print the subtracted values.
• Finally, print N. Subtract arr[i – 1] from the element. Print arr[i – 1].

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach``#include ``using` `namespace` `std;` `// Function to reduce all``// array elements to zero``void` `ConvertArray(``int` `arr[], ``int` `N)``{``    ``// If size of array is 1``    ``if` `(N == 1) {` `        ``// First operation``        ``cout << ``"Operation 1 : "` `<< 1``             ``<< ``" "` `<< 1 << endl;``        ``cout << ``"Added elements: "``             ``<< -1 * arr << endl;``        ``cout << endl;` `        ``// 2nd Operation``        ``cout << ``"Operation 2 : "``             ``<< 1 << ``" "` `<< 1 << endl;``        ``cout << ``"Added elements: "``             ``<< 1 * arr << endl;``        ``cout << endl;` `        ``// 3rd Operation``        ``cout << ``"Operation 3 : "``             ``<< 1 << ``" "` `<< 1 << endl;``        ``cout << ``"Added elements: "``             ``<< -1 * arr << endl;``    ``}` `    ``// Otherwise``    ``else` `{` `        ``// 1st Operation``        ``cout << ``"Operation 1 : "``             ``<< 1 << ``" "` `<< N << endl;``        ``cout << ``"Added elements: "``;``        ``for` `(``int` `i = 0; i < N; i++) {``            ``cout << -1 * arr[i] * N << ``" "``;``        ``}``        ``cout << endl;``        ``cout << endl;` `        ``// 2nd Operation``        ``cout << ``"Operation 2 : "``             ``<< 1 << ``" "` `<< N - 1 << endl;``        ``cout << ``"Added elements: "``;``        ``for` `(``int` `i = 0; i < N - 1; i++) {``            ``cout << arr[i] * (N - 1) << ``" "``;``        ``}``        ``cout << endl;``        ``cout << endl;` `        ``// 3rd Operation``        ``cout << ``"Operation 3 : "` `<< N``             ``<< ``" "` `<< N << endl;``        ``cout << ``"Added elements: "``;``        ``cout << arr[N - 1] * (N - 1) << endl;``    ``}``}` `// Driver Code``int` `main()``{``    ``// Input``    ``int` `arr[] = { 1, 3, 2, 4 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function call to make all``    ``// array elements equal to 0``    ``ConvertArray(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG{` `  ``// Function to reduce all``  ``// array elements to zero``  ``static` `void` `ConvertArray(``int` `arr[], ``int` `N)``  ``{` `    ``// If size of array is 1``    ``if` `(N == ``1``) {` `      ``// First operation``      ``System.out.println(``"Operation 1 : "` `+ ``1``                         ``+ ``" "` `+ ``1` `);``      ``System.out.println(``"Added elements: "``                         ``+ -``1` `* arr[``0``] );``      ``System.out.println();` `      ``// 2nd Operation``      ``System.out.println(``"Operation 2 : "``                         ``+ ``1` `+ ``" "` `+ ``1` `);``      ``System.out.println(``"Added elements: "``                         ``+ ``1` `* arr[``0``] );``      ``System.out.println();` `      ``// 3rd Operation``      ``System.out.println(``"Operation 3 : "``                         ``+ ``1` `+ ``" "` `+ ``1` `);``      ``System.out.println(``"Added elements: "``                         ``+ -``1` `* arr[``0``] );``    ``}` `    ``// Otherwise``    ``else` `{` `      ``// 1st Operation``      ``System.out.println(``"Operation 1 : "``                         ``+ ``1` `+ ``" "` `+ N );``      ``System.out.print(``"Added elements: "``);``      ``for` `(``int` `i = ``0``; i < N; i++) {``        ``System.out.print(-``1` `* arr[i] * N + ``" "``);``      ``}``      ``System.out.println();``      ``System.out.println();` `      ``// 2nd Operation``      ``System.out.println(``"Operation 2 : "``                         ``+ ``1` `+ ``" "` `+ (N - ``1``) );``      ``System.out.print(``"Added elements: "``);``      ``for` `(``int` `i = ``0``; i < N - ``1``; i++) {``        ``System.out.print(arr[i] * (N - ``1``) + ``" "``);``      ``}``      ``System.out.println();``      ``System.out.println();` `      ``// 3rd Operation``      ``System.out.println(``"Operation 3 : "` `+ N``                         ``+ ``" "` `+ N );``      ``System.out.print(``"Added elements: "``);``      ``System.out.println(arr[N - ``1``] * (N - ``1``) );``    ``}``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``// Input``    ``int` `arr[] = { ``1``, ``3``, ``2``, ``4` `};``    ``int` `N = arr.length;` `    ``// Function call to make all``    ``// array elements equal to 0``    ``ConvertArray(arr, N);``  ``}``}` `// This code is contributed by souravghosh0416.`

## Python3

 `# Python 3 program of the above approach` `# Function to reduce all``# array elements to zero``def` `ConvertArray(arr, N):``  ` `    ``# If size of array is 1``    ``if` `(N ``=``=` `1``):``      ` `        ``# First operation``        ``print``(``"Operation 1 :"``,``1``,``1``)``        ``print``(``"Added elements:"``,``-``1` `*` `arr[``0``])``        ``print``(``"\n"``,end ``=` `"")` `        ``# 2nd Operation``        ``print``(``"Operation 2 :"``,``1``,``1``)``        ``print``(``"Added elements:"``,``1` `*` `arr[``0``])``        ``print``(``"\n"``,end ``=` `"")` `        ``# 3rd Operation``        ``print``(``"Operation 3 :"``,``1``,``1``)``        ``print``(``"Added elements:"``,``-``1` `*` `arr[``0``])``        ``print``(``"\n"``,end ``=` `"")` `    ``# Otherwise``    ``else``:``      ` `        ``# 1st Operation``        ``print``(``"Operation 1 :"``,``1``,N)``        ``print``(``"Added elements:"``,end ``=` `" "``)``        ``for` `i ``in` `range``(N):``            ``print``(``-``1` `*` `arr[i] ``*` `N,end ``=` `" "``)``        ``print``(``"\n"``)` `        ``# 2nd Operation``        ``print``(``"Operation 2 :"``,``1``,N ``-` `1``)``        ``print``(``"Added elements:"``,end ``=` `" "``)``        ``for` `i ``in` `range``(N ``-` `1``):``            ``print``(arr[i] ``*` `(N ``-` `1``),end ``=` `" "``)``        ``print``(``"\n"``)` `        ``# 3rd Operation``        ``print``(``"Operation 3 : "``,N,N)``        ``print``(``"Added elements:"``,end ``=` `" "``)``        ``print``(arr[N ``-` `1``] ``*` `(N ``-` `1``))` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Input``    ``arr ``=`  `[``1``, ``3``, ``2``, ``4``]``    ``N ``=`  `len``(arr)``    ` `    ``# Function call to make all``    ``# array elements equal to 0``    ``ConvertArray(arr, N)``    ` `    ``# This code is contributed by ipg2016107.`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG{` `  ``// Function to reduce all``  ``// array elements to zero``  ``static` `void` `ConvertArray(``int``[] arr, ``int` `N)``  ``{` `    ``// If size of array is 1``    ``if` `(N == 1) {` `      ``// First operation``      ``Console.WriteLine(``"Operation 1 : "` `+ 1``                         ``+ ``" "` `+ 1 );``      ``Console.WriteLine(``"Added elements: "``                         ``+ -1 * arr );``      ``Console.WriteLine();` `      ``// 2nd Operation``      ``Console.WriteLine(``"Operation 2 : "``                         ``+ 1 + ``" "` `+ 1 );``      ``Console.WriteLine(``"Added elements: "``                         ``+ 1 * arr );``      ``Console.WriteLine();` `      ``// 3rd Operation``      ``Console.WriteLine(``"Operation 3 : "``                         ``+ 1 + ``" "` `+ 1 );``      ``Console.WriteLine(``"Added elements: "``                         ``+ -1 * arr );``    ``}` `    ``// Otherwise``    ``else` `{` `      ``// 1st Operation``      ``Console.WriteLine(``"Operation 1 : "``                         ``+ 1 + ``" "` `+ N );``      ``Console.Write(``"Added elements: "``);``      ``for` `(``int` `i = 0; i < N; i++) {``        ``Console.Write(-1 * arr[i] * N + ``" "``);``      ``}``      ``Console.WriteLine();``      ``Console.WriteLine();` `      ``// 2nd Operation``      ``Console.WriteLine(``"Operation 2 : "``                         ``+ 1 + ``" "` `+ (N - 1) );``      ``Console.Write(``"Added elements: "``);``      ``for` `(``int` `i = 0; i < N - 1; i++) {``        ``Console.Write(arr[i] * (N - 1) + ``" "``);``      ``}``      ``Console.WriteLine();``      ``Console.WriteLine();` `      ``// 3rd Operation``      ``Console.WriteLine(``"Operation 3 : "` `+ N``                         ``+ ``" "` `+ N );``      ``Console.Write(``"Added elements: "``);``      ``Console.WriteLine(arr[N - 1] * (N - 1) );``    ``}``  ``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``  ` `    ``// Input``    ``int``[] arr = { 1, 3, 2, 4 };``    ``int` `N = arr.Length;` `    ``// Function call to make all``    ``// array elements equal to 0``    ``ConvertArray(arr, N);``}``}` `// This code is contributed by code_hunt.`

## Javascript

 ``

Output:
```Operation 1 : 1 4
Added elements: -4 -12 -8 -16

Operation 2 : 1 3

Operation 3 : 4 4

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

My Personal Notes arrow_drop_up