Remove Insignificant Trailing Zeros from a Number

How to remove trailing zeros using Dart

I made regular expression pattern for that feature.

double num = 12.50; // 12.5
double num2 = 12.0; // 12
double num3 = 1000; // 1000

RegExp regex = RegExp(r'([.]*0)(?!.*\d)');

String s = num.toString().replaceAll(regex, '');

Javascript: Remove last decimal if zero

You could check the last digit of a stringed number and remove the last zero, if exists.

console.log([1.5, 1.49, 1.579].map(v => {    var temp = v.toFixed(3);    return temp.slice(-1) === '0'        ? temp.slice(0, -1)        : temp;}));

Remove trailing zeros

Is it not as simple as this, if the input IS a string? You can use one of these:

string.Format("{0:G29}", decimal.Parse("2.0044"))

decimal.Parse("2.0044").ToString("G29")

2.0m.ToString("G29")

This should work for all input.

Update Check out the Standard Numeric Formats I've had to explicitly set the precision specifier to 29 as the docs clearly state:

However, if the number is a Decimal and the precision specifier is omitted, fixed-point notation is always used and trailing zeros are preserved

Update Konrad pointed out in the comments:

Watch out for values like 0.000001. G29 format will present them in the shortest possible way so it will switch to the exponential notation. string.Format("{0:G29}", decimal.Parse("0.00000001",System.Globalization.CultureInfo.GetCultureInfo("en-US"))) will give "1E-08" as the result.

How to remove trailing zeros from a binary number

Here is a brute force approach:

long long remove_trailing_zeroes(long long v) {
    if (v != 0) {
        while ((v & 1) == 0)
            v /= 2;
    }
    return v;
}

Here is a direct approach for unsigned numbers, but the division might be more costly than the above iteration:

unsigned long long remove_trailing_zeroes(unsigned long long v) {
    if (v != 0) {
        // v and (v - 1) differ only in the trailing 0 bits plus 1
        // shifting v ^ (v - 1) right by 1 and adding 1 gives the power of 2
        // by which to divide v to remove all trailing 0 bits
        v /= (((v ^ (v - 1)) >> 1) + 1);
    }
    return v;
}

harold suggested this simplification:

unsigned long long remove_trailing_zeroes(unsigned long long v) {
    if (v != 0) {
        // `-v`, which is `(~v + 1)` has all bits flipped except the least
        // significant 1 bit.
        // dividing v by `-v & v` shifts all trailing zero bits out,
        v /= -v & v;
    }
    return v;
}

Which can be simplified as a single expression:

unsigned long long remove_trailing_zeroes(unsigned long long v) {
    return v ? v / (-v & v) : v;
}

To avoid the division, you could count the number of bits in v ^ (v - 1) with an efficient method and shift v right by one less than this number. This would work for 0 as well so you would get branchless code.

You can find other methods in the fascinating word of Bit Twiddling Hacks

Remove trailing zeros Intl.NumberFormat - JavaScript

Use ~~maximumSignificantDigits~~ maximumFractionDigits. Something like:

function getAmount(number) {
  if ((number | 0) < number) {
    return Intl.NumberFormat('sv-SE', {
      style: 'currency',
      currency: 'SEK'
    }).format(number)
  }
  return Intl.NumberFormat('sv-SE', {
    style: 'currency',
    currency: 'SEK',
    maximumFractionDigits: 0
  }).format(number);
}

console.log(getAmount(200));
console.log(getAmount(200.23));

Using RegEx how do I remove the trailing zeros and decimal also if needed

^(\d+(?:\.\d*?[1-9](?=0|\b))?)\.?0*$

Demo here.

explanation

^         //Beginning of line
(         //Start collecting our group
\d+       //All digits before decimal
(?:       //START-Non collecting group
\.        //Decimal point
\d*?      //It should actually be [0-9]
[1-9]     //Last significant digit after decimal
(?=0|\b)  //Either should be followed by zero or END OF WORD
)?        //END-Non collecting group
          //The non-capturing group after decimal is optional
)         //End collecting our group
\.?       //Optional decimal (decimal collected if it wasn't used earlier)
0*        //All the remaining zeros no + as all digits might be significant that is no ending zero
$         //End of line.

Remove trailing zero in C++

This is one thing that IMHO is overly complicated in C++. Anyway, you need to specify the desired format by setting properties on the output stream. For convenience a number of manipulators are defined.

In this case, you need to set fixed representation and set precision to 2 to obtain the rounding to 2 decimals after the point using the corresponding manipulators, see below (notice that setprecisioncauses rounding to the desired precision). The tricky part is then to remove trailing zeroes. As far as I know C++ does not support this out of the box, so you have to do some string manipulation.

To be able to do this, we will first "print" the value to a string and then manipulate that string before printing it:

#include <iostream>
#include <iomanip>

int main()
{ 
    double value = 12.498;
    // Print value to a string
    std::stringstream ss;
    ss << std::fixed << std::setprecision(2) << value;
    std::string str = ss.str();
    // Ensure that there is a decimal point somewhere (there should be)
    if(str.find('.') != std::string::npos)
    {
        // Remove trailing zeroes
        str = str.substr(0, str.find_last_not_of('0')+1);
        // If the decimal point is now the last character, remove that as well
        if(str.find('.') == str.size()-1)
        {
            str = str.substr(0, str.size()-1);
        }
    }
    std::cout << str << std::endl;
}