 GeeksforGeeks App
Open App Browser
Continue

# Proizvolov’s Identity

Given two arrays A and B of size N. Array A is in increasing order and B is in decreasing order. Both arrays are the subsequences of the numbers from 1 to 2N. The task is to find the sum of the absolute difference of two arrays.

Sum = |A1 – B1| + |A2 – B2| + |A3 – B3| + …. + |AN – BN

Examples:

Input : A[] = {1, 2, 3, 4, 5}, B[] = {10, 9, 8, 7, 6}
Output : 25
Input : A[] = {1, 5, 6, 8, 10, 12}, B[] = {11, 9, 7, 4, 3, 2}
Output : 36

Naive Approach: A naive approach is to run a loop and find the sum of the absolute differences.
Efficient Approach: Proizvolov’s identity is an identity concerning sums of the differences of positive integers. It states that if we take first 2N integers and partition them into two subsets of N numbers each.
Arrange one subset in increasing order : A1 < A2 < A3 < …. < AN
Arrange another subset in decreasing order : B1 > B2 > B3 > …. > BN
Then the sum |A1 – B1| + |A2 – B2| + |A3 – B3| + …. + |AN – BN| is always equals to N2
Below is the implementation of the above approach:

## C++

 `// CPP program to implement proizvolov's identity``#include``using` `namespace` `std;` `// Function to implement proizvolov's identity``int` `proizvolov(``int` `a[], ``int` `b[], ``int` `n)``{``    ``// According to proizvolov's identity``    ``return` `n*n;``}` `// Driver code``int` `main()``{``    ``int` `a[] = {1, 5, 6, 8, 10}, b[] = {9, 7, 4, 3, 2};``    ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ` `    ``// Function call``    ``cout << proizvolov(a, b, n);``    ` `    ``return` `0;``}`

## Java

 `// Java program to implement proizvolov's identity``class` `GFG``{``    ``// Function to implement proizvolov's identity``    ``static` `int` `proizvolov(``int` `a [], ``int` `b [], ``int` `n)``    ``{``        ``// According to proizvolov's identity``        ``return` `n * n;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `a [] = {``1``, ``5``, ``6``, ``8``, ``10``};``        ``int` `b [] = {``9``, ``7``, ``4``, ``3``, ``2``};``        ` `        ``int` `n = a.length;``        ` `        ``// Function call``        ``System.out.println(proizvolov(a, b, n));``    ``}``}` `// This code is contributed by ihritik`

## Python3

 `# Python3 program to implement``# proizvolov's identity` `# Function to implement``# proizvolov's identity``def` `proizvolov(a, b, n):``    ``return` `n ``*` `n` `# Driver code``a ``=` `[ ``1``, ``5``, ``6``, ``8``, ``10` `]``b ``=` `[ ``9``, ``7``, ``4``, ``3``, ``2` `]``n ``=` `len``(a)` `# Function call``print``(proizvolov(a, b, n, ))` `# This code is contributed by nidhiva`

## C#

 `// C# program to implement proizvolov's identity``using` `System;` `class` `GFG``{``    ``// Function to implement proizvolov's identity``    ``static` `int` `proizvolov(``int` `[] a,``                          ``int` `[] b, ``int` `n)``    ``{``        ``// According to proizvolov's identity``        ``return` `n * n;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main ()``    ``{``        ``int` `[] a = {1, 5, 6, 8, 10};``        ``int` `[] b = {9, 7, 4, 3, 2};``        ` `        ``int` `n = a.Length;``        ` `        ``// Function call``        ``Console.WriteLine(proizvolov(a, b, n));``    ``}``}` `// This code is contributed by ihritik`

## Javascript

 ``

Output:

`25`

Time complexity: O(1) because constant operations are done

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up