LeetCode 1056 Confusing Number Solution & Explanation

Prerequisites

Before attempting this problem, you should be comfortable with:

Hash Maps / Dictionaries - Used to map digits to their rotated counterparts for O(1) lookup
String Manipulation - Converting integers to strings and reversing strings
Modular Arithmetic - Extracting digits using modulo and integer division operations

1. Invert and Reverse

Intuition

A confusing number looks different when rotated 180 degrees. Only digits 0, 1, 6, 8, and 9 remain valid after rotation (6 becomes 9 and vice versa). We invert each digit, reverse the result, and check if it differs from the original.

Algorithm

Create a mapping of valid digits to their rotated counterparts: 0->0, 1->1, 6->9, 8->8, 9->6.
Iterate through each digit of n as a string.
If any digit is not in the map (2, 3, 4, 5, 7), return false immediately.
Build the rotated number by appending the inverted digit for each character.
Reverse the rotated number and compare it to the original. If different, return true.

class Solution:
    def confusingNumber(self, n: int) -> bool:
        # Use 'invertMap' to invert each valid digit.
        invert_map = {"0":"0", "1":"1", "8":"8", "6":"9", "9":"6"}
        rotated_number = []

        # Iterate over each digit of 'n'.
        for ch in str(n):
            if ch not in invert_map:
                return False

            # Append the inverted digit of 'ch' to the end of 'rotated_number'.
            rotated_number.append(invert_map[ch])

        rotated_number = "".join(rotated_number)

        # Check if the reversed 'rotated_number' equals 'n'.
        return int(rotated_number[::-1]) != n

class Solution {
    public boolean confusingNumber(int n) {
        // Use 'invertMap' to invert each valid digit.
        Map<Character, Character> invertMap = new HashMap<>() {{
            put('0', '0');
            put('1', '1');
            put('6', '9');
            put('8', '8');
            put('9', '6');
        }};
        StringBuilder sb = new StringBuilder();

        // Iterate over each digit of 'n'.
        for (char ch : String.valueOf(n).toCharArray()) {
            if (!invertMap.containsKey(ch)) {
                return false;
            }

            // Append the inverted digit of 'ch' to the end of 'rotatedNumber'.
            sb.append(invertMap.get(ch));
        }

        // Check if the reversed 'rotatedNumber' equals 'n'.
        sb.reverse();
        return Integer.parseInt(sb.toString()) != n;
    }
}

class Solution {
public:
    bool confusingNumber(int n) {
        // Use 'invertMap' to invert each valid digit.
        unordered_map<char, char> invertMap = {{'0','0'}, {'1','1'}, {'6','9'}, {'8','8'}, {'9','6'}};
        string rotatedNumber;

        // Iterate over each digit of 'n'.
        for (auto ch : to_string(n)) {
            if (invertMap.find(ch) == invertMap.end()) {
                return false;
            }

            // Append the inverted digit of 'ch' to the end of 'rotatedNumber'.
            rotatedNumber += invertMap[ch];
        }

        // Check if the reversed 'rotatedNumber' equals 'n'.
        reverse(begin(rotatedNumber), end(rotatedNumber));
        return stoi(rotatedNumber) != n;
    }
};

class Solution {
    /**
     * @param {number} n
     * @return {boolean}
     */
    confusingNumber(n) {
        // Use 'invertMap' to invert each valid digit.
        const invertMap = {
            0: '0',
            1: '1',
            6: '9',
            8: '8',
            9: '6',
        };

        let rotatedNumber = '';
        // Iterate over each digit of 'n'.
        for (const ch of String(n)) {
            if (!(ch in invertMap)) {
                return false;
            }
            // Append the inverted digit of 'ch' to the end of 'rotatedNumber'.
            rotatedNumber += invertMap[ch];
        }
        // Check if the reversed 'rotatedNumber' equals 'n'.
        rotatedNumber = rotatedNumber.split('').reverse().join('');
        return parseInt(rotatedNumber) !== n;
    }
}

public class Solution {
    public bool ConfusingNumber(int n) {
        // Use 'invertMap' to invert each valid digit.
        var invertMap = new Dictionary<char, char> {
            {'0', '0'}, {'1', '1'}, {'6', '9'}, {'8', '8'}, {'9', '6'}
        };
        var sb = new StringBuilder();

        // Iterate over each digit of 'n'.
        foreach (char ch in n.ToString()) {
            if (!invertMap.ContainsKey(ch)) {
                return false;
            }
            // Append the inverted digit of 'ch' to the end of 'rotatedNumber'.
            sb.Append(invertMap[ch]);
        }

        // Check if the reversed 'rotatedNumber' equals 'n'.
        char[] arr = sb.ToString().ToCharArray();
        Array.Reverse(arr);
        return int.Parse(new string(arr)) != n;
    }
}

func confusingNumber(n int) bool {
    // Use 'invertMap' to invert each valid digit.
    invertMap := map[byte]byte{
        '0': '0', '1': '1', '6': '9', '8': '8', '9': '6',
    }
    s := strconv.Itoa(n)
    rotatedNumber := make([]byte, len(s))

    // Iterate over each digit of 'n'.
    for i := 0; i < len(s); i++ {
        ch := s[i]
        if _, ok := invertMap[ch]; !ok {
            return false
        }
        // Append the inverted digit of 'ch' to the end of 'rotatedNumber'.
        rotatedNumber[i] = invertMap[ch]
    }

    // Check if the reversed 'rotatedNumber' equals 'n'.
    for i, j := 0, len(rotatedNumber)-1; i < j; i, j = i+1, j-1 {
        rotatedNumber[i], rotatedNumber[j] = rotatedNumber[j], rotatedNumber[i]
    }
    result, _ := strconv.Atoi(string(rotatedNumber))
    return result != n
}

class Solution {
    fun confusingNumber(n: Int): Boolean {
        // Use 'invertMap' to invert each valid digit.
        val invertMap = mapOf(
            '0' to '0', '1' to '1', '6' to '9', '8' to '8', '9' to '6'
        )
        val sb = StringBuilder()

        // Iterate over each digit of 'n'.
        for (ch in n.toString()) {
            if (ch !in invertMap) {
                return false
            }
            // Append the inverted digit of 'ch' to the end of 'rotatedNumber'.
            sb.append(invertMap[ch])
        }

        // Check if the reversed 'rotatedNumber' equals 'n'.
        return sb.reverse().toString().toInt() != n
    }
}

class Solution {
    func confusingNumber(_ n: Int) -> Bool {
        // Use 'invertMap' to invert each valid digit.
        let invertMap: [Character: Character] = [
            "0": "0", "1": "1", "6": "9", "8": "8", "9": "6"
        ]
        var rotatedNumber = ""

        // Iterate over each digit of 'n'.
        for ch in String(n) {
            guard let inverted = invertMap[ch] else {
                return false
            }
            // Append the inverted digit of 'ch' to the end of 'rotatedNumber'.
            rotatedNumber.append(inverted)
        }

        // Check if the reversed 'rotatedNumber' equals 'n'.
        return Int(String(rotatedNumber.reversed()))! != n
    }
}

impl Solution {
    pub fn confusing_number(n: i32) -> bool {
        // Use 'invert_map' to invert each valid digit.
        let invert_map: HashMap<char, char> = [
            ('0', '0'), ('1', '1'), ('6', '9'), ('8', '8'), ('9', '6'),
        ].iter().cloned().collect();
        let mut rotated_number = String::new();

        // Iterate over each digit of 'n'.
        for ch in n.to_string().chars() {
            match invert_map.get(&ch) {
                Some(&inverted) => rotated_number.push(inverted),
                None => return false,
            }
        }

        // Check if the reversed 'rotatedNumber' equals 'n'.
        let reversed: String = rotated_number.chars().rev().collect();
        reversed.parse::<i32>().unwrap() != n
    }
}

Time & Space Complexity

Time complexity: $O(L)$
Space complexity: $O(L)$ extra space used

Where $L$ is the maximum number of digits $n$ can have ( $L = \log_{10} n$ ).

2. Use the remainder

Intuition

Instead of converting to a string, we can extract digits using modular arithmetic. Processing digits from right to left while building the rotated number from left to right naturally produces the reversed rotated version.

Algorithm

Create a mapping of valid digits (0, 1, 6, 8, 9) to their rotated values.
Make a copy of n and initialize the rotated number to 0.
Extract digits using modulo 10. If a digit is invalid, return false.
Build the rotated number by multiplying by 10 and adding the inverted digit.
Divide the copy by 10 to move to the next digit. After processing all digits, compare the rotated number to the original.

class Solution:
    def confusingNumber(self, n: int) -> bool:
        # Use 'invert_map' to invert each valid digit. Since we don't want to modify
        # 'n', we create a copy of it as 'nCopy'.
        invert_map = {0:0, 1:1, 8:8, 6:9, 9:6}
        invert_number = 0
        n_copy = n

        # Get every digit of 'n_copy' by taking the remainder of it to 10.
        while n_copy:
            res = n_copy % 10
            if res not in invert_map:
                return False

            # Append the inverted digit of 'res' to the end of 'rotated_number'.
            invert_number = invert_number * 10 + invert_map[res]
            n_copy //= 10

        # Check if 'rotated_number' equals 'n'.
        return  invert_number != n

class Solution {
    public boolean confusingNumber(int n) {
        // Use 'invertMap' to invert each valid digit. Since we don't want to modify
        // 'n', we create a copy of it as 'nCopy'.
        Map<Integer, Integer> invertMap = new HashMap<>() {{
            put(0, 0);
            put(1, 1);
            put(6, 9);
            put(8, 8);
            put(9, 6);
        }};
        int nCopy = n, rotatedNumber = 0;

        // Get every digit of 'nCopy' by taking the remainder of it to 10.
        while (nCopy > 0) {
            int res = nCopy % 10;
            if (!invertMap.containsKey(res)) {
                return false;
            }

            // Append the inverted digit of 'res' to the end of 'rotatedNumber'.
            rotatedNumber = rotatedNumber * 10 + invertMap.get(res);
            nCopy /= 10;
        }

        // Check if 'rotatedNumber' equals 'n'.
        return rotatedNumber != n;
    }
}

class Solution {
public:
    bool confusingNumber(int n) {
        // Use 'invertMap' to invert each valid digit. Since we don't want to modify
        // 'n', we create a copy of it as 'nCopy'.
        map<int, int> invertMap = {{0, 0}, {1, 1}, {6, 9}, {8, 8}, {9, 6}};
        int rotatedNumber = 0, nCopy = n;

        // Get every digit of 'nCopy' by taking the remainder of it to 10.
        while (nCopy > 0) {
            int res = nCopy % 10;
            if (invertMap.find(res) == invertMap.end()) {
                return false;
            }

            // Append the inverted digit of 'res' to the end of 'rotatedNumber'.
            rotatedNumber = rotatedNumber * 10 + invertMap[res];
            nCopy /= 10;
        }

        // Check if 'rotatedNumber' equals 'n'.
        return rotatedNumber != n;
    }
};

class Solution {
    /**
     * @param {number} n
     * @return {boolean}
     */
    confusingNumber(n) {
        // Use 'invertMap' to invert each valid digit. Since we don't want to modify
        // 'n', we create a copy of it as 'nCopy'.
        const invertMap = {
            0: 0,
            1: 1,
            6: 9,
            8: 8,
            9: 6,
        };
        let nCopy = n;
        let rotatedNumber = 0;

        // Get every digit of 'nCopy' by taking the remainder of it to 10.
        while (nCopy > 0) {
            let res = nCopy % 10;
            if (!(res in invertMap)) {
                return false;
            }
            // Append the inverted digit of 'res' to the end of 'rotatedNumber'.
            rotatedNumber = rotatedNumber * 10 + invertMap[res];
            nCopy = Math.floor(nCopy / 10);
        }
        // Check if 'rotatedNumber' equals 'n'.
        return rotatedNumber !== n;
    }
}

public class Solution {
    public bool ConfusingNumber(int n) {
        // Use 'invertMap' to invert each valid digit. Since we don't want to modify
        // 'n', we create a copy of it as 'nCopy'.
        var invertMap = new Dictionary<int, int> {
            {0, 0}, {1, 1}, {6, 9}, {8, 8}, {9, 6}
        };
        int nCopy = n, rotatedNumber = 0;

        // Get every digit of 'nCopy' by taking the remainder of it to 10.
        while (nCopy > 0) {
            int res = nCopy % 10;
            if (!invertMap.ContainsKey(res)) {
                return false;
            }
            // Append the inverted digit of 'res' to the end of 'rotatedNumber'.
            rotatedNumber = rotatedNumber * 10 + invertMap[res];
            nCopy /= 10;
        }

        // Check if 'rotatedNumber' equals 'n'.
        return rotatedNumber != n;
    }
}

func confusingNumber(n int) bool {
    // Use 'invertMap' to invert each valid digit. Since we don't want to modify
    // 'n', we create a copy of it as 'nCopy'.
    invertMap := map[int]int{0: 0, 1: 1, 6: 9, 8: 8, 9: 6}
    nCopy := n
    rotatedNumber := 0

    // Get every digit of 'nCopy' by taking the remainder of it to 10.
    for nCopy > 0 {
        res := nCopy % 10
        if _, ok := invertMap[res]; !ok {
            return false
        }
        // Append the inverted digit of 'res' to the end of 'rotatedNumber'.
        rotatedNumber = rotatedNumber*10 + invertMap[res]
        nCopy /= 10
    }

    // Check if 'rotatedNumber' equals 'n'.
    return rotatedNumber != n
}

class Solution {
    fun confusingNumber(n: Int): Boolean {
        // Use 'invertMap' to invert each valid digit. Since we don't want to modify
        // 'n', we create a copy of it as 'nCopy'.
        val invertMap = mapOf(0 to 0, 1 to 1, 6 to 9, 8 to 8, 9 to 6)
        var nCopy = n
        var rotatedNumber = 0

        // Get every digit of 'nCopy' by taking the remainder of it to 10.
        while (nCopy > 0) {
            val res = nCopy % 10
            if (res !in invertMap) {
                return false
            }
            // Append the inverted digit of 'res' to the end of 'rotatedNumber'.
            rotatedNumber = rotatedNumber * 10 + invertMap[res]!!
            nCopy /= 10
        }

        // Check if 'rotatedNumber' equals 'n'.
        return rotatedNumber != n
    }
}

class Solution {
    func confusingNumber(_ n: Int) -> Bool {
        // Use 'invertMap' to invert each valid digit. Since we don't want to modify
        // 'n', we create a copy of it as 'nCopy'.
        let invertMap: [Int: Int] = [0: 0, 1: 1, 6: 9, 8: 8, 9: 6]
        var nCopy = n
        var rotatedNumber = 0

        // Get every digit of 'nCopy' by taking the remainder of it to 10.
        while nCopy > 0 {
            let res = nCopy % 10
            guard let inverted = invertMap[res] else {
                return false
            }
            // Append the inverted digit of 'res' to the end of 'rotatedNumber'.
            rotatedNumber = rotatedNumber * 10 + inverted
            nCopy /= 10
        }

        // Check if 'rotatedNumber' equals 'n'.
        return rotatedNumber != n
    }
}

impl Solution {
    pub fn confusing_number(n: i32) -> bool {
        // Use 'invert_map' to invert each valid digit. Since we don't want to modify
        // 'n', we create a copy of it as 'n_copy'.
        let invert_map: HashMap<i32, i32> = [
            (0, 0), (1, 1), (6, 9), (8, 8), (9, 6),
        ].iter().cloned().collect();
        let mut n_copy = n;
        let mut rotated_number = 0;

        // Get every digit of 'n_copy' by taking the remainder of it to 10.
        while n_copy > 0 {
            let res = n_copy % 10;
            match invert_map.get(&res) {
                Some(&inverted) => {
                    // Append the inverted digit of 'res' to the end of 'rotated_number'.
                    rotated_number = rotated_number * 10 + inverted;
                }
                None => return false,
            }
            n_copy /= 10;
        }

        // Check if 'rotated_number' equals 'n'.
        rotated_number != n
    }
}

Time & Space Complexity

Time complexity: $O(L)$
Space complexity: $O(L)$ extra space used

Where $L$ is the maximum number of digits $n$ can have.

Common Pitfalls

Confusing "Different" with "Invalid"

A confusing number must be valid (all digits can be rotated) AND look different after rotation. Returning true for invalid digits like 2, 3, 4, 5, 7 instead of returning false is incorrect.

# Wrong: treats invalid digits as confusing
if ch not in invert_map:
    return True  # Should be False

# Correct
if ch not in invert_map:
    return False

Forgetting to Reverse After Inversion

Rotating 180 degrees means both inverting each digit AND reversing their order. Only inverting without reversing (or vice versa) gives the wrong result. For example, 69 inverts to 96 but must then reverse to 69, so 69 is NOT confusing.