Digit Operations to Make Two Integers Equal

Digit Operations to Make Two Integers Equal - Problem

Imagine you're playing a number transformation game where you need to turn one number into another by incrementing or decrementing individual digits, but there's a catch - your number can never become prime!

Given two integers n and m with the same number of digits, you can perform these operations on n:

🔼 Increment: Choose any digit that's not 9 and increase it by 1
🔽 Decrement: Choose any digit that's not 0 and decrease it by 1

Critical Rule: The number n must never be prime at any point during the transformation process (including its original value).

The cost of transformation is the sum of all intermediate values that n takes during the operations. Your goal is to find the minimum cost to transform n into m.

Return -1 if the transformation is impossible.

Input & Output

example_1.py — Basic Transformation

$ Input: n = 10, m = 12

› Output: 85

💡 Note: Transform 10 → 11 → 12. Cost = 10 + 11 + 12 = 33. But we need to avoid primes: 10 → 20 → 21 → 22 → 12 might be one valid path with higher cost of 85.

example_2.py — Prime Start Invalid

$ Input: n = 17, m = 19

› Output: -1

💡 Note: Since 17 is prime, we cannot start the transformation process. Return -1.

example_3.py — Same Numbers

$ Input: n = 48, m = 48

› Output: 48

💡 Note: n and m are the same. Since 48 is not prime, the cost is just n itself = 48.

Constraints

1 ≤ n, m < 10⁴
n and m have the same number of digits
n must not be prime initially

Visualization

Tap to expand

Understanding the Visualization

Map the Territory

Identify all valid (non-prime) numbers as safe nodes in our network

Find Connections

Each number connects to others by incrementing/decrementing individual digits

Calculate Costs

Each step to a new number costs the value of that destination number

Navigate Optimally

Use Dijkstra's algorithm to find the cheapest route from start to destination

Key Takeaway

🎯 Key Insight: Transform a number manipulation problem into a graph shortest-path problem by treating valid numbers as nodes and digit operations as weighted edges.

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 15 f Meta 12

This problem is a shortest path problem in disguise. Model each non-prime number as a graph node and digit operations as weighted edges. Use Dijkstra's algorithm to find the minimum cost transformation path from n to m, ensuring no intermediate number is prime. The key insight is recognizing this as a graph traversal problem rather than a simple digit manipulation challenge.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (BFS with All Paths)	O(10^d × d)	O(10^d)	Explore all possible transformation sequences using BFS
Dijkstra's Shortest Path (Optimal)	O(10^d × d × log(10^d))	O(10^d)	Use Dijkstra's algorithm to find minimum cost transformation path

Brute Force (BFS with All Paths) — Algorithm Steps

Check if starting number n is prime - if so, return -1
Use BFS to explore all possible digit modifications
For each number, generate all valid neighbors (increment/decrement digits)
Check if each neighbor is prime - skip if prime
Track minimum cost to reach each number
Return cost when target m is reached, or -1 if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at n

Begin BFS from starting number n

Generate neighbors

Create all numbers by incrementing/decrementing each digit

Check primality

Filter out prime numbers as invalid states

Continue BFS

Add valid neighbors to queue and continue exploration

Code -

solution.c — C

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

#define MAX_QUEUE 100000

typedef struct {
    int num;
    int cost;
} State;

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;
}

int getNeighbors(int num, int* neighbors) {
    char numStr[10];
    sprintf(numStr, "%d", num);
    int len = strlen(numStr);
    int count = 0;
    
    for (int i = 0; i < len; i++) {
        int digit = numStr[i] - '0';
        if (digit < 9) {
            char newStr[10];
            strcpy(newStr, numStr);
            newStr[i] = '0' + digit + 1;
            neighbors[count++] = atoi(newStr);
        }
        if (digit > 0) {
            char newStr[10];
            strcpy(newStr, numStr);
            newStr[i] = '0' + digit - 1;
            neighbors[count++] = atoi(newStr);
        }
    }
    
    return count;
}

int minimumCost(int n, int m) {
    if (isPrime(n)) return -1;
    if (n == m) return n;
    
    State queue[MAX_QUEUE];
    bool visited[100000] = {false};
    int front = 0, rear = 0;
    
    queue[rear++] = (State){n, n};
    visited[n] = true;
    
    while (front < rear) {
        State current = queue[front++];
        int neighbors[20];
        int neighborCount = getNeighbors(current.num, neighbors);
        
        for (int i = 0; i < neighborCount; i++) {
            int neighbor = neighbors[i];
            if (neighbor == m) {
                return current.cost + neighbor;
            }
            
            if (neighbor < 100000 && !visited[neighbor] && !isPrime(neighbor)) {
                visited[neighbor] = true;
                queue[rear++] = (State){neighbor, current.cost + neighbor};
            }
        }
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^d × d)

Where d is number of digits. We may visit all possible d-digit numbers, and for each we check d digit operations

✓ Linear Growth

Space Complexity

O(10^d)

Store visited numbers and queue for BFS traversal

✓ Linear Space

26.1K Views

Medium Frequency

~35 min Avg. Time

847 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

Brute Force (BFS with All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler