Least Operators to Express Number

Least Operators to Express Number - Problem

Given a single positive integer x, we will write an expression of the form x (op1) x (op2) x (op3) x ... where each operator op1, op2, etc. is either addition, subtraction, multiplication, or division (+, -, *, or /).

For example, with x = 3, we might write 3 * 3 / 3 + 3 - 3 which is a value of 3.

When writing such an expression, we adhere to the following conventions:

The division operator (/) returns rational numbers.
There are no parentheses placed anywhere.
We use the usual order of operations: multiplication and division happen before addition and subtraction.
It is not allowed to use the unary negation operator (-). For example, x - x is a valid expression as it only uses subtraction, but -x + x is not because it uses negation.

We would like to write an expression with the least number of operators such that the expression equals the given target. Return the least number of operators used.

Input & Output

Example 1 — Small Target

$ Input: x = 3, target = 19

› Output: 5

💡 Note: We can write 19 as 3*3*3 - 3 - 3 - 3 + 3/3, which uses 5 operators: 3 multiplications + 2 subtractions = 5 total operators

Example 2 — Simple Case

$ Input: x = 5, target = 501

› Output: 8

💡 Note: 501 can be expressed as 5*5*5*4 + 1, where 4 = 5-1 and 1 = 5/5, requiring 8 operators total

Example 3 — Edge Case

$ Input: x = 100, target = 100

› Output: 1

💡 Note: Target equals x, so we just need 1 occurrence of x with 0 operators between

Constraints

2 ≤ x ≤ 100
1 ≤ target ≤ 2 × 10⁸

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is to treat this as a base conversion problem where we express the target using powers of x with minimal operators. The optimal approach uses mathematical decomposition to build the target efficiently by considering both positive and negative contributions. Time: O(log(target)), Space: O(1)

Common Approaches

✓ Brute Force Recursion

⏱️ Time: O(4^n) Space: O(n)

Generate all possible expressions by trying each operator at each position. For each expression, evaluate the result and count operators. This approach explores the entire search space without pruning.

Memoized Recursion

⏱️ Time: O(log²(target)) Space: O(log(target))

Same recursive approach but cache results for each (current_value, power_index) state. This dramatically reduces computation by avoiding redundant calculations of the same subproblems.

Optimized Mathematical Approach

⏱️ Time: O(log(target)) Space: O(1)

Instead of trying all combinations, analyze the target mathematically. Build the number using powers of x, considering both positive and negative contributions. Handle edge cases like target=x directly.

Brute Force Recursion — Algorithm Steps

Start with base case: if target equals x^k for some k, return k operators
Try adding/subtracting different powers of x
Recursively solve for remaining target
Return minimum operators found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with target and explore all operator choices

Branch

Try +, -, *, / at each position recursively

Count

Track minimum operators needed

Code -

solution.c — C

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

#define HASH_SIZE 100003

typedef struct HashNode {
    char key[50];
    int value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];
int x, target;

int hash(const char* key) {
    unsigned long hash = 5381;
    int c;
    while ((c = *key++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % HASH_SIZE;
}

int getMemo(const char* key) {
    int h = hash(key);
    HashNode* node = hashTable[h];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return -1;
}

void setMemo(const char* key, int value) {
    int h = hash(key);
    HashNode* node = malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->value = value;
    node->next = hashTable[h];
    hashTable[h] = node;
}

long long power(int base, int exp) {
    long long result = 1;
    for (int i = 0; i < exp; i++) {
        if (result > LLONG_MAX / base) {
            return LLONG_MAX;
        }
        result *= base;
    }
    return result;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int dp(long long cur, int k) {
    if (k >= 40) return 1000000000;
    if (cur == target) return 0;
    
    char key[50];
    sprintf(key, "%lld,%d", cur, k);
    
    int cached = getMemo(key);
    if (cached != -1) return cached;
    
    // Cost to make x^k
    int posCost, negCost;
    if (k == 0) {
        posCost = 2;  // x/x costs 2 operators
        negCost = 2;
    } else if (k == 1) {
        posCost = 0;  // x itself costs 0 operators
        negCost = 0;
    } else {
        posCost = k;  // x^k costs k operators
        negCost = k;
    }
    
    // Power value
    long long powerVal = power(x, k);
    
    int ans = dp(cur, k + 1);  // Skip this power
    
    // Add this power
    if (posCost < 1000000000 && powerVal != LLONG_MAX) {
        ans = min(ans, posCost + dp(cur + powerVal, k + 1));
    }
    
    // Subtract this power
    if (negCost < 1000000000 && powerVal != LLONG_MAX) {
        ans = min(ans, negCost + dp(cur - powerVal, k + 1));
    }
    
    setMemo(key, ans);
    return ans;
}

int solution(int x, int target) {
    // Clear hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    return dp(0, 0);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

Each position can have 4 operators, creating exponential branches

⚡ Linearithmic

Space Complexity

O(n)

Recursion stack depth proportional to expression length

✓ Linear Space

28.0K Views

Medium Frequency

~35 min Avg. Time

845 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 Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler