编程能力提升_3

最新推荐文章于 2020-09-03 23:45:38 发布

manjhOK

最新推荐文章于 2020-09-03 23:45:38 发布

阅读量343

点赞数

分类专栏：算法笔试 python 算法每日提升

本文链接：https://blog.csdn.net/manjhok/article/details/88654033

版权

算法笔试同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

python 算法每日提升

12 篇文章 1 订阅

订阅专栏

1.给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

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

3.给定两个二进制字符串，返回他们的和（用二进制表示）。

4.实现 int sqrt(int x) 函数。

5.假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

6.给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

7.给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

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:
        #从nums的首元素开始加和，如果前面的子串的加和大于0，则保留该子串，
        #如果小于零则子串作废
        maxstr=nums[0]
        thepart=0
        for i in range(len(nums)): 
            #将thepart与当前数据加和，如果小于零，则thepart作废
            thepart+=nums[i]
            # maxstr每次都能替换保存最大子串的加和
            if thepart>maxstr:
                maxstr=thepart
            #thepart的判断，如果小于0则置0
            if thepart<0:
                thepart=0                
        return maxstr

方法二：

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
         """
        for i in range(1, len(nums)):
            nums[i]= nums[i] + max(nums[i-1], 0)
        return max(nums)

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

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

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

示例 1:

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

class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        strs=[str(x) for x in digits]
        thenum=int(''.join(strs))+1
        return [int(x) for x in str(thenum)]

3.给定两个二进制字符串，返回他们的和（用二进制表示）。

输入为非空字符串且只包含数字 1 和 0。

示例 1:

输入: a = "11", b = "1"
输出: "100"

方法一：

class Solution(object):
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        #将二进制字符串a转换成int10进制数
        #int函数将第一个参数转换成10进制，其第二个参数来说明第一个参数的进制数
        a10=int(a,2)#即将二进制的字符串a转换成10进制数
        b10=int(b,2)
        retr=a10+b10
        #bin()函数将10进制数转换成2进制数，字符串的形式
        #其前两位为0b,可以切片的方式去除
        return bin(retr)[2:]

方法二：

class Solution(object):          
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        lena = len(a)
        lenb = len(b)

        a = a[::-1]
        b = b[::-1]
        l = max(lena,lenb)

        ans = ''
        carry = 0
        for i in range(l):
            if i >= lena:
                sum = int(b[i])+carry
            elif i >= lenb:
                sum = int(a[i])+carry
            else:
                sum = int(a[i])+int(b[i])+carry
            #在sum=0,1时，不进位，在sum=2,3时，需要进位
            #2,3时进位1，其自身变为0,1，所以用sum模2
            carry = sum//2
            ans += str(sum%2)
        if carry == 1:
            ans += '1'
        ans = ans[::-1]
        return ans

4.实现 `int sqrt(int x)` 函数。

计算并返回 x 的平方根，其中 x 是非负整数。由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2

class Solution:
    def mySqrt(self, x: int) -> int:
        if x<1:
            return 0
        sq=x       
        while sq > x/sq :
            sq=(sq+x/sq)//2
        return int(sq)

5.假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

方法一：

class Solution:
    def climbStairs(self, n: int) -> int:
        n1, n2= 1,2
        #给定n个阶梯，可以将其拆分成最后只剩一个阶梯
        #和只剩两个阶梯的情况，所以
        #f(n)=f(n-1)+f(n-2)
        i=1
        while i < n:
            n1,n2=n2,n1+n2
            i+=1
        return n1

方法二：递归，耗损计算量大，会超时

class Solution:
    def climbStairs(self, n):
        if n == 1:
            return 1
        elif n == 2:
            return 2
        else:
            return self.climbStairs(n - 1) + self.climbStairs(n - 2)

6.给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1->1->2
输出: 1->2

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        newhead=head
        while(head!=None and head.next!=None):
            #当前值与下一个值相等时，只修改next的指向
            if head.val==head.next.val:
                head.next=head.next.next
            #当前值与下一个值不相等时才移动head到下一个
            else:
                head=head.next
        return newhead

7.给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:

初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3

输出: [1,2,2,3,5,6]

方法一：

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        while m > 0 and n >0 :
            if nums1[m-1] > nums2[n-1]:
                nums1[m+n-1] = nums1[m-1]
                m -= 1
                
            else:
                nums1[m+n-1] = nums2[n-1]
                n -=1
                
        if n > 0:
            nums1[:n] = nums2[:n]

方法二：

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        for i in range(1,n+1):
            nums1[-i]=nums2[i-1]
        nums1.sort()

manjhOK

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录