 GFG App
Open App Browser
Continue

# Minimize Array size by replacing adjacent integers by their Modulo

Given an array arr[] of positive integers of size N, the task is to find the minimum possible size of the array that can be obtained by replacing any two adjacent positive elements with their modulo i.e., (arr[i]%arr[i+1] or arr[i+1]%arr[i]).

Examples:

Input: arr[] = {3, 4, 5, 2, 1}
Output: 1
Explanation:  The following series of operations leads to a minimum size of the array under given conditions.
Select i = 0 and i+1. Replace them with 3%4. Updated arr[] = {3, 5, 2, 1}
Select i = 0 and i+1. Replace them with 3%5. Updated arr[] = {3, 2, 1}
Select i = 1 and i+1. Replace them with 1%2. Updated arr[] = {3, 1}
Select i = 1 and i+1. Replace them with 1%3. Updated arr[] = {1}

Input: arr[] = {2, 2, 2, 2}
Output: 2
Explanation: The following series of operations leads to a minimum size of the array under given conditions.
Select i = 0 and i+1. Replace them 2%2. Updated arr[] = {0, 2, 2}
Select i = 1 and i+1. Replace them 2%2. Updated arr[] = {0, 0}
Since there are no more adjacent positive integers left in the array we cannot perform the operation. So the final array will have no less than 2 elements.

Approach: The problem can be solved based on the following idea:

If two adjacent elements in the array are unequal then we can always  make their modulo to be equal to the smaller number (a%b = a where a is smaller than b). Therefore, we can say that the smallest element in the array will remain at last after all the operations are done.
Therefore, we can say the count of the number of occurrences of the smallest element of the array is the required answer.

Follow the below steps to implement the idea:

• Initialize the cnt = 0, to store the frequency of the minimum element.
• Iterate over the array arr[],  and keep on checking the count of minimum element.
• If the length of array arr[] is 1 or 2, always return 1.
• Otherwise, return ceil(cnt / 2).

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Function to find minimum array size` `int` `min_size(``int` `arr[], ``int` `n)` `{` `    ``// If the array has one or two positive` `    ``// integers then answer will always be 1` `    ``if` `(n == 1 || n == 2) {` `        ``return` `1;` `    ``}`   `    ``int` `min_ele = INT_MAX, i = 0;`   `    ``// Stores the number of occurrences` `    ``// of the smallest element` `    ``int` `cnt = 0;`   `    ``// Loop to find the minimum element and` `    ``// the occurrences of it` `    ``for` `(i = 0; i < n; i++) {`   `        ``// If arr[i] is smaller than min_ele` `        ``if` `(arr[i] < min_ele) {` `            ``cnt = 0;` `            ``min_ele = arr[i];` `        ``}`   `        ``if` `(arr[i] == min_ele) {` `            ``cnt++;` `        ``}` `    ``}`   `    ``return` `ceil``((``float``)cnt / 2);` `}`   `// Driver code` `int` `main()` `{` `    ``// Test case 1` `    ``int` `arr1[] = { 5, 5, 5, 5, 4 };` `    ``int` `N = ``sizeof``(arr1) / ``sizeof``(arr1);`   `    ``// Function call` `    ``cout << min_size(arr1, N) << endl;`   `    ``// Test case 2` `    ``int` `arr2[] = { 2, 2, 2, 2, 2, 2, 2 };` `    ``N = ``sizeof``(arr2) / ``sizeof``(arr2);`   `    ``// Function call` `    ``cout << min_size(arr2, N) << endl;`   `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach` `import` `java.io.*;`   `class` `GFG {`   `  ``// Function to find minimum array size` `  ``static` `int` `min_size(``int``[] arr, ``int` `n)` `  ``{` `    ``// If the array has one or two positive` `    ``// integers then answer will always be 1` `    ``if` `(n == ``1` `|| n == ``2``) {` `      ``return` `1``;` `    ``}`   `    ``int` `min_ele = Integer.MAX_VALUE, i = ``0``;`   `    ``// Stores the number of occurrences` `    ``// of the smallest element` `    ``int` `cnt = ``0``;`   `    ``// Loop to find the minimum element and` `    ``// the occurrences of it` `    ``for` `(i = ``0``; i < n; i++) {`   `      ``// If arr[i] is smaller than min_ele` `      ``if` `(arr[i] < min_ele) {` `        ``cnt = ``0``;` `        ``min_ele = arr[i];` `      ``}`   `      ``if` `(arr[i] == min_ele) {` `        ``cnt++;` `      ``}` `    ``}`   `    ``return` `(``int``)Math.ceil((``float``)cnt / ``2``);` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``// Test case 1` `    ``int``[] arr1 = { ``5``, ``5``, ``5``, ``5``, ``4` `};` `    ``int` `N = arr1.length;`   `    ``// Function call` `    ``System.out.println(min_size(arr1, N));`   `    ``// Test case 2` `    ``int``[] arr2 = { ``2``, ``2``, ``2``, ``2``, ``2``, ``2``, ``2` `};` `    ``N = arr2.length;`   `    ``// Function call` `    ``System.out.println(min_size(arr2, N));` `  ``}` `}`   `// This code is contributed by lokeshmvs21.`

## Python3

 `# python implementation` `import` `math` `import` `sys`   `def` `min_size(arr, n):` `    ``# If the array has one or two positive` `    ``# integers then answer will always be 1` `    ``if` `n ``=``=` `1` `or` `n ``=``=` `2``:` `        ``return` `1`   `    ``min_ele ``=` `sys.maxsize` `    ``cnt ``=` `0` `    ``for` `i ``in` `range``(n):` `        ``# If arr[i] is smaller than min_ele` `        ``if` `arr[i] < min_ele:` `            ``cnt ``=` `0` `            ``min_ele ``=` `arr[i]` `        ``if` `arr[i] ``=``=` `min_ele:` `            ``cnt ``+``=` `1`   `    ``return` `math.ceil(cnt ``/` `2``)`     `# Test case 1` `arr1 ``=` `[``5``, ``5``, ``5``, ``5``, ``4``]` `N ``=` `len``(arr1)`   `# Function call` `print``(min_size(arr1, N))`   `# Test case 2` `arr2 ``=` `[``2``, ``2``, ``2``, ``2``, ``2``, ``2``, ``2``]` `N ``=` `len``(arr2)`   `# Function call` `print``(min_size(arr2, N))`   `# This code is contributed by ksam24000`

## C#

 `// C# code to implement the approach` `using` `System;`   `public` `class` `GFG {`   `  ``// Function to find minimum array size` `  ``static` `int` `min_size(``int``[] arr, ``int` `n)` `  ``{` `    ``// If the array has one or two positive` `    ``// integers then answer will always be 1` `    ``if` `(n == 1 || n == 2) {` `      ``return` `1;` `    ``}`   `    ``int` `min_ele = ``int``.MaxValue, i = 0;`   `    ``// Stores the number of occurrences` `    ``// of the smallest element` `    ``int` `cnt = 0;`   `    ``// Loop to find the minimum element and` `    ``// the occurrences of it` `    ``for` `(i = 0; i < n; i++) {` `      ``// If arr[i] is smaller than min_ele` `      ``if` `(arr[i] < min_ele) {` `        ``cnt = 0;` `        ``min_ele = arr[i];` `      ``}`   `      ``if` `(arr[i] == min_ele) {` `        ``cnt++;` `      ``}` `    ``}`   `    ``return` `(``int``)Math.Ceiling((``double``)cnt / 2);` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``// Test case 1` `    ``int``[] arr1 = { 5, 5, 5, 5, 4 };` `    ``int` `N = arr1.Length;`   `    ``// Function call` `    ``Console.WriteLine(min_size(arr1, N));`   `    ``// Test case 2` `    ``int``[] arr2 = { 2, 2, 2, 2, 2, 2, 2 };` `    ``N = arr2.Length;`   `    ``// Function call` `    ``Console.WriteLine(min_size(arr2, N));` `  ``}` `}`   `// This code is contributed by lokesh.`

## Javascript

 `// JavaScript code to implement the approach`   `// Function to find minimum array size` `function` `min_size(arr, n)` `{` `    ``// If the array has one or two positive` `    ``// integers then answer will always be 1` `    ``if` `(n == 1 || n == 2) {` `        ``return` `1;` `    ``}`   `    ``let min_ele = 1e9, i = 0;`   `    ``// Stores the number of occurrences` `    ``// of the smallest element` `    ``let cnt = 0;`   `    ``// Loop to find the minimum element and` `    ``// the occurrences of it` `    ``for` `(i = 0; i < n; i++) {`   `        ``// If arr[i] is smaller than min_ele` `        ``if` `(arr[i] < min_ele) {` `            ``cnt = 0;` `            ``min_ele = arr[i];` `        ``}`   `        ``if` `(arr[i] == min_ele) {` `            ``cnt++;` `        ``}` `    ``}`   `    ``return` `Math.ceil(parseFloat(cnt) / 2);` `}`   `// Driver code` `    ``// Test case 1` `    ``let arr1 = [ 5, 5, 5, 5, 4 ];` `    ``let N = arr1.length;`   `    ``// Function call` `    ``console.log( min_size(arr1, N));`   `    ``// Test case 2` `    ``let arr2 = [2, 2, 2, 2, 2, 2, 2 ];` `    ``N = arr2.length;`   `    ``// Function call` `    ``console.log( min_size(arr2, N));`   `// This code is contributed by poojaagarwal2.`

## PHP

 ``

Output

```1
4```

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

Related Articles:

My Personal Notes arrow_drop_up