leetcode整理（一）

leetcode题目整理，基本上不是最优解

1. 回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true

示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

# 思路：将整数转化为字符串，用字符串切片的方法，步长取-1，将字符串反转，与原数比较
def func(x):
    if x == int(str(x)[::-1]):
        return True
    else:
        return False

res = func(121)

2. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

# 思路：用目标值target减去数组中的一个值，比较 得到的值是否在数组nums中，若在就返回这两个数的索引值
def two_sum(nums, target):
    for i in range(len(nums)):  # for 循环遍历，取出nums的索引值
        sub = target - nums[i]
        if sub in nums:
            res = nums.index(sub)  # 获取另一个值的索引
            if res != i:
                return [i, res]

3. 整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321

示例 2:
输入: -123
输出: -321

示例 3:
输入: 120
输出: 21

注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2**31,  2**31 − 1]。
请根据这个假设，如果反转后整数溢出那么就返回 0。

3. 整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321

示例 2:
输入: -123
输出: -321

示例 3:
输入: 120
输出: 21

注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2**31,  2**31 − 1]。
请根据这个假设，如果反转后整数溢出那么就返回 0。

# 思路：先转化为列表反转，用reverse方法。负整数有负号，先判断
def int_reverse(x):
    lt = list(str(x))
    if lt[0] == '-':
        lt.reverse()
        lt2 = lt[0:len(lt) - 1]  # 负整数反转之后，不取"-"
        res = -int(''.join(lt2))
        if res < -2 ** 31:
            return 0
        else:
            return res

    else:
        lt.reverse()
        lt2 = lt[0:len(lt)]
        res = int(''.join(lt2))
        if res > 2 ** 31 - 1:
            return 0
        else:
            return res

4. 按奇偶排序数组
给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。
你可以返回满足此条件的任何数组作为答案。

示例：
输入：[3,1,2,4]
输出：[2,4,3,1]
输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。

提示：
1 <= A.length <= 5000
0 <= A[i] <= 5000

def sort_A(A):
    lt1 = []
    lt2 = []  # 定义两个列表，分别接收奇数和偶数
    for i in A:
        if i % 2 == 0:
            lt1.append(i)
        else:
            lt2.append(i)
    return lt1 + lt2

'''
5. IP地址无效化
给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。
所谓无效化 IP 地址，其实就是用 "[.]" 代替了每个 "."。

示例 1：
输入：address = "1.1.1.1"
输出："1[.]1[.]1[.]1"

示例 2：
输入：address = "255.100.50.0"
输出："255[.]100[.]50[.]0"

提示：
给出的 address 是一个有效的 IPv4 地址
'''

def ipaddr(s):
    s2 = s.split('.')
    res = '[.]'.join(s2)
    return res

6.宝石与石头
给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。
S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。

示例 1:
输入: J = "aA", S = "aAAbbbb"
输出: 3

示例 2:
输入: J = "z", S = "ZZ"
输出: 0
注意:
S 和 J 最多含有50个字母。
 J 中的字符不重复。
'''

def func(J, S):
    sum = 0
    for i in J:
        sum += S.count(i)
    return sum

'''
7.有序数组的平方
给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
示例 1：
输入：[-4,-1,0,3,10]
输出：[0,1,9,16,100]

示例 2：
输入：[-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：
1 <= A.length <= 10000
-10000 <= A[i] <= 10000
A 已按非递减顺序排序。
'''

def sorted_square(A):
    lt = []
    for i in A:
        lt.append(i ** 2)
        lt.sort()
    return lt

'''
8. 反转字符串中的单词
给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 1:
输入: "Let's take LeetCode contest"
输出: "s'teL ekat edoCteeL tsetnoc"
注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。
'''

# 思路：转换为列表，遍历取出单词反转
def sorted_str(s):
    lt = []
    s_list = s.split(' ')
    for i in s_list:
        lt.append(i[::-1])
    return ' '.join(lt)

'''
9. 按奇偶排序数组
给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。
对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。
你可以返回任何满足上述条件的数组作为答案。

示例：
输入：[4,2,5,7]
输出：[4,5,2,7]
解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。
提示：
2 <= A.length <= 20000
A.length % 2 == 0
0 <= A[i] <= 1000
'''

def func3(A):
    lt, lt1, lt2 = [], [], []
    for i in A:
        if i % 2 == 0:
            lt1.append(i)
        else:
            lt2.append(i)  # lt1 存储偶数，lt2 存储奇数
    while lt1 and lt2:
        lt.append(lt1.pop())
        lt.append(lt2.pop())  # pop()默认删除最后一个，返回删除的数
    return lt

'''
10. 各位相加
给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。

示例:

输入: 38
输出: 2
解释: 各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。 由于 2 是一位数，所以返回 2。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-digits
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
'''

def add_digit(num):
    if num < 9:
        return num
    elif num == 9:
        return 9
    else:
        return num % 9

'''
11. 存在重复元素
给定一个整数数组，判断是否存在重复元素。

如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

示例 1:

输入: [1,2,3,1]
输出: true
示例 2:

输入: [1,2,3,4]
输出: false
示例 3:

输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/contains-duplicate
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
'''
# 思路：用集合set，重复元素删除，比较原数组和集合的长度
def func4(nums):
    if len(nums) == len(set(nums)):
        return True
    else:
        return False
func4([1,1,1,3,3,4,3,2,4,2])

'''
12. 只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例 2:

输入: [4,1,2,1,2]
输出: 4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/single-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
'''

def func5(nums):
    lt = []
    for i in nums:
        if i not in lt:
            lt.append(i)
        else:
            lt.remove(i)
    return lt[0]
func5([4,1,2,1,2])

'''
13. 移除元素
给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。
示例 2:

给定 nums = [0,1,2,2,3,0,4,2], val = 2,

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。

你不需要考虑数组中超出新长度后面的元素。
说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
'''

def remove_elemnet(nums, val):
    i = 0    # i为数组长度
    for j in range(0, len(nums)):
        if nums[j] != val:
            nums[i] = nums[j]
            i += 1
    return i