Codestin Search App

Least Operators to Express Number - Problem

Imagine you're a mathematician with a unique challenge: you can only use a single number x to build mathematical expressions, but you can use it as many times as you want with basic operators!

The Challenge: Given a positive integer x and a target value, create an expression using only the number x and the operators +, -, *, and / that equals the target. Your goal is to use the minimum number of operators possible.

Rules:

You can only use the number x (as many times as needed)
Available operators: addition (+), subtraction (-), multiplication (*), division (/)
Follow standard order of operations (*, / before +, -)
No parentheses allowed
No unary negation (can't start with -x)
Division returns exact rational numbers

Example: With x = 3 and target = 19, one solution could be 3 * 3 * 3 - 3 - 3 - 3 + 3 which uses 6 operators, but there might be a more efficient way!

Input & Output

example_1.py — Basic Case

$ Input: x = 3, target = 19

› Output: 5

💡 Note: One optimal solution is 3 * 3 + 3 * 3 + 3 / 3 which equals 9 + 9 + 1 = 19, using 5 operators (* + * + /). The expression follows order of operations: multiplications and division first, then addition.

example_2.py — Simple Target

$ Input: x = 5, target = 501

› Output: 8

💡 Note: We can express 501 as 5 * 5 * 5 * 4 + 1, which is 5 * 5 * 5 * (5 - 1) + 1 = 125 * 4 + 1 = 501. This uses 8 operators total when properly expanded with only 5's and basic operators.

example_3.py — Edge Case

$ Input: x = 2, target = 1

› Output: 1

💡 Note: The simplest way to get 1 using only 2's is 2 / 2 = 1, which uses exactly 1 operator (division). This is more efficient than using addition/subtraction approaches.

Constraints

2 ≤ x ≤ 100
1 ≤ target ≤ 2 × 10⁸
All operations follow standard mathematical precedence
No parentheses are allowed in expressions
Division always yields exact rational results

Visualization

Tap to expand

Understanding the Visualization

Identify Building Blocks

Calculate cost to build each power: x⁰=1 (costs 2: x/x), x¹=x (costs 1), x²=x×x (costs 2), etc.

Express as Sum

Try to write target = ±x^i ± remaining, where we choose the sign and power optimally

Recursive Breakdown

Solve the remaining part recursively, trying all feasible powers of x

Memoize Results

Cache solutions for each target value to avoid recomputation

Find Minimum

Return the minimum operators across all valid decompositions

Key Takeaway

🎯 Key Insight: Transform the problem into finding optimal coefficients for powers of x, where each power has a known construction cost. Dynamic programming with memoization ensures we don't recalculate the same subproblems.

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 19

The optimal approach uses dynamic programming with memoization to build the target as a sum of powers of x. The key insight is that any number can be expressed as a linear combination of powers: target = a₁×x¹ + a₂×x² + a₃×x³ + ... where coefficients can be positive or negative. We recursively explore all possibilities and memoize results to achieve O(target × log target) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive Exploration)	O(target × log target)	O(target × log target)	Recursively try all possible ways to build the target using different powers of x

Brute Force (Recursive Exploration) — Algorithm Steps

For each possible power of x (both positive and negative), calculate how many operators it takes to build
Try adding/subtracting this power term from the target
Recursively solve for the remaining value
Take the minimum across all possibilities
Use memoization to avoid recalculating the same subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Problem

Start with target value, need to express using x and operators

Try Powers of x

Consider x^0=1, x^1=x, x^2=x*x, etc. as building blocks

Recursive Breakdown

For each power, solve subproblem: target - power or power - target

Memoization

Store results to avoid recalculating same subproblems

Optimal Solution

Return minimum operators needed across all valid combinations

Code -

solution.c — C

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

#define MAXN 100000
int memo[MAXN];
int x_global;

int solve(int cur) {
    if (cur >= 0 && cur < MAXN && memo[cur] != -1) {
        return memo[cur];
    }
    if (cur == 0) return 0;
    if (cur == 1) {
        int result = x_global > 2 ? 2 : x_global;
        if (cur < MAXN) memo[cur] = result;
        return result;
    }
    
    int result = INT_MAX;
    int power = 1;
    long long base = x_global;
    
    while (power <= 40 && base <= 2LL * cur) {
        if (base <= cur) {
            int temp = solve(cur - base);
            if (temp != INT_MAX && temp + power < result) {
                result = temp + power;
            }
        }
        if (base > cur) {
            int temp = solve(base - cur);
            if (temp != INT_MAX && temp + power < result) {
                result = temp + power;
            }
        }
        
        power++;
        base *= x_global;
    }
    
    if (cur >= 0 && cur < MAXN) {
        memo[cur] = result;
    }
    return result;
}

int main() {
    int target;
    scanf("%d %d", &x_global, &target);
    
    memset(memo, -1, sizeof(memo));
    printf("%d\n", solve(target));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(target × log target)

With memoization, each unique target value is computed once, and we consider O(log target) different powers of x

⚡ Linearithmic

Space Complexity

O(target × log target)

Memoization table stores results for different target values and recursion depth

✓ Linear Space

43.3K Views

Medium Frequency

~25 min Avg. Time

1.8K 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 (Recursive Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler