Create confusing_number_ii.py

Author: erjan

confusing_number_ii.py

@@ -0,0 +1,166 @@
+'''
+A confusing number is a number that when rotated 180 degrees becomes a different number with each digit valid.
+
+We can rotate digits of a number by 180 degrees to form new digits.
+
+When 0, 1, 6, 8, and 9 are rotated 180 degrees, they become 0, 1, 9, 8, and 6 respectively.
+When 2, 3, 4, 5, and 7 are rotated 180 degrees, they become invalid.
+Note that after rotating a number, we can ignore leading zeros.
+
+For example, after rotating 8000, we have 0008 which is considered as just 8.
+Given an integer n, return the number of confusing numbers in the inclusive range [1, n]
+'''
+
+
+class Solution:
+    def confusingNumberII(self, N: int) -> int:
+        rotatables = [1, 0, 6, 8, 9]
+        rotation_map = {1:1, 0:0, 6:9, 8:8, 9:6}        
+        confusing_number_count = 0
+        
+        def count_rotatables(cur_num=0):
+            nonlocal confusing_number_count
+            if cur_num * 10 > N:
+                return
+            for num in rotatables:
+                next_num = cur_num*10 + num
+                if next_num == 0:
+                    continue
+                confusing_number_count += next_num <= N and is_valid_rotation(next_num)
+                count_rotatables(next_num)
+        
+        def is_valid_rotation(num):
+            rotated = 0
+            cur_num = num
+            while cur_num:
+                rotated = rotated * 10 + rotation_map[cur_num%10]
+                cur_num //= 10
+            return rotated != num
+        
+        count_rotatables()
+        
+        return confusing_number_count
+      
+------------------------------------------------------------------------------------------
+class Solution:
+    def confusingNumberII(self, N: int) -> int:
+        rotations = {1:1, 6:9, 8:8, 9:6, 0:0}
+        valid = [0, 1, 6, 8, 9]
+        
+        def backtrack(num, rotation, position):
+            if num > N:
+                return
+            
+            if num != rotation:
+                count[0] += 1
+            
+            for digit in valid:
+                backtrack(num * 10 + digit, rotations[digit] * position + rotation, position * 10)
+        
+        count = [0]
+        for digit in valid[1:]:
+            backtrack(digit, rotations[digit], 10)
+        return count[0]
+      
+------------------------------------------------------------------------
+Main idea: Call numbers that are the same as themselves after rotating 180 degrees "cyclic numbers". Call all numbers that are still valid after rotating 180 degrees "valid numbers". The number of confusing numbers is the number of valid numbers minus the number of cyclic numbers.
+
+There are lots of edge cases in this problem so the code is not very clean.
+
+class Solution(object):
+    def confusingNumberII(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        N = max(len(str(n)), 3)
+        g = [-1] * N # g(n) = num of exact n digit cyclic numbers
+        f = [-1] * N # n digit cyclic where two ends can be 0's
+        g[0] = 1
+        g[1] = 2
+        f[0] = 1
+        f[1] = 3
+        for i in range(2,N):
+            g[i] = 4 * f[i-2]
+            f[i] = sum(g[j] for j in range(i, -1, -2))
+            
+            if i%2 != 0:
+                # we missed all zeros situation for odd i's
+                f[i] += 1
+
+        cds = [0, 1, 6, 8, 9] # confusing digits
+        A = list(str(n))
+        A = [int(a) for a in A]
+        
+        # count the number of valid numbers <= n
+        valid_count = 0
+        for i in range(len(A)):
+            smaller_num = len([j for j in cds if j<A[i]])
+            valid_count += smaller_num * 5**(len(A)-i-1) # definetly within range
+            
+            if A[i] not in cds:
+                break
+            else:
+                if i==len(A)-1:
+                    valid_count+=1
+        print("valid_count", valid_count)
+        
+        flip = {0:0,1:1,6:9,8:8,9:6}
+        
+        # count the number of cyclic numbers
+        ptr = 0
+        cyclic_count = 0
+        lastptr = len(A) - 1
+        backdigits = [] # list of set back digits, start from the last reverse order
+        while ptr < lastptr:
+            smaller_num = len([i for i in cds if i<A[ptr]]) #
+            if smaller_num >= 1: # if 0 < A[ptr]
+                if len(backdigits) > 0:
+                    cyclic_count += smaller_num * f[(lastptr-ptr-1)]
+                else:
+                    cyclic_count += (smaller_num-1) * f[(lastptr-ptr-1)] # if not 0
+                    cyclic_count += sum(g[0:(lastptr-ptr)+1]) # if we choose 0
+            
+            if A[ptr] in cds:
+                backdigits.insert(0, flip[A[ptr]])
+                ptr += 1
+                lastptr -= 1
+            else:
+                break
+                
+        print("cyclic", cyclic_count)
+        
+        # check if we reached the middle
+        if ptr > lastptr:
+            # strart from the ptr, if everything fixed so far is fine, add 1
+            adder = 1
+            j = 0
+            for i in range(ptr, len(A)):
+                if A[i] > backdigits[j]:
+                    adder = 1
+                    break
+                elif A[i] < backdigits[j]:
+                    adder = 0
+                    break
+                j += 1
+            cyclic_count += adder
+        elif ptr == lastptr:
+            # strart from the ptr, if everything fixed so far is fine, add 1
+            single_cyclic_set = [0,1,8]
+            cyclic_count += len([i for i in single_cyclic_set if i<A[ptr]])
+            # count ways for the center digit. These will be smaller than A
+            if A[ptr] in single_cyclic_set:
+                adder = 1
+                j = 0
+                for i in range(ptr+1, len(A)):
+                    if A[i] < backdigits[j]:
+                        adder = 0
+                        break
+                    elif A[i] > backdigits[j]:
+                        adder = 1
+                        break
+                    j += 1
+                cyclic_count += adder
+        
+        result = valid_count - cyclic_count
+        return result