如何在C ++中从一串科学数字中修剪零

Question

I am trying to trim zeros from strings in scientific number form:

1. 1.200e+12 should be 1.2e+12
2. 1.0200e+12 should be 1.02e+12
3. 1.0000e+12 should be 1e+12
4. 1.0e+12 should be 1e+12
5. 100e+12 should be 100e+12
6. 1.e+12 should be 1e+12 (optional)
   

I am using this function to do this:

std::regex_replace(s,std::regex("([^\\.]+(?=\\.)|[^\\.]+\\.\\d+?)0*(e.*)$"),\
                            "$1$2",std::regex_constants::format_first_only)

But the regex seems to be not correct. It gives me wrong result:

1. 1.0e for 1.000e
2. 1.0e for 1.0e
3. 1.e for 1.e

How can I do this with regex or is there another efficient way without using regex at all?

Answer 1

I would use a conditional regex like this:

(\d*)(?:(?=[.]0*e)[.]0*|(?![.]0+e)([.][0-9]*?)0*)(e(?:[+]\d+)?)

See regex demo . Replace with $1$2$3 .

The regex matches...

• (\\d*) - (Group 1) 0 or more digits
• (?:(?=[.]0*e)[.]0*|(?![.]0+e)([.][0-9]*?)0*) - two alternatives:
  • (?=[.]0*e)[.]0* - match 0 or more zeros if these are 0s coming after a dot up to e
  • | - or...
  • (?![.]0+e)([.][0-9]*?)0* - match and capture into Group 2 a dot with as few digits as possible before 0 or more 0 s if there are no just zeros after . up to e
• (e(?:[+]\\d+)?) - (Group 3) match and capture e or e+ followed with 1 or more digits.

IDEONE demo :

#include <iostream>
#include <regex>
using namespace std;

int main() {
    std::vector<std::string> strings;
    strings.push_back("1.200e+12");
    strings.push_back("1.0200e+12");
    strings.push_back("1.0000e+12");
    strings.push_back("1.0e+12");
    strings.push_back("1.e+12");
    strings.push_back("100e");
    strings.push_back("100e+12");
    std::regex reg(R"((\d*)(?:(?=[.]0*e)[.]0*|(?![.]0+e)([.][0-9]*?)0*)(e(?:[+]\d+)?))");
    for (size_t k = 0; k < strings.size(); k++)
    {
        std::cout << "Next string: " << strings[k] << std::endl;
        std::cout << "Replace result: " 
                     << std::regex_replace(strings[k], reg, "$1$2$3") << std::endl;
    }
    return 0;
}

Answer 2

I'd suggest that you proceed with 2 steps:

1. remove trailing 0 s: https://regex101.com/r/aV0sM6/1

    RegEx: s/([0-9]+)\\.([0-9]*[^0])?(0*)[eE]([-+][0-9]+)/\\1.\\2e\\4/ Input: Output: 1.200e+12 1.2e+12 1.0200e+12 1.02e+12 1.0000e+12 1.e+12 1.0e+12 1.e+12 1.e+12 1.e+12 

2. remove trailing . s: https://regex101.com/r/zT3wI2/1

    s/([0-9]+)\\.[eE]([-+][0-9]+)/\\1e\\2/ Input: Output: 1.2e+12 1.2e+12 1.02e+12 1.02e+12 1.e+12 1e+12 1.e+12 1e+12 1.e+12 1e+12 

EDIT Here's another solution that doesn't use regular expressions:

Run It Online

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;

string trim(string str)
{
    // return integers without modification
    if (str.find('.') == string::npos)
    {
        return str;
    }

    // process floating point numbers

    // find the exponent symbol
    const size_t pos_e  = str.rfind('e');
    const size_t rpos_e = str.length() - pos_e;

    // find the first trailing zero (if any)
    const size_t rpos_firstTrailingZero = std::distance(
        str.rbegin(),
        std::find_if(str.rbegin() + rpos_e,
                     str.rend(),
                     [](const char c) { return c != '0'; })
    );
    const size_t pos_firstTrailingZero = str.length()
                                       - rpos_firstTrailingZero;

    // compute the trimming position
    // if the fractional part was only zeros (e.g. 1.000), then trailing '.' should be removed
    const size_t pos_trimming = (str[pos_firstTrailingZero - 1] != '.')
                              ? pos_firstTrailingZero
                              : (pos_firstTrailingZero - 1);

    // copy the exponent part to where the string should be trimmed
    const size_t len_exp = str.length() - pos_e;  // length of the exponentiation part
    std::copy(str.begin() + pos_e,
              str.end(),
              str.begin() + pos_trimming);
    str.resize(pos_trimming + len_exp);

    // done
    return str;
}

int main()
{
    cout << trim("1.200e+12")  << endl;
    cout << trim("1.0200e+12") << endl;
    cout << trim("1.0000e+12") << endl;
    cout << trim("1.0e+12")    << endl;
    cout << trim("1.e+12")     << endl;
    cout << trim("100e")       << endl;
    cout << trim("100e+12")    << endl;
}

Output:

1.2e+12
1.02e+12
1e+12
1e+12
1e+12
100e
100e+12

Answer 3

This is what I could think of, and it works for all your given cases.

string solve(string x)
{
    string y;
    auto d=x.find('.');
    if (d==string::npos) return x;
    for (int i=0; i!=d; i++) y.push_back(x[i]);
    int j, k;
    for (k=d+1; tolower(x[k])!='e'; k++);
    for (j=k-1; x[j]=='0'; j--);
    if (j==d) j--;
    for (int i=d; i<=j; i++) y.push_back(x[i]);
    for (int i=k; i<x.length(); i++) y.push_back(x[i]);
    return y;
}

Answer 4

You could use a stack. For example:

• Push each char in the string onto a stack until you reach the 'e'.
• Pop each char off of the stack, stopping when you reach the first non-zero char.
• Put this (unless it is a decimal) and the remaining chars on the stack into a new string.
• append the remaining characters of the original string (after and including the 'e') onto the new string.

Answer 5

The regex function is too heavy. It takes too much time comparing to a straight forward process. I ended up doing this without regex:

typedef std::string String;

bool stringContains(String s1,String s2){
    if (s1.find(s2) != String::npos) {return true;}
    else return false;}

String ltrim(String s,const String& delim){return s.erase(0,s.find_first_not_of(delim));}
String rtrim(String s,String delim){return s.erase(s.find_last_not_of(delim)+1);}

String trimZeroFromScientificNumber(const String& s){
    if(!stringContains(s,"."))return s;
    int pos = s.find_first_of("eE");
    if(pos!=(int)String::npos){
        return rtrim(rtrim(s.substr(0,pos),"0"),".")+s.substr(pos,1)+ltrim(s.substr(pos+1,String::npos),"0");
    }
    else return s;
}

Using this function it saved 0.2 seconds in 14 consecutive execution comparing to that regex function in a test run.

It can also easily be expanded to trim zeros from non-scientific numbers ( 1.00,1.00200 etc..).

To get a function that can trim floating zeros from both scientific and non-scientific numbers, just change the else return s; (in the last line) to else return rtrim(rtrim(s,"0"),".");