首页 > 试题广场 >

表示数值的字符串

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

热度指数：66897 时间限制：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

算法知识视频讲解

Java

two倩

import java.util.*;

public class Solution {

/**

* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可

* @param str string字符串

* @return bool布尔型

public static boolean isNumeric(String str) {

if (str == null)

return false;

boolean isInterger = false;//标识是否出现了数字

boolean isFloat = false;// 标识是否出现了小数点要求小数点位置在e之前

boolean ishaveE = false;//标识是否出现了E

boolean isIntergetAfterE = false;//记录在E后面的数字是不是一个合法的整数

//去掉前后空格

str = str.trim();

int i = 0;

while (i < str.length()) {

//有正负号并且在首位

if (i == 0 && (str.charAt(i) == '+' || str.charAt(i) == '-')) {

i++;

}

//记录是否出现整数

else if (str.charAt(i) >= '0' && str.charAt(i) <= '9') {

//在e之后出现的整数

if (ishaveE) {

isIntergetAfterE = true;

}

//在e之前出现的整数

else {

isInterger = true;

}

i++;

}

//记录是否出现小数点要求只出现一次且在e之前出现

else if (str.charAt(i) == '.') {

if (isFloat || ishaveE) {

return false;

} else

isFloat = true;

i++;

}

//出现了e 要求 e前面有一个整数或者小数

else if (str.charAt(i) == 'E' || str.charAt(i) == 'e') {

//第一次出现e

if (!ishaveE) {

ishaveE = true;

//e的前面是整数或者小数

if (isFloat && isInterger || isInterger && !isFloat) {

i++;

} else

return false;

//e的后面是否出现了正负号

if (i < str.length() && (str.charAt(i) == '+' || str.charAt(i) == '-'))

i++;

} else

return false;

}

//如果出现了e 要求后面一定是整数 ->isIntergetAfterE

else {

//出现了其余字符

return false;

}

if (ishaveE) {

return isIntergetAfterE;

}

//没有e出现判断整数/小数是否符合要求

return isFloat && isInterger || isInterger && !isFloat;

}

发表于 2023-03-31 23:47:54 回复(0)

Java

牛客849316302号

不整这些花里胡哨的我非常暴力。

public class Solution {

public boolean isNumeric (String str) {

return isZhengShu(str) || isXiaoShu(str) || isScience(str) ;

}

public boolean isZhengShu(String str) {
int index = 0;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str.charAt(i) != ' ') {
break;
}
index += 1;
}
if ((index<len) && (str.charAt(index) == '+' || str.charAt(index) == '-' )) {
index++;
}
if (index<len && ((str.charAt(index) - '0') <= 9 && ((str.charAt(index) - '0') >= 0)) ) {
index++;
}
else {
return false;
}
for (int i = index; i < len; i++) {
if ((str.charAt(index) - '0')<= 9 && (str.charAt(index) - '0') >= 0) {
index++;
}
else break;
}
for (int i = index; i < len; i++) {
if (str.charAt(i) == ' ') {
index++;
}
else return false;
}
return true;
}

public boolean isXiaoShu(String str) {
int index = 0;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str.charAt(i) != ' ') {
break;
}
index++;
}
if (index<len && (str.charAt(index) == '+' || str.charAt(index) == '-' )) {
index++;
}
//接.的情况
if (index<len && str.charAt(index) == '.') {
index++;
if (index<len && ((str.charAt(index) - '0') <= 9 && ((str.charAt(index) - '0') >= 0) )) {
index++;
}
else return false;
for (int i = index; i < len; i++) {
if ((str.charAt(index) - '0') <= 9 && ((str.charAt(index) - '0') >= 0) ) {
index++;
}
else break;
}
}
else if (index<len && (str.charAt(index) - '0') <= 9 && (str.charAt(index) - '0') >= 0) {
index ++;
for (int i = index; i < len; i++) {
if ((str.charAt(index) - '0') <= 9 && ((str.charAt(index) - '0') >= 0) ) {
index++;
}
else break;
}
if (index<len && str.charAt(index) == '.') {
index ++;
}
else return false;
for (int i = index; i < len; i++) {
if ((str.charAt(index) - '0') <= 9 && ((str.charAt(index) - '0') >= 0) ) {
index++;
}
else break;
}

}
else {
return false;
}
for (int i = index; i < len; i++) {
if (str.charAt(i) == ' ') {
index++;
}
else{
return false;
}
}
return true;

}

public boolean isScience(String str) {
int index = 0;

int e_index = -1;
int len = str.length();
for (int i = 0; i < len; i++) {
if (str.charAt(i) != ' ') {
break;
}
index++;
}
for (int i = index; i < len; i++) {
if (str.charAt(i) == 'e' || str.charAt(i) == 'E' ) {
e_index = i;

break;
}

}
//没有e
if (e_index < 0) {
if (isXiaoShu(str.substring(index)) || isZhengShu(str.substring(index))) return true;
else return false;
}
else {

if(index < e_index && (isXiaoShu(str.substring(index, e_index)) || isZhengShu(str.substring(index, e_index)))) {

index = e_index + 1;
if (index < len) {
if (str.charAt(index) == ' ') return false;
else {

if (isZhengShu(str.substring(e_index+1))) return true;
else return false;
}
}
}
else return false;
}

return false;
}
}

发表于 2022-07-30 22:11:19 回复(0)

Java

624huiguorou

表示数值的字符串

先trim

.只能出现一次，且只能在e前面出现

e只能出现一次，且出现时前面应有数字

+ -只能出现在开头或e后面

空格，用trim处理，中间有空格时直接当失败返回

用boolean来表示每一个情况是否出现，只写成功的情况

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @return bool布尔型
     */
    public boolean isNumeric (String str) {
        // write code here
        
        //.只能出现一次，且只能在e前面出现
        //e只能出现一次，且出现时前面应有数字
        //+ -只能出现在开头或e后面
        //空格，用trim处理，中间有空格时直接当失败返回
        
        str = str.trim();
        //用boolean来表示每一个情况是否出现，是否出现一次（用!XXX来判断）
        boolean numFlag = false, dotFlag = false, eFlag = false, plusFlag = false;
        //只写成功的情况
        for(int i = 0; i < str.length(); i++){
            if(str.charAt(i) >= '0' && str.charAt(i) <= '9'){
                numFlag = true;
            }else if(str.charAt(i) == '.' && !dotFlag && !eFlag){
                dotFlag = true;
            }else if((str.charAt(i) == 'e' || str.charAt(i) == 'E') &&
                     !eFlag && numFlag){
                eFlag = true;
                //处理132e这种情况
                numFlag = false;
            }else if((str.charAt(i) == '+' || str.charAt(i) == '-') && 
                     (i == 0 || str.charAt(i-1) == 'e' || str.charAt(i-1) == 'E')){
                //什么也不干
            }else {
                return false;
            }
        }
        return numFlag;
    }
}

发表于 2022-07-30 20:11:31 回复(0)

Java

牛客312617402号

正则表达式 yyds

发表于 2022-07-10 11:07:46 回复(1)

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)

Java

球球给个班上吧

累了

public class Solution {
    public boolean isNumeric (String str) {
        boolean flag = true;
        try {
            Double result = Double.parseDouble(str);
        } catch (Exception e) {
            flag = false;
        }
        return flag;
    }
}

发表于 2022-02-17 14:58:52 回复(0)

Java

浮鸟(BAT实习ing，目标外企~)

状态机解法。断断续续看了三天，终于搞懂的那一刻真的原地起飞。

import java.util.*;

// 挑战一下状态机解法：
public class Solution {
    // step1：画好状态转移图后，构建状态state和输入字符种类charType的枚举
    // 这里不同于题解，我先去了空格，初始态INITIAL也是没有逻辑含义的，只是为了有一个初态
    enum State{
        INITIAL,
        INT_SIGN,
        INT_NUMBER,
        DOT,
        DOT_WITHOUT_INT,
        FRACTION,
        E,
        E_SIGN,
        E_NUMBER,
    }
    // 对于正负号或者0-9的数字，可以合并为一种char类型
    enum CharType{
        SIGN,
        NUMBER,
        DOT,
        E,
        REFUSE
        }
    
    // step2：定义char类型和枚举转换函数
    public CharType getCharType(char c){
        if(c>='0' && c<='9'){
            return CharType.NUMBER;
        }else if(c=='.'){
            return CharType.DOT;
        }else if(c=='e'||c=='E'){
            return CharType.E;
        }else if(c=='-'||c=='+'){
            return CharType.SIGN;
        }else{
            return CharType.REFUSE;
        }
    }
    
    public boolean isNumeric (String str) {
        // 先去空格
        str = str.trim();
        
        // step3:用嵌套map存储状态转移关系
        Map<State, Map<CharType, State>> map = new HashMap<>();
        
        // 初始态，可以指向INT_SIGN,INT_NUMBER,DOT_WITHOUT_INT
        Map<CharType, State> initialMap = new HashMap<CharType, State>(){{
            put(CharType.SIGN, State.INT_SIGN);
            put(CharType.NUMBER, State.INT_NUMBER);
            put(CharType.DOT, State.DOT_WITHOUT_INT);
        }};
        map.put(State.INITIAL, initialMap);
        
        // int部分的符号位，可以指向INT_NUMBER,DOT_WITHOUT_INT
        Map<CharType, State> intSignMap = new HashMap<CharType, State>(){{
            put(CharType.NUMBER, State.INT_NUMBER);
            put(CharType.DOT, State.DOT_WITHOUT_INT);
        }};
        map.put(State.INT_SIGN, intSignMap);
        
        // int部分的数字，可以指向E,INT_NUMBER,DOT
        Map<CharType, State> intNumberMap = new HashMap<CharType, State>(){{
            put(CharType.NUMBER, State.INT_NUMBER);
            put(CharType.E, State.E);
            put(CharType.DOT, State.DOT);
        }};
        map.put(State.INT_NUMBER, intNumberMap);
        
        // 小数点，可以指向E,FRACTION
        Map<CharType, State> dotMap = new HashMap<CharType, State>(){{
            put(CharType.E, State.E);
            put(CharType.NUMBER, State.FRACTION);
        }};
        map.put(State.DOT, dotMap);
        
        // 前面没有数字的小数点，可以指向FRACTION
        Map<CharType, State> dotNoIntMap = new HashMap<CharType, State>(){{
            put(CharType.NUMBER, State.FRACTION);
        }};
        map.put(State.DOT_WITHOUT_INT, dotNoIntMap);
        
        // 小数数字，可以指向E,FRACTION
        Map<CharType, State> fractionMap = new HashMap<CharType, State>(){{
            put(CharType.E, State.E);
            put(CharType.NUMBER, State.FRACTION);
        }};
        map.put(State.FRACTION, fractionMap);
        
        // E，可以指向E_SIGN，E_NUMBER
        Map<CharType, State> eMap = new HashMap<CharType, State>(){{
            put(CharType.SIGN, State.E_SIGN);
            put(CharType.NUMBER, State.E_NUMBER);
        }};
        map.put(State.E, eMap);
        
        // E之后的符号位，可以指向E_NUMBER
        Map<CharType, State> eSignMap = new HashMap<CharType, State>(){{
            put(CharType.NUMBER, State.E_NUMBER);
        }};
        map.put(State.E_SIGN, eSignMap);
        
        // E之后的数字，可以指向E_NUMBER
        Map<CharType, State> eNumberMap = new HashMap<CharType, State>(){{
            put(CharType.NUMBER, State.E_NUMBER);
        }};
        map.put(State.E_NUMBER, eNumberMap);
        
        
        // step4：遍历字符串
        // 初始状态为INITIAL
        State state = State.INITIAL;
        for(int i=0;i<str.length();i++){
            // 下个触发转移的条件
            CharType type = getCharType(str.charAt(i));
            // 不包含只有2种情况，要么输入的是 REFUSE 字符类型,要么是子map中未记录char到state的转移规则
            if(!map.get(state).containsKey(type)){
                return false;
            }
            // 更新state
            state = map.get(state).get(type);
        }
        // step5：状态机结束后（遍历完字符串后）只有停在指定状态，才算通过校验
        return state==State.INT_NUMBER || state==State.DOT || state==State.FRACTION || state==State.E_NUMBER;
        
    }
}

发表于 2022-01-23 17:04:15 回复(0)

Java

校招求生

这道题就是很无聊

发表于 2021-11-09 00:14:44 回复(0)

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

派大星攻城狮

离大谱解法，兄弟们别翻了，我写了个特殊处理后的正则

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();
    }
}

发表于 2021-09-28 16:19:29 回复(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)

Java

牛客834002708号

import java.util.*;
import java.lang.*;
public class Solution {
    public boolean isNumeric (String str) {
        String s = str.trim();  // 去除str左右两端的空格
        if(s.length() == 0){    // 若全是空格，则判错
            return false;
        }
        // 若输入负数，则去掉负号后再去除空格，避免负号与数值之间存在空格（例："  -  2.5e7  ")
        // 不过本题忽略这一步也可以，因为测试案例中不存在这种情况
        if(s.charAt(0) == '-'){
            s = s.substring(1).trim();
        }
        //**************************************** 检测是否为数值
        try{
            double num = Double.parseDouble(s); // 转为数值
        }catch(NumberFormatException e){        // 若不是数值，则会抛出NumberFormatException异常
            return false;                       // 此时直接判错即可
        }
        // 若没有异常，则可以正常转换，判对
        return true;  // 注意：不能写在finally中，否则不管有没有抛出异常都会return true
    }
}

发表于 2021-08-23 23:05:09 回复(0)

Java

我没变秃，但变强了

认真学了java正则表达式后写出来的菜鸡方法。。。

public boolean isNumeric (String str) {

// write code here
if(str==null||str.length()==0){
return false;
}
String pattern1 = "^\\s*[+-]?\\d+\\s*$";
String pattern2 = "^\\s*[+-]?\\d+\\.(\\d+)?+\\s*$";
String pattern3 = "^\\s*[+-]?\\.\\d+\\s*$";
String pattern4 = "^\\s*[+-]?\\d+\\s*[eE][+-]?\\d+\\s*$";
String pattern5 = "^\\s*[+-]?\\d+\\.(\\d+)?[eE]?[+-]?\\d+\\s*$";
String pattern6 = "^\\s*[+-]?\\.\\d+[eE]?[+-]?\\d+\\s*$";
return str.matches(pattern1)||
str.matches(pattern2)||
str.matches(pattern3)||
str.matches(pattern4)||
str.matches(pattern5)||
str.matches(pattern6);
}

发表于 2021-08-21 17:48:45 回复(0)

Java

together"

主要就是将原书给的两种模式 A[.[B]][e|EC] 和 .B[e|EC]，用正则表达式表示出来：

去除前后空格："^\s*...\s*$"
匹配0个或1个正负号："^\s***[+-]?**...\s*$"
匹配第一种模式的整数和小数部分："^\s*[+-]?((\d+(\.[+-]?\d*)?)|...)\s*$"
匹配第二种模式的整数和小数部分："^\s*[+-]?((\d+(\.[+-]?\d*)?)|(\.[+-]?\d+))...\s*$"
匹配指数部分："^\s*[+-]?((\d+(\.[+-]?\d*)?)|(\.[+-]?\d+))([eE][+-]?\d+)?\s*$"

public class Solution {
    public boolean isNumeric(String str) {
        if (str == null || str.length() == 0) {
            return false;
        }
        
        // A[.[B]][e|EC] 或者 .B[e|EC]
        String pattern = "^\\s*[+-]?((\\d+(\\.[+-]?\\d*)?)|(\\.[+-]?\\d+))([eE][+-]?\\d+)?\\s*$";
        return str.matches(pattern);
    }
}

复习一下正则表达式：

? 匹配0个或1个前面的字符或子表达式
* 匹配0个或n个前面的字符或子表达式
+ 匹配1个或n个前面的字符或子表达式
^ 匹配开头，$ 匹配结尾
\s 匹配一个空白字符
\d 匹配一个数字字符
[abcd] 匹配方括号内的任意一个字符，只有【^在头、-在中、[、]、\】需要转义

发表于 2021-08-14 16:53:58 回复(0)

Java

牛客901292146号

-.123 这个是对的?

发表于 2021-08-04 15:49:50 回复(0)

提交观点

问题信息

字符串

上传者：牛客301499号

难度：

27条回答 627收藏 8721浏览

通过挑战的用户

查看代码

无人溯西风

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

表示数值的字符串

输入

输出

输入

输出

输入

输出

输入

输出

问题信息

热门推荐

通过挑战的用户

相关试题