Remove Trailing Zeros From a String - Practice Coding Problems

Remove Trailing Zeros From a String - Problem

String Easy

Remove Trailing Zeros From a String

You are given a positive integer represented as a string, and your task is to remove all trailing zeros from it.

🎯 Goal: Return the integer without any trailing zeros, still as a string.

Examples:
• Input: "12300" → Output: "123"
• Input: "10200" → Output: "102"
• Input: "123" → Output: "123" (no trailing zeros)

This problem is commonly used in string processing, number formatting, and data cleaning scenarios where you need to normalize numeric strings by removing unnecessary trailing zeros.

Input & Output

example_1.py — Basic Case

$ Input: "12300"

› Output: "123"

💡 Note: The input has two trailing zeros '00' that need to be removed, leaving us with '123'.

example_2.py — Multiple Trailing Zeros

$ Input: "10200"

› Output: "102"

💡 Note: Only the trailing zeros are removed. The zero in the middle ('102') is preserved because it's not trailing.

example_3.py — No Trailing Zeros

$ Input: "123"

› Output: "123"

💡 Note: Since there are no trailing zeros, the string remains unchanged.

Constraints

1 ≤ num.length ≤ 1000
num consists of only digits
num represents a positive integer

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

We need to remove trailing zeros while preserving the rest

Choose Direction

Start from the end since that's where trailing zeros are

Stop at Content

As soon as we find a non-zero, we know where to cut

Key Takeaway

🎯 Key Insight: By scanning from right to left, we can stop as soon as we find the first non-zero character, making the algorithm more efficient for strings with many trailing zeros.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal approach is to use reverse iteration - start from the end of the string and work backwards until you find the first non-zero character. This is more efficient than scanning the entire string, especially for inputs with many trailing zeros. In Python, you can use rstrip('0') for a one-liner solution.

Common Approaches

Approach	Time	Space	Notes
✓ Reverse Iteration (Optimal)	O(n)	O(1)	Start from the end and work backwards until first non-zero
Brute Force (Character by Character)	O(n)	O(n)	Iterate through string and rebuild without trailing zeros

Reverse Iteration (Optimal) — Algorithm Steps

Start from the end of the string
Move backwards until we find a non-zero character
Return the substring from start to that position

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from End

Begin at the last character of the string

Move Backwards

Skip all trailing zeros by moving left

Stop at Non-Zero

Stop when we hit first non-zero character

Code -

solution.c — C

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

char* removeTrailingZeros(char* num) {
    int len = strlen(num);
    int end = len - 1;
    
    // Find the end position by going backwards
    while (end >= 0 && num[end] == '0') {
        end--;
    }
    
    // Create result string
    char* result = (char*)malloc((end + 2) * sizeof(char));
    strncpy(result, num, end + 1);
    result[end + 1] = '\0';
    
    return result;
}

int main() {
    char num[1001];
    fgets(num, sizeof(num), stdin);
    
    // Remove newline and quotes
    num[strcspn(num, "\n")] = 0;
    if (num[0] == '"') {
        memmove(num, num + 1, strlen(num));
        num[strlen(num) - 1] = '\0';
    }
    
    char* result = removeTrailingZeros(num);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case (no trailing zeros), we scan the entire string

✓ Linear Growth

Space Complexity

O(1)

Using built-in string methods, we don't create additional data structures

✓ Linear Space

23.4K Views

Medium Frequency

~8 min Avg. Time

892 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

Reverse Iteration (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler