python3 解法

每个元素的值是 i*j

def gen_array(x, y):
    arr = []
    for i in range(x):
        fi = []  # fi列表再次进行初始化
        for j in range(y):
            fi.append( i * j )
        arr.append(fi)
    print(arr)


gen_array(3, 5)
[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]

2021 年学习计划

技术类

优先级从上到下，系统的学习。

1. 学习 istio 。
2. 学习 kubernetes ，网络，存储等等。
3. 学习 go 语言，使用 go 语言编写个小工具吧。
4. 学习 ceph 分布式存储。

书籍

1. OKR 体系学习
2. SRE：Google 运维解密
3. SRE 生存指南：系统中断响应与正常运行时间最大化

其他的能看多少看多少。

2020 年学习计划 [总结]

技术类

优先级从上到下，系统的学习。

1. 学习 rhca【没学】
2. 学习 redis5.0【完成】
3. 学习 mysql【没学】
4. 学习 kubernetes【完成】
5. 学习 istio【没学】
6. 学习 hashicorp 全家桶【完成】
7. 学习 tigk 监控方案【完成】

书籍

1. Kubernetes 网络权威指南：基础、原理与实践
2. Kubernetes 微服务实战
3. 基于 Kubernetes 的容器云平台实战
4. Kafka 并不难学！入门、进阶、商业实战
5. Kubernetes 权威指南：从 Docker 到 Kubernetes 实践全接触（第 4 版）
6. 阿里云运维架构实践秘籍
7. Elasticsearch 实战与原理解析
8. InfluxDB 原理与实战
9. DevOps 和自动化运维实践
10. Prometheus 监控实战
11. Jenkins 2.x 实践指南
12. Redis 5 设计与源码分析
13. Redis 使用手册

1. 首先学会 shell 语法。
2. 尝试使用 shell 来解决需求。
3. 借鉴好脚本的写法。
4. 看看最佳实践。
5. shell 资料 https://cs.leops.cn/#/cheatsheet/linux/bash

顶顶顶

上面是以前搞的 iis 发布。

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        # 贪心算法
        g.sort()
        s.sort()
        i = 0
        j = 0
        while i < len(g) and j < len(s):
            if g[i] <= s[j]:
                i += 1
            j += 1
        return i

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        return s in (s + s)[1: len(s)*2 -1]

class Solution:
    def minMoves(self, nums: List[int]) -> int:
        sum = 0
        minmum = min(nums)
        for i in nums:
            sum += i-minmum
        return sum

class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        # 将所有正数作为数组下标，置对应数组值为负值。那么，仍为正数的位置即为（未出现过）消失的数字。
        for num in nums:
            nums[abs(num)-1] = -abs(nums[abs(num)-1])
        print(nums)
        return [i+1 for i,num in enumerate(nums) if num>0]

class Solution:
    def numberOfBoomerangs(self, points: List[List[int]]) -> int:
        result=0
        for m in points:
            dic={}
            for j in points:
                distance=(m[0]-j[0])**2+(m[1]-j[1])**2
                if distance not in dic:
                    dic[distance]=1
                else:
                    dic[distance]+=1
            for val in dic.values():
                if val>=2:
                    result+=val*(val-1)
        return result

class Solution:
    def compress(self, chars: List[str]) -> int:
        count = 1

        length = len(chars)
        for index in range(length-1, -1, -1):
            if index > 0 and chars[index] == chars[index-1]:
                count += 1
            else:
                end = index+count
                chars[index: end] = [chars[index]] if count == 1 else [chars[index]] +  list(str(count))
                count = 1

        return len(chars)

class Solution:
    def arrangeCoins(self, n: int) -> int:
        c = 0
        while n > c:
            c = c + 1
            n = n - c
        return c

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def pathSum(self, root, sum):
        if root == None:
            return 0
        return self.count(root,sum)+self.pathSum(root.left,sum)+self.pathSum(root.right,sum)
    def count(self,root,sum):
        if root ==None:
            return 0
        return int(root.val == sum) + self.count(root.left,sum-root.val) + self.count(root.right,sum-root.val)

class Solution:
    def countSegments(self, s: str) -> int:
        return len(s.split())

class Solution:
    def addStrings(self, num1: str, num2: str) -> str:
        res = ""
        i, j, carry = len(num1) - 1, len(num2) - 1, 0
        while i >= 0 or j >= 0:
            n1 = int(num1[i]) if i >= 0 else 0
            n2 = int(num2[j]) if j >= 0 else 0
            tmp = n1 + n2 + carry
            carry = tmp // 10
            res = str(tmp % 10) + res
            i, j = i - 1, j - 1
        return "1" + res if carry else res

class Solution:
    def thirdMax(self, nums: List[int]) -> int:
        a = b = c = float('-inf')

        for num in nums:
            if a < num:
                a , b , c = num , a , b 
            elif b < num < a:
                b , c = num , b
            elif c < num < b:
                c = num
        return a if c == float('-inf') else c

class Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        res = []
        for i in range(1,n+1):
            res.append('Fizz'[i%3*len('Fizz')::]+'Buzz'[i%5*len('Buzz')::] or str(i))
        return res

class Solution:
    def longestPalindrome(self, s: str) -> int:
        d = {}
        for i in range(len(s)):
            if s[i] not in d:
                d[s[i]] = 1
            else:
                d[s[i]] += 1
        count = 0
        for j in d:
            count += d[j] // 2 * 2
            if d[j] % 2 == 1 and count % 2 == 0:
                count += 1
        return count

class Solution:
    def toHex(self, num: int) -> str:
        return hex(num&0xFFFFFFFF)[2:]

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def sumOfLeftLeaves(self, root: TreeNode) -> int:
        if root==None:
            return 0
        if root.left and root.left.left==None and root.left.right==None:
            return root.left.val+self.sumOfLeftLeaves(root.right)
        else:
            return self.sumOfLeftLeaves(root.left)+self.sumOfLeftLeaves(root.right)

class Solution:
    def readBinaryWatch(self, num: int) -> List[str]:
        bins = [str(bin(i))[2:].count('1') for i in range(60)]
        results = []
        for hour in range(12):
            for minute in range(60):
                if bins[hour] + bins[minute] == num:
                    results.append('%d:%02d'%(hour, minute))
        return results

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        t = iter(t)
        return all(i in t for i in s) 

class Solution:
    def firstUniqChar(self, s: str) -> int:
        """
        遍历字符串中的字符，如果满足以下两个条件，则返回idx
        1. 该字符不存在于 s[:idx]
        2. 该字符不存在于 s[idx + 1:]
        :param s:
        :return:
        """
        for idx, c in enumerate(s):
            if c not in s[idx + 1:] and c not in s[:idx]:
                return idx
        return -1

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        a = list(ransomNote)
        b = list(magazine)

        try:
            for i in a:
                b.remove(i)
            return True
        except:
            return False