Digit Operations to Make Two Integers Equal

Digit Operations to Make Two Integers Equal - Problem

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.

Important constraint: 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.

Input & Output

Example 1 — Basic Transformation

$ Input: n = 10, m = 12

› Output: 42

💡 Note: Path: 10 → 20 → 12. Cost = 10 + 20 + 12 = 42. We avoid 11 because it's prime.

Example 2 — Same Number

$ Input: n = 34, m = 34

› Output: 34

💡 Note: Numbers are already equal, so the cost is just the starting number 34.

Example 3 — Impossible Case

$ Input: n = 23, m = 56

› Output: -1

💡 Note: Starting number 23 is prime, so no transformations are allowed. Return -1.

Constraints

1 ≤ n, m ≤ 10⁴
n and m have the same number of digits
n and m are positive integers

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

This is a shortest path problem where we need to transform one number to another through digit operations while avoiding prime numbers. The key insight is to model this as a graph where each non-prime number is a node, and use Dijkstra's algorithm to find the minimum cost path. Best approach is Dijkstra with priority queue. Time: O(10^d × log(10^d) × √n), Space: O(10^d).

Common Approaches

✓ BFS with All Paths

⏱️ Time: O(10^d × d) Space: O(10^d)

Try all possible digit changes level by level, tracking the cumulative cost and avoiding prime numbers. This explores all possible paths without optimization.

Dijkstra's Algorithm

⏱️ Time: O(10^d × log(10^d) × √n) Space: O(10^d)

Model this as a graph where each non-prime number is a node, and edges connect numbers that differ by one digit operation. Use Dijkstra's algorithm to find the minimum cost path.

BFS with All Paths — Algorithm Steps

Check if starting number is prime (return -1 if so)
Use BFS to explore all digit modifications
For each number, try +1/-1 on each digit
Skip if result is prime or out of bounds
Return minimum cost when target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with n=10, target m=12

Explore

Try all digit +1/-1 operations

Filter

Skip prime numbers like 11

Result

Find shortest path: 10→20→12

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

bool isPrime(int num) {
    if (num < 2) return false;
    if (num == 2) return true;
    if (num % 2 == 0) return false;
    for (int i = 3; i * i <= num; i += 2) {
        if (num % i == 0) return false;
    }
    return true;
}

struct State {
    int cost;
    int num;
};

struct MinHeap {
    struct State* data;
    int size;
    int capacity;
};

void heapInit(struct MinHeap* heap) {
    heap->data = malloc(100000 * sizeof(struct State));
    heap->size = 0;
    heap->capacity = 100000;
}

void heapPush(struct MinHeap* heap, int cost, int num) {
    if (heap->size >= heap->capacity) return;
    
    int idx = heap->size++;
    heap->data[idx].cost = cost;
    heap->data[idx].num = num;
    
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap->data[parent].cost <= heap->data[idx].cost) break;
        struct State temp = heap->data[parent];
        heap->data[parent] = heap->data[idx];
        heap->data[idx] = temp;
        idx = parent;
    }
}

bool heapPop(struct MinHeap* heap, int* cost, int* num) {
    if (heap->size == 0) return false;
    
    *cost = heap->data[0].cost;
    *num = heap->data[0].num;
    
    heap->data[0] = heap->data[--heap->size];
    
    int idx = 0;
    while (true) {
        int minIdx = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < heap->size && heap->data[left].cost < heap->data[minIdx].cost) {
            minIdx = left;
        }
        if (right < heap->size && heap->data[right].cost < heap->data[minIdx].cost) {
            minIdx = right;
        }
        
        if (minIdx == idx) break;
        struct State temp = heap->data[idx];
        heap->data[idx] = heap->data[minIdx];
        heap->data[minIdx] = temp;
        idx = minIdx;
    }
    
    return true;
}

int solution(int n, int m) {
    if (n == m) return n;
    if (isPrime(n)) return -1;
    
    struct MinHeap heap;
    heapInit(&heap);
    static bool visited[100000];
    memset(visited, false, sizeof(visited));
    
    heapPush(&heap, n, n);
    
    char nStr[10];
    sprintf(nStr, "%d", n);
    int numDigits = strlen(nStr);
    
    int cost, currNum;
    while (heapPop(&heap, &cost, &currNum)) {
        if (visited[currNum]) continue;
        visited[currNum] = true;
        
        if (currNum == m) {
            free(heap.data);
            return cost;
        }
        
        char currStr[10];
        sprintf(currStr, "%0*d", numDigits, currNum);
        
        for (int i = 0; i < numDigits; i++) {
            int digit = currStr[i] - '0';
            
            // Try increasing digit
            if (digit < 9) {
                char newStr[10];
                strcpy(newStr, currStr);
                newStr[i] = (digit + 1) + '0';
                int newNum = atoi(newStr);
                
                if (newNum < 100000 && !visited[newNum] && !isPrime(newNum)) {
                    heapPush(&heap, cost + newNum, newNum);
                }
            }
            
            // Try decreasing digit
            if (digit > 0) {
                char newStr[10];
                strcpy(newStr, currStr);
                newStr[i] = (digit - 1) + '0';
                int newNum = atoi(newStr);
                
                if (newNum < 100000 && !visited[newNum] && !isPrime(newNum)) {
                    heapPush(&heap, cost + newNum, newNum);
                }
            }
        }
    }
    
    free(heap.data);
    return -1;
}

int main() {
    int n, m;
    scanf("%d", &n);
    scanf("%d", &m);
    printf("%d\n", solution(n, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^d × d)

10^d possible numbers with d digits, each requiring prime check of O(√n)

⚡ Linearithmic

Space Complexity

O(10^d)

Queue and visited set can store up to 10^d numbers

✓ Linear Space

8.8K Views

Medium Frequency

~35 min Avg. Time

234 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS with All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler