# Solving Leetcode Interviews in Seconds with AI: Digit Operations to Make Two Integers Equal # Introduction In this blog post, we will explore how to solve the LeetCode problem "3377" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months. # Problem Statement > You are given two integers n and m that consist of the same number of digits. You can perform the following operations any number of times: Choose any digit from n that is not 9 and increase it by 1. Choose any digit from n that is not 0 and decrease it by 1. The integer n must not be a prime number at any point, including its original value and after each operation. The cost of a transformation is the sum of all values that n takes throughout the operations performed. Return the minimum cost to transform n into m. If it is impossible, return -1.   Example 1: Input: n = 10, m = 12 Output: 85 Explanation: We perform the following operations: Increase the first digit, now n = 20. Increase the second digit, now n = 21. Increase the second digit, now n = 22. Decrease the first digit, now n = 12. Example 2: Input: n = 4, m = 8 Output: -1 Explanation: It is impossible to make n equal to m. Example 3: Input: n = 6, m = 2 Output: -1 Explanation:  Since 2 is already a prime, we can't make n equal to m.   Constraints: 1 <= n, m < 104 n and m consist of the same number of digits. # Explanation Here's the breakdown of the solution: * **Graph Representation:** Model the problem as a graph where each node represents a number. An edge exists between two nodes if one can be reached from the other by incrementing/decrementing a single digit, ensuring that the intermediate numbers are never prime. * **Breadth-First Search (BFS):** Use BFS to find the shortest path (minimum number of operations) from the initial number 'n' to the target number 'm'. Keep track of the cumulative cost along each path. * **Prime Check Optimization:** Precompute a list of primes up to a certain limit (10000) using the Sieve of Eratosthenes for efficient prime checking during graph construction and BFS. * Runtime Complexity: O(V + E), where V is the number of possible states (numbers between 1000 and 9999 for 4-digit numbers) and E is the number of possible transitions between states. The Sieve of Eratosthenes takes O(N log log N) time, which can be considered O(N) for our constraints. Storage Complexity: O(V) to store the graph, visited nodes, and cost. ```python import collections def solve(): def is_prime(num, primes): return num in primes def get_neighbors(num, primes): s_num = str(num) neighbors = [] for i in range(len(s_num)): digit = int(s_num[i]) # Increment if digit < 9: new_digit = digit + 1 new_num_str = s_num[:i] + str(new_digit) + s_num[i+1:] new_num = int(new_num_str) if not is_prime(new_num, primes): neighbors.append(new_num) # Decrement if digit > 0: new_digit = digit - 1 new_num_str = s_num[:i] + str(new_digit) + s_num[i+1:] new_num = int(new_num_str) if not is_prime(new_num, primes): neighbors.append(new_num) return neighbors def bfs(start, end, primes, n_digits): q = collections.deque([(start, 0, start)]) # (node, cost, total_cost) visited = {start} while q: node, cost, total_cost = q.popleft() if node == end: return total_cost neighbors = get_neighbors(node, primes) for neighbor in neighbors: if neighbor not in visited: visited.add(neighbor) q.append((neighbor, cost + neighbor, total_cost + neighbor)) return -1 n = int(input()) m = int(input()) n_digits = len(str(n)) limit = 10 ** n_digits lower_bound = 10**(n_digits-1) # Sieve of Eratosthenes primes = set() is_composite = [False] * limit for i in range(2, limit): if not is_composite[i]: if i >= lower_bound: primes.add(i) for j in range(i * i, limit, i): is_composite[j] = True if is_prime(m, primes): print(-1) return print(bfs(n, m, primes, n_digits)) # Code ```python import olletions def solve(): def is_prime(num, primes): return num in primes def get_neighbors(num, primes): s_num = str(num) neighbors = [] for i in range(len(s_num)): digit = int(s_num[i]) # Increment if digit < 9: new_digit = digit + 1 new_num_str = s_num[:i] + str(new_digit) + s_num[i+1:] new_num = int(new_num_str) if not is_prime(new_num, primes): neighbors.append(new_num) # Decrement if digit > 0: new_digit = digit - 1 new_num_str = s_num[:i] + str(new_digit) + s_num[i+1:] new_num = int(new_num_str) if not is_prime(new_num, primes): neighbors.append(new_num) return neighbors def bfs(start, end, primes, n_digits): q = collections.deque([(start, 0, start)]) # (node, cost, total_cost) visited = {start} while q: node, cost, total_cost = q.popleft() if node == end: return total_cost neighbors = get_neighbors(node, primes) for neighbor in neighbors: if neighbor not in visited: visited.add(neighbor) q.append((neighbor, cost + neighbor, total_cost + neighbor)) return -1 n = int(input()) m = int(input()) n_digits = len(str(n)) limit = 10 ** n_digits lower_bound = 10**(n_digits-1) # Sieve of Eratosthenes primes = set() is_composite = [False] * limit for i in range(2, limit): if not is_composite[i]: if i >= lower_bound: primes.add(i) for j in range(i * i, limit, i): is_composite[j] = True if is_prime(m, primes): print(-1) return print(bfs(n, m, primes, n_digits)) solve() ```