.
.
.
.
.
.
.

1 打印9x9 乘法表

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

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

# c版

#include <stdio.h>
int main()
{
    int i;
    int k;
    for (i = 1; i < 10; i++)
    {
        for (k = 1; k <= i; k++)
        { printf("%d x %d = %d  ", i, k, i * k);}
        printf("\n");
    }

    return 0;
}

# 外层循环控制层数，
# 内存循环控制每层 乘式的个数

.
.
.
.
.
.
.
.
.

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

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循环了？？？
------------------------------------------------

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


def xxx():
    val_to_index_dict = {}   # 搞个空字典 里面准备放列表的值与索引的对应关系
    for i in range(0, len(l1)):
        need_res = target - l1[i]

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

        if l1[i] not in val_to_index_dict.keys():
            # 如果本次迭代出的列表里的值，还没有在字典里面添加过了
            # 也就是本次迭代出的列表里的值，还没有作为键添加到字典里面
            # 就把该值作为键与列表里对应的索引作为值，放到字典里
            # 这里加这个if的判断还有一个好处，就是列表相同的数，不会重复添加到字典里面
            # 也就是不会让相同的值，去更新字典里面的键对应的索引
            # 这样最后返出来的两个数组的下标，左边的下标一定是符合的，且最小的
            # 比如此处不加if判断，最后出的结果就是（1,3）  加了结果就是（0,3）
            d1[l1[i]] = i

    return None


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

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

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

-----------------
# 测试用例
class Solution(object):
    def twoSum(self, nums, target):
        # 维护 val -> index 的映射
        val_to_index_dict = {}
        for i in range(len(nums)):
            # 查表，看看是否有能和 nums[i] 凑出 target 的元素
            need_res = target - nums[i]
            if need_res in val_to_index_dict:
                return [val_to_index_dict[need_res], i]
            if nums[i] not in val_to_index_dict.keys():
            # 存入 val -> index 的映射
                val_to_index_dict[nums[i]] = i
        return []

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.