剑指offer_剩下全部

最新推荐文章于 2022-08-09 16:32:19 发布
原创 最新推荐文章于 2022-08-09 16:32:19 发布 · 161 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

树

#12.py

# 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

# [["a","b","c","e"],
# ["s","f","c","s"],
# ["a","d","e","e"]]

# 但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

#  

# 示例 1：

# 输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
# 输出：true
# 示例 2：

# 输入：board = [["a","b"],["c","d"]], word = "abcd"
# 输出：false
class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        dx=[0,-1,0,1]
        dy=[-1,0,1,0]
        def dfs(x,y,k):
            if word[k]!=board[x][y]:
                return False
            if k==len(word)-1:return True
            t=board[x][y]
            board[x][y]="*"
            for i in range(4):
                if 0<=x+dx[i]<=len(board)-1 and 0<=y+dy[i]<=len(board[0])-1:
                    if dfs(x+dx[i],y+dy[i],k+1):
                        return True
            board[x][y]=t

        for i in range(len(board)):
            for j in range(len(board[0])):
                print(i,j)
                if dfs(i,j,0):
                    return True
            
        return False

#13.py

# 地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

# 示例 1：
# 输入：m = 2, n = 3, k = 1
# 输出：3
# 示例 2：
# 输入：m = 3, n = 1, k = 0
# 输出：1
class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        def dfs(i, j, si, sj):
            if i>=m or j>=n or si+sj>k or (i,j) in visited:return 0
            visited.add((i,j))
            return 1+dfs(i+1,j,si+1 if (i+1)%10!=0 else si-8,sj)+dfs(i,j+1,si,sj+1 if (j+1)%10!=0 else sj-8)
        
        visited=set()
        return dfs(0,0,0,0)

#14_1.py

# 给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m-1] 。请问 k[0]*k[1]*...*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

# 示例 1：

# 输入: 2
# 输出: 1
# 解释: 2 = 1 + 1, 1 × 1 = 1
# 示例 2:

# 输入: 10
# 输出: 36
# 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
class Solution:
    def cuttingRope(self, n: int) -> int:
        if n<=3:
            return n-1
        div=n//3
        remain=n%3
        if remain==0:
            return 3**div
        if remain==1:
            return 3**(div-1)*4
        if remain==2:
            return 2*3**div

#17.py

# 输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

# 示例 1:

# 输入: n = 1
# 输出: [1,2,3,4,5,6,7,8,9]
class Solution:
    def printNumbers(self, n: int) -> List[int]:
        largest=9
        for i in range(1,n):
            largest=largest*10+9
        return [i for i in range(1,largest+1)]

#20.py

#请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100"、"5e2"、"-123"、"3.1416"、"-1E-16"、"0123"都表示数值，但"12e"、"1a3.14"、"1.2.3"、"+-5"及"12e+5.4"都不是。
class Solution:
    def isNumber(self, s: str) -> bool:

        state = [
            {},
            # 状态1,初始状态(扫描通过的空格)
            {"blank": 1, "sign": 2, "digit": 3, ".": 4},
            # 状态2,发现符号位(后面跟数字或者小数点)
            {"digit": 3, ".": 4},
            # 状态3,数字(一直循环到非数字)
            {"digit": 3, ".": 5, "e": 6, "blank": 9},
            # 状态4,小数点(后面只有紧接数字)
            {"digit": 5},
            # 状态5,小数点之后(后面只能为数字,e,或者以空格结束)
            {"digit": 5, "e": 6, "blank": 9},
            # 状态6,发现e(后面只能符号位, 和数字)
            {"sign": 7, "digit": 8},
            # 状态7,e之后(只能为数字)
            {"digit": 8},
            # 状态8,e之后的数字后面(只能为数字或者以空格结束)
            {"digit": 8, "blank": 9},
            # 状态9, 终止状态 (如果发现非空,就失败)
            {"blank": 9}
        ]
        cur_state = 1
        for c in s:
            if c.isdigit():
                c = "digit"
            elif c in " ":
                c = "blank"
            elif c in "+-":
                c = "sign"

            if c not in state[cur_state]:
                return False
            cur_state=state[cur_state][c]

        if cur_state not in [3,5,8,9]:
            return False
        return True

#29.py

# 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

#  

# 示例 1：

# 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
# 输出：[1,2,3,6,9,8,7,4,5]
# 示例 2：

# 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
# 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        res = []
        while matrix:
            res.extend(matrix.pop(0))
            matrix=list(zip(*matrix))[::-1]
        return res

#3.py

# jc3找出数组中重复的数字。
# 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
# 示例 1：
# 输入：
# [2, 3, 1, 0, 2, 5, 3]
# 输出：2 或 3  
# 限制：
# 2 <= n <= 100000
class Solution:
    def findRepeatNumber(self, nums: List[int]) -> int:
        c=Counter(nums)
        for k,v in c.items():
            if v>1:
                return k

#30.py

# 定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。
# 示例:

# MinStack minStack = new MinStack();
# minStack.push(-2);
# minStack.push(0);
# minStack.push(-3);
# minStack.min();   --> 返回 -3.
# minStack.pop();
# minStack.top();      --> 返回 0.
# minStack.min();   --> 返回 -2.
class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack=[]
        self.minstack=[]

    def push(self, x: int) -> None:
        self.stack.append(x)
        if not self.minstack or x<=self.minstack[-1]:
            self.minstack.append(x)

    def pop(self) -> None:
        x=self.stack.pop()
        if x==self.minstack[-1]:
            self.minstack.pop()     

    def top(self) -> int:
        return self.stack[-1]

    def min(self) -> int:
        return self.minstack[-1]

#31.py

# 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

# 示例 1：

# 输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
# 输出：true
# 解释：我们可以按以下顺序执行：
# push(1), push(2), push(3), push(4), pop() -> 4,
# push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
# 示例 2：

# 输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
# 输出：false
# 解释：1 不能在 2 之前弹出。
class Solution:
    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
        stack=[]
        p=0
        for item in pushed:
            stack.insert(0,item)
            while stack and popped[p]==stack[0]:
                p+=1
                stack.pop(0)
        
        return not stack

#38.py

# 输入一个字符串，打印出该字符串中字符的所有排列。
# 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
class Solution:
    def permutation(self, s: str) -> List[str]:
        s="".join(sorted(s))
        res=[]
        def dfs(s,tmp):
            if len(s)==0:
                res.append(tmp)
            for i in range(len(s)):
                if i-1>=0 and s[i]==s[i-1]:
                    continue
                else:
                    dfs(s[0:i]+s[i+1:],tmp+s[i])
        dfs(s,"")
        return res

#39.py

# 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
# 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
# 示例 1:
# 输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
# 输出: 2

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        nums.sort()
        return nums[len(nums)//2]

#40.py

# 输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
# 示例 1：
# 输入：arr = [3,2,1], k = 2
# 输出：[1,2] 或者 [2,1]
# 示例 2：
# 输入：arr = [0,1,2,1], k = 1
# 输出：[0]
class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        q=[]
        heapq.heapify(arr)
        for i in range(k):
            q.append(heapq.heappop(arr))
        res3=q
        return res3

#41.py

# 输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。

# 要求时间复杂度为O(n)。
# 示例1:

# 输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
# 输出: 6
# 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        dp=[0]*len(nums)
        dp[0]=nums[0]
        
        for i in range(1,len(nums)):
            dp[i]=max(dp[i-1]+nums[i],nums[i])
        return max(dp)

#46.py

# 给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

# 示例 1:

# 输入: 12258
# 输出: 5
# 解释: 12258有5种不同的翻译，分别是"bccfi", "bwfi", "bczi", "mcfi"和"mzi"
class Solution:
    def translateNum(self, num: int) -> int:
        s=str(num)
        res=1
        tmp=1
        for i in range(2,len(s)+1):
            if "10" <= s[i - 2:i] <= "25":
                c=res+tmp
            else:
                c=res
            tmp=res
            res=c

        return res

#49.py

# 我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。
# 示例:

# 输入: n = 10
# 输出: 12
# 解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。

class Solution:
    def nthUglyNumber(self, n: int) -> int:
        heap=[1]
        heapq.heapify(heap)
        i=0
        res=[]
        while i<n:
            cur=heapq.heappop(heap)
            if cur not in res:
                i+=1
                res.append(cur)
                for j in [2,3,5]:
                    
                    x=j*cur
                    heapq.heappush(heap,x)
        return res[-1]

#5.py

# 请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
# 示例 1：

# 输入：s = "We are happy."
# 输出："We%20are%20happy."

#50.py

# 在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。

# 示例:
# s = "abaccdeff"
# 返回 "b"
# s = "" 
# 返回 " "
class Solution:
    def firstUniqChar(self, s: str) -> str:
        c=Counter(s)
        uniqset=set()
        for k,v in c.items():
            if v==1:
                uniqset.add(k)
        for i in s:
            if i in uniqset:
                return i
        return " "

#51.py

# 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
# 示例 1:

# 输入: [7,5,6,4]
# 输出: 5
class Solution:
    def reversePairs(self, nums: List[int]) -> int:
        self.cnt=0
        def merge(nums,start,mid,end):
            tmp=[]
            i=start
            j=mid+1
            while i<=mid and j<=end:
                if nums[i]<=nums[j]:
                    tmp.append(nums[i])
                    i+=1
                else:
                    self.cnt+=mid-i+1
                    tmp.append(nums[j])
                    j+=1
            
            while i<=mid:
                tmp.append(nums[i])
                i+=1
            while j<=end:
                tmp.append(nums[j])
                j+=1
            for i in range(len(tmp)):
                nums[start+i]=tmp[i]

        def mergeSort(nums,start,end):
            if start>=end:return
            mid=(start+end)//2
            mergeSort(nums,start,mid)
            mergeSort(nums,mid+1,end)
            merge(nums,start,mid,end)

        mergeSort(nums,0,len(nums)-1)
        return self.cnt

#56.py

# 一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。
# 示例 1：
# 输入：nums = [4,1,4,6]
# 输出：[1,6] 或 [6,1]
# 示例 2：
# 输入：nums = [1,2,10,4,1,4,3,3]
# 输出：[2,10] 或 [10,2]
class Solution:
    def singleNumbers(self, nums: List[int]) -> List[int]:
        c=Counter(nums)
        res=[]
        for k,v in c.items():
            if v==1:
                res.append(k)
        return res

#56_2.py

# 一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。
# 示例 1：
# 输入：nums = [4,1,4,6]
# 输出：[1,6] 或 [6,1]
# 示例 2：
# 输入：nums = [1,2,10,4,1,4,3,3]
# 输出：[2,10] 或 [10,2]
class Solution:
    def singleNumbers(self, nums: List[int]) -> List[int]:
        c=Counter(nums)
        res=[]
        for k,v in c.items():
            if v==1:
                res.append(k)
        return res

#58.py

#输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. "，则输出"student. a am I"。
class Solution:
    def reverseWords(self, s: str) -> str:
        s=s.strip()
        s=s[::-1]
        res=""
        j=0
        for i in range(len(s)):
            if s[i]==' ' and s[i+1]!=' ':
                res+=s[j:i][::-1].strip()+' '
                j=i
        res+=s[j:][::-1].strip()
        return res

#58_2.py

# 字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

# 示例 1：

# 输入: s = "abcdefg", k = 2
# 输出: "cdefgab"
# 示例 2：

# 输入: s = "lrloseumgh", k = 6
# 输出: "umghlrlose"
class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        return s[n:]+s[:n]

#59.py

# 给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

# 示例:

# 输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
# 输出: [3,3,5,5,6,7] 
# 解释: 

#   滑动窗口的位置                最大值
# ---------------               -----
# [1  3  -1] -3  5  3  6  7       3
#  1 [3  -1  -3] 5  3  6  7       3
#  1  3 [-1  -3  5] 3  6  7       5
#  1  3  -1 [-3  5  3] 6  7       5
#  1  3  -1  -3 [5  3  6] 7       6
#  1  3  -1  -3  5 [3  6  7]      7
class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        q=[]
        res=[]
        for i in range(len(nums)):
            if i-k>=0 and nums[i-k]==q[0]:
                q.pop(0)

            while q and nums[i]>q[-1]:
                q.pop()
            q.append(nums[i])    

            print(q)
            if i>=k-1:
                res.append(q[0])
        return res

#59_2.py

# 请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

# 若队列为空，pop_front 和 max_value 需要返回 -1

# 示例 1：

# 输入: 
# ["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
# [[],[1],[2],[],[],[]]
# 输出: [null,null,null,2,1,2]
# 示例 2：

# 输入: 
# ["MaxQueue","pop_front","max_value"]
# [[],[],[]]
# 输出: [null,-1,-1]
class MaxQueue:

    def __init__(self):
        self.q=[]
        self.sort_q=[]


    def max_value(self) -> int:
        if self.q:
            return self.sort_q[0]
        else:
            return -1


    def push_back(self, value: int) -> None:
        self.q.append(value)
        
        while self.sort_q and self.sort_q[-1]<value:
            self.sort_q.pop(-1)
        self.sort_q.append(value)

    def pop_front(self) -> int:
        print(self.q,self.sort_q)
        if not self.q:
            return -1
        else:
            x=self.q.pop(0)
            if x==self.sort_q[0]:
                self.sort_q.pop(0)
        return x

#60.py

# 把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。
# 你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。
class Solution:
    def twoSum(self, n: int) -> List[float]:
        res=[]
        l1=[1/6]*6
        for i in range(1,n):
            tmp=[0]*(5*i+6)
            #l2=[1/6]*6
            for j in range(len(l1)):
                for k in range(6):
                    #print(len(tmp),j,k)
                    tmp[j+k]+=l1[j]*1/6
            l1=tmp
        return l1

#61.py

# 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。
# 示例 1:

# 输入: [1,2,3,4,5]
# 输出: True
#  

# 示例 2:

# 输入: [0,0,1,2,5]
# 输出: True
class Solution:
    def isStraight(self, nums: List[int]) -> bool:
        nums.sort()
        count=0
        # nums for i in nums
        for i in range(len(nums)-1):
            if nums[i]==0:
                count+=1
                continue
            elif nums[i]==nums[i+1]:
                return False
        if nums[-1]-nums[count]<5:
            return True
        else:    
            return False

#62.py

# 0,1,,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。

# 例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。
# 示例 1：

# 输入: n = 5, m = 3
# 输出: 3
# 示例 2：

# 输入: n = 10, m = 17
# 输出: 2
class Solution:
    def lastRemaining(self, n: int, m: int) -> int:
        q=[i for i in range(n)] 
        last=0
        while len(q)>1:
            index=(last+m-1)%len(q)
            q.pop(index)
            last=index
            
        return q[-1]

#63.py

# 假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？
# 示例 1:

# 输入: [7,1,5,3,6,4]
# 输出: 5
# 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
#      注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
# 示例 2:

# 输入: [7,6,4,3,1]
# 输出: 0
# 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        profit,temp=0,0

        for i in range(len(prices)-1):
            temp=max(0,temp+prices[i+1]-prices[i])
            profit=max(profit,temp)
        return profit

#64.py

# 求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

# 示例 1：

# 输入: n = 3
# 输出: 6
# 示例 2：

# 输入: n = 9
# 输出: 45
class Solution:
    def sumNums(self, n: int) -> int:
        
        return n and n+self.sumNums(n-1)

#65.py

# 写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。
# 示例:

# 输入: a = 1, b = 1
# 输出: 2
class Solution:
    def add(self, a: int, b: int) -> int:
        trans=0xffffffff
        a,b=a&trans,b&trans
        while b!=0:
            carry=(a&b)<<1
            a^=b
            b=carry&trans
        if a<=0x7FFFFFFF:return a
        else:
            return ~(a^trans)

#66.py

# 给定一个数组 A[0,1,…,n-1]，请构建一个数组 B[0,1,…,n-1]，其中 B 中的元素 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。不能使用除法。

#  

# 示例:

# 输入: [1,2,3,4,5]
# 输出: [120,60,40,30,24]
class Solution:
    def constructArr(self, a: List[int]) -> List[int]:
        if not a:return []
        left=[1]
        right=[1]
        for i in range(1,len(a)):
            left.append(left[-1]*a[i-1])
            right.insert(0,right[0]*a[len(a)-i])
        #print(right)
        res=[]
        for i in range(len(left)):
            res.append(left[i]*right[i])
        return res

#67.py

# 写一个函数 StrToInt，实现把字符串转换成整数这个功能。不能使用 atoi 或者其他类似的库函数。

# 首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。

# 当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。

# 该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。

# 注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。

# 在任何情况下，若函数不能进行有效的转换时，请返回 0。

# 说明：

# 假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231,  231 − 1]。如果数值超过这个范围，请返回  INT_MAX (231 − 1) 或 INT_MIN (−231) 。

# 示例 1:

# 输入: "42"
# 输出: 42
# 示例 2:

# 输入: "   -42"
# 输出: -42
# 解释: 第一个非空白字符为 '-', 它是一个负号。
#      我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。
# 示例 3:

# 输入: "4193 with words"
# 输出: 4193
# 解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。
# 示例 4:

# 输入: "words and 987"
# 输出: 0
# 解释: 第一个非空字符是 'w', 但它不是数字或正、负号。
#      因此无法执行有效的转换。
# 示例 5:

# 输入: "-91283472332"
# 输出: -2147483648
# 解释: 数字 "-91283472332" 超过 32 位有符号整数范围。 
#      因此返回 INT_MIN (−231) 。
class Solution:
    def strToInt(self, str: str) -> int:
        
        s=str.strip()
        if len(s)==0:return 0
        print(s)
        nums=0
        flag=True
        if s[0]=="-" and len(s[1:])>0:
            flag=False
            s=s[1:]
            print(s)
        elif s[0]=="+" and len(s[1:])>0:
            s=s[1:]
        print(s)
        for i in range(len(s)):
            if 0<=ord(s[i])-ord('0')<=9:
                nums=10*nums+ord(s[i])-ord('0')
            else:
                break
        if not flag:
            if nums<2**31:
                return -nums
            else:
                return -2**31
        else:
            if nums<2**31:
                return nums           
            else:
                return 2**31-1

#9.py

# 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )
# 示例 1：

# 输入：
# ["CQueue","appendTail","deleteHead","deleteHead"]
# [[],[3],[],[]]
# 输出：[null,null,3,-1]
# 示例 2：

# 输入：
# ["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
# [[],[],[5],[2],[],[]]
# 输出：[null,-1,null,null,5,2]
class CQueue:

    def __init__(self):
        self.a=[]
        #b是辅助栈
        self.b=[]


    def appendTail(self, value: int) -> None:
        while self.a:
            self.b.insert(0,self.a.pop(0))
        self.a.insert(0,value)
        while len(self.b):
            self.a.insert(0,self.b.pop(0))
        #print(self.a)


    def deleteHead(self) -> int:
        #print(self.a)
        if not self.a:return -1
        return self.a.pop(0)
剑指offer所有编程练习总结分析
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
07-25 172万+
给出剑指offer所有题目描述和对应的解题思路，并且在最有给出对应的代码展示和测试内容 由于牛客剑指Offer题目经过整理和筛选，是面试备考的经典资源之一，因此它的重要性在面试准备过程中是很高的。做这些题目可以帮助面试者熟悉常见的面试题型、巩固基础知识、提升编程能力，为应对面试提供了很好的准备。然而，还需注意不仅仅局限于做题，理解背后的原理和思想同样重要，以便能够在面试时灵活运用和展示自己的能力。
剑指offer-所有题目源代码下载
11-24
绝对物超所值，该压缩包包含了每一道题的详细代码，以及相关的测试函数。均可直接运行。 使用方法：解压缩，使用VS2012直接打开目录中的打开文件。所有题目的源码会一起加载进去。
剑指offer题目代码.rar
03-03
剑指offer例题代码 不想看书可以直接看代码 学完了找工作、机试、考研都不会有问题 剑指offer例题代码 不想看书可以直接看代码 学完了找工作、机试、考研都不会有问题 剑指offer例题代码 不想看书可以直接看代码 学完了找工作、机试、考研都不会有问题 剑指offer例题代码 不想看书可以直接看代码 学完了找工作、机试、考研都不会有问题剑指offer例题代码 不想看书可以直接看代码 学完了找工作、机试、考研都不会有问题
剑指offer源代码
09-02
剑指offer全部源代码，代码全部有Java编写 ，包括目录
剑指offer代码下
dataastron的博客
08-17 178
#40.py # 输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。 # 示例 1： # 输入：arr = [3,2,1], k = 2 # 输出：[1,2] 或者 [2,1] # 示例 2： # 输入：arr = [0,1,2,1], k = 1 # 输出：[0] class Solution: def getLeastNumbers(self, arr: List[int], k: int) -> Lis
剑指offer_Go版
蒟蒻的最后的倔强
11-13 1286
剑指offer_Go版 前言 要工作了 大概率是写Go 我记得今年3 4 月份就想着搞个go版剑指offer一直拖到现在 仅仅go语法基础 还是几个月前学的 现在回顾下 要写好久可能 慢慢更 剑指 Offer 03. 数组中重复的数字 func findRepeatNumber(nums []int) int { for i, num := range nums { if i == num { continue } if num
剑指offer_抽象建模能力
xywams的博客
08-09 869
本来以为该题和“CCF201712-2 游戏”这个题目时一样的原理，但仔细看是不一样的。该题是每次淘汰之后，重新从0开始记数到m个数淘汰它，而后者报数一直增加，遇到k的倍数或者个位数为k则淘汰。...
牛客网剑指Offer_66道python（更新中）
uestcwm的博客
06-05 1216
牛客网剑指Offer_编程题导语1 Fibonacci数列及其应用(考察：递归与循环）2 数组3 查找与排序4功能快捷键5合理的创建标题，有助于目录的生成6如何改变文本的样式7插入链接与图片8如何插入一段漂亮的代码片9生成一个适合你的列表10创建一个表格11设定内容居中、居左、居右12SmartyPants13创建一个自定义列表14如何创建一个注脚15注释也是必不可少的16KaTeX数学公式...
leetcode_剑指offer_57
qq_37976683的博客
12-20 625
本题时间复杂度没有优化到最好，只能算通过，如果直接进行两重for循环，时间复杂度较高。 首先将每一个vector中的数进行遍历，使用target做差之后，再在剩下的数据中进行二分查找,时间复杂度为O(nlog(n))。 代码如下： vector<int>twoSum(vector<int>&nums,inttarget){ vector<int>result; for(inti=0;i<nums....
python程序员面试宝典 剑指offer_面试必刷-《剑指offer》刷题小结
weixin_39712724的博客
11-24 335
目录写在前面正文数据结构类题目具体算法类题目组队学习写在前面面试季来了，不管是作为面试者还是以后作为面试官，了解算法这门程序员之间的沟通方式都是非常必要的。找过工作的朋友应该都听说过《剑指offer》，本文主要对我这些天刷过的《剑指offer》做个简单的分类小结，方便后面专项复(练)习~正文笔者是NLP方向，这两篇相关方向的面经写得很不错：如果您是高分段选手，看完觉得不用刷题，请点(x)然后私信我...
Heitao5200#CodeForOffer#剑指offer_第十六题_合并两个排序的链表1
07-25
1.对两个链表，比较它们的头节点，头节点小的即为合并之链表后的头节点 2.对与剩下的链表，比较他们的头节点，然后将头节点小的与之前合并链表的尾部连接起来 3.重
《剑指Offer》题目及代码.zip
06-28
《剑指Offer》 1. 赋值运算函数 2. 单例设计模式 3. 二维数组中查找目标值 4. 替换字符串中的空格 5. 从尾到头打印链表 6. 由前序和中序遍历重建二叉树 7. 用两个栈实现队列 8. 求旋转数组的最小数字 9. ...
《剑指Offer》题目及代码.pdf
05-31
《剑指Offer》是一本广受欢迎的算法面试书籍，主要针对中国的IT面试市场。该书中包含了大量面试题以及针对这些题目的解题思路和代码实现。本书涵盖的知识点广泛，难度从基础到进阶不等，非常适合准备面试和提高编程...
剑指offer_递归和循环
u012597288的博客
06-05 235
斐波那契数列 题目描述 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。n&lt;=39 代码 public class Solution { public int Fibonacci(int n) { if(n == 0 ){ return 0; }else if(n == ...
剑指offer_28 java
weixin_41935211的博客
08-11 236
剑指offer_28 题目描述 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。 题解 参考地址 https://blog.nowcoder.net/n/e4290272e9ba42aa96cfd012e17e4c25?f=comment 这道题，最直白的解法是使用一个 map 来记录各个数字出现的次数，最后取出现次数最多的作为解。但这个方法需要消
牛客 剑指offer_编程题 详细题解 （已完结）
weixin_44211980的博客
01-31 4814
文章目录剑指offer_编程题【1.二维数组中的查找】【2.替换空格】C++JAVA【3.从尾到头打印链表】【4.重建二叉树】【5.用两个栈实现队列】【6.旋转数组的最小数字】暴力Sort二分法【7.斐波那契数列】【8.跳台阶】【9.变态跳台阶】 剑指offer_编程题 【1.二维数组中的查找】 【题目描述】 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都...
剑指Offer完整源代码链接
ly969434341的专栏
09-27 6433
https://github.com/zhedahht/ChineseCodingInterviewAppendix/blob/master/DeleteDuplicatedListNode/DeleteDuplication.cpp
《剑指Offer》精华思路总结：42道经典算法题
"《剑指offer》思路汇总---简化版的原书思路共42页，涵盖了数组、字符串、链表、树与二叉树、栈和队列、递归与循环六大主题的算法题目及解题思路，旨在帮助求职者准备面试和提升编程能力。" 这篇文档是《剑指Offer...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值