Skip to main content

Compute Decimal Representation - Solution & Explanation

EasyArrayMath6 min readAsked at: Meta
Practice this problem

Problem Statement

You are given a positive integer n.

A positive integer is a base-10 component if it is the product of a single digit from 1 to 9 and a non-negative power of 10. For example, 500, 30, and 7 are base-10 components, while 537, 102, and 11 are not.

Express n as a sum of only base-10 components, using the fewest base-10 components possible.

Return an array containing these base-10 components in descending order.

 

Example 1:

Input: n = 537

Output: [500,30,7]

Explanation:

We can express 537 as 500 + 30 + 7. It is impossible to express 537 as a sum using fewer than 3 base-10 components.

Example 2:

Input: n = 102

Output: [100,2]

Explanation:

We can express 102 as 100 + 2. 102 is not a base-10 component, which means 2 base-10 components are needed.

Example 3:

Input: n = 6

Output: [6]

Explanation:

6 is a base-10 component.

 

Constraints:

  • 1 <= n <= 109

Approach Overview

Problem Overview: Given an integer, compute its decimal representation as a sequence of digits. Instead of relying on built-in string conversion, you explicitly derive each digit using basic arithmetic operations.

Approach 1: Simulation with Division and Modulo (O(d) time, O(d) space)

The straightforward method simulates how humans extract digits from a number. Repeatedly apply num % 10 to get the least significant digit, append it to a result container, then update the number using num // 10. Continue until the value becomes zero. Because digits are collected from least significant to most significant, reverse the result at the end to restore the correct order.

This method directly models decimal decomposition. Each iteration isolates one digit, so the loop runs once per digit in the number. The number of iterations is proportional to the digit count d, giving O(d) time complexity. The output array stores all digits, so space complexity is also O(d). The approach relies only on arithmetic operations and a dynamic array, which makes it predictable and language‑agnostic.

This technique appears frequently in problems involving manual number processing, base conversions, and digit manipulation. Understanding it helps with tasks like reversing numbers, checking palindromes, or implementing custom numeric formats using math operations and array storage.

Recommended for interviews: The simulation approach is exactly what interviewers expect. It demonstrates that you understand how decimal numbers are constructed from digits using division and modulo. Even though many languages provide built‑in conversions, implementing the digit extraction manually shows control over fundamental math operations and array manipulation.

Solution

We can repeatedly perform modulo and division operations on n. Each modulo result multiplied by the current position value p represents a decimal component. If the modulo result is not 0, we add this component to our answer. Then we multiply p by 10 and continue processing the next position.

Finally, we reverse the answer to arrange it in descending order.

The time complexity is O(log n), where n is the input positive integer. The space complexity is O(log n) for storing the answer.

Code

Python

Java

C++

Go

TypeScript

Try this approach in the editor →

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Simulation using division and moduloO(d)O(d)General case when manually extracting digits of a number
String conversion then iterateO(d)O(d)Quick implementation when language conversion utilities are allowed

Video Solution

Leetcode Weekly Contest 469 Q1. Compute Decimal Representation • ADevOpsEngineer • 555 views views

Watch 8 more video solutions →

Frequently Asked Questions

Is Compute Decimal Representation easy or hard?
Compute Decimal Representation is considered an Easy problem. The logic relies on basic arithmetic operations and simple array handling, making it a common warm‑up question for practicing number manipulation.
Compute Decimal Representation Python/Java solution
In Python or Java, loop while the number is greater than zero, append num % 10 to a list, then update num //= 10 (or num /= 10 in Java integer arithmetic). Reverse the collected digits to produce the final decimal representation.
How to solve Compute Decimal Representation in O(n)?
Treat n as the number of digits. Repeatedly apply modulo 10 to extract the last digit and integer division by 10 to remove it. Store each digit in a list and reverse the list at the end to obtain the correct decimal order, resulting in O(n) time.
What is the best approach for Compute Decimal Representation?
The standard approach uses simulation with division and modulo. Repeatedly compute num % 10 to extract the last digit, store it, then update the number with integer division by 10. This runs in O(d) time where d is the number of digits and uses O(d) space for the result array.
Is Compute Decimal Representation asked at Google/Amazon/Meta?
Digit extraction and number manipulation problems frequently appear in technical interviews at companies like Google, Amazon, and Meta. While this exact problem may vary in wording, the same idea is used in tasks involving number reversal, palindrome checks, and base conversion.
What data structure is used in Compute Decimal Representation?
An array or dynamic list is typically used to store the digits as they are extracted. Arithmetic operations like modulo and integer division handle the math part, while the array maintains the final ordered sequence of digits.
What is the time complexity of Compute Decimal Representation?
Time complexity is O(d), where d represents the number of digits in the input number. Each loop iteration extracts one digit using modulo and division operations. Space complexity is also O(d) because the algorithm stores all digits in an array or list.

Ready to solve this problem?

Practice Compute Decimal Representation with our built-in code editor and test cases.

Practice on FleetCode