Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimum inverting factor in an array

  • Difficulty Level : Easy
  • Last Updated : 31 May, 2021

Given an array of n positive integers, the task is to find the minimum inverting factor in the given array. 
Inverting factor is defined as the absolute difference between the reverse of any two numbers arri and arrj where i != j. 
Note : Trailing zeroes should be ignored while reversing the digits i.e. 1200 becomes 21 when reversed.
Examples:
 

Input : arr[] = { 56, 20, 47, 93, 45 } 
Output : 9 
The minimum inverting factor is 9, of the pair (56, 47).
Input : arr[] = { 26, 15, 45, 150 } 
Output : 0 
The minimum inverting factor is 0, of the pair (15, 150). 
 

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.

 



A naive approach is to iterate over two loops to find all possible pairs. Reverse both the numbers individually and find their absolute difference. Update the inverting factor (minimum absolute difference) at every step. Time Complexity would be O(N2).
An efficient approach would be to precompute the reverse of each array element and store it in its reversed form only (considering the case of trailing zeroes also). Now, to find the minimum inverting factor, sort the array in non-decreasing order. Since the array is sorted, minimum absolute difference always occurs among any two adjacent numbers. 
Below is the implementation of above approach . 
 

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum inverting factor
int findMinimumInvertingFactor(int arr[], int N)
{
    // ans stores the minimum inverting factor
    int ans = INT_MAX;
 
    // Iterate over the loop and convert each
    // array element into its reversed form
    for (int i = 0; i < N; i++) {
        string s;
        int num = arr[i];
 
        // Extract each digit of the number and
        // store it in reverse order
        while (num > 0) {
            s.push_back(num % 10 + '0');
            num /= 10;
        }
 
        // Find the position upto which trailing
        // zeroes occur
        int pos;
        for (pos = 0; pos < s.size(); pos++)
            if (s[pos] != 0)
                break;
 
        // Form the reversed number
        num = 0;
        for (int j = pos; j < s.size(); j++)
            num = num * 10 + (s[j] - '0');
        arr[i] = num;
    }
    sort(arr, arr + N);
 
    // Consider all adjacent pairs and update the
    // answer accordingly
    for (int i = 1; i < N; i++)
        ans = min(ans, abs(arr[i] - arr[i - 1]));
 
    return ans;
}
 
// Driver Code
int main()
{
    int arr[] = { 56, 20, 47, 93, 45 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    cout << findMinimumInvertingFactor(arr, N) << endl;
    return 0;
}
Java



// Java implementation of the above approach
import java.util.*;
 
class GFG
{
     
// Function to find the minimum inverting factor
static int findMinimumInvertingFactor(int arr[], int N)
{
    // ans stores the minimum inverting factor
    int ans = Integer.MAX_VALUE;
 
    // Iterate over the loop and convert each
    // array element into its reversed form
    for (int i = 0; i < N; i++)
    {
        String s = "";
        int num = arr[i];
 
        // Extract each digit of the number and
        // store it in reverse order
        while (num > 0)
        {
            s+=(char)((num % 10) + '0');
            num /= 10;
        }
 
        // Find the position upto which trailing
        // zeroes occur
        int pos;
        for (pos = 0; pos < s.length(); pos++)
            if (s.charAt(pos) != 0)
                break;
 
        // Form the reversed number
        num = 0;
        for (int j = pos; j < s.length(); j++)
            num = num * 10 + (s.charAt(j) - '0');
        arr[i] = num;
    }
    Arrays.sort(arr);
 
    // Consider all adjacent pairs and update the
    // answer accordingly
    for (int i = 1; i < N; i++)
        ans = Math.min(ans, Math.abs(arr[i] - arr[i - 1]));
 
    return ans;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 56, 20, 47, 93, 45 };
    int N = arr.length;
 
    System.out.println(findMinimumInvertingFactor(arr, N));
}
}
 
// This code contributed by Rajput-Ji
Python3



# Python3 implementation of the above approach
 
import sys
 
# Function to find the minimum inverting factor
def findMinimumInvertingFactor(arr, N) :
     
    # ans stores the minimum inverting factor
    ans = sys.maxsize
 
    # Iterate over the loop and convert each
    # array element into its reversed form
    for i in range(N) :
        num = arr[i]
        s = ""
 
        # Extract each digit of the number and
        # store it in reverse order
        while (num > 0) :
            s += str(num % 10)
            num //= 10
          
 
        # Find the position upto which trailing
        # zeroes occur
        for pos in range(len(s)) :
            if (s[pos] != "0") :
                break;
 
        # Form the reversed number
        num = 0
        for j in range(pos, len(s)) :
            num = num * 10 + (ord(s[j]) - ord("0"))
        arr[i] = num
      
    arr.sort()
    # Consider all adjacent pairs and update the
    # answer accordingly
    for i in range(N) :
        ans = min(ans, abs(arr[i] - arr[i - 1]))
 
    return ans
  
 
# Driver Code
if __name__ == "__main__" :
 
    arr= [ 56, 20, 47, 93, 45 ]
    N = len(arr)
     
    print(findMinimumInvertingFactor(arr, N))
 
# This code is contributed by Ryuga
C#



// C# implementation of the approach
using System;
 
class GFG
{
     
// Function to find the minimum inverting factor
static int findMinimumInvertingFactor(int []arr, int N)
{
    // ans stores the minimum inverting factor
    int ans = int.MaxValue;
 
    // Iterate over the loop and convert each
    // array element into its reversed form
    for (int i = 0; i < N; i++)
    {
        String s = "";
        int num = arr[i];
 
        // Extract each digit of the number and
        // store it in reverse order
        while (num > 0)
        {
            s+=(char)((num % 10) + '0');
            num /= 10;
        }
 
        // Find the position upto which trailing
        // zeroes occur
        int pos;
        for (pos = 0; pos < s.Length;pos++)
            if (s[pos] != 0)
                break;
 
        // Form the reversed number
        num = 0;
        for (int j = pos; j < s.Length; j++)
            num = num * 10 + (s[j] - '0');
        arr[i] = num;
    }
    Array.Sort(arr);
 
    // Consider all adjacent pairs and update the
    // answer accordingly
    for (int i = 1; i < N; i++)
        ans = Math.Min(ans, Math.Abs(arr[i] - arr[i - 1]));
 
    return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 56, 20, 47, 93, 45 };
    int N = arr.Length;
 
    Console.WriteLine(findMinimumInvertingFactor(arr, N));
}
}
 
/* This code contributed by PrinciRaj1992 */
PHP



<?php
// PHP implementation of the above approach
 
// Function to find the minimum inverting factor
function findMinimumInvertingFactor($arr, $N)
{
    // ans stores the minimum inverting factor
    $ans = PHP_INT_MAX;
 
    // Iterate over the loop and convert each
    // array element into its reversed form
    for ($i = 0; $i < $N; $i++)
    {
        $s="";
        $num = $arr[$i];
 
        // Extract each digit of the number and
        // store it in reverse order
        while ($num > 0)
        {
            $s.=chr($num % 10 + ord('0'));
            $num =(int)($num/10);
        }
 
        // Find the position upto which trailing
        // zeroes occur
        for ($pos = 0; $pos < strlen($s); $pos++)
            if ($s[$pos] != 0)
                break;
 
        // Form the reversed number
        $num = 0;
        for ($j = $pos; $j < strlen($s); $j++)
            $num = $num * 10 + (ord($s[$j]) - ord('0'));
        $arr[$i] = $num;
    }
    sort($arr);
 
    // Consider all adjacent pairs and update the
    // answer accordingly
    for ($i = 1; $i < $N; $i++)
        $ans = min($ans, abs($arr[$i] - $arr[$i - 1]));
 
    return $ans;
}
 
// Driver Code
 
$arr = array( 56, 20, 47, 93, 45 );
$N = count($arr);
 
echo findMinimumInvertingFactor($arr, $N)."\n";
 
// This code is contributed by mits
?>
Javascript



<script>
    // Javascript implementation of the approach
     
    // Function to find the minimum inverting factor
    function findMinimumInvertingFactor(arr, N)
    {
     
        // ans stores the minimum inverting factor
        let ans = Number.MAX_VALUE;
 
        // Iterate over the loop and convert each
        // array element into its reversed form
        for (let i = 0; i < N; i++)
        {
            let s = "";
            let num = arr[i];
 
            // Extract each digit of the number and
            // store it in reverse order
            while (num > 0)
            {
                s+=String.fromCharCode((num % 10) + '0'.charCodeAt());
                num = parseInt(num / 10, 10);
            }
 
            // Find the position upto which trailing
            // zeroes occur
            let pos;
            for (pos = 0; pos < s.length;pos++)
                if (s[pos] != 0)
                    break;
 
            // Form the reversed number
            num = 0;
            for (let j = pos; j < s.length; j++)
                num = num * 10 + (s[j].charCodeAt() - '0'.charCodeAt());
            arr[i] = num;
        }
        arr.sort(function(a, b){return a - b});
 
        // Consider all adjacent pairs and update the
        // answer accordingly
        for (let i = 1; i < N; i++)
            ans = Math.min(ans, Math.abs(arr[i] - arr[i - 1]));
 
        return ans;
    }
     
    let arr = [ 56, 20, 47, 93, 45 ];
    let N = arr.length;
   
    document.write(findMinimumInvertingFactor(arr, N));
     
    // This code is contributed by decode2207.
</script>
Output: 
9
 
Time Complexity : O(N * logN)
 



My Personal Notes
arrow_drop_up
Previous
BigDecimal movePointLeft() Method in Java
Next

Computer Organization | Locality and Cache friendly code
Recommended Articles
Page :
Total distinct pairs from two arrays such that second number can be obtained by inverting bits of first
04, Apr 19
Maximum Subarray Sum after inverting at most two elements
29, Mar 19
Find smallest number formed by inverting digits of given number N
28, Jul 20
Check if all the elements can be made of same parity by inverting adjacent elements
06, Jan 20
Maximize subarray sum by inverting sign of elements of any subarray at most twice
05, Oct 21
Sum of Maximum and Minimum prime factor of every number in the Array
18, Feb 20
Count minimum factor jumps required to reach the end of an Array
05, May 20
Count of permutations of an Array having each element as a multiple or a factor of its index
21, Aug 20
Convert a number to another by dividing by its factor or removing first occurrence of a digit from an array
15, Apr 21
Count of pairs (i, j) in the array such that arr[i] is a factor of arr[j]
21, May 20
Count of subarrays whose products don't have any repeating prime factor
04, Jul 17
Maximum length subsequence such that adjacent elements in the subsequence have a common factor
11, Feb 19
Find the total number of composite factor for a given number
10, Jun 19
Count pairs whose product contains single distinct prime factor
03, Nov 20
Longest subarray in which all elements are a factor of K
18, Nov 20
Find largest factor of N such that N/F is less than K
08, Jul 20
Count subsets consisting of each element as a factor of the next element in that subset
15, Feb 21
Minimize steps required to make two values equal by repeated division by any of their prime factor which is less than M
26, Feb 21
Maximum size of subset such that product of all subset elements is a factor of N
27, Sep 21
Minimum count of array elements that must be changed such that difference between maximum and minimum array element is N - 1
27, Sep 21
Maximum and minimum of an array using minimum number of comparisons
15, Feb 10
Minimum sum by choosing minimum of pairs from array
25, Oct 17
Remove minimum numbers from the array to get minimum OR value
27, Dec 19
Split array into minimum number of subsets with every element of a subset divisible by its minimum
12, Feb 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Nishant Tanwar
@Nishant Tanwar
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!