算法训练营 Day1

努力追上那个曾经被寄予厚望的自己

—— 25.4.25

一、LeetCode_26 删除有序数组中的重复项

给你⼀个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现⼀次，返回删除后数组的
新⻓度。元素的相对顺序应该保持⼀致。
由于在某些语⾔中不能改变数组的⻓度，所以必须将结果放在数组nums的第⼀部分。更规范地说，如果在删除重
复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插⼊ nums 的前 k 个位置后返回 k 。
不要使⽤额外的空间，你必须在原地修改输⼊数组并在使⽤ O(1) 额外空间的条件下完成。

思路：

解题要点是要判断数组是否有重复元素，

而另一个要点是题目只要求返回最终删除数组后的剩余数量，而并不是要求返回删除后的剩余数组
因此，我们可以重新定义一个变量，初始化为0，再用原先数组从头开始遍历
将不重复的元素放入数组的前面，并返回新变量的值，即为最终删除数组后的剩余数量。

map() 函数是一个内置的高阶函数，它的主要作用是对可迭代对象（如列表、元组等）中的每个元素应用指定的函数，并返回一个迭代器，该迭代器会生成函数应用后的结果。
参数1 function：指定一个函数，该函数将作用于可迭代对象中的每个元素。
参数2 iterable：指定一个可迭代对象，如列表、元组等，该对象中的每个元素都将被函数处理。
返回值：返回一个迭代器，该迭代器会生成函数应用后的结果。

'''
给你⼀个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现⼀次 ，返回删除后数组的
新⻓度。元素的 相对顺序 应该保持 ⼀致 。
由于在某些语⾔中不能改变数组的⻓度，所以必须将结果放在数组nums的第⼀部分。更规范地说，如果在删除重
复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插⼊ nums 的前 k 个位置后返回 k 。
不要使⽤额外的空间，你必须在 原地 修改输⼊数组并在使⽤ O(1) 额外空间的条件下完成。
'''


'''
思路：解题要点是要判断数组是否有重复元素，而另一个要点是 题目只要求返回最终删除数组后的剩余数量，而并不是要求返回删除后的剩余数组
因此，我们可以重新定义一个变量，初始化为0，再用原先数组从头开始遍历
将不重复的元素放入数组的前面，并返回新变量的值，即为最终删除数组后的剩余数量。

map() 函数是一个内置的高阶函数，它的主要作用是对可迭代对象（如列表、元组等）中的每个元素应用指定的函数，并返回一个迭代器，该迭代器会生成函数应用后的结果。
    参数1 function：指定一个函数，该函数将作用于可迭代对象中的每个元素。
    参数2 iterable：指定一个可迭代对象，如列表、元组等，该对象中的每个元素都将被函数处理。
    返回值：返回一个迭代器，该迭代器会生成函数应用后的结果。
'''

# def removeDuplicates(nums):
#     if not nums:
#         return 0
#     n = len(nums)
#     i = 0
#     for j in range(n):
#         if j == 0 or nums[j] != nums[j - 1]:
#             nums[i] = nums[j]
#             i += 1
#     return i

def removeDuplicates(nums):
    if not nums:
        return 0
    n = len(nums)
    i = 0
    for j in range(n):
        if j == n - 1 or nums[j] != nums[j + 1]:
            nums[i] = nums[j]
            i += 1
    return i


nums1 = [1, 1, 2]
print(removeDuplicates(nums1))

nums2 = []
print(removeDuplicates(nums2))

nums3 = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
print(removeDuplicates(nums3))

nums = input("请输入您给出的数组,输入请按照空格进行分割：\n")
nums = list(map(int, nums.split(",")))
print("根据您输入的结果，不重复的数组长度为：", removeDuplicates(nums))

二、LeetCode_27 移除元素

给你⼀个数组 nums 和⼀个值 val ，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新⻓度。
不要使⽤额外的数组空间，你必须仅使⽤ O(1) 额外空间并原地修改输⼊数组。
元素的顺序可以改变。你不需要考虑数组中超出新⻓度后⾯的元素。

思路

定义一个指针 i，指向数组中不等于 val 的元素，遍历数组，

对于数组中每一个元素 nums[j]，如果不等于值 val，
就将其赋值给指针i 的位置，然后将指针i 后移
最终返回指针 i，即为原数组中不等于值 val 的元素的个数

python中从键盘输入一个列表（数组）应该使用：
list(map(int, input("请您输入一个数组：").split(",")))
输入数组以","分成每个元素，对于每个元素使用 int() 函数转化为整数

'''
给你⼀个数组 nums 和⼀个值 val ，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新⻓度。
不要使⽤额外的数组空间，你必须仅使⽤ O(1) 额外空间并 原地 修改输⼊数组。
元素的顺序可以改变。你不需要考虑数组中超出新⻓度后⾯的元素。
'''

'''
思路：定义一个指针 i，指向数组中不等于 val 的元素，遍历数组，对于数组中每一个元素 nums[j]，如果不等于值 val
就将其赋值给 指针i 的位置，然后将 指针i 后移
最终返回指针 i，即为原数组中不等于值 val 的元素的个数

python中从键盘输入一个列表（数组）应该使用：
   list(map(int, input("请您输入一个数组：").split(",")))
   输入数组以","分成每个元素，对于每个元素使用 int() 函数转化为整数
'''

def removeElement(nums, val):
    i = 0
    for j in range(len(nums)):
        if nums[j] != val:
            nums[i] = nums[j]
            i += 1
    return i

input_nums = list(map(int, input("请您输入一个数组：").split(",")))
res = removeElement(list(input_nums), int(input("请您输入要删除的元素：")))
print("移除后数组的新长度为：", res)

三、LeetCode 283 移动零

给定⼀个数组 nums ，编写⼀个函数将所有 0 移动到数组的末尾，同时保持⾮零元素的相对顺序。
请注意，必须在不复制数组的情况下原地对数组进⾏操作。

思路

定义一个指针 i，遍历数组nums，如果 nums[j] 不等于 0，则将其赋值给 nums[i]，然后 i 后移一位。
最后，将 i 之后的元素全部赋值为 0。
返回修改后的数组 nums

'''
给定⼀个数组 nums ，编写⼀个函数将所有 0 移动到数组的末尾，同时保持⾮零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进⾏操作。
'''

'''
思路：定义一个指针 i，遍历数组nums，如果 nums[j] 不等于 0，则将其赋值给 nums[i]，然后 i 后移一位。
最后，将 i 之后的元素全部赋值为 0。
返回修改后的数组 nums
'''
def moveZeroes(nums):
    i = 0
    n = len(nums)
    for j in range(n):
        if nums[j] != 0:
            nums[i] = nums[j]
            i += 1
    for j in range(i, n):
        nums[j] = 0
    return nums

nums1 = [0, 1, 0, 3, 12]
print(moveZeroes(nums1))

nums = list(map(int, input("请输入一个数组，用逗号隔开：").split(",")))
print(moveZeroes(nums))

四、LeetCode 485 最大连续1的个数

给定⼀个⼆进制数组 nums ，计算其中最⼤连续 1 的个数。
示例 1：
输⼊：nums = [1,1,0,1,1,1] 输出：3 解释：开头的两位和最后的三位都是连续 1 ，所以最⼤连续 1 的个数是 3.
示例 2:
输⼊：nums = [1,0,1,1,0,1] 输出：2
提示：
1 <= nums.length <= 10^5
nums[i] 不是 0 就是 1 .

思路

遍历传入的列表，如果当前位置的列表（数组）元素为1，则将计数器count加1，并更新最大值maxCount；

如果当前位置的元素为0，则计数器count清零。重新计算

'''
给定⼀个⼆进制数组 nums ， 计算其中最⼤连续 1 的个数。
示例 1：
输⼊：nums = [1,1,0,1,1,1] 输出：3 解释：开头的两位和最后的三位都是连续 1 ，所以最⼤连续 1 的个数是 3.
示例 2:
输⼊：nums = [1,0,1,1,0,1] 输出：2
提示：
1 <= nums.length <= 10^5
nums[i] 不是 0 就是 1 .

遍历传入的列表，如果当前位置的列表（数组）元素为1，则将计数器count加1，并更新最大值maxCount；如果当前位置的元素为0，则计数器count清零。重新计算
'''


def findMaxConsecutiveOnes(nums):
    maxCount = 0
    count = 0
    n = len(nums)
    for i in range(n):
        if nums[i] == 1:
            count += 1
            maxCount = max(maxCount, count)  # 更新最大值
        else:
            count = 0  # 遇到0，计数器清零
    return maxCount


nums = list(map(int, input("请输入一个0/1数组，用逗号隔开：").split(",")))
maxCount = findMaxConsecutiveOnes(nums)
print("最⼤连续 1 的个数是：", maxCount)