Go最新《剑指offer》详解-Python(3)，2024年最新不同层级的Golang开发者的不同行为

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

)

O(n)

O(n) | 模拟这个过程 | Done |
| 47.求1+2+3+…+n | Easy |

O

(

n

)

O(n)

O(n) | 利用and实现递归终止 | Done |
| 48.不用加减乘除做加法 | Medium |

O

(

1

)

O(1)

O(1) | 利用位运算来实现 | ToDO |
| 49.把字符串转换成整数 | Easy |

O

(

n

)

O(n)

O(n) | 主要是负数和特殊情况 | Done |
| 50.数组中重复的数字 | Easy |

O

(

n

)

O(n)

O(n) | 哈希表保存次数然后输出 | Done |
| 51.构建乘积数组 | Medium |

O

(

n

)

O(n)

O(n) | 正反向遍历，依次保存之前的乘积值 | Done |
| 53.表示数值的字符串 | Easy |

O

(

1

)

O(1)

O(1) | 作弊式操作float | Done |
| 矩阵中路径 | Medium | 回溯法，关键是如何写递归 | | |

1.二维数组中的查找

Q: 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

A1： 遍历整个二维数组，

O

(

n

2

)

O(n^2)

O(n2)

A2: 从右上或者左下开始查找。从右上开始查找：如果数组中的数比这个整数大，向左移动一位，如果数组中的数比这个数小，向下移动一位，

O

(

n

)

O(n)

O(n)。

class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        if array == []:
            return False
        num_row = len(array)
        num_col = len(array[0])
        i,j = 0, num_col-1
        while j >= 0 and i < num_row:
            if array[i][j] > target:
                j -= 1
            elif array[i][j] < target:
                i += 1
            else:
                return True

2.替换空格

Q: 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

A1： 先计算最终需要给出的长度，然后建立两个指针p1,p2，p1指向原始字符串的末尾，p2指向替换后的字符串的末尾。同时移动p1,p2, 将p1指的内容逐个复制到p2, 当p1遇到空格时，在p2处插入 %20， p1向前移动一个位置，p2向前移动3个位置，当p1和p2位置重合时，全部替换完成。

# 30ms
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        if not isinstance(s, str) or len(s) <= 0 or s == None:
            return ''
        spaceNum = 0
        for i in s:
            if i == " ":
                spaceNum += 1
        
        newStrLen = len(s) + spaceNum \* 2
        newStr = newStrLen \* [None]
        indexOfOriginal, indexOfNew = len(s) - 1, newStrLen - 1
        while indexOfNew >= 0 and indexOfOriginal <= indexOfNew:
            if s[indexOfOriginal] == ' ':
                newStr[indexOfNew - 2: indexOfNew + 1] = ['%', '2', '0']
                indexOfNew -= 3
                indexOfOriginal -= 1
            else: 
                newStr[indexOfNew] = s[indexOfOriginal]
                indexOfNew -= 1
                indexOfOriginal -= 1
        return ''.join(newStr)

A2： python中可以利用append() [O(1)]，新建list，一次遍历，碰到空格就添加 %20，否则就添加原始字符串s内容。

# 27ms
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        if not isinstance(s, str) or len(s) <= 0 or s == None:
            return ''
        result = []
        for char in s:
            if char == ' ':
                result.append('%20')
            else:
                result.append(char)
        return ''.join(result)

    def replaceSpace(self, s):
        # write code here
        result = ''
        for char in s:
            if char == ' ':
                result += '%20'
            else:
                result += char
        return result

3.从尾到头打印链表arrayList：

遍历链表，保存在list中，然后倒序输出.

# 运行时间：24ms
# 占用内存：5752k
class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if listNode == None:
            return []
        result = []
        while listNode != None:
            result.append(listNode.val)
            listNode = listNode.next
        return result[::-1]

同样使用list，但是将其插入在list的0位置处。

# 运行时间：23ms
# 占用内存：5728k
class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if not listNode:
            return []
        
        result =[]
        
        while listNode:
            result.insert(0, listNode.val)
            listNode = listNode.next
        return result

4.两个栈实现一个队列：

stack2作为中转stack，直接对stack1做push，pop的时候将stack1的pop到stack2中，便可以实现。stack：先入后出，queue：后入先出。

# 运行时间：25ms
# 占用内存：5724k
# -\*- coding:utf-8 -\*-
class Solution:
    def \_\_init\_\_(self):
        self.stack1 = []
        self.stack2 = []
        
    def push(self, node):
        # write code here
        self.stack1.append(node)
        
    def pop(self):
        # return xx
        if len(self.stack1) == 0 and len(self.stack2) == 0:
            return 
        if len(self.stack2) == 0:
            while len(self.stack1) != 0:
                self.stack2.append(self.stack1.pop())
        return self.stack2.pop()

6.旋转数组的最小数字

Q: 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

A1: 遍历数组；
A2: 二分查找的变形，旋转数组的首元素肯定不小于旋转数组的尾元素，找一个中间点，如果中间点比首元素大，说明最小数字在中间点后面，如果中间点比尾元素小，说明最小数字在中间点前面。然后循环。 但是在一次循环中，首元素小于尾元素，说明该数组是排序的，首元素就是最小数字，如果出现首元素、尾元素、中间值三者相等，则只能在此区域中顺序查找。

# -\*- coding:utf-8 -\*-

class Solution:
# 运行时间：1127ms
# 占用内存：5864k
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        if len(rotateArray) == 0:
            return 0
        result = rotateArray[0]
        for num in rotateArray:
            if num < result:
                result = num
        return result

class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        if len(rotateArray) == 0:
            return 0
        left,right = 0,len(rotateArray)-1

        if rotateArray[left] < rotateArray[right]:
            return rotateArray[left]
        else:
            while (right - left) > 1:
                middle = (left+right)//2
                if rotateArray[middle] <= rotateArray[right]:
                    right = middle
                elif rotateArray[middle] >= rotateArray[left]:
                    left = middle
                elif rotateArray[middle] == rotateArray[right] == rotateArray[left]:
                    minval = rotateArray[0] 
                    for num in rotateArray:
                        minval = min(minval, num)
                    return minval
        return rotateArray[right]

7.斐波那契数列

class Solution:
    def Fibonacci(self, n):
        # write code here
        num1 = 0
        num2 = 1
        target = 0
        for i in range(1, n+1):
            num1 = num2
            num2 = target
            target = num1 + num2
        return target

8.跳台阶：

和第七题类似，跳第n阶有两种情况，由倒数第二阶直接跳到第n阶，倒数第一阶直接跳到第n阶。

# -\*- coding:utf-8 -\*-
class Solution:
    def jumpFloor(self, number):
        # write code here
        if number == 1:
            return 1
        elif number == 2:
            return 2
        num1 = 1
        num2 = 2
        target = num1 + num2
        for i in range(2, number-1):
            num1 = num2
            num2 = target
            target = num1 + num2
        return target

9.变态跳台阶：

通过归纳法得出规律，然后直接由公式求解。

# -\*- coding:utf-8 -\*-
class Solution:
    def jumpFloorII(self, number):
        # write code here
        return 2\*\*(number - 1)

10矩形覆盖：

# -\*- coding:utf-8 -\*-
class Solution:
    def rectCover(self, number):
        # write code here
        if number == 1:
            return 1
        elif number == 2:
            return 2
        elif number == 0:
            return 0
        num1 = 1
        num2 = 2
        target = num1 + num2
        for i in range(2, number-1):
            num1 = num2
            num2 = target
            target = num1 + num2
        return target

11. 二进制中1的个数：

将

n

n

n和

n

−

1

n-1

n−1按位做与运算，会将最右边的1设置为0。n不为0一直统计统计个数。

# -\*- coding:utf-8 -\*-
class Solution:
# 运行时间：27ms
# 占用内存：5728k
    def NumberOf1(self, n):
        # write code here
        count = 0
        if n < 0:
            n = n & 0xffffffff
        while n!= 0:
            count += 1
            n = (n-1)& n
        return count

12.数值的整数次方

通过递归求解，如果幂次是偶数，直接除以2，如果是奇数，提取一个base后除以2。举例发现规律。注意点：幂次是否小于0，奇偶幂次的区分，幂次为0和1

# -\*- coding:utf-8 -\*-
class Solution:
# 运行时间：23ms
# 占用内存：5624k
    def Power(self, base, exponent):
        # write code here
        try:
            if exponent >= 0:
                return self.Power_value(base, exponent)
            else:
                return 1/self.Power_value(base, abs(exponent))
        except:
            print('base == zero')

    def Power\_value(self, base, exponent):
        if exponent == 1:
            return base
        elif exponent == 0:
            return 1
        if exponent%2 == 0:
            return self.Power(base, exponent>>1)\*\*2
        else:
            return base\*self.Power(base, exponent>>1)\*\*2

采用位运算可以加快速度，除以2可以通过向右移1位来实现，判断奇偶可以通过与1按位与来实现。

13.调整数组顺序使奇数位于偶数前面

python使用lambda解决。

class Solution:
# 运行时间：28ms
# 占用内存：5752k
    def reOrderArray(self, array):
        # write code here
        return sorted(array,key=lambda c:c%2,reverse=True)

14.链表中倒数第k个结点：

Q: 输入一个链表，输出该链表中倒数第k个结点。

A: 设置两个指针指向头节点，第一个指针向前走k-1步，走到第k个结点，此时，第二个指针和第一个指针同时移动，当第一个指针到尾节点的时候，第二个指针指向倒数第k个结点，注意链表为空，k为0，k大于链表的长度的情况.

# 27ms
class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        if head == None or k <= 0:
            return None
        
        pointA = head
        pointB = None

        for i in range(k-1):
            if pointA.next != None:
                pointA = pointA.next
            else:
                return None
        
        pointB = head
        while pointA.next != None:
            pointA = pointA.next
            pointB = pointB.next

        return pointB

15.反转链表：

Q: 输入一个链表，反转链表后，输出新链表的表头。

A: 主要注意当头结点为空或者整个链表只有一个结点时，翻转后的链表断裂，返回的翻转之后的头节点不是原来的尾节点。所以需要一个翻转后的头节点，一个指向当前结点的指针，两个分别指向当前结点的前后结点的指针，防止断裂。也可以使用递归。

class Solution:
# 35ms
    def ReverseList(self, pHead):
        # write code here
        res = None
        while pHead:
            res,res.next,pHead = pHead,res,pHead.next
        return res

16.合并两个排序的链表：

Q: 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

A1递归: 比较头节点大小，小的作为合并后链表的头节点，再比较剩余部分和另一个链表的头节点，取小的，然后一直递归此过程。

class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
        if pHead1 == None:
            return pHead2
        if pHead2 == None:
            return pHead1
        
        pMergeHead = None
        if pHead1.val < pHead2.val:
            pMergeHead = pHead1
            pMergeHead.next = self.Merge(pHead1.next, pHead2)
        else:
            pMergeHead = pHead2
            pMergeHead.next = self.Merge(pHead1, pHead2.next)
        return pMergeHead

17.树的子结构：

# -\*- coding:utf-8 -\*-
# class TreeNode:
# def \_\_init\_\_(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        result = False
        if pRoot1 != None and pRoot2 != None:
            if pRoot1.val == pRoot2.val:
                result = self.DoesTree1haveTree2(pRoot1, pRoot2)
            
            if not result:
                result = self.DoesTree1haveTree2(pRoot1.left, pRoot2)
            
            if not result:
                result = self.DoesTree1haveTree2(pRoot1.right, pRoot2)
        
        return result

    def DoesTree1haveTree2(self, pRoot1, pRoot2):
        if pRoot2 == None:
            return True
        if pRoot1 == None:
            return False
        if pRoot1.val != pRoot2.val:
            return False

        return self.DoesTree1haveTree2(pRoot1.left, pRoot2.left) & self.DoesTree1haveTree2(pRoot1.right, pRoot2.right)

18.二叉树的镜像：

class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if root == None:
            return None
        if root.left == None and root.right == None:
            return root

        temp = root.left
        root.left = root.right
        root.right = temp

        self.Mirror(root.left)
        self.Mirror(root.right)

20.包含min函数的栈：

求得栈的最小值，时间复杂度是

O

(

1

)

O(1)

O(1)。建立一个辅助栈，每增加一个数，保存目前所有数的最小值在辅助栈的栈顶。

class Solution:
# 运行时间：23ms
# 占用内存：5752k
    def \_\_init\_\_(self):
        self.stack = []
        self.minStack = []
        
    def push(self, node):
        # write code here
        self.stack.append(node)
        if self.minStack == [] or node < self.min():
            self.minStack.append(node)
        else:
            temp = self.min()
            self.minStack.append(temp)
        
    def pop(self):
        # write code here
        if self.stack == None or self.minStack == None:
            return None
        self.minStack.pop()
        self.stack.pop()
        
    def top(self):
        # write code here
        return self.stack[-1]
        
    def min(self):
        # write code here
        return self.minStack[-1]

28.数组中出现次数超过一半的数字：

暴力做法，保存每一个数出现的次数，然后判断每一个数的次数是否超过一半。

# 运行时间：28ms
# 占用内存：5860k
class Solution:
    def MoreThanHalfNum\_Solution(self, numbers):
        # write code here

        num_dict = {}
        lenght = len(numbers)
        result = 0
        for num in numbers:
            try:
                num_dict[num] = num_dict[num] + 1
            except:
                num_dict[num] = 1

        for key, values in num_dict.items():
            if values > lenght//2:
                result = key

        return result

如果这个数存在那么一定在数组的中间，提取数组中间这个数，然后统计其出现的次数，判断是否超过一半：

class Solution:
# 运行时间：28ms
#占用内存：5744k
    def MoreThanHalfNum\_Solution(self, numbers):
        # write code here

        numbers = sorted(numbers)
        middle = len(numbers)//2
        left = right = middle
        middle_num = numbers[middle]
        print(numbers)
        while left >= 0 and right < len(numbers):
            if numbers[left] != middle_num and numbers[right] != middle_num:
                break
            print(left,right)
            if numbers[left] == middle_num:
                left -= 1
            if numbers[right] == middle_num:
                right += 1


        if right - left-1 > len(numbers)//2:
            return middle_num
        else:
            return 0

29.最小的k个数：

排序然后取前k个：

# 运行时间：29ms
# 占用内存：5624k
# -\*- coding:utf-8 -\*-
class Solution:
    def GetLeastNumbers\_Solution(self, tinput, k):
        # write code here
        if k > len(tinput):
            return []
        tinput = sorted(tinput)
        return tinput[:k]

保存前k个值在result中，依次遍历后续n-k个值，如果出现数小于result的最大值，替换这个最大值。

# -\*- coding:utf-8 -\*-
# 时间：24ms
# 占用内存：5728k
class Solution:
    def GetLeastNumbers\_Solution(self, tinput, k):
        # write code here
        if k > len(tinput) or k == 0:
            return []
        result = tinput[:k]
        for num in tinput[k:]:
            temp_max = max(result)
            if num < temp_max:
                result.remove(temp_max)
                result.append(num)
        return sorted(result)

30.连续子数组的和：

遍历所有子数组，然后比较大小。

class Solution:
# 运行时间：20ms
# 占用内存：5732k
    def FindGreatestSumOfSubArray(self, array):
        # write code here
        maxsum = -1e19
        for i in range(len(array)-1):
            for j in range(i+1, len(array)+1):
                maxsum = max(maxsum, sum(array[i:j]))
        return maxsum

31.整数中1出现的次数：

遍历1：n，然后求每个数中1的个数，对10取余得到个位数，然后依次除以10。

# -\*- coding:utf-8 -\*-
class Solution:
    def NumberOf1Between1AndN\_Solution(self, n):
        result = 0
        for num in range(1,n+1):
            while num != 0:
                if num%10 == 1:
                    result += 1
                num = num//10
        return result

数学规律法，相对简单但是一般很难想到。

class Solution:
    def NumberOf1Between1AndN\_Solution(self, n):
        # write code here
        count, m =0, 1
        while m <= n:
            count += (n // m + 8) // 10 \* m + (n // m % 10 == 1) \* (n % m + 1)
            m\*=10
        return count

32.把数组排成最小的数：

对数组内的数字两两比较，寻找str1str2，和str2str1两种组合中较小的一个。两两较小，最后得到的即最小。

# -\*- coding:utf-8 -\*-
# 运行时间：20ms
# 占用内存：5856k
class Solution:
    def PrintMinNumber(self, numbers):
        # write code hereu
        if not numbers:
            return ''
        numbers = [str(num) for num in numbers]
        for i in range(len(numbers)-1):
            for j in range(i+1, len(numbers)):
                if numbers[j] + numbers[i] < numbers[i] + numbers[j]:
                    numbers[i],numbers[j] = numbers[j],numbers[i]
        return ''.join(numbers)

33.丑数：

生成第K个丑数（质因子只有2,3,5）。建立一个set，从1开始，依次保存和1,2,3分别相乘后值，取较小的值作为下一个丑数，同时从set中去掉已经作为丑数的这个数。

# -\*- coding:utf-8 -\*-
class Solution:
# 运行时间：28ms
# 占用内存：5856k
    def GetUglyNumber\_Solution(self, index):
        # write code here
        if index == 0:
            return 0
        count = 1
        result = 1
        ugly_list = set()
        while count < index:
            ugly_list.add(2\*result)
            ugly_list.add(3\*result)
            ugly_list.add(5\*result)
            result = min(ugly_list)
            ugly_list.remove(result)
            count += 1
        return result

34.第一个只出现一次的字符：

统计每个字符出现的次数，保存在字典中。然后再次遍历字符串，获取每个字符的次数，如果为1，直接输出。

# -\*- coding:utf-8 -\*-
class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        char_count = {}
        for char in s:
            try:
                char_count[char] += 1
            except:
                char_count[char] = 1
        for char in s:
            if char_count[char] == 1:
                return s.index(char)
        return -1

35.数组中的逆序对

直接暴力法，双指针，判断当前指针的数是否大于第二个指针的数字。

class Solution:
    def InversePairs(self, data):
        # write code here
        length = len(data)
        count = 0
        for i in range(length-1):
            for j in range(i+1, length):
                if data[i] > data[j]:
                    count += 1
        return count%1000000007

将原数组排序，然后从小到大遍历排序数组，求这个数在原数组中的index，这个index就代表有多少个数字在该数的前面。

class Solution:
    def InversePairs(self, data):
        # write code here
        data2 = sorted(data)
        length = len(data)
        count = 0
        for num in data2:
            count += data.index(num)
            data.remove(num)
        return count%1000000007

37.数字在排序数组中出现的次数：

直接遍历然后求和

运行时间：31ms
占用内存：5712k
# -\*- coding:utf-8 -\*-
class Solution:
    def GetNumberOfK(self, data, k):
        # write code here
        count = 0
        for num in data:
            if num == k:
                count += 1
        return count

采用二分查找，通过二分查找依次找到左边，右边和k相等的起始点。

# -\*- coding:utf-8 -\*-
class Solution:
# 运行时间：23ms
# 占用内存：5752k
    def GetNumberOfK(self, data, k):
        # write code here
        if not data:
            return 0
        if self.GetLastK(data, k) == -1 and self.GetFirstK(data, k) == -1:
            return 0
        return self.GetLastK(data, k) - self.GetFirstK(data, k) + 1
        

    def GetFirstK(self, data, k):
        low = 0
        high = len(data) - 1
        while low <= high:
            mid = (low + high) // 2
            if data[mid] < k:
                low = mid + 1
            elif data[mid] == k and (mid == low or data[mid-1]!=k):
                return mid
            else:
                high = mid - 1
        return -1

    def GetLastK(self, data, k):
        low = 0
        high = len(data) - 1
        while low <= high:
            mid = (low + high) // 2
            if data[mid] > k:
                high = mid - 1
            elif data[mid] == k and (mid == high or data[mid+1]!=k):
                return mid
            else:
                low = mid + 1
        return -1

40.数组中只出现一次的数字:

建立一个Hash表保存每个数出现的次数，然后遍历Hash表输出只出现一次的那个数。

# 运行时间：26ms
# 占用内存：5752k
# -\*- coding:utf-8 -\*-
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        num_count = {}
        result = []
        for num in array:
            num_count[num] = num_count.get(num,0) + 1
        for key,value in num_count.items():
            if value == 1:
                result.append(key)
        return result

采用异或操作，如果两个数相同，那么他们异或是0，不同则非0。有两个只出现一次的数，后面还要判断有点麻烦，如果是只有一个数出现一次，判断起来会相对比较简单。

41.和为s的连续正数序列：

双指针，如果和大于tsum，那么减去最小的值，同时最小值index+1。如果和小于tsum，最大值的index+1，然后增加新的最大值。

# 运行时间：26ms
# 占用内存：5852k
# -\*- coding:utf-8 -\*-
class Solution:
    def FindContinuousSequence(self, tsum):
        # write code here
        small, big,res = 1, 2, []
        csum = small + big
        while small < big:
            if csum > tsum:
                csum -= small
                small += 1
            elif csum == tsum:
                res.append([i for i in range(small,big+1)])
                big += 1
                csum += big
            else:
                big += 1
                csum += big
        return res

42.和为s的两个数字

双指针，分别从头和尾开始，如果两个数的和小于S，left+=1，大于S，right-=1。

class Solution:
# 运行时间：36ms
# 占用内存：5740k
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        if not array or not tsum:
            return []
        start = 0
        end = len(array) - 1
        while start < end:
            csum = array[start] + array[end]
            if csum < tsum:
                start += 1
            elif csum > tsum:
                end -= 1
            else:
                return [array[start],array[end]]
        return []

43.左旋转字符串

2333这题目逆天吧，前面的提出贴在后面不就好了吗。

class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        return s[n:]+ s[:n]

44.翻转单词顺序列：

翻转组合即可，list.reverse()的复杂度是

O

(

n

)

O(n)

O(n).

# 运行时间：30ms
# 占用内存：5708k
# -\*- coding:utf-8 -\*-
class Solution:
    def ReverseSentence(self, s):
        # write code here
        s = s.split(' ')
        s.reverse()
        return ' '.join(s)

45.扑克牌顺子：

替换，然后统计gap的次数，如果存在gap，比较大小王的个数，是否大于gap的个数。注意两个数字相等的情况。

# 运行时间：37ms
# 占用内存：5624k
# -\*- coding:utf-8 -\*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if not numbers or len(numbers) == 0:
            return False
        transdict = {'A':1,'J':11,'Q':12,'K':13}
        numbers = [transdict[num] if num in transdict else num for num in numbers]
        numbers = sorted(numbers)
        count_wang = 0
        while numbers[count_wang] == 0:
            count_wang += 1
        gap = 0
        for i in range(count_wang,len(numbers)-1):
            if numbers[i+1] == numbers[i]:
                return False
            gap += numbers[i+1] - numbers[i]-1
        
        return True if count_wang >= gap else False   

46.孩子们的游戏(圆圈中最后剩下的数)

约瑟夫环问题，可以直接进行模拟，也就是模拟去掉人的过程，直到最后只剩下一个人。注意起点和被去掉的人，循环一圈后如何表达。(start+m-1)%n，n为当时圆圈内的人数，没去掉一个人，n-1.

# 运行时间：22ms
# 占用内存：5860k
# -\*- coding:utf-8 -\*-
class Solution:
    def LastRemaining\_Solution(self, n, m):
        if n < 1 or m < 1:
            return -1
        start = 0
        circle = range(n)
        while circle:
            index = (start+m-1)%n
            end = circle.pop(index)
            start = index
            n -= 1
        return end

47.求1+2+3+…+n:

问题奇葩，直接抛开限制，各种答案比较下：

# 运行时间：22ms
# 占用内存：5724k
def Sum\_Solution(self, n):
    return sum(range(1,n+1))

利用and来实现递归的终止，因为不能使用if else来确定终止条件，所以使用and语句。任何数和0与是0(False)。

# 运行时间：20ms
# 占用内存：5864k
def Sum\_Solution(self, n):
    return n and self.Sum_Solution(n - 1) + n

48.不用加减乘除做加法

通过位运算来实现。

class Solution:
    def Add(self, num1, num2):
        # write code here
        while num2 != 0:
            temp = num1 ^ num2
            num2 = (num1 & num2) << 1
            num1 = temp & 0xFFFFFFFF
        return num1 if num1 >> 31 == 0 else num1 - 4294967296

49.把字符串转换成整数

直接利用int操作。

class Solution:
    def StrToInt(self, s):
        try:
            return int(s)
        except:
            return 0

不用内部函数来实现：

# 运行时间：21ms
# 占用内存：5732k
# -\*- coding:utf-8 -\*-
class Solution:
    def StrToInt(self, s):
        if not s or len(s) < 1:
            return 0
        numdict = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
        result = 0
        nums = []
        for char in s:
            if char == '+' or char == '-':
                continue
            elif char in numdict:
                nums.append(numdict[char])
            else:
                return 0
        # 由list得到数值，这个写法要会
        for i in nums:
            result = result\*10 + i
        return -1\*result if s[0] == '-' else result

50.数组中重复的数字

保存哈希表，然后再遍历依次即可。哈希表的查找时间是

O

(

1

)

O(1)

O(1).

# -\*- coding:utf-8 -\*-
class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        count_dict = {}
        for num in numbers:
            count_dict[num] = count_dict.get(num,0) + 1
        for num in numbers:
            if count_dict[num] > 1:
                duplication[0] = num
                return True
        return False


![img](https://img-blog.csdnimg.cn/img_convert/eba69efa330ac7e009857ffd7467dd2f.png)
![img](https://img-blog.csdnimg.cn/img_convert/2c71896b0af6ef00e896e28f4ea9bbbb.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

oding:utf-8 -\*-
class Solution:
    def StrToInt(self, s):
        if not s or len(s) < 1:
            return 0
        numdict = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
        result = 0
        nums = []
        for char in s:
            if char == '+' or char == '-':
                continue
            elif char in numdict:
                nums.append(numdict[char])
            else:
                return 0
        # 由list得到数值，这个写法要会
        for i in nums:
            result = result\*10 + i
        return -1\*result if s[0] == '-' else result

50.数组中重复的数字

保存哈希表，然后再遍历依次即可。哈希表的查找时间是

O

(

1

)

O(1)

O(1).

# -\*- coding:utf-8 -\*-
class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        count_dict = {}
        for num in numbers:
            count_dict[num] = count_dict.get(num,0) + 1
        for num in numbers:
            if count_dict[num] > 1:
                duplication[0] = num
                return True
        return False


[外链图片转存中...(img-W1Df2qIY-1715888820984)]
[外链图片转存中...(img-cSOvcVGQ-1715888820985)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**