冬瓜头学编程第三站——表示数值的字符串

最新推荐文章于 2024-10-20 10:43:07 发布
最新推荐文章于 2024-10-20 10:43:07 发布
阅读量46 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49738082/article/details/131802120
版权
文章介绍了如何判断一个字符串是否表示数值，包括整数和小数。主要思路是通过枚举和有限状态自动机来分析字符串的各个部分，如正负号、小数点、指数等。文章提供了两种方法，一种是暴力枚举，另一种是使用更规范的状态转移枚举策略，后者在处理大规模程序时更为高效。
摘要由CSDN通过智能技术生成

题目描述：请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。

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

  1. 若干空格
  2. 一个 小数 或者 整数
  3. （可选）一个 'e' 或 'E' ，后面跟着一个 整数
  4. 若干空格

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

  1. （可选）一个符号字符（'+' 或 '-'）
  2. 下述格式之一：
    1. 至少一位数字，后面跟着一个点 '.'
    2. 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字
    3. 一个点 '.' ，后面跟着至少一位数字

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

  1. （可选）一个符号字符（'+' 或 '-'）
  2. 至少一位数字

思路概述：看到这道题，就会想到枚举枚举，因为脑袋里貌似还真没有合适的算法适配它，所以最后还是毅然决然选择了暴力枚举。显然这道题正向枚举肯定情况太多了，毕竟有很多很多搭配，所以要枚举大概率还是反向枚举合适，即：不符合条件的情况返回false，其他的情况返回true。

        当然，由题目的描述可以知道，字符串中有说空格开头和空格结尾的情况，为了避免麻烦，我将这一部分跳出，选择直接判断中间的字符串，而字符串中可能出现的字符为正负号'+'、'-'，小数点'.'，指数'e'、‘E'，还有就是数字了，然后从这几种类型出发来进行枚举。

bool isNumber(char* s){
    bool isnum=false,ise=false,ispot=false,issign=false;//判断上一个位置的字符类型
    bool pot=false,e=false;//判断之前是否已经出现过小数点或者'e'、'E'
    int leng = strlen(s);
    int head=0;
    int tail;
    for(;head<leng;head++){//记录非空格字符串的起点
        if(s[head]!=' '){
            break;
        }
    }
    if(head == leng){
        return false;
    }
    for(tail=head;tail<leng;tail++){//记录非空格字符串的重点
        if(s[tail]==' '){
            break;
        }
    }
    for(int i=tail;i<leng;i++){
        if(s[i]!=' '){
            return false;
        }
    }
    for(int i=head;i<tail;i++){
        if(s[i]=='+'||s[i]=='-'){//指针位置为正负号
            if((!ise&&i!=head)||isnum||ispot||issign){
                return false;
            }
            else if(ise){
                if(!(s[i+1]>='0'&&s[i+1]<='9')){
                    return false;
                }
            }
            else{
                if(ise){
                    ise = false;
                }
                issign = true;
            }
        }
        else if(s[i] == '.'){//指针位置为小数点
            if(pot||e){
                return false;
            }
            else{
                if(isnum){
                    ispot = true;
                    isnum = false;
                }
                else{
                    if(s[i+1]>='0'&&s[i+1]<='9'){
                        if(issign){
                            issign = false;
                            ispot = true;
                        }
                        else if(i == head){
                            ispot = true;
                        }
                        else{
                            return false;
                        }
                    }
                    else{
                        return false;
                    }
                }
            }
            pot = true;
        }
        else if(s[i] == 'e' ||s[i] =='E'){//指针位置为'e'或者'E'
            if(e){
                return false;
            }
            if(!isnum&&!ispot){
                return false;
            }
            ise = true;
            isnum = false;
            ispot = false;
            e = true;
            if((s[i+1]>='0'&&s[i+1]<='9')||s[i+1]=='+'||s[i+1]=='-'){
            }
            else{
                return false;
            }
        }
        else if(s[i] >= '0'&&s[i] <= '9'){//指针位置为数字
            isnum = true;
            ise = false;
            ispot = false;
            issign = false;
        }
        else{//指针位置为其他的不在定义范围的字符
            return false;
        }
    }
    return true;
}

         当然，自己的暴力解法结束了就要开始学习其他人的方法了，我发现官方解答给了一种规范的枚举策略——有限状态自动机，他将其中的所有可以枚举的东西都列举了出来，这种策略用于大规模的程序中肯定是优势远大于我这种直接性的暴力枚举。

enum State {
    STATE_INITIAL,
    STATE_INT_SIGN,
    STATE_INTEGER,
    STATE_POINT,
    STATE_POINT_WITHOUT_INT,
    STATE_FRACTION,
    STATE_EXP,
    STATE_EXP_SIGN,
    STATE_EXP_NUMBER,
    STATE_END,
    STATE_ILLEGAL
};

enum CharType {
    CHAR_NUMBER,
    CHAR_EXP,
    CHAR_POINT,
    CHAR_SIGN,
    CHAR_SPACE,
    CHAR_ILLEGAL
};

enum CharType toCharType(char ch) {
    if (ch >= '0' && ch <= '9') {
        return CHAR_NUMBER;
    } else if (ch == 'e' || ch == 'E') {
        return CHAR_EXP;
    } else if (ch == '.') {
        return CHAR_POINT;
    } else if (ch == '+' || ch == '-') {
        return CHAR_SIGN;
    } else if (ch == ' ') {
        return CHAR_SPACE;
    } else {
        return CHAR_ILLEGAL;
    }
}

enum State transfer(enum State st, enum CharType typ) {
    switch (st) {
        case STATE_INITIAL: {
            switch (typ) {
                case CHAR_SPACE:
                    return STATE_INITIAL;
                case CHAR_NUMBER:
                    return STATE_INTEGER;
                case CHAR_POINT:
                    return STATE_POINT_WITHOUT_INT;
                case CHAR_SIGN:
                    return STATE_INT_SIGN;
                default:
                    return STATE_ILLEGAL;
            }
        }
        case STATE_INT_SIGN: {
            switch (typ) {
                case CHAR_NUMBER:
                    return STATE_INTEGER;
                case CHAR_POINT:
                    return STATE_POINT_WITHOUT_INT;
                default:
                    return STATE_ILLEGAL;
            }
        }
        case STATE_INTEGER: {
            switch (typ) {
                case CHAR_NUMBER:
                    return STATE_INTEGER;
                case CHAR_EXP:
                    return STATE_EXP;
                case CHAR_POINT:
                    return STATE_POINT;
                case CHAR_SPACE:
                    return STATE_END;
                default:
                    return STATE_ILLEGAL;
            }
        }
        case STATE_POINT: {
            switch (typ) {
                case CHAR_NUMBER:
                    return STATE_FRACTION;
                case CHAR_EXP:
                    return STATE_EXP;
                case CHAR_SPACE:
                    return STATE_END;
                default:
                    return STATE_ILLEGAL;
            }
        }
        case STATE_POINT_WITHOUT_INT: {
            switch (typ) {
                case CHAR_NUMBER:
                    return STATE_FRACTION;
                default:
                    return STATE_ILLEGAL;
            }
        }
        case STATE_FRACTION: {
            switch (typ) {
                case CHAR_NUMBER:
                    return STATE_FRACTION;
                case CHAR_EXP:
                    return STATE_EXP;
                case CHAR_SPACE:
                    return STATE_END;
                default:
                    return STATE_ILLEGAL;
            }
        }
        case STATE_EXP: {
            switch (typ) {
                case CHAR_NUMBER:
                    return STATE_EXP_NUMBER;
                case CHAR_SIGN:
                    return STATE_EXP_SIGN;
                default:
                    return STATE_ILLEGAL;
            }
        }
        case STATE_EXP_SIGN: {
            switch (typ) {
                case CHAR_NUMBER:
                    return STATE_EXP_NUMBER;
                default:
                    return STATE_ILLEGAL;
            }
        }
        case STATE_EXP_NUMBER: {
            switch (typ) {
                case CHAR_NUMBER:
                    return STATE_EXP_NUMBER;
                case CHAR_SPACE:
                    return STATE_END;
                default:
                    return STATE_ILLEGAL;
            }
        }
        case STATE_END: {
            switch (typ) {
                case CHAR_SPACE:
                    return STATE_END;
                default:
                    return STATE_ILLEGAL;
            }
        }
        default:
            return STATE_ILLEGAL;
    }
}

bool isNumber(char* s) {
    int len = strlen(s);
    enum State st = STATE_INITIAL;

    for (int i = 0; i < len; i++) {
        enum CharType typ = toCharType(s[i]);
        enum State nextState = transfer(st, typ);
        if (nextState == STATE_ILLEGAL) return false;
        st = nextState;
    }
    return st == STATE_INTEGER || st == STATE_POINT || st == STATE_FRACTION || st == STATE_EXP_NUMBER || st == STATE_END;
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/solutions/372095/biao-shi-shu-zhi-de-zi-fu-chuan-by-leetcode-soluti/

憨憨冬瓜头
关注
编程实践精华总结集锦系列1: SpringBoot/Maven/IDEA/Java/Kotlin/Redis等等
AI天才研究院
07-24 1万+
UNIX 设计哲学：Do one thing and do it well一次只做一件事，并做到极致。《UNIX编程艺术》一书，提出的17条编程原则，经过时间和实践的锤炼，发展成为Unix...
java8 多行字符串_JDK8字符串拼接的正确姿势
weixin_42303107的博客
02-13 3215
1. 对列表中的元素进行拼接以前，对一个列表中的字符串进行拼接时，常见的代码如示例1所示：代码示例1List ids = ImmutableList.of("1", "2", "3");StringBuilder sb = new StringBuilder();for (String id : ids) {if (sb.length() > 0) {sb.append(",");}sb.a...
pandas——python
m0_58086930的博客
07-09 1906
【pandas中的Series和DataFrame】 学Python不学数据处理就像学英语不练口语，Python之所以强大，数据处理是不可或缺的一部分。 如果你希望通过Python一键高效解决日常凌乱的报表和数据，那就快来学习numpy和pandas吧。 从此告别重复无聊的表格处理工作，5分钟解决掉一天的工作。 .........
编程书籍大全
06-02 3827
MFC程序开发参考大全USB应用开发技术大全HTML参考大全Java范例开发大全Java开发技术大全Java 2参考大全Java Web开发典型模块大全Java Web开发技术大全精通Java Web整合开发Java 2游戏设计Java游戏编程Java Web开发实战1200例Java Web 2.0架构开发与项目实战开发者突击Java Web 开发详解 XML+XSLT+Servlet+JS...
软件工程基础个人项目——生成数独终局以及求解数独
weixin_40629184的博客
12-29 1561
这里写自定义目录标题软件工程基础个人项目——生成数独终局以及求解数独一. 项目的GitHub地址二. 填写表格中的预计时间三. 解题思路描述四. 设计实现过程功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学...
js面向数据编程(DOP)一点分享(转载)
04-16 425
js面向数据编程(DOP)一点分享 by zhangxinxu from http://www.zhangxinxu.com 本文地址：http://www.zhangxinxu.com/wordpress/?p=1384 一、小历史 面对数据编程(data-oriented-programme)这个概念第一次接受是在去年前年阿里巴巴举行的D2前端论坛上，来自Baidu金大为：...
计算机编程书籍大全
浮生未歇的博客
04-09 5631
MFC程序开发参考大全 USB应用开发技术大全 HTML参考大全 Java范例开发大全 Java开发技术大全 Java 2参考大全 Java Web开发典型模块大全 Java Web开发技术大全 精通Java Web整合开发 Java 2游戏设计 Java游戏编程 Java Web开发实战1200例 Java Web 2.0架构开发与项目实战 开发者突击 Java We
(前端编程题：（手撕代码）
Handsome2013的博客
08-17 1464
前端编程题：1.节流和防抖函数节流：一个函数执行一次后，只有大于设定的执行周期后才会执行第二次防抖函数：一个需要频繁触发的函数，在规定时间内，只让最后一次生效，前面的不生效。2.深拷贝 1.节流和防抖 函数节流：一个函数执行一次后，只有大于设定的执行周期后才会执行第二次 function throttle(fn, delay) { // 记录上一次函数触发的时间 var lastTime = 0; return function() { // 记录当前函数触发的时间
c语言学习笔记_全面细致_重难点答疑解惑
m0_53753096的博客
08-09 2252
这篇文章系统整理了C语言的学习要点。首先介绍了C语言的特点和历史背景，强调了其在解决实际问题中的重要性，尤其是在数据参数化和算法设计方面。文章详细讲解了C语言中的常见编程技巧，如变量初始化、数字处理、字符串操作等，以及常用的算法如排序和搜索等。接着，文章还探讨了C语言的编程格式、错误处理、终端操作等内容，并深入解析了数据类型、指针、动态内存管理等高级特性。此外，还提供了关于编辑器、编译器和IDE的使用建议，帮助读者更好地掌握C语言编程。
T 沙龙 2018 年 1 月上海第 10 次线下活动总结
weixin_34416754的博客
01-24 700
技术编辑：冬瓜 & EyreFree 运营编辑：千叶知风 零. 前言 作为 2018 年的开箱活动，我们为大家带来了 AI 与算法专场。过去的一年里 AI 有多火热，想必大家都非常清楚，所以虽然是 Swift 沙龙，但我们仍然特意为大家准备了这么一场以 AI 为主题的分享活动。 下面是我们沙龙技术编辑童鞋对这三个 Topic 的一些总结： 一. 自适应学习 - 机器学习在开心词场中的...
1营养午餐——学生学习课件
11-23
### 1营养午餐——学生学习课件 #### 知识点概述 本课件主要针对学生午餐营养标准及其重要性进行了详细的介绍与分析。通过学习本课件，学生能够了解到健康饮食的重要性，学会如何评估食物的营养价值，并掌握利用...
华为校招编程题集：C++解决字符串与字符计数问题
最后返回计数`num`，表示字符在输入字符串中出现的次数。例如，对于输入"ABCDEFA"和字符'A'，输出结果为1，因为字符'A'出现了1次。 这两道题目都是基础的字符串处理和查找操作，体现了面试中对基本数据结构和算法...
React——第三篇，两天的学习
Front_ends的博客
11-29 117
import React,{ Component,Fragment } from 'react'; import Item from './item'; import './app.css' class APP extends Component{ constructor(props){ super(props); this.state={ ...
二分查找算法（折半查找算法）
最新发布
Mooczx的博客
10-20 275
是一种在有序数组中查找特定元素的搜索算法。该算法通过将数组分成两半，逐步缩小查找范围来提高查找效率。具体来说，每次比较中间元素与目标值，根据比较结果决定是继续在左半部分还是右半部分进行查找，从而每次迭代都能排除一半的查找空间，时间复杂度对数级别O(logn)
【算法】深入了解 CRC 校验码的计算过程
qq_20623849的博客
10-16 561
CRC（循环冗余校验，Cyclic Redundancy Check）是一种常见的错误检测方法，它通过生成冗余码来确保数据传输的可靠性。在这篇文章中，我们将探讨 CRC 码的基本原理，并详细介绍其计算过程。通过对数据进行 CRC 校验，我们可以在传输过程中检测到潜在的错误并采取适当的纠正措施。这个新的数据包在传输时，如果接收方再次计算 CRC 校验码并与附带的校验码进行比较，可以确定数据是否在传输过程中出现了错误。：将附加了零位的数据通过生成多项式进行二进制除法运算，得出的余数就是 CRC 校验码。
【LeetCode热题100】分治-归并
qq_48460693的博客
10-20 223
分治-排序
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 360
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
端盘子问题（二分查找+广度优先）
u012011912的博客
10-16 311
终于中午放学铃声打响了，小明想要尽快地前往食堂打自己最喜欢吃的菜。小明觉得，他会准备好若干个盘子再出发，带了几个盘子就打几份菜。但是一路上人群拥挤程度不同，如果太过拥挤，小明会拿不稳太多盘子。经过观察，小明发现食堂的地形可以用一个(1,1)(n,n)小明行走，并且每次可以花费 1 秒，从当前位置(i, j)移动到相邻的(i+1, j)(i, j+1)(i-1, j)或(i, j-1)。(1,1)(n,n)如果无论如何也不能在规定时间内到达终点，输出0。第一行包含两个整数n和Tnn × nT接下来n。
【C语言】一维数组应用Fibonacci数列
我的我的博客
10-16 262
前两项为1，从第三项开始，每一项为前两项的和。可以知道连续三项的关系：f[i]=f[i-1]+f[i-2]使用数组进行存储，十分方便。可以知道前n项的fibonacci数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值