• [2020-01-29] 二维数组 at 2021年01月29日

    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
    
  • 412. Fizz Buzz[简单] at 2020年06月09日
    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