[closed] Valid Number

My solution using finite automata (inspired by @luckynoob):

bool isNumber(const char *s) {
    enum InputType {
        INVALID,    // 0
        SPACE,      // 1
        SIGN,       // 2
        DIGIT,      // 3
        DOT,        // 4
        EXPONENT,   // 5
        NUM_INPUTS  // 6
    };
    int transitionTable[][NUM_INPUTS] = {
        -1,  0,  3,  1,  2, -1,     // next states for state 0
        -1,  8, -1,  1,  4,  5,     // next states for state 1
        -1, -1, -1,  4, -1, -1,     // next states for state 2
        -1, -1, -1,  1,  2, -1,     // next states for state 3
        -1,  8, -1,  4, -1,  5,     // next states for state 4
        -1, -1,  6,  7, -1, -1,     // next states for state 5
        -1, -1, -1,  7, -1, -1,     // next states for state 6
        -1,  8, -1,  7, -1, -1,     // next states for state 7
        -1,  8, -1, -1, -1, -1,     // next states for state 8
    };

int state = 0;
while (*s != '\0') {
    InputType inputType = INVALID;
    if (isspace(*s))
        inputType = SPACE;
    else if (*s == '+' || *s == '-')
        inputType = SIGN;
    else if (isdigit(*s))
        inputType = DIGIT;
    else if (*s == '.')
        inputType = DOT;
    else if (*s == 'e' || *s == 'E')
        inputType = EXPONENT;

    // Get next state from current state and input symbol
    state = transitionTable[state][inputType];

    // Invalid input
    if (state == -1) return false;
    else ++s;
}
// If the current state belongs to one of the accepting (final) states,
// then the number is valid
return state == 1 || state == 4 || state == 7 || state == 8;

}

bool isNumber(const char *s) {
    int mat[11][7] = {0 ,0 ,0 ,0 ,0 ,0 ,0, // false
                      0 ,2 ,3 ,0 ,1 ,4 ,0, // 1
                      0 ,2 ,5 ,6 ,9 ,0 ,10,// 2
                      0 ,5 ,0 ,0 ,0 ,0 ,0, // 3
                      0 ,2 ,3 ,0 ,0 ,0 ,0, // 4
                      0 ,5 ,0 ,6 ,9 ,0 ,10,// 5
                      0 ,7 ,0 ,0 ,0 ,8 ,0, // 6
                      0 ,7 ,0 ,0 ,9 ,0 ,10,// 7
                      0 ,7 ,0 ,0 ,0 ,0 ,0, // 8
                      0 ,0 ,0 ,0 ,9 ,0 ,10,// 9
                      10,10,10,10,10,10,10 // 10
                    };
    int i = 0;
    int stat = 1;
    while(s[i] != 0) {
        int type = 0;
        if(s[i] >= '0' && s[i] <= '9')
            type = 1;
        else if(s[i] == '.')
            type = 2;
        else if(s[i] == 'e')
            type = 3;
        else if(s[i] == ' ')
            type = 4;
        else if(s[i] == '+' || s[i] == '-')
            type = 5;
        if(stat == 0)
            return false;
        stat = mat[stat][type];
        i++;
    }
    stat = mat[stat][6];
    if(stat == 10)
        return true;
    else
        return false;
}

Well, if we are allowed to use regex, this can be done in one line code. The running time depends on how the compile parses regex though.

public boolean isNumber(String s) {
  return s.matches("^\\s*[+-]?(\\d+|\\d*\\.\\d+|\\d+\\.\\d*)([eE][+-]?\\d+)?\\s*$");
}

public boolean isNumber(String s) {
   if(s==null)
        return false;
    char[] sArr = s.trim().toCharArray();

    if(sArr.length==0)
        return false;
    if(sArr.length==1&&!Character.isDigit(sArr[0]))
        return false;

    boolean decimalFound = false;
    boolean eFound = false;
    int end = sArr.length-1;
    for(int i=0;i<=end;i++){        
        char nextChar = i>=end?'x':sArr[i+1];
        char prevChar = i<=0?'x':sArr[i-1];
        switch(sArr[i]){
        case '+':
        case '-':
            if(prevChar!='e'&&i!=0)
                return false;
            if(prevChar=='e'&&i==end)
                return false;
            if (i==0&&nextChar=='e')
                return false;
            break;
        case '.':
            if(decimalFound || eFound)
                return false;
            if(i>=end && i<=0)
                return false;
            if(!Character.isDigit(prevChar) && !Character.isDigit(nextChar))
                return false;
            decimalFound = true;
            break;
        case 'e':
            if(eFound)
                return false;
            if(!Character.isDigit(prevChar) && !Character.isDigit(nextChar)
                &&nextChar!='-'|| end==i || i==0){
                        return false;                        
            }
            eFound = true;
            break;
        case ' ':
            return false;
        default:
            if(!Character.isDigit(sArr[i]))
                return false;
        }

    }
    return true;
}

private:

enum Token { Null, Sign, Num, Point, E, Space };
bool isDigit(char c) { return c >= '0' && c <= '9'; }
bool isSpace(char c) { return c == ' ' || c == '\t'; }

public:

bool isNumber(const char *s) {
    // Start typing your C/C++ solution below
    // DO NOT write int main() function
    int i = 0;
    bool hasNum = false;
    int pointCnt = 0, eCnt = 0;
    Token preToken = Token::Null;
    while (s[i] != 0) {
        if (isDigit(s[i])) hasNum = true;

        switch (preToken) {
        case Token::Null:
            if (isSpace(s[i])) break;
            else if (s[i] == '-' || s[i] == '+') { preToken = Token::Sign; break; }
            else if (s[i] == '.') { preToken = Token::Point; pointCnt++; break; }
            else if (isDigit(s[i])){ preToken = Token::Num; break;}
            else return false;

        case Token::Sign:
            if (s[i] == '.') { preToken = Token::Point; pointCnt++; break; }
            if (isDigit(s[i])){ preToken = Token::Num; break; }
            else return false;

        case Token::Num:
            if (isDigit(s[i])) break;
            else if (s[i] == 'e' || s[i] == 'E') { preToken = Token::E; eCnt++; break; }
            else if (s[i] == '.') { if (eCnt > 0) return false; preToken = Token::Point; pointCnt++; break; }
            else if (isSpace(s[i])) { preToken = Token::Space; break; }
            else return false;

        case Token::Point:
            if (isDigit(s[i])) { preToken = Token::Num; break; }
            else if (s[i] == 'e' || s[i] == 'E' || isSpace(s[i])) {
                if (!hasNum) return false;
                if (isSpace(s[i])) { preToken = Token::Space; break; }
                else { preToken = Token::E; break; }
            }
            else return false;

        case Token::E:
            if (isDigit(s[i])) { preToken = Token::Num; break; }
            else if (s[i] == '-' || s[i] == '+') { preToken = Token::Sign; break; }
            else return false;

        case Token::Space:
            if (isSpace(s[i])) break;
            else return false;
        }
        i++;
    }
    if (pointCnt > 1 || eCnt > 1)
        return false;
    if (preToken == Token::Num || preToken == Token::Space ||
        (preToken == Token::Point && hasNum))
        return true;
    return false;
}

enum input_type{
    e_digit, //1
    e_point, //2
    e_exponent, //3
    e_sign, //4
    e_space, //5
    e_invalid, //6
    ENUM_SIZE //
};

input_type get_value(char s){
    switch (s) {
        case ' ': return e_space;
        case '.': return e_point;
        case 'e': return e_exponent;
        case '-': return e_sign;
        case '+': return e_sign;
        default:{
            if(s>='0' && s<='9')
                return e_digit;
            else
                return e_invalid;
        }
    }
}

bool isNumber(const char *s) {
    // Start typing your C/C++ solution below
    // DO NOT write int main() function
    int transition_table[][ENUM_SIZE] = {
         1,  6, -1,  4,  0, -1,     //state 0:begin
         1,  2,  7, -1,  5, -1,     //state 1:digit
         2, -1,  7, -1,  5, -1,     //state 2:pointed with num front
         3, -1, -1, -1,  5, -1,     //state 3:exponented with num front
         1,  6, -1, -1, -1, -1,     //state 4:signed
        -1, -1, -1, -1,  5, -1,     //state 5:space after num
         2, -1, -1, -1, -1, -1,     //state 6:pointed with out num front
         3, -1, -1,  9, -1, -1,     //state 7:exponented with out num
         8, -1, -1, -1,  5, -1,     //state 8:exponented signed
         8, -1, -1, -1, -1, -1      //state 9:exponented signed with out num after
        //stat -1:invalid
    };
    bool final_state[]={0, 1, 1, 1, 0, 1, 0, 0, 1, 0};
    int state = 0;
    while(*s != '\0' && state != -1){
        input_type in = get_value(*(s++));
        state = transition_table[state][in];
    }
    if(state == -1 || !final_state[state])
        return false;
    else
        return true;
}

more readable finite automata

class Solution { public: bool isNumKernel(string&& s, bool num, bool point) { if (s.size()==1) { if(isdigit(s[0]) || (s[0]=='.' && num && !point)) return true; else return false; }

    if (isdigit(s[0])) return isNumKernel(s.substr(1), true, point);
    else if (s[0]=='.' && !point)   return isNumKernel(s.substr(1), num, true);
    else return false;
}

bool isNumber(const char *s) {
    // Note: The Solution object is instantiated only once and is reused by each test case.
    stringstream numCan(s);
    string first, second;
    numCan >> first >> second;
    if (first.empty() || !second.empty())  return false;

    int len = first.size();

    size_t epos = first.find('e');
    if (epos == first.size()-1)     return false;
    else if (epos <= first.size()-2)
    {
        string tmp = first.substr(epos+1);
        int len = tmp.size();
        if (len==1 && !isdigit(tmp[0]))     return false;
        if (!isdigit(tmp[0]) && (tmp[0]!='+' && tmp[0]!='-'))
            return false;
        for (int i=1; i<len; ++i)
            if (!isdigit(tmp[i]))
                return false;
    }

    second = first.substr(0, epos);
    len = second.size();
    if (len == 0)   return false;
    else if (len==1) return isdigit(second[0])?true:false;
    if (second[0]=='+' || second[0]=='-')
        return isNumKernel(second.substr(1), false, false);
    else if (second[0] == '.')
        return isNumKernel(second.substr(1), false, true);
    else if (isdigit(second[0]))
        return isNumKernel(second.substr(1), true, false);
    else 
        return false;
}

};

We can focus on the effectual string by using sstream. Dividing the string into 2 parts by 'e', the right part (if existed) should contain only sign and digits, while the left part should be a float.

Ugly solution. Submitted and revised 10 time before accepted ...

public class Solution {
public boolean isNumber(String s) {
    if(s==null || s.length()==0)  return false;
    int i=0;
    int digitPointCnt = 0;
    while(i<s.length() && s.charAt(i)==' ')  i++;  // ignore prevailing spaces
    if(i<s.length() && (s.charAt(i)=='-' || s.charAt(i)=='+'))  i++;  // - or + sign
    if(i<s.length() && s.charAt(i)=='.') {
        i++;   // allow starting digit point
        digitPointCnt++;
    }
    if(isNonNum(s,i))  return false;  // start with non-num
    i = nextNonNum(s,i);  
    if(i==s.length())  return true;  // all numerics
    if(s.charAt(i)==' ')  return allSpaces(s,i);  // check trailing spaces
    if(s.charAt(i)=='.')  {
        digitPointCnt++;
        if(digitPointCnt>1)  return false;   // two digit points are invalid
        i++;
        if(i==s.length())  return true;   // allow trailing digit point
        if(s.charAt(i)==' ')  return allSpaces(s,i);
        if(s.charAt(i)=='e'||s.charAt(i)=='E')  return validExp(s,i+1);  // allow .e
        if(isNonNum(s,i))  return false;  // digit point followed by non-num
        i = nextNonNum(s,i); 
        if(i==s.length())  return true;  // all nums
        if(s.charAt(i)==' ')  return allSpaces(s,i);  // check trailing spaces
        if(s.charAt(i)=='e'||s.charAt(i)=='E')  return validExp(s,i+1);
        return false;  // any other characters are invalid
    }
    else if(s.charAt(i)=='e'||s.charAt(i)=='E')  {
        return validExp(s,i+1);
    }
    return false;
}
public boolean isNonNum(String s, int i)  {
    if(i>=s.length())  return true;
    return s.charAt(i)<'0' || s.charAt(i)>'9';
}
// find next non-num position
public int nextNonNum(String s, int i)  {
    while(i<s.length() && s.charAt(i)>='0' && s.charAt(i)<='9')  i++;
    return i;
}
// check trailing spaces
public boolean allSpaces(String s, int i)  {
    while(i<s.length() && s.charAt(i)==' ')  i++;
    if(i==s.length())  return true; 
    return false;        
}
// check valid exponential num
public boolean validExp(String s, int i)  {
    if(i<s.length() && (s.charAt(i)=='-' || s.charAt(i)=='+'))  i++;
    if(isNonNum(s,i))  return false;
    i = nextNonNum(s,i);
    if(i==s.length())  return true;  // all numerics
    if(s.charAt(i)==' ')  return allSpaces(s,i);  // check trailing spaces
    return false;
}

}