leetcode 65. 有效数字 66. 寻找两个正序数组的中位数

最新推荐文章于 2024-07-14 02:25:25 发布
最新推荐文章于 2024-07-14 02:25:25 发布
阅读量144 收藏
点赞数 1
分类专栏： leetcode 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mtl1994/article/details/122617805
版权

leetcode 65. 有效数字 66. 寻找两个正序数组的中位数

65. 有效数字

难度困难295

有效数字（按顺序）可以分成以下几个部分：

  1. 一个 小数 或者 整数
  2. （可选）一个 'e' 或 'E' ，后面跟着一个 整数

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

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

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

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

部分有效数字列举如下：

  • ["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]

部分无效数字列举如下：

  • ["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]

给你一个字符串 s ，如果 s 是一个 有效数字 ，请返回 true 。

示例 1：

输入：s = "0"
输出：true

示例 2：

输入：s = "e"
输出：false

示例 3：

输入：s = "."
输出：false

示例 4：

输入：s = ".1"
输出：true

提示：

  • 1 <= s.length <= 20
  • s 仅含英文字母（大写和小写），数字（0-9），加号 '+' ，减号 '-' ，或者点 '.' 。
# -*- coding: utf-8 -*-
# !/usr/bin/env python
# @Time    : 2022/1/14 14:52 
# @Author  : mtl
# @Desc    : ***
# @File    : 65.py
# @Software: PyCharm
import traceback
from typing import List
from enum import Enum

class Solution:
    def isNumber(self, s: str) -> bool:
        if s == ".":
            return False
        def find(patten: str, s: str):
            plen, slen = len(patten), len(s)
            if slen == 0 or s == ".":
                return False
            i, j = 0, 0
            # jump = True
            arr_num = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
            while i < plen:
                pstr = patten[i]
                if patten[i] == "(":
                    i2 = i + 1
                    while i2 < plen:
                        if patten[i2] == ")":
                            pstr = patten[i+1:i2].split("|")
                            break
                        i2+=1
                    i = i2
                elif patten[i] == "\\":
                    i += 1
                    pstr = patten[i]
                    if pstr == "d":
                        pstr = arr_num
                elif patten[i] not in arr_num:
                    pstr = patten[i]
                i += 1
                flag = False
                while j < slen:
                    flag = False
                    if isinstance(pstr, List):
                        if s[j] in pstr:
                            flag = True
                            j += 1
                    if isinstance(pstr, str):
                        if s[j] == pstr:
                            flag = True
                            j += 1
                    if patten[i] == "?":
                        flag = True
                        i += 1
                    elif patten[i] != "*" and not flag:
                        return False
                    if i >= plen or patten[i] != "*":
                        break
                    if not flag:
                        i += 1
                        break
                if j >= slen:
                    if str(patten[i]) in ["*", "?"]:
                        i += 1
                    elif not flag:
                        break
            if i != plen or j != slen:
                return False
            return True
        s = s.upper()
        if "e" in s or "E" in s:
            sarr = s.split("E")
            if len(sarr) > 2:
                return False
            if "." in sarr[0]:
                f1 = find("(+|-)?\d\d*.?\d*", sarr[0]) or find("(+|-)?\d*.?\d\d*", sarr[0])
            else:
                f1 = find("(+|-)?\d\d*", sarr[0])
            f2 = find("(+|-)?\d\d*", sarr[1])
            return f1 and f2
        else:
            if "." in s:
                return find("(+|-)?\d\d*.?\d*", s) or find("(+|-)?\d*.?\d\d*", s)
            return find("(+|-)?\d\d*", s)

    def isNumber(self, s: str):
        arr_num = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]

        def getTask(patten: str):
            i, plen = 0, len(patten)
            while i < plen:
                if patten[i] == "(":
                    i2 = i + 1
                    while i2 < plen:
                        if patten[i2] == ")":
                            return i2 + 1, patten[i + 1:i2].split("|")
                        i2 += 1
                if patten[i] == "\\":
                    i += 1
                    pstr = patten[i]
                    if pstr == "d":
                        return i + 1, arr_num
                return i + 1, patten[i]

        def search(s: str, patten):
            if s == "" or s == ".":
                return False
            l, flag = "*", True
            while flag and len(patten) > 0:
                i, p = getTask(patten)
                l = patten[i] if len(patten) > i else ""
                flag = False
                if len(s) > 0:
                    if isinstance(p, str):
                        if s[0] == p:
                            flag = True
                    elif isinstance(p, List):
                        if s[0] in p:
                            flag = True
                    else:
                        flag = False
                    if flag:
                        s = s[1:]
                if i >= len(patten) and len(s) > 0:
                    flag = False
                    break
                if l == "?":
                    flag = True
                    patten = patten[i + 1:]
                elif l != "*":
                    patten = patten[i:]
                elif l == "*" and not flag:
                    flag = True
                    patten = patten[i + 1:]
                if flag and len(s) > 0 and patten == "":
                    flag = False
                    break
            return flag
        pattens = ["(+|-)?\d\d*.", "(+|-)?\d\d*.\d\d*", "(+|-)?.\d\d*", "(+|-)?\d\d*"]
        flag = False
        sarr = s.upper().split("E")
        if len(sarr) > 2:
            return False
        for patten in pattens:
            s2 = sarr[0]
            flag = search(s2, patten)
            if flag:
                break
        if len(sarr) > 1 and flag:
            flag = search(sarr[1], "(+|-)?\d\d*")
        return flag

    def isNumber(self, s: str):
        if s == "":
            return False
        i, slen = 0, len(s)
        add_flag, num_flag, point_flag, has_point, e_flag, flag = False, False, False, False, False, True
        num_arr = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "."]
        symbol_arr = ["+", "-", "e", "E"]
        while i < slen:
            if s[i] in symbol_arr[:-2] and not add_flag:
                if (i > 0 and not e_flag) or (e_flag and s[i - 1] not in symbol_arr[2:]):
                    flag = False
                    break
                add_flag = True
            elif add_flag:
                if s[i] in num_arr[:-1]:
                    add_flag = False
                    num_flag = True
                elif s[i] == ".":
                    add_flag = False
                    continue
                else:
                    flag = False
                if e_flag and not add_flag:
                    flag = True
            elif e_flag:
                if s[i] not in num_arr[:-1]:
                    flag = False
                    break
                elif s[i - 1] in symbol_arr[2:] and not flag:
                    flag = True
            elif s[i] == ".":
                if point_flag or has_point:
                    flag = False
                    break
                if not num_flag:
                    point_flag = True
                    flag = False
                has_point = True
            elif point_flag:
                if s[i] in num_arr:
                    num_flag = True
                else:
                    break
                if num_flag:
                    point_flag = False
                    flag = True
            elif s[i] in num_arr[:-1]:
                num_flag = True
                if e_flag:
                    flag = True
            elif s[i] in symbol_arr[2:] and not e_flag:
                e_flag = True
                flag = False
                if i == 0:
                    break
            if s[i] not in num_arr[:-1]:
                num_flag = False
            if s[i] not in num_arr and s[i] not in symbol_arr:
                flag = False
            if not flag and not e_flag and not point_flag:
                break
            i += 1
        return flag

    def isNumber(self, s: str) -> bool:
        State = 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"
        ])
        Chartype = Enum("Chartype", [
            "CHAR_NUMBER",
            "CHAR_EXP",
            "CHAR_POINT",
            "CHAR_SIGN",
            "CHAR_ILLEGAL"
        ])

        def toChartype(ch: str) -> Chartype:
            if ch.isdigit():
                return Chartype.CHAR_NUMBER
            elif ch.lower() == "e":
                return Chartype.CHAR_EXP
            elif ch == ".":
                return Chartype.CHAR_POINT
            elif ch == "+" or ch == "-":
                return Chartype.CHAR_SIGN
            else:
                return Chartype.CHAR_ILLEGAL

        transfer = {
            State.STATE_INITIAL: {
                Chartype.CHAR_NUMBER: State.STATE_INTEGER,
                Chartype.CHAR_POINT: State.STATE_POINT_WITHOUT_INT,
                Chartype.CHAR_SIGN: State.STATE_INT_SIGN
            },
            State.STATE_INT_SIGN: {
                Chartype.CHAR_NUMBER: State.STATE_INTEGER,
                Chartype.CHAR_POINT: State.STATE_POINT_WITHOUT_INT
            },
            State.STATE_INTEGER: {
                Chartype.CHAR_NUMBER: State.STATE_INTEGER,
                Chartype.CHAR_EXP: State.STATE_EXP,
                Chartype.CHAR_POINT: State.STATE_POINT
            },
            State.STATE_POINT: {
                Chartype.CHAR_NUMBER: State.STATE_FRACTION,
                Chartype.CHAR_EXP: State.STATE_EXP
            },
            State.STATE_POINT_WITHOUT_INT: {
                Chartype.CHAR_NUMBER: State.STATE_FRACTION
            },
            State.STATE_FRACTION: {
                Chartype.CHAR_NUMBER: State.STATE_FRACTION,
                Chartype.CHAR_EXP: State.STATE_EXP
            },
            State.STATE_EXP: {
                Chartype.CHAR_NUMBER: State.STATE_EXP_NUMBER,
                Chartype.CHAR_SIGN: State.STATE_EXP_SIGN
            },
            State.STATE_EXP_SIGN: {
                Chartype.CHAR_NUMBER: State.STATE_EXP_NUMBER
            },
            State.STATE_EXP_NUMBER: {
                Chartype.CHAR_NUMBER: State.STATE_EXP_NUMBER
            },
        }

        st = State.STATE_INITIAL
        for ch in s:
            typ = toChartype(ch)
            if typ not in transfer[st]:
                return False
            st = transfer[st][typ]

        return st in [State.STATE_INTEGER, State.STATE_POINT, State.STATE_FRACTION, State.STATE_EXP_NUMBER,
                      State.STATE_END]

if __name__ == '__main__':
    # s = "0"
    sa = ["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]
    sa = ["12345.", "123.312", "1.1", "1.123123213213123"]
    sa = ["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]
    # sa = ["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]
    # sa = ["."]
    # sa = ["0.."]
    # sa = ["3."]
    # sa = [".e1"]
    # sa = ["11234.1."]
    # sa = ["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]
    # sa = ["2e0", ".e1", "+.", "+E3", "7e69e"]
    # sa = ["7e69e"]

    num_arr = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "."]

    sa = ["7e3+"]

    # print(num_arr[:-1])
    for s in sa:
        print(Solution().isNumber(s))
    # search("(\d{1,}.|\d{1,}.\d{1,}|.\d{1,}|\d{1,})", "123.123")
    # # s = " 123 "
    # # print(s[1:-1])
    #
    # str = "   hello word  "
    #
    # print(str[1:])
    #
    # left, right = 0,  len(str) - 1
    # while left < len(str) and str[left] == " ":
    #     left += 1
    # while right > 0 and str[right] == " ":
    #     right -= 1
    # print(str[left:right + 1])
66. 加一

难度简单904

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1：

输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。

示例 2：

输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。

示例 3：

输入：digits = [0]
输出：[1]

提示：

  • 1 <= digits.length <= 100
  • 0 <= digits[i] <= 9

通过次数426,939

提交次数923,900

# -*- coding: utf-8 -*-
# !/usr/bin/env python
# @Time    : 2022/1/20 16:49 
# @Author  : mtl
# @Desc    : ***
# @File    : 66.py
# @Software: PyCharm
from typing import List


class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        dlen = len(digits)
        def add(i):
            if -i > dlen:
                digits.insert(0, 1)
            elif digits[i] + 1 == 10:
                digits[i] = 0
                add(i - 1)
            else:
                digits[i] += 1
            return digits
        return add(-1)

    def plusOne2(self, digits: List[int]) -> List[int]:
        right = len(digits) - 1
        while right >= -1:
            if right == -1:
                digits.insert(0, 1)
                break
            digits[right] += 1
            if digits[right] == 10:
                digits[right] = 0
            else:
                break
            right -= 1
        return digits

    def plusOne(self, digits: List[int]) -> List[int]:
        digits[-1] += 1
        for d in range(len(digits) - 1, -1, -1):
            if digits[d] == 10:
                digits[d] = 0
                if d - 1 < 0:
                    digits.insert(0, 1)
                else:
                    digits[d - 1] += 1
            else:
                break
        return digits

if __name__ == '__main__':
    digits = [9, 9, 8]
    # print(digits[:-1])
    print(Solution().plusOne(digits))
LeetCode——65. 有效数字(Valid Number)[中等]——分析及代码（Java）
江南土豆的博客
06-21 394
LeetCode——65. 有效数字[Valid Number][中等]——分析及代码[Java]一、题目二、分析及代码1. 确定有限状态自动机（1）思路（2）代码（3）结果三、其他 一、题目 有效数字（按顺序）可以分成以下几个部分： 一个 小数 或者 整数 （可选）一个 ‘e’ 或 ‘E’ ，后面跟着一个 整数 小数（按顺序）可以分成以下几个部分： （可选）一个符号字符（’+’ 或 ‘-’） 下述格式之一： 至少一位数字，后面跟着一个点 ‘.’ 至少一位数字，后面跟着一个点 ‘.’ ，后面再跟着至
【LeetCode】剑指 Offer 20. 表示数值的字符串
jiiiiiaaaa的博客
09-02 336
题目 请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100"、"5e2"、"-123"、"3.1416"、"-1E-16"、"0123"都表示数值，但"12e"、"1a3.14"、"1.2.3"、"+-5"及"12e+5.4"都不是。 解题思路 本题使用有限状态自动机。根据字符类型和合法数值的特点，先定义状态，再画出状态转移图，最后编写代码即可。 确定有限状态自动机（以下简称「自动机」）是一类计算模型。它包含一系列状态，这些状态中： 有一个特殊的状态，被称作「初始状态
[LeetCode]65. 有效数字
张小猪的家
08-05 370
65. 有效数字 难度：困难 有效数字（按顺序）可以分成以下几个部分： 一个 小数 或者 整数 （可选）一个 'e' 或 'E' ，后面跟着一个 整数 小数（按顺序）可以分成以下几个部分： （可选）一个符号字符（'+' 或 '-'） 下述格式之一： 至少一位数字，后面跟着一个点 '.' 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字 一个点 '.' ，后面跟着至少一位数字 整数（按顺序）可以分成以下几个部分： （可选）一个符号字符（'+' 或 '-'） 至少一位数字 部分有
LeetCode：65. 有效数字
无聊星期三的博客
07-01 760
题目 LeetCode: 65. Valid Number 验证给定的字符串是否为数字。 示例： "0" =&gt; true " 0.1 " =&gt; true "abc" =&gt; false "1 a" =&gt; false "2e10" =&gt; true 思路 有限状态机 序列的情形是有限的，我觉得这个题有限状态机非常合适。
65. 有效数字
zrh_CSDN的博客
09-04 373
验证给定的字符串是否为数字。 例如:"0" =&gt; true" 0.1 " =&gt; true"abc" =&gt; false"1 a" =&gt; false"2e10" =&gt; true 说明: 我们有意将问题陈述地比较模糊。在实现代码之前，你应当事先思考所有可能的情况。 更新于 2015-02-10:C++函数的形式已经更新了。如果你仍然看见你的
丢失的最小正整数leetcode-LeetCode:力码
06-30
寻找两个正序数组的中位数 7 整数反转 9 回文数 13 罗马数字转整数 14 最长公共前缀 15 三数之和 16 最接近的三数之和 20 有效的括号 21 合并两个有序链表 26 删除排序数组中的重复项 27 移除元素 28 实现strStr 32 ...
LeetCode题解汇总
31楼下小黑的博客
08-28 883
97. 交错字符串
LeetCode刷题总结
星河灿烂的博客
01-19 1297
dfsa
LeetCode刷题汇总
热门推荐
weixin_44171872的博客
09-19 2万+
剑指offer 剑指 Offer 03 数组中重复的数字 剑指 Offer 04 二维数组中的查找 剑指 Offer 05 替换空格 剑指 Offer 06 从尾到头打印链表 剑指 Offer 07 重建二叉树 剑指 Offer 09 用两个栈实现队列 剑指 Offer 10- I 斐波那契数列 剑指 Offer 10- II 青蛙跳台阶问题 剑指 Offer 11 旋转数组的最小数字 剑指 Offer 12 矩阵中的路径 剑指 Offer 13 机器人的运动范围 剑指 Offer 14- I 剪绳子 剑指
Leetcode HOT 100 (Java 版)
最新发布
dwtianwen的博客
07-14 921
一刷 Leetcode HOT 100 记录
65.有效数字
个人记录使用
10-27 196
难度：困难 题目描述： 思路： 这题有多种思路，但是我唯一能想到的就是暴力穷举法，但是这么多用例还是穷举不过来，最后1400多用例只能通过1200多。因此只能跪求大佬解法了。 思路一：思路之清奇不是对编程语言极度熟悉的大佬肯定想不出来。这个题换句话说就是将字符串转换为浮点数。因此try-catch再加上float()就能完成。今日份的leetcode时间用完，先列出来这个方法吧，其余方法晚上抽时...
（每日一练c++）65. 有效数字
weixin_39827856的博客
06-02 336
有效数字（按顺序）可以分成以下几个部分： 一个 小数 或者 整数 （可选）一个 'e' 或 'E' ，后面跟着一个 整数 小数（按顺序）可以分成以下几个部分： （可选）一个符号字符（'+' 或 '-'） 下述格式之一： 至少一位数字，后面跟着一个点 '.' 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字 一个点 '.' ，后面跟着至少一位数字 整数（按顺序）可以分成以下几个部分： （可选）一个符号字符（'+' 或 '-'） 至少一位数字 部分有效数字列举如下：["2", "0089",
【LeetCode】65 有效数字
qq_36269372的博客
11-20 384
验证给定的字符串是否为数字。 例如: “0” =&gt; true " 0.1 " =&gt; true “abc” =&gt; false “1 a” =&gt; false “2e10” =&gt; true 说明: 我们有意将问题陈述地比较模糊。在实现代码之前，你应当事先思考所有可能的情况。 解题思路： 这道题的情况十分复杂，需要自己一个一个尝试某个形式算不算数字，也正因此，这道题斩获...
65. 有效数字-H
longtails的博客
03-10 312
65. 有效数字 验证给定的字符串是否为数字。 例如: “0” =&amp;amp;gt; true &amp;quot; 0.1 &amp;quot; =&amp;amp;gt; true “abc” =&amp;amp;gt; false “1 a” =&amp;amp;gt; false “2e10” =&amp;amp;gt; true 说明: 我们有意将问题陈述地比较模糊。在实现代码之前，你应当事先思考所有可能的情况。 更新于 2015-02
leetCode 65.Valid Number (有效数字)
Android进阶
07-17 1141
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
LeetCode 有效数字
hestyle的博客
02-14 392
验证给定的字符串是否为数字。 例如: "0" =&gt; true " 0.1 " =&gt; true "abc" =&gt; false "1 a" =&gt; false "2e10" =&gt; true 说明: 我们有意将问题陈述地比较模糊。在实现代码之前，你应当事先思考所有可能的情况。 思路分析：这题干给的不是一般的模糊，不要将什么策略，撸起袖子就是干！！
Leetcode 有效数字
一夜星尘
02-13 1568
有效数字 题目描述： 有效数字（按顺序）可以分成以下几个部分： 一个小数或者整数 （可选）一个 'e' 或 'E' ，后面跟着一个整数 小数（按顺序）可以分成以下几个部分： （可选）一个符号字符（'+' 或 '-'） 下述格式之一： 至少一位数字，后面跟着一个点 '.' 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字 一个点 '.' ，后面跟着至少一位数字 整数（按顺序）可以分成以下几个部分： （可选）一个符号字符（
leetcode中寻找两个正序数组的中位数python
05-30
好的，下面是寻找两个正序数组的中位数的 Python 代码： ```python def findMedianSortedArrays(nums1, nums2): nums = sorted(nums1 + nums2) n = len(nums) if n % 2 == 0: return (nums[n // 2 - 1] + nums[n // 2]) / 2 else: return nums[n // 2] ``` 其中，nums1和nums2分别是两个正序数组，函数返回它们的中位数。我们将两个数组合并并排序，然后判断数组长度的奇偶性，分别返回中位数。如果数组长度是偶数，我们取中间两个数的平均值作为中位数；如果数组长度是奇数，我们直接返回中间的那个数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

matianlongg

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值