常见判断易出的问题

常见判断易出的问题

l1 = []
print(l1 is None)  # false
print(l1 == True)  # false
print(l1 == False)  # false
print(l1 == [])  # true
print(l1 is True)  # false
print(l1 is False)  # false


---------------------------------------

判断一个数是由数组里面的哪两个数相加而成，如果有返回两个数的数组下标，注意不能是同一个数相加

l1 = [3, 5, 3, 4]
target = 6

# 错误解法：
def xxx():
    for i in l1:
        for k in l1:
            if l1.index(i) == l1.index(k):
                continue
            if i + k == target:
                return l1.index(i), l1.index(k)
        return None


res = xxx()
print(res)  # None
# 这个index方法只能获取目标元素，在数组中的下标位置，并且只返回第一个符合的元素位置
# 所以 按理我们需要返回的结果是（0,1）
# 但是第一次外层循环内层循环时，第一次迭代出的值通过判断直接break了，同理第二次迭代也break了
# 同理第二次外层循环内层循环时，也是两次迭代都是走到了break了
-------------------------------------------

# 解法1
def xxx():
    for i in range(0, len(l1)):
        for k in range(0, len(l1)):
            if i == k:
                continue
            if l1[i] + l1[k] == target:
                return i, k
        return None


res = xxx()
print(res)  # (0, 2)

------------------------------------------------

# 解法2
# 一层for循环解决
def xxx():
    for i in range(0, len(l1)):
        res = target - l1[i]
        if res in l1:
            # 如果减出来的结果 在l1 里面，并且该值的下标和当前for循环的小标一样，就结束本次循环，继续下次循环
            if l1.index(res) == i:
                continue
            return i, l1.index(res)
    return None


res = xxx()
print(res)  # (2, 0)
# 但这种解法，多走步骤了，我们通过手动的将减出来的结果的下标与当前for循环的下标比较，如果一样就结束本次循环了
# 最好是减出来的结果，如果在l1里面，且不是当前for循环的值，就结束循环了，也就是第一次循环时，就能找到结果结束
# 返回(0,2) 这样的结果，才是最优解

------------------------------------------------

# 解法3
def xxx():
    for i in range(0, len(l1)):
        res = target - l1[i]
        if res in l1:
            # 如果减出来的结果 在l1 里面，并且该值的下标和当前for循环的下标一样，那就获取下一个也是该减出来的结果的值的下标
            for index, k in enumerate(l1):
                if k == res:
                    if index == i:
                        continue
                    return i, index
    return None


res = xxx()
print(res)  # (0, 2)

# 还是两层for循环了，和第一种解法实际上没有本质区别，怎么压缩成1层for循环了？？？
------------------------------------------------

l1 = [3, 3, 4, 5, 3, 4, 1]
target = 8


def xxx():
    d1 = {}  # 搞个空字典
    for i in range(0, len(l1)):
        res = target - l1[i]

        if res in d1:
            # 减出来的结果，在字典的键里面，说明之前的循环里面，将值作为键，下标索引作为值，放到了字典里面去了
            # 这个时候将之前放到字典里的键值对的值，拿到就是对应列表里的索引下标
            # 这时候就结束了，之前放到字典里的列表索引下标，就是两数相加的左边的一个数的列表索引下标
            # 因为是之前循环放进去的，所以和本次循环的得到的数，一定不是列表里的同一个数！！！
            return d1[res], i

        if d1.get(l1[i], None) == None:
            # 如果本次迭代出的列表里的值，还没有在字典里面添加过了，也就是本次迭代出的列表里的值，还没有作为键添加到字典里面
            # 这里不要用d1.get(l1[i], None) 是不是False  来判断
            # 判断字典里面有没有这个键，没有的话，就把键与列表里对应的索引作为值，放到字典里
            d1[l1[i]] = i

    return None


# 整体的逻辑就是 根据列表 与 目标值
# 首先for循环列表，拿到列表里面元素的值，以及当前元素需要和一个什么数相加，才能等于目标值
# 然后判断这个需要的相加数，在for循环开始前定义的空字典里面有没有，如果有的话，就说明之前循环的时候，将值作为键，下标索引作为值，放到了字典里面去了
# 这个时候寻找已经结束了

# 如果 当前列表迭代出的值，没有在字典里面添加过，就添加到字典里面去，键是值，值是下标索引 加到字典里
# 比如我们第一次迭代的值是3，将3作为键，0作为值，放到字典里面去
# 第二次迭代的值是3，我们判断字典里面已经有键3了，不需要再给字典里面键3对应的值，也就是索引更新了 字典里还是{3:0}
# 也就是列表里面同样的元素，只会把第一个元素的下标索引作为值，放到字典里，不会重复放，字典里面该键的值也不会改


res = xxx()
print(res)  # (0, 3)

.
.
.

for i in range(1, 10):
    for k in range(1, i + 1):
        print(f'{i}X{k} \t', end='')
    print('\n')

.
.
.