# Rearrangement of a number which is also divisible by it

Given a number n, we need to rearrange all its digits such that the new arrangement is divisible by n. Also, the new number should not be equal to x. If no such rearrangement is possible, print -1.

Examples:

```Input : n = 1035
Output : 3105
The result 3105 is divisible by
given n and has the same set of digits.

Input : n = 1782
Output : m = 7128
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Simple Approach : Find all the permutation of given n and then check whether it is divisible by n or not also check that new permutation should not be equal to n.

Efficient Approach : Let’s suppose that y is our result then y = m * n, also we know that y must be a rearrangement of digits of n so we can say now restrict m (the multiplier) as per given conditions.
1) y has the same number of digits as n has. So, m must be less than 10.
2) y must not be equal to n. So, m will be greater than 1.
So we get the multiplier m in the range [2,9]. So we will find all the possible y and then check that should y has the same digits as n or not.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

 `// CPP program for finding rearrangement of n ` `// that is divisible  by n ` `#include ` `using` `namespace` `std; ` ` `  `// perform hashing for given n ` `void` `storeDigitCounts(``int` `n, vector<``int``> &hash) ` `{ ` `    ``// perform hashing ` `    ``while` `(n) ` `    ``{ ` `        ``hash[n%10]++; ` `        ``n /= 10; ` `    ``} ` `} ` ` `  `// check whether any arrangement exists ` `int` `rearrange (``int` `n) ` `{ ` `    ``// Create a hash for given number n ` `    ``// The hash is of size 10 and stores ` `    ``// count of each digit in n. ` `    ``vector<``int``> hash_n(10, 0); ` `    ``storeDigitCounts(n, hash_n); ` `     `  `    ``// check for all possible multipliers ` `    ``for` `(``int` `mult=2; mult<10; mult++) ` `    ``{ ` `        ``int` `curr = n*mult; ` `         `  `        ``vector<``int``> hash_curr(10, 0); ` `        ``storeDigitCounts(curr, hash_curr); ` `         `  `        ``// check hash table for both.  ` `        ``// Please refer below link for help  ` `        ``// of equal() ` `        ``// https://www.geeksforgeeks.org/stdequal-in-cpp/amp/ ` `        ``if` `(equal(hash_n.begin(), hash_n.end(), ` `                             ``hash_curr.begin())) ` `            ``return` `curr; ` `    ``} ` `    ``return` `-1; ` `} ` ` `  `// driver program ` `int` `main() ` `{ ` `    ``int` `n = 10035; ` `    ``cout << rearrange(n); ` `    ``return` `0; ` `} `

 `# Python3 program for finding rearrangement  ` `# of n that is divisible by n  ` ` `  `# Perform hashing for given n  ` `def` `storeDigitCounts(n, ``Hash``):  ` ` `  `    ``# perform hashing  ` `    ``while` `n > ``0``:  ` `     `  `        ``Hash``[n ``%` `10``] ``+``=` `1` `        ``n ``/``/``=` `10` ` `  `# check whether any arrangement exists  ` `def` `rearrange(n):  ` ` `  `    ``# Create a hash for given number n  ` `    ``# The hash is of size 10 and stores  ` `    ``# count of each digit in n.  ` `    ``hash_n ``=` `[``0``] ``*` `10` `    ``storeDigitCounts(n, hash_n)  ` `     `  `    ``# check for all possible multipliers  ` `    ``for` `mult ``in` `range``(``2``, ``10``):  ` `     `  `        ``curr ``=` `n ``*` `mult  ` `         `  `        ``hash_curr ``=` `[``0``] ``*` `10` `        ``storeDigitCounts(curr, hash_curr)  ` `         `  `        ``# check hash table for both.  ` `        ``if` `hash_n ``=``=` `hash_curr:  ` `            ``return` `curr  ` `     `  `    ``return` `-``1` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``:  ` ` `  `    ``n ``=` `10035` `    ``print``(rearrange(n)) ` `     `  `# This code is contributed by Rituraj Jain `

Output:

```30105
```