【leetcode】Valid Number

Valid Number

Validate if a given string is numeric.

Some examples:
"0" => true
" 0.1 " => true
"abc" => false
"1 a" => false
"2e10" => true

Note: It is intended for the problem statement to be ambiguous. You should gather all requirements up front before implementing one.

其他测试用例：

" "    false

"3."  true

"e"   false

"."    false

"3. " true

"46.e3" true

" 005047e+6" true

"6+1" false

 

 

1.符号 后面只能跟 数字，点

2.点 后面只能跟 数字，空格，指数e

3.指数 后面只能跟 数字，符号

4.空格只能位于开头或结尾，去除开头的空格后，空格后面只能接空格（必须位于末尾）

5.去除开头的符号后，符号只能位于指数e之后，且只能出现一次

6.点只能出现一次，且不能位于指数之后

7.指数只能出现一次，且前面需要有数字

8.符号，指数，单独的点，不能做结尾

 

 class Solution {
 public:
 
     enum TYPE
     {
         INVALID,
         SPACE,
         SIGN,
         DIGIT,
         DOT,
         EXP
     };
 
     bool isNumber(const char *s) {
 
         while(*s!='\0'&&*s==' ') s++;
         if(*s=='+'||*s=='-') s++;
 
         if(strlen(s)==) return false;
 
         bool hasSign=false;
         bool hasDigit=false;
         bool hasDot=false;
         bool hasExp=false;
 
         TYPE preType;
         TYPE type;
         while(*s!='\0')
         {
             type=getType(s);
 
             if(type==INVALID) return false;
 
             if(preType==SIGN &&(type!=DIGIT&&type!=DOT)) return false;
             if(preType==DOT&&(type!=DIGIT&&type!=SPACE&&type!=EXP))return false;
             if(preType==EXP&&(type!=DIGIT&&type!=SIGN))return false;
             if(preType==SPACE&&type!=SPACE)return false;
 
             switch(type)
             {
                 case SPACE:
                     preType=SPACE;
                     break;
                 case SIGN:
                     if(hasSign) return false;
                     else
                     {
                         if(preType!=EXP) return false;
                         hasSign=true;
                         preType=SIGN;
                     }
                     break;
                 case DIGIT:
                     hasDigit=true;
                     preType=DIGIT;
                     break;
                 case DOT:
                     if(hasDot||hasExp) return false;
                     else
                     {
                         hasDot=true;
                         preType=DOT;
                     }
                     break;
                 case EXP:
                     if(hasExp||!hasDigit) return false;
                     else
                     {
                         hasExp=true;
                         preType=EXP;
                     }
                     break;
             }
             s++;
         }
 
         if(preType==SIGN||preType==EXP||(!hasDigit&&hasDot)) return false;
 
         return true;
     }
 
     TYPE getType(const char *s)
     {
         if(*s==' ') return SPACE;
         else if(*s=='+'||*s=='-') return SIGN;
         else if(isdigit(*s))return DIGIT;
         else if(*s=='.')return DOT;
         else if(*s=='e')return EXP;
         else return INVALID;
     }
 };