Confusing Number

Problem Statement

The concept of a confusing number involves determining if a number becomes a different number when each of its digits is rotated by 180 degrees. Not all digits can be rotated to form valid digits using this rotation technique. The digits 0, 1, 6, 8, and 9 transform into other valid digits - they turn into 0, 1, 9, 8, and 6, respectively, upon rotation. Conversely, the digits 2, 3, 4, 5, and 7 do not yield valid numbers when rotated by 180 degrees.

A number is defined as "confusing" if, after this rotation, it does not retain its original form and all the transformed digits remain valid. For example, the number 6 becomes 9 and does not equal its original form, thus making it a confusing number. However, the number 11 remains unchanged after rotation and therefore is not confusing. In this task, given any integer n, the objective is to check whether it is a confusing number or not by following these rotation rules and return a boolean value (i.e., true or false).

Examples

Example 1

Input:

n = 6

Output:

true

Explanation:

We get 9 after rotating 6, 9 is a valid number, and 9 != 6.

Example 2

Input:

n = 89

Output:

true

Explanation:

We get 68 after rotating 89, 68 is a valid number and 68 != 89.

Example 3

Input:

n = 11

Output:

false

Explanation:

We get 11 after rotating 11, 11 is a valid number but the value remains the same, thus 11 is not a confusing number

Constraints

• 0 <= n <= 109

Approach and Intuition

To determine whether a given number n is a confusing number, follow the below approach:

1. Convert the number n to its string representation to access each digit individually.
2. Create a dictionary to map each rotatable digit to its corresponding digit post-rotation (e.g., {'6': '9', '9': '6', '0': '0', '1': '1','8': '8'}).
3. Iterate through each digit of the number:
   • Check if the digit is rotatable (i.e., it exists in the transformation dictionary).
   • If any digit is not rotatable (not present in the dictionary), immediately return false as the number contains invalid digits post-rotation.
4. Construct the rotated number by appending the transformed digits in reverse order (as rotating affects the sequence).
5. Compare the newly formed number after all valid transformations to the original number.
   • If the rotated number is different from the original and all digits are valid, return true, indicating it is a confusing number.
   • If the rotated number is the same as the original, return false, as the number is not confusing.

By following this plan, one can efficiently determine whether a number n qualifies as a confusing number by handling the rotation and validation of each digit. This technique ensures that all conditions regarding the transformation and validity of digits are carefully observed, aligning with the problem constraints mentioned.

Solutions

class Solution {
public:
    bool isConfusing(int num) {
        unordered_map<char, char> reverseMap = {{'0','0'}, {'1','1'}, {'6','9'}, {'8','8'}, {'9','6'}};
        string transformed;
    
        for (auto digit : to_string(num)) {
            if (reverseMap.find(digit) == reverseMap.end()) {
                return false;
            }
            transformed += reverseMap[digit];
        }
    
        reverse(begin(transformed), end(transformed));
        return stoi(transformed) != num;
    }
};