首页 > 试题广场 >

表示数值的字符串

[编程题]表示数值的字符串

热度指数：63751 时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 256M，其他语言512M
算法知识视频讲解

请实现一个函数用来判断字符串str是否表示数值（包括科学计数法的数字，小数和整数）。

科学计数法的数字(按顺序）可以分成以下几个部分:

1.若干空格

2.一个整数或者小数

3.（可选）一个 'e' 或 'E' ，后面跟着一个整数(可正可负)

4.若干空格

小数（按顺序）可以分成以下几个部分：

1.若干空格

2.（可选）一个符号字符（'+' 或 '-'）

3. 可能是以下描述格式之一:

3.1 至少一位数字，后面跟着一个点 '.'

3.2 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字

3.3 一个点 '.' ，后面跟着至少一位数字

4.若干空格

整数（按顺序）可以分成以下几个部分：

1.若干空格
2.（可选）一个符号字符（'+' 或 '-')

3. 至少一位数字

4.若干空格

例如，字符串["+100","5e2","-123","3.1416","-1E-16"]都表示数值。

但是["12e","1a3.14","1.2.3","+-5","12e+4.3"]都不是数值。

提示:

1.1 <= str.length <= 25

2.str 仅含英文字母（大写和小写），数字（0-9），加号 '+' ，减号 '-' ，空格 ' ' 或者点 '.' 。

3.如果怀疑用例是不是能表示为数值的，可以使用python的print(float(str))去查看

进阶：时间复杂度 $O(n)\$ ，空间复杂度 $O(n)\$

示例1

输入

"123.45e+6"

输出

true

示例2

输入

"1.2.3"

输出

false

示例3

输入

"."

输出

false

示例4

输入

"    .2  "

输出

true

算法知识视频讲解

幻之飞雪

枚举各种类型判断

    public boolean isNumeric (String str) {
        if(str==null || str.length()==0) {
            return false;
        }
        boolean hasFlag = false;
        boolean hasDecimal = false;
        boolean hasE = false;
        boolean hasNum = false;
        for(int i=0;i<str.length();++i) {
            char c = str.charAt(i);
            if(c=='+' || c=='-') {
                if(hasFlag) {
                    return false;
                } else if(hasNum) {
                    return false;
                } else {
                    hasFlag = true;
                }
            } else if(c>='0' && c<='9') {
                hasNum = true;
            } else if(c=='e' || c=='E') {
                if(hasE) {
                    return false;
                }
                if(!hasNum) {
                    return false;
                }
                hasFlag = false;
                hasE = true;
                hasNum = false;
                hasDecimal = true;
            } else if(c=='.') {
                if(hasDecimal) {
                    return false;
                }
                hasDecimal = true;
            } else {
                return false;
            }
        }
        if(hasE && !hasNum) {
            return false;
        }
        if(hasDecimal && !hasNum) {
            return false;
        }
        if(hasFlag && !hasNum) {
            return false;
        }
        return true;
    }

编辑于 2021-05-22 15:49:11 回复(1)

C++

Spectre_

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @return bool布尔型
     */
    bool isNumeric(string str) {
        // 时间复杂度O(N)，空间复杂度O(N)
        return isNumerci(str.c_str());
    }
    bool isNumerci(const char *str) {
        while (*str == ' ') ++str;
        bool numeric = scanInteger(&str);
        if (*str == '.') {
            ++str;
            numeric = scanUnsignedInteger(&str) || numeric;
        }
        if (*str == 'e' || *str == 'E') {
            ++str;
            numeric = numeric && scanInteger(&str);
        }
        while (*str == ' ') ++str;
        return numeric && *str == '\0';
    }
    bool scanInteger(const char **str) {
        if (**str == '+' || **str == '-') ++(*str);
        return scanUnsignedInteger(str);
    }
    bool scanUnsignedInteger(const char **str) {
        const char *before = *str;
        while (**str != '\0' && **str >= '0' && **str <= '9') ++(*str);
        return *str > before;
    }
};

发表于 2022-08-17 23:09:44 回复(0)

C++

放屁的狐狸

开始一脸懵

需要先记录是否已经遇到各种情况的bool.

2.这题先只看判断小数和整数，因为这两种数的前面判断相差不多(也好写出来)

但遇到符号，数，点时，判断是否可以继续。(只关心整数和小数，便于思考，后面再看E)

3.前面可以判断成功后，再判断含E的情况，当含E时，E后面的数为一个可带符号的整数，但是不能为小数

那么就是后面不能含有点，(记录点的bool设true)

不能再次有E(记录E的设true)

可以有数（记录数的为false）

可以有符号(符号位设为false)

4.后面再提交，不通过时(因为有一些其他难以思考到的点，如含有 a 等无关字符)

看着案列修改代码，即可。

这样思路才清晰，对我来讲代码如下:

class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param str string字符串
* @return bool布尔型
*/
bool isNumeric(string str) {
// write code here
    bool suu=false;//数
    bool tenn=false;//点
    bool fugou=false;//符号
    bool Ee=false;//Ee
    bool siro=false;//空格
    for(int i=0; i<str.size(); i++) {
if(str[i]==' ') {//空格处理
if(!siro) {
siro=true;
while(++i<str.size()) {
if(str[i]!=' ') {
--i;
break;
                    }
}
continue;
}
while(++i<str.size()) {//cout<<"非空格导致推出！！"<<":"<<str[i]<<":"<<endl;
if(str[i]!=' ')
return false;
}
break;
}
else if(str[i]>='0'&&str[i]<='9')
suu=true;
else if(str[i]=='-'||str[i]=='+') {
if(suu||fugou) return false;//已经有数字或符号直接结束
fugou=true;
}
else if(str[i]=='.') {
if(tenn) return false;//已经有· 结束
tenn=true;
}
else if(str[i]=='e'||str[i]=='E') {
if(!suu) return false;
if(Ee) return false;
Ee=true;
tenn=true;
fugou=false;
suu=false;
}
else return false;
}
if(Ee)
if(!suu)
return false;
if(suu)
return true;
else
return false;
}
};

发表于 2022-02-21 20:53:31 回复(0)

李橙子

import java.util.*;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param str string字符串
* @return bool布尔型
*/
public boolean isNumeric (String str) {
if(str.indexOf('.') != str.lastIndexOf('.')){
return false;
}
String pattern = "^\\s*[+-]?[.]?\\d+([.]\\d*)?([Ee][+-]?\\d+)?\\s*$";
Pattern p = Pattern.compile(pattern);
Matcher matcher = p.matcher(str);
return matcher.matches();
}
}

发表于 2022-02-10 16:09:46 回复(1)

Java

^ǒ^月亮船^

import java.util.*;

/**
思路：
1.先删除字符串首尾的空格字符
2.先判断整数、再判断小数、再判断科学计数法，这个顺序不能乱。
*/
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @return bool布尔型
     */
    public boolean isNumeric (String str) {
        
        if(str == null || "".equals(str)){
            return false;
        }
        
        //删除首尾字符串的空格
        str = deleteKongGe(str);
        if( str == null){
            return false;
        }
        
        return judgeInteger(str) || judgeDecimal(str) || judgeScientificNotation(str);
    }
    
    //删除字符串的前后空格
    public String deleteKongGe(String str){
        
        char[] c = str.toCharArray();
        
        //定位-1用来判断全部是空格的极端情况
        int firstIndex = -1;
        
        int laterIndex = c.length - 1;
        
        //计算从前数第一个非空格字符索引
        for(int i = 0 ; i < c.length ; i++){
            //32表示空格
            if(c[i] != 32){
                firstIndex = i;
                break;
            }
        }
        
        //计算从后数第一个非空格字符索引
        for(int j = laterIndex ; j >= 0 ; j--){
            if(c[j] != 32){
                laterIndex = j;
                break;
            }
        }
        
        //若全是空格返回null否则返回…………
        return (firstIndex == -1) ? null : str.substring(firstIndex,laterIndex + 1);
    }
    
    //判断是否是整数
    public boolean judgeInteger(String str){
        
        //删除正负号
        if((str.charAt(0) == '+' || str.charAt(0) == '-')  && str.length() > 1){
            str = str.substring(1,str.length());
        }
        
        return judgeNumber(str);
    }
    
    //判断是否是小数
    public boolean judgeDecimal(String str){
        
        //删除正负号
        if((str.charAt(0) == '+' || str.charAt(0) == '-') && str.length() > 1){
            str = str.substring(1,str.length());
        }
        
        //3.1 至少一位数字，后面跟着一个点‘.’
        if(str.charAt(str.length() - 1) == '.'){
            //将尾‘.’删掉
            str = str.substring(0,str.length() - 1);
            
            return judgeNumber(str);
        }
        
        //3.3 一个点 '.' ，后面跟着至少一位数字
        if(str.charAt(0) == '.'){
            //将头‘.’删掉
            str = str.substring(1,str.length());
            
            return judgeNumber(str);
        }
        
        //3.2 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字
        if(str.contains(".")){
            int index = str.indexOf(".");
            //‘.’前面和后面至少应该有一位
            if(index > 0 || index < (str.length() - 1)){
                //将中间的‘.’删掉
                String str1 = str.substring(0,str.indexOf("."));
                String str2 = str.substring(str.indexOf(".") + 1);
                str = str1 + str2;
            
                return judgeNumber(str);
            }
            return false;
        }
        
        return false;
    }
    
    //判断是否是科学计数法
    public boolean judgeScientificNotation(String str){
        
        //科学计数法至少要三位
        if(str.length() < 3){
            return false;
        }
        
        int eIndex = str.indexOf("e") != -1 ? str.indexOf("e") : str.indexOf("E");
        
        if(eIndex == -1){
            return false;
        }
        
        //eIndex前面和后面至少应该有一位
        if(eIndex > 0 && eIndex < (str.length() - 1 )){
            //前半部分
            String fontStr = str.substring(0,eIndex);
            //后半部分
            String backStr = str.substring(eIndex + 1, str.length());
            
            //一个整数或者小数后面跟着一个整数
            return (judgeInteger(fontStr) || judgeDecimal(fontStr)) && judgeInteger(backStr);
        }
        
        return false;
    }
    
    //判断是否是纯数字
    public boolean judgeNumber(String str){
        
        //不满足至少有一位数字的要求
        if("".equals(str)){
            return false;
        }
        
        char[] c = str.toCharArray();
        
        for(int i = 0 ; i < c.length ; i++){
            if(c[i] < 48 || c[i] > 57){
                return false;
            }
        }
        
        return true;
    }
   
}

发表于 2021-10-29 20:37:39 回复(0)

Java

牛客886639131号

//代码很长，但是简单易懂，写起来很快的，不会把'.''e'凑一起写头疼
//将判断条件提取为几个相同的函数：去除前后空格+是否至少包含一位数字+是否是整数
//                           +是否是小数+是否是科学计数法的数 

import java.util.*;
public class Solution {
    public boolean isNumeric (String str) {
        // write code here
        String trimString = trim(str);         //去除前后空格
        int len = trimString.length();
        if (len == 0) {       
            return false;
        }
        return isScientificNumber(trimString)  //检测去除空格后的字符串是不是科学计数法
            || isInteger(trimString, 0, len-1) //或者整数或者小数
            || isDecimal(trimString, 0, len-1);
        
    }
    //去除字符串前后空格
    private String trim(String str) {
        int left = 0, right = str.length()-1;
        while (left <= right) {
            if (str.charAt(left) == ' ') {
                left ++;
            } else {
                break;
            }
        }
        while (left <= right) {
            if (str.charAt(right) == ' ') {
                right --;
            } else {
                break;
            }
        }
        if (left <= right) {
            return str.substring(left, right+1);
        }
        return "";
    }
    //检测字符串是不是整数
    private boolean isInteger(String str, int left, int right) {
        if (left > right) return false;
        if (str.charAt(left) == '+' || str.charAt(left) == '-') {
            left++;
            if (left > right) return false;
        }
        return containsOneNumber(str, left, right) ? true : false;
    }
    //检测字符串是不是小数
    private boolean isDecimal(String str, int left, int right) {
        if (left > right) return false;
        if (str.charAt(left) == '+' || str.charAt(left) == '-') {
            left ++;
            if (left > right) return false;
        }
        int start = left;
        boolean mark = false;                      //标记是否有'.'
        for (int i=left; i<=right; ++i) {
            if (str.charAt(i) == '.') {
                start = i;
                mark = true;
                break;
            }
        }
        if (mark) {
            if (start == right) {
                return containsOneNumber(str, left, start-1);
            } else if (start == left){
                return containsOneNumber(str, left+1, right);
            } else {
                return containsOneNumber(str, left, start-1) && containsOneNumber(str, start+1, right);
            }
        }
        return false;
    }
    //检测字符串是不是至少包含一位数字
    private boolean containsOneNumber(String str, int left, int right) {
        if (left > right) return false;
        while (left <= right) {
            if (str.charAt(left) < '0' || str.charAt(left) > '9') {
                return false;
            }
            left ++;
        }
        return true;
    }
    //
    private boolean isScientificNumber(String str) {
        boolean mark = false;                                     //标记是否有'e'或'E'
        int start = 0;
        for (int i=0; i<str.length(); ++i) {
            if (str.charAt(i) == 'e' || str.charAt(i) == 'E') {
                start = i;
                mark = true;
                break;
            }
        }
        if (mark) {
            return (isInteger(str, 0, start-1) || isDecimal(str, 0, start-1))
                && isInteger(str, start+1, str.length()-1);
        }
        return false;
    } 
}

发表于 2021-08-24 22:59:21 回复(0)

xidian_mao

class Solution:
    def is_inter(self, s): #是否为整数
        if len(s) == 0:
            return False
        for it in s:
            if it < '0'&nbs***bsp;it > '9':
                return False
        return True
    
    def is_with_flag_inter(self, s): # 带符号整数
        if len(s) == 0:
            return False
        if s[0] == '+'&nbs***bsp;s[0] == '-':
            s = s[1:]
        return self.is_inter(s)
    
    def is_float(self, s): # 浮点数
        s = s.split('.')
        if len(s) > 2&nbs***bsp;len(s) == 0:
            return False
        flag = self.is_with_flag_inter(s[0])
        special_flag = len(s[0]) == 1 and (s[0] in ['+', '-']) and len(s) == 2 and self.is_inter(s[1])
        # special_flag  -.123
        return flag and (len(s)==1&nbs***bsp;self.is_inter(s[1]))&nbs***bsp;special_flag
        
    
    def isNumeric(self , s):
        s = s.replace('E', 'e')
        s = s.split('e')
        if len(s) == 0&nbs***bsp;len(s) > 2:
            return False
        flag = self.is_float(s[0])
        if len(s) == 2:
            flag = flag and self.is_with_flag_inter(s[1])
        return flag

发表于 2021-05-22 16:38:00 回复(0)

Python

zbzz

import re
class Solution:
def isNumeric(self , str ):
# write code here

return re.search(r'^[+-]?(\d+(\.\d+)?|(\.\d+))([eE][+-]?\d+)?$',str)

正则

最开始构思为为

+- 0-1次

数字 0-n次 #因为这里有个 .1也算数字，也就是.之前的数字可以有0个

（.（数字0-n次）） 0-1次

（eE（+- 0-1次）（数字1-n次）） 0-1次

结果出现了 +号也匹配的情况

所以考虑到小数点之前和之后两个匹配不能同时为0个，至少有一个时1个，所以中间变为(\d+(\.\d+)?|(\.\d+))

发表于 2021-04-20 21:17:30 回复(0)

1666

考虑出现.+-eE的限制条件

    public boolean isNumeric (String str) {
        char[] chars = str.toCharArray();
        boolean point = false;//表示小数点是否已存在
        boolean e = false;//表示e是否已存在
        boolean lOperator = false;//表示e左边运算符是否已存在
        boolean rOperator = false;//表示e右边运算符是否已存在
        int len = chars.length;
        int eIndex = len;//e出现的位置
        for (int i = 0; i < len; i++) {
            if (chars[i] == '.'){
                if (point || i > eIndex) return false;//小数点只能有一个，并且必须在e前面
                point = true;
            }else if (chars[i] == 'e' || chars[i] == 'E'){
                if (e || i == 0 || i == len-1) return false;//e只能有一个，并且不能在首位和末位
                eIndex = i;
                e = true;
            }else if (chars[i] == '+' || chars[i] == '-'){
                if (i < eIndex){
                    if (lOperator || i != 0) return false;//e左边运算符只能有一个，并且只能在第一位
                    lOperator = true;
                }else {
                    if (rOperator || i - eIndex != 1) return false;//e右边运算符只能有一个,并且只能紧挨e后面
                    rOperator = true;
                }
            }else if (chars[i] >= '0' && chars[i] <= '9'){//数字出现在哪都可以
                continue;
            }else {//不能出现.+-eE和数字以外的字符
                return false;
            }
        }
        return true;
    }

发表于 2021-03-18 18:06:22 回复(1)

C++

牛客817736661号

使用到<sstream>中的stringstream

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @return bool布尔型
     */
    bool isNumeric(string str) {
        // write code here
        stringstream ss(str);
        long double dValue;
        bool flag = true;
        int index = 0;
        while (!ss.eof())
        {
            if (!(ss >> dValue))
            {
                flag = false;
                break;
            }
            ++index;
        }
        if(1 != index || false == flag)
            return false;
        return true;
    }
};

发表于 2021-07-21 17:06:25 回复(0)

C/C++

Clannad丶Fan

ifelse就完事了，这道题顺便帮我理清了浮点数的格式😄

（更新：顺手刷了LeetCode上的这道题，发现代码还存在一定的缺陷，比如对于“E9”这种测试用例输出为true，改进方法是分别对整数部分和小数部分的位数进行计数，两者不能同时为0，此外比如“1 ”这种测试用例，数字后面跟个空格，不知道是哪位带师给出的用例，加个空格忽略机制应该可以解决.....这道题属实给爷恶心坏了，真就面向测试用例编程）

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @return bool布尔型
     */
    bool isNumeric(string str) {
        int i = 0;
        //开头有正负号的情况
        if(str[i] == '+' || str[i] == '-')
            ++i;
        //整数部分
        while(str[i] <= '9' && str[i] >= '0')
        {
            ++i;
            if(i == str.size())
                return true;
        }
            
        //下一个部分只能是小数点、‘E’、‘e’
        if(str[i] == '.')
        {
            ++i;
            //小数点后的整数部分
            while(str[i] <= '9' && str[i] >= '0')
            {
                ++i;
                if(i == str.size())
                    return true;
            }
            if(str[i] == 'e' || str[i] == 'E')
            {
                ++i;
                if(i == str.size())
                    return false;
                if(str[i] == '+' || str[i] == '-')
                    ++i;
                if(i == str.size())
                    return false;
                while(i < str.size() && str[i] <= '9' && str[i] >= '0')
                    ++i;
                if(i != str.size())
                    return false;
            }
            else
                return false;
                
        }
        else if(str[i] == 'e' || str[i] == 'E')
        {
            ++i;
            if(i == str.size())
                return false;
            if(str[i] == '+' || str[i] == '-')
                ++i;
            if(i == str.size())
                return false;
            while(i < str.size() && str[i] <= '9' && str[i] >= '0')
                ++i;
            if(i != str.size())
                return false;
        }
        else
            return false;
        return true;
    }
};

编辑于 2021-03-21 21:19:55 回复(1)

◤特种⌒核桃◥

这个题讨论怎么这么少，放一个Python的解法（四个步骤）：

1、判断一下正负号,只能出现在首位和e后面一位，如果不是，返回False；

2、判断小数点，只能出现0或1次，不能在e后面出现，如果不是，返回False；

3、判断是否出现过数字；

4、判断字符e，前后都必须有数字，还需要再判断一下e后面是否出现数字（见代码），只能出现0或1次，如果不是，返回False，；


class Solution:
    def isNumeric(self , s):
        # write code here
        n = False # 观察数字,必须有数字   '0'<= n <='9'
        e = False # 观察字符e，前后必须有数字，只能出现0或1次
        d = False #观察字符小数点，只能出现0或1次，不能在e后面出现
        l = len(s) #字符长度
        for i in range(l):
            #1、判断一下正负号,只能出现在首位和e后面一位
            if s[i] in ('+','-') :
                if i != 0 and s[i-1] not in ('e','E'):
                    return False
            #2、判断小数点，只能出现0或1次，不能在e后面出现，如果不是，返回False
            elif s[i] == '.':
                if e or d:
                    return False
                d = True
            #3、判断是否出现过数字
            elif '0'<=s[i]<='9':
                n = True
            #4、判断字符e，前后必须有数字，只能出现0或1次，如果不是，返回False
            elif s[i] in ('e','E'):
                if e or not n:
                    return False
                e = True
                n = False
            else:
                return False
        return n

编辑于 2021-04-26 08:13:04 回复(4)

Java

阿尼亚瓦库瓦库

正则表达式一行搞定：（看一下菜鸟教程学了一下，挺方便的）

import java.util.*;


public class Solution {
    
    public boolean isNumeric (String str) {
        return str.matches("[+-]?\\d*\\.?\\d+|[+-]?\\d*\\.?\\d+[eE][+-]?\\d+");
    }
}

编辑于 2021-05-01 16:11:30 回复(5)

Java

Invoker_123

import java.util.*;

public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param str string字符串
* @return bool布尔型
*/
public boolean isNumeric (String str) {
// write code here
try{
double d = Double.parseDouble(str);
}catch(Exception e){
return false;
}
return true;
}
}

发表于 2021-04-07 23:13:52 回复(1)

Python

kk-li

class Solution:
def isNumeric(self , str ):
# write code here
try:
float(str)
except:
return False
return True

发表于 2021-05-08 17:17:16 回复(2)

明天再说121

class Solution {
public:
    bool isNumeric(string str)
    {
        bool sign = false, decimal = false, hasE = false;
        for(int i = 0;i < str.length();i++)
        {
            if(str[i] == 'e' || str[i] == 'E')
            {
                if(i == str.length() - 1) return false;
                if(hasE) return false;
                hasE = true;
            }
            else if(str[i] == '+' || str[i] == '-')
            {
                if(sign && str[i - 1] != 'e' && str[i - 1] != 'E') return false;
                if(!sign && i > 0 && str[i - 1] != 'e' && str[i - 1] != 'E') return false;
                sign = true;
            }
            else if(str[i] == '.')
            {
                if(hasE || decimal) return false;
                decimal = true;
            }
            else if(str[i] < '0' || str[i] > '9')
            {
                return false;
            }
        }
        return true;
    }
};

发表于 2021-02-26 13:21:36 回复(0)

C++

龙年毕业顺利

C++ 题解

class Solution {
public:
    bool isNumeric(string str) {
        if(str.empty()) return false;

        int pos = 0; //字符串索引

        while(str[pos] == ' ') pos++; //开头去除空格

        bool isCorrcet = false; //整数部分
        if(str[pos] == '+' || str[pos] == '-') pos++;
        while(str[pos]!='\0' && str[pos] >= '0' && str[pos] <= '9'){
            isCorrcet = true; //必须是数字
            pos++;
        }

        if(str[pos] == '.'){
            pos++; //小数部分
            while(str[pos]!='\0' && str[pos] >= '0' && str[pos] <= '9'){
                isCorrcet = true; //必须是数字
                pos++;
            }
        }

        if(str[pos] == 'e' || str[pos] == 'E'){
            pos++; //指数数部分
            if(str[pos] == '+' || str[pos] == '-') pos++;
            if(str[pos] == '\0' || str[pos] < '0' || str[pos] > '9') isCorrcet = false;
            while(str[pos]!='\0' && str[pos] >= '0' && str[pos] <= '9'){
                isCorrcet = isCorrcet && true; //必须是数字
                pos++;
            }
        }

        while(str[pos] == ' ') pos++; //结尾去除空格

        //最终长度一致 && 整数和小数必须有一个存在 && 若有指数必须格式正确
        return (pos == str.size()) && isCorrcet;
    }
};

编辑于 2022-06-18 11:37:08 回复(0)

JavaScript

球球来一个offer吧

使用正则表达式，考虑 .3和3. 的情况

function isNumeric( str ) {
    // write code here
    let res = /^[+-]?([0-9]*\.[0-9]+|[0-9]+(\.[0-9]*)?)([Ee][+-]?[0-9]+)?$/;
    return res.test(str);
}

编辑于 2021-04-03 09:26:52 回复(0)

C/C++

lysemo

bool isNumeric(string str)

{

// write code here

if(str.empty()) //如果字符串为空，则返回false

{

return false;

}

int i = 0;

string pre = "";

string post = "";

while(i<str.size()) //按e将字符串分成2段

{

if(str[i]=='E' || str[i]=='e')

{

break;

}

i++;

}

if(i==str.size()) //如果没有e，pre=str

{

pre = str;

}

else //如果有e，pre为e前半段，post为e后半段

{

pre = str.substr(0,i);

post = str.substr(i+1);

if(pre.empty()) return false;

if(post.empty()) return false;

}

i = 0;

if(post[0]=='+' || post[0]=='-') //如果post第一个字符为'+'/'-'，后面一个字符必须为数字，否则返回false

{

if(post[1]>='0' && post[1]<='9')

{

i = 1;

}

else

{

return false;

}

while(i<post.size()) //对应post的非第一个字符，其他的必须在0-9之间

{

if(post[i]<'0' || post[i]>'9')

return false;

i++;

}

i = 0;

int dot = 0; //统计前半段小数点出现的次数，如果>1,返回false

if(pre[0]=='+' || pre[0]=='-') //如果pre第一个字符为'+'/'-'

{

if(pre[1]>='0' && pre[1]<='9') //第二个字符要么为0-9之间

{

i = 1;

}

else if(pre[1]=='.' && pre[2]>='0' && pre[2]<='9') //要么为'.'，但第三个字符必须为0-9之间

{

i = 1;

}

else //其他的均为false

{

return false;

}

while(i<pre.size()) //对于除第一个字符的字符，要么在0-9之间，要么为点，且点出现的次数只能为1次

{

if(pre[i]=='.') //如果为点，dot++，如果>1，之间返回false

{

dot++;

i++;

if(dot>1)

{

return false;

}

continue;

}

if(pre[i]<'0' || pre[i]>'9') return false; //如果在0-9之外，false

i++;

}

return true;

}

发表于 2021-03-30 09:40:57 回复(0)

Java

奋斗的羊羔

本来想用正则表达式的，结果好像包出了点问题，于是用判断。

将三个选择做了三个函数判断，整数、小数、科学计数。使用try-catch方法，在里面对字符串进行强转，如果出现异常则强转失败，则可以判断不是该类型，返回FALSE。

import java.util.*;
public class Solution {

    public boolean isNumeric (String str) {
         str=str.trim();
        if(isInt(str)) return true;
        if(isFloat(str)) return true;
        if(isE(str)) return true;
        return false;
    }
    
    //判读是否是整数
   public boolean isInt (String str) {
       str=str.trim();
       if(str==null) return false;
       try{
           int x = Integer.parseInt(str);
           return true;
       }catch(Exception e) {
           return false;
       }
    }
        //判读是否是小数
    public boolean isFloat (String str) {
       str=str.trim();
       if(str==null) return false;
       try{
           float x = Float.parseFloat(str);
           return true;
       }catch(Exception e) {
           return false;
       }
    }
        //判读是否是科学计数
    public boolean isE (String str) {
        str=str.trim();
       if(str==null) return false;
       String[] s = null;
       if(str.contains("E"))
            s = str.split("E") ;
       else if(str.contains("e")) 
            s = str.split("e") ;
       else
           return false;
       if(s.length!=2)
           return false;
       if((isInt(s[0]) || isFloat(s[0])) && isInt(s[1]))
           return true;
       return false;
    }
}

发表于 2022-03-08 10:03:59 回复(1)

提交观点

问题信息

字符串

上传者：牛客301499号

难度：

107条回答 584收藏 7818浏览

通过挑战的用户

查看代码

无人溯西风

2022-09-16 11:34:01
牛客66488...

2022-09-16 10:49:19
牛客40369...

2022-09-15 17:58:46
牛客57316...

2022-09-15 16:30:52
牛客84244...

2022-09-15 14:29:07

表示数值的字符串

输入

输出

输入

输出

输入

输出

输入

输出

考虑出现.+-eE的限制条件

问题信息

热门推荐

通过挑战的用户

相关试题