GFG App
Open App
Browser
Continue

# Coordinate Compression

Given an array, arr[] containing Integers from 1 to 10^12 compress them to numbers ranging from 1 to 10^6. size of the array is ≤ 10^6.

Examples:

Input: arr[] = {100000000000, 100000000001, 100000000002, 999999999999}
Output: arr[] = {100000, 100000, 100000, 999999, 0, 1, 2, 999999}
Explanation: Every element of the new array is in the range 1 to 10^6

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

Approach: To solve the problem follow the below idea:

We can use a Mod value of 10^6 and store its quotient and remainder in two places i.e., i and N + i. Where N is the size of original array. So, we have to construct the array of size 2*N. After the operations, every element of new array is in the range 1 to 10^6.

Follow the below steps to solve the problem:

• Initialize a value, Mod = 10^6, and array res[] of size 2*N.
• Pass the array res[], arr[], and N to the solve function.
• Run a loop and set, res[i] = arr[i] / Mod and res[N + i] = arr[i] % Mod.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the above approach`   `#include ` `using` `namespace` `std;`   `const` `int` `Mod = 1e6;`   `// Function to compress the array containing` `// number from 1 to 10^12 to 1 to 10^6` `void` `solve(``long` `long``* arr, ``int``* res, ``int` `N)` `{`   `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``res[i] = arr[i] / Mod;` `        ``res[N + i] = arr[i] % Mod;` `    ``}` `}`   `// Function to print New Array` `void` `printAns(``int` `arr[], ``int` `N)` `{` `    ``for` `(``int` `i = 0; i < 2 * N; i++) {` `        ``cout << arr[i] << ``" "``;` `    ``}` `    ``cout << endl;` `}`   `// Function to print original array` `// recovered from new one` `void` `OrigArray(``int` `arr[], ``int` `N)` `{` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``cout << ((``long` `long``)arr[i] * Mod + arr[N + i])` `             ``<< ``" "``;` `    ``}` `    ``cout << endl;` `}`   `// Driver Code` `int` `main()` `{`   `    ``long` `long` `arr[] = { 100000000000, 100000000001,` `                        ``100000000002, 999999999999 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `res[2 * N] = {};`   `    ``solve(arr, res, N);`   `    ``cout << ``"New Array is : "` `<< endl;` `    ``printAns(res, N);`   `    ``cout << ``"\nOriginal Array recovered from new one is : "` `         ``<< endl;` `    ``OrigArray(res, N);` `    ``return` `0;` `}`

## Java

 `// Java code to implement the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `  ``public` `static` `final` `int` `Mod = ``1000000``;`   `  ``// Function to compress the array containing` `  ``// number from 1 to 10^12 to 1 to 10^6` `  ``public` `static` `void` `solve(``long``[] arr, ``int``[] res)` `  ``{` `    ``int` `N = arr.length;` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``res[i] = (``int``)(arr[i] / Mod);` `      ``res[N + i] = (``int``)(arr[i] % Mod);` `    ``}` `  ``}`   `  ``// Function to print New Array` `  ``public` `static` `void` `printAns(``int``[] arr)` `  ``{` `    ``for` `(``int` `i : arr) {` `      ``System.out.print(i + ``" "``);` `    ``}` `    ``System.out.println();` `  ``}`   `  ``// Function to print original array` `  ``// recovered from new one` `  ``public` `static` `void` `OrigArray(``int``[] arr)` `  ``{` `    ``int` `N = arr.length / ``2``;` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``System.out.print(` `        ``((``long``)arr[i] * Mod + arr[N + i]) + ``" "``);` `    ``}` `    ``System.out.println();` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``long``[] arr = { 100000000000L, 100000000001L,` `                  ``100000000002L, 999999999999L };` `    ``int``[] res = ``new` `int``[``2` `* arr.length];`   `    ``solve(arr, res);`   `    ``System.out.println(``"New Array is : "``);` `    ``printAns(res);`   `    ``System.out.println(` `      ``"\nOriginal Array recovered from new one is : "``);` `    ``OrigArray(res);` `  ``}` `}`   `// This code is contributed by lokesh.`

## Python3

 `#Python3 code for the above approach`   `def` `solve(arr, N):` `    ``"""` `    ``Function to compress the array containing` `    ``number from 1 to 10^12 to 1 to 10^6` `    ``"""` `    ``res ``=` `[``0``] ``*` `(``2` `*` `N)` `    ``for` `i ``in` `range``(N):` `        ``res[i] ``=` `arr[i] ``/``/` `Mod` `        ``res[N ``+` `i] ``=` `arr[i] ``%` `Mod` `    ``return` `res`   `def` `print_ans(arr, N):` `    ``"""` `    ``Function to print New Array` `    ``"""` `    ``for` `i ``in` `range``(``2` `*` `N):` `        ``print``(arr[i], end``=``" "``)` `    ``print``()`   `def` `OrigArray(arr, N):` `    ``"""` `    ``Function to print original array` `    ``recovered from new one` `    ``"""` `    ``for` `i ``in` `range``(N):` `        ``print``((arr[i] ``*` `Mod ``+` `arr[N ``+` `i]), end``=``" "``)` `    ``print``()`   `Mod ``=` `1000000` `arr ``=` `[``100000000000``, ``100000000001``, ``100000000002``, ``999999999999``]` `N ``=` `len``(arr)` `res ``=` `solve(arr, N)`   `print``(``"New Array is:"``)` `print_ans(res, N)`   `print``(``"\nOriginal Array recovered from new one is:"``)` `OrigArray(res, N)` `#This code is contributed by Potta Lokesh`

## C#

 `// C# code to implement the above approach`   `using` `System;` `using` `System.Linq;`   `public` `class` `GFG {`   `    ``public` `const` `int` `Mod = 1000000;`   `    ``// Function to compress the array containing` `    ``// number from 1 to 10^12 to 1 to 10^6` `    ``public` `static` `void` `Solve(``long``[] arr, ``int``[] res)` `    ``{` `        ``int` `N = arr.Length;` `        ``for` `(``int` `i = 0; i < N; i++) {` `            ``res[i] = (``int``)(arr[i] / Mod);` `            ``res[N + i] = (``int``)(arr[i] % Mod);` `        ``}` `    ``}`   `    ``// Function to print New Array` `    ``public` `static` `void` `PrintAns(``int``[] arr)` `    ``{` `        ``foreach``(``int` `i ``in` `arr) { Console.Write(i + ``" "``); }` `        ``Console.WriteLine();` `    ``}`   `    ``// Function to print original array` `    ``// recovered from new one` `    ``public` `static` `void` `OrigArray(``int``[] arr)` `    ``{` `        ``int` `N = arr.Length / 2;` `        ``for` `(``int` `i = 0; i < N; i++) {` `            ``Console.Write(((``long``)arr[i] * Mod + arr[N + i])` `                          ``+ ``" "``);` `        ``}` `        ``Console.WriteLine();` `    ``}`   `    ``static` `public` `void` `Main()` `    ``{`   `        ``// Code` `        ``long``[] arr = { 100000000000L, 100000000001L,` `                       ``100000000002L, 999999999999L };` `        ``int``[] res = ``new` `int``[2 * arr.Length];`   `        ``Solve(arr, res);`   `        ``Console.WriteLine(``"New Array is : "``);` `        ``PrintAns(res);`   `        ``Console.WriteLine(` `            ``"\nOriginal Array recovered from new one is : "``);` `        ``OrigArray(res);` `    ``}` `}`   `// This code is contributed by lokeshmvs21.`

## Javascript

 `// Javascript code to implement the above approach` `const Mod = 1e6;`   `// Function to compress the array containing` `// number from 1 to 10^12 to 1 to 10^6` `function` `solve( arr, res,  N)` `{`   `    ``for` `(let i = 0; i < N; i++) {` `        ``res[i] = Math.floor(arr[i] / Mod);` `        ``res[N + i] = arr[i] % Mod;` `    ``}` `}`   `// Function to print New Array` `function` `printAns( arr, N)` `{` `    ``for` `(let i = 0; i < 2 * N; i++) {` `        ``console.log(arr[i] + ``" "``);` `    ``}` `}`   `// Function to print original array` `// recovered from new one` `function` `OrigArray(arr,  N)` `{` `    ``for` `(let i = 0; i < N; i++) {` `        ``console.log(arr[i] * Mod + arr[N + i])+ ``" "``;` `    ``}` `}`   `// Driver Code` `    ``let arr = [ 100000000000, 100000000001,` `                        ``100000000002, 999999999999 ];` `    ``let N = arr.length;` `    ``let res=``new` `Array(2*N);`   `    ``solve(arr, res, N);`   `    ``console.log(``"New Array is : \n"``);` `    ``printAns(res, N);`   `    ``console.log(``"\nOriginal Array recovered from new one is : "``);` `    ``OrigArray(res, N);` ` `  ` ``// This code is contributed by poojaagarwal2.`

Output

```New Array is :
100000 100000 100000 999999 0 1 2 999999

Original Array recovered from new one is :
100000000000 100000000001 100000000002 999999999999 ```

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

Related Articles:

My Personal Notes arrow_drop_up