# Check if all array elements can be converted to pronic numbers by rotating digits

• Difficulty Level : Basic
• Last Updated : 29 May, 2021

Given an array arr[] of size N, the task is to check if it is possible to convert all of the array elements to a pronic number by rotating the digits of array elements any number of times.

Examples:

Input: {321, 402, 246, 299}
Output: True
Explanation:
arr[0] â†’ Right rotation once modifies arr[0] to 132 (= 11 Ã— 12).
arr[1] â†’ Right rotation once modifies arr[0] to 240 (= 15 Ã— 16).
arr[2] â†’ Right rotation twice modifies arr[2] to 462 (= 21 Ã— 22).
arr[3] â†’ Right rotation twice modifies arr[3] to 992 (= 31 Ã— 32).

Input: {433, 653, 402, 186}
Output: False

Approach: Follow the steps below to solve the problem:

• Traverse the array and check for each array element, whether it is possible to convert it to a pronic number.
• For each array element, apply all the possible rotations and check after each rotation, whether the generated number is pronic or not.
• If it is not possible to convert any array element to a pronic number, print “False”.
• Otherwise, print “True”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// function to check Pronic Number` `bool` `isPronic(``int` `x)` `{` `    ``for` `(``int` `i = 0; i < (``int``)(``sqrt``(x)) + 1; i++) ` `    ``{`   `        ``// Checking Pronic Number` `        ``// by multiplying consecutive` `        ``// numbers` `        ``if` `(x == i * (i + 1)) ` `        ``{` `            ``return` `true``;` `        ``}` `    ``}` `    ``return` `false``;` `}`   `// Function to check if any permutation` `// of val is a pronic number or not` `bool` `checkRot(``int` `val)` `{`   `    ``string temp = to_string(val);` `    ``for` `(``int` `i = 0; i < temp.length(); i++) ` `    ``{` `        ``if` `(isPronic(stoi(temp)) == ``true``)` `        ``{` `            ``return` `true``;` `        ``}` `        ``temp = temp.substr(1, temp.size() - 1) + temp[0];` `    ``}` `    ``return` `false``;` `}`   `// Function to check if all array` `// elements can be converted to` `// a pronic number or not` `bool` `check(``int` `arr[], ``int` `N)` `{`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) ` `    ``{`   `        ``// If current element` `        ``// cannot be converted` `        ``// to a pronic number` `        ``if` `(checkRot(arr[i]) == ``false``) ` `        ``{` `            ``return` `false``;` `        ``}` `    ``}` `    ``return` `true``;` `}`   `// Driven Program` `int` `main()` `{` `  `  `    ``// Given array` `    ``int` `arr[] = { 321, 402, 246, 299 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// function call` `    ``cout << (check(arr, N) ? ``"True"` `: ``"False"``);`   `    ``return` `0;` `}`   `// This code is contributed by Kingash.`

## Java

 `// Java program for the above approach`   `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `class` `GFG {`   `  ``// function to check Pronic Number` `  ``static` `boolean` `isPronic(``int` `x)` `  ``{`   `    ``for` `(``int` `i = ``0``; i < (``int``)(Math.sqrt(x)) + ``1``; i++) {`   `      ``// Checking Pronic Number` `      ``// by multiplying consecutive` `      ``// numbers` `      ``if` `(x == i * (i + ``1``)) {` `        ``return` `true``;` `      ``}` `    ``}`   `    ``return` `false``;` `  ``}`   `  ``// Function to check if any permutation` `  ``// of val is a pronic number or not` `  ``static` `boolean` `checkRot(``int` `val)` `  ``{` `    ``String temp = Integer.toString(val);` `    ``for` `(``int` `i = ``0``; i < temp.length(); i++) ` `    ``{` `      ``if` `(isPronic(Integer.parseInt(temp)) == ``true``) {` `        ``return` `true``;` `      ``}`   `      ``temp = temp.substring(``1``) + temp.charAt(``0``);` `    ``}` `    ``return` `false``;` `  ``}`   `  ``// Function to check if all array` `  ``// elements can be converted to` `  ``// a pronic number or not` `  ``static` `boolean` `check(``int` `arr[], ``int` `N)` `  ``{`   `    ``// Traverse the array` `    ``for` `(``int` `i = ``0``; i < N; i++) ` `    ``{`   `      ``// If current element` `      ``// cannot be converted` `      ``// to a pronic number` `      ``if` `(checkRot(arr[i]) == ``false``) ` `      ``{` `        ``return` `false``;` `      ``}` `    ``}` `    ``return` `true``;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{`   `    ``// Given array` `    ``int` `arr[] = { ``321``, ``402``, ``246``, ``299` `};` `    ``int` `N = arr.length;`   `    ``// Function call` `    ``System.out.println(` `      ``(check(arr, N) ? ``"True"` `: ``"False"``));` `  ``}` `}`   `// This code is contributed by Kingash.`

## Python3

 `# Python implementation of` `# the above approach`   `# Function to check if a number` `# is a pronic number or not` `def` `isPronic(n):`   `  ``for` `i ``in` `range``(``int``(n``*``*``(``1` `/` `2``)) ``+` `1``):` `    ``if` `i ``*` `(i ``+` `1``) ``=``=` `n:` `      ``return` `True`   `  ``return` `False`   `# Function to check if any permutation` `# of n is a pronic number or not` `def` `checkRot(n):`   `  ``temp ``=` `str``(n)`   `  ``for` `i ``in` `range``(``len``(temp)):`   `    ``if` `isPronic(``int``(temp)):` `      ``return` `True`   `    ``temp ``=` `temp[``1``:]``+``temp[``0``]`   `  ``return` `False`   `# Function to check if all array` `# elements can be converted to` `# a pronic number or not` `def` `check(arr):`   `  ``# Traverse the array` `  ``for` `i ``in` `arr:`   `    ``# If current element` `    ``# cannot be converted ` `    ``# to a pronic number` `    ``if` `not` `checkRot(i):` `      ``return` `False` `  ``return` `True`   `# Driver Code` `arr ``=` `[ ``321``, ``402``, ``246``, ``299` `]` `print``(check(arr))`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `  ``// function to check Pronic Number` `  ``static` `bool` `isPronic(``int` `x)` `  ``{` `    ``int` `val  = (``int``)Math.Sqrt(x);` `    ``val += 1;` `    ``for` `(``int` `i = 0; i < val; i++) ` `    ``{`   `      ``// Checking Pronic Number` `      ``// by multiplying consecutive` `      ``// numbers` `      ``if` `(x == i * (i + 1)) ` `      ``{` `        ``return` `true``;` `      ``}` `    ``}` `    ``return` `false``;` `  ``}`   `  ``// Function to check if any permutation` `  ``// of val is a pronic number or not` `  ``static` `bool` `checkRot(``int` `val)` `  ``{`   `    ``string` `temp = val.ToString();` `    ``for` `(``int` `i = 0; i < temp.Length; i++) ` `    ``{` `      ``int` `a = Int32.Parse(temp); ` `      ``if` `(isPronic(a) == ``true``)` `      ``{` `        ``return` `true``;` `      ``}` `      ``temp = temp.Substring(1, temp.Length - 1) + temp[0];` `    ``}` `    ``return` `false``;` `  ``}`   `  ``// Function to check if all array` `  ``// elements can be converted to` `  ``// a pronic number or not` `  ``static` `bool` `check(``int` `[]arr, ``int` `N)` `  ``{`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) ` `    ``{`   `      ``// If current element` `      ``// cannot be converted` `      ``// to a pronic number` `      ``if` `(checkRot(arr[i]) == ``false``) ` `      ``{` `        ``return` `false``;` `      ``}` `    ``}` `    ``return` `true``;` `  ``}`   `  ``// Driven Program` `  ``public` `static` `void` `Main()` `  ``{`   `    ``// Given array` `    ``int` `[]arr = { 321, 402, 246, 299 };` `    ``int` `N = arr.Length;`   `    ``// function call` `    ``Console.WriteLine(check(arr, N) ? ``"True"` `: ``"False"``);` `  ``}` `}`   `// This code is contributed by ipg2016107.`

## Javascript

 ``

Output:

`True`

Time Complexity: O(N3/2)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :