lecode算法题 小总结

.
.
.
.
.
.
.

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(num_list)):
        need_res = target - num_list[i]

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

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

    return None


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

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

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

-----------------------------------------------
# 这样也行！！！
nums = [3,3,2, 7, 11, 15]
target = 5

def xxx():
    val_to_index ={}
    for i in range(4):
        now_res = nums[i]
        need_res = target-now_res
        if now_res not in val_to_index:
            val_to_index[now_res] = i
        if need_res in val_to_index and nums.index(need_res)!=i:
            return val_to_index[need_res],i
    return None

# 该算法的核心就是列表里面的不重复元素，转移字典里面去，值作为键，下标作为值
# 这样就不用两次for循环了！！！
# 其次就是直接上来先把for循环的列表元素如果没添加过，先添加到字典里面后，
# 然后再判断需要的值在不在字典里面，并且在加个限制条件保证这个需要的这个值，不是本次添加到字典里的值
# 让需要的值的索引不能等于当前添加到字典里的元素的键，因为如果一样了，那说明是同一个元素了，
# 本题要找的是两个不同的元素
res = xxx()
print(res)



-----------------------------------------------
# 测试用例
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 []

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

# c语言版

#include <stdio.h>

int twoSum(int *nums, int target, int sz)
{
    int i, j;
    for (i = 0; i < sz; i++)
    {
        int now_res = nums[i];
        int need_res = target - now_res;
        for (j = 0; j < sz; j++)
        {
            if (j == i)
            {
                continue;
            }
            if (nums[j] == need_res)
            {
                int arr1[] = {i, j};
                printf("%d  %d", arr1[0], arr1[1]);
                return 0;
            }
        }
    }
    int arr1[] = {999, 999};
    printf("%d  %d", arr1[0], arr1[1]);
    return 0;
}

int main()
{
    int nums[] = {2, 7, 11, 15};
    int target;
    scanf("%d", &target);
    int sz = sizeof(nums) / sizeof(nums[0]);
    int a = twoSum(nums, target, sz);
    return 0;
}

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

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

实现两个列表里面，相同索引位置元素的相加 的效果，模拟十进制相加的效果，低位在左，高位在右

def addTwoNumbers(l1, l2):
        res_list = []
        is_add = 0
        if len(l1) > len(l2):
            for i in range(len(l1)):
                if i < len(l2):
                    if (l1[i] + l2[i] + is_add )> 10:
                        res = l1[i] + l2[i] - 10 + is_add
                        is_add = 1
                        res_list.append(res)
                    else:
                        res_list.append(l1[i] + l2[i]+is_add)
                        is_add = 0
                if i >= len(l2):
                    if (l1[i] + is_add ) == 10:
                         res = 0
                         is_add = 1
                         res_list.append(res)
                    else:
                        res_list.append(l1[i]+is_add)
                        is_add = 0
        else:
            for i in range(len(l2)):
                if i < len(l1):
                    if (l1[i] + l2[i] + is_add )> 10:
                        res = l1[i] + l2[i] - 10 + is_add
                        is_add = 1
                        res_list.append(res)
                    else:
                        res_list.append(l1[i] + l2[i]+is_add)
                        is_add = 0
                if i >= len(l1):
                    if (l2[i] + is_add )== 10:
                         res = 0
                         is_add = 1
                         res_list.append(res)
                    else:
                        res_list.append(l2[i]+is_add)
                        is_add = 0
        if is_add == 1:
            res_list.append(1)
        return res_list

l1 = [9,9,9,9,9,9,9]
l2 = [9,9,9,9]

res = addTwoNumbers(l1,l2)
print(res)  # [8, 9, 9, 9, 0, 0, 0, 1]

.
.
.
.

冒泡排序

// 冒泡排序
#include <stdio.h>
void bubble_sort(int arr[], int sz)
{
    // 确定冒泡排序的趟数数组元素9个，冒泡排序就要排8趟
    int i = 1;
    for (i = 1; i < sz; i++)
    {
        // 每一趟冒泡排序
        int j = 0;
        for (j = 0; j < sz; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main()
{
    int arr[] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    // 对arr进行排序，排成升序
    bubble_sort(arr, sz);
    for (i = 0; i < sz; i++)
    {
        printf("%d \n", arr[i]);
    }
}

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

//                     9, 8, 7, 6, 5, 4, 3, 2, 1
// 冒泡排序第一趟后变成  8, 7, 6, 5, 4, 3, 2, 1, 9
// 冒泡排序第二趟后变成  7, 6, 5, 4, 3, 2, 1, 8, 9
// 冒泡排序第三趟后变成  6, 5, 4, 3, 2, 1, 7, 8, 9
//                     5, 4, 3, 2, 1, 6, 7, 8, 9
//                     4, 3, 2, 1, 5, 6, 7, 8, 9
//                     3, 2, 1, 4, 5, 6, 7, 8, 9
// 冒泡排序第七趟后变成  2, 1, 3, 4, 5, 6, 7, 8, 9
// 冒泡排序第八趟后变成  1, 2, 3, 4, 5, 6, 7, 8, 9
// 实际上,后续每趟的排序里面，已经不需要一直比到最后一个了,
// 第二趟排序的8就已经不需要再和9比较了,同理第八趟第0位与第1位比较互换数据后，就已经结束了

// 冒泡排序
#include <stdio.h>
void bubble_sort(int arr[], int sz)
{
    // 确定冒泡排序的趟数数组元素9个，冒泡排序就要排8趟
    int i = 1;
    for (i = 1; i < sz; i++)
    {
        // 每一趟冒泡排序
        int j = 0;
        // sz - i   这样第一趟冒泡排序的时候，从下标第0位开始，到下标第7位结束，正好比完
        // 第二趟 从下标第0位开始，到下标第6位结束   随着趟数的增加，结束的下标位置逐渐减小
        for (j = 0; j < sz - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main()
{
    int arr[] = {12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    // 对arr进行排序，排成升序
    bubble_sort(arr, sz);
    for (i = 0; i < sz; i++)
    {
        printf("%d \n", arr[i]);
    }
}

.
.
.
.
.
.
.