Thousand Separator

EASY

Description

Given an integer n, add a dot (".") as the thousands separator and return it in string format.

Example 1:

Input: n = 987
Output: "987"

Example 2:

Input: n = 1234
Output: "1.234"

Constraints:

0 <= n <= 2³¹ - 1

Approaches

Checkout 2 different approaches to solve Thousand Separator. Click on different approaches to view the approach and algorithm in detail.

Iterate from Right with StringBuilder and Reverse

This is a very intuitive approach. We first convert the number to a string. Then, we iterate through this string from right to left, building a new string. We keep a counter to track digits, and every three digits, we add a dot. Since we build the result string in reverse order (from the least significant digit to the most significant), we need to reverse it at the end to get the final correct format.

Algorithm

Convert the input integer n to its string representation, let's call it s.
If the length of s is less than or equal to 3, no separator is needed. Return s directly.
Initialize a StringBuilder to construct the result.
Initialize a counter, digitCount, to 0.
Loop through the string s from the last character to the first (index s.length() - 1 down to 0).
Inside the loop, append the current character to the StringBuilder.
Increment digitCount.
Check if digitCount is 3 and if we are not at the very beginning of the string (i.e., the loop index is not 0). If both conditions are true, append a . separator to the StringBuilder and reset digitCount to 0.
After the loop completes, the StringBuilder holds the formatted string but in reverse order.
Call the reverse() method on the StringBuilder and then convert it to a string to get the final answer.

This approach works by processing the number's string representation from right to left, which is the natural way to group digits into thousands. A StringBuilder is used for efficient string construction.

class Solution {
    public String thousandSeparator(int n) {
        String s = Integer.toString(n);
        if (s.length() <= 3) {
            return s;
        }
        
        StringBuilder resultBuilder = new StringBuilder();
        int count = 0;
        for (int i = s.length() - 1; i >= 0; i--) {
            resultBuilder.append(s.charAt(i));
            count++;
            // Add a dot after every 3 digits, but not at the very beginning
            if (count % 3 == 0 && i > 0) {
                resultBuilder.append('.');
            }
        }
        
        // The string was built backwards, so we need to reverse it
        return resultBuilder.reverse().toString();
    }
}

Complexity Analysis

Time Complexity: O(L), where L is the number of digits in `n`. Converting the integer to a string takes O(L). The loop iterates L times, and operations inside (appending to `StringBuilder`) are amortized O(1). The final reversal also takes O(L).Space Complexity: O(L), where L is the number of digits in `n`. The `StringBuilder` requires space proportional to the number of digits plus the separators.

Pros and Cons

Pros:

The logic is simple and follows a natural way of thinking about the problem (grouping from the right).
Easy to implement correctly.

Cons:

Requires a final reversal step, which adds an extra pass over the constructed string.

Code Solutions

Checking out 3 solutions in different languages for Thousand Separator. Click on different languages to view the code.

class Solution {
public
  String thousandSeparator(int n) {
    int cnt = 0;
    StringBuilder ans = new StringBuilder();
    while (true) {
      int v = n % 10;
      n /= 10;
      ans.append(v);
      ++cnt;
      if (n == 0) {
        break;
      }
      if (cnt == 3) {
        ans.append('.');
        cnt = 0;
      }
    }
    return ans.reverse().toString();
  }
}

Video Solution

Watch the video walkthrough for Thousand Separator

Data Structures:

String