希望能解决大家的问题，也欢迎老哥们来骚扰技术交流业务中的问题

def get_length_from_i(i_url): m = re.match(".*(http(s)?://)?i\w*?\.go2yd\.com/image(?:\.php\?url=|/)([A-Za-z0-9_]{8,60}).*", i_url) if not m: m = re.match( ".*(http(s)?:\\\\?/\\\\?/)?i\w*?\.go2yd\.com\\\\?/imag

所谓函数式编程，是指代码中每一块都是不可变的（immutable），都由纯函数（pure function）的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用[就算传进来一个引用也不会改变这个引用，而是新创建一个返回]。map\reduce\filter\sortedmap，对列表中每一个元素按照传入函数做运算。reduce，对列表中两个元素按照传入函数做合并运算，如求1-5累加，reduce(lambda x,y:x+y, range(1,6)

(common) ➜ [/Users/admin/yidian/script-tool/dk/dockerfile-py] docker export 9d88c87a0ab0 > ./warning_kafka_py.tar (common) ➜ [/Users/admin/yidian/script-tool/dk/dockerfile-py] docker import ./warning_kafka_py.tar warn_test sha256:7b52f33ff4785f

编译时就知道变量类型的是静态类型；运行时才知道一个变量类型的叫做动态类型。不允许隐式转换的是强类型，允许隐式转换的是弱类型。编译型。编译型语言，目标计算机以编译语言直接翻译程序。而对于解释型语言，源代码不会直接由目标计算机翻译，而是由 另一个 程序（即解释器）读取并执行代码。详细：https://www.zhihu.com/question/420516398...

# https://www.cnblogs.com/superhin/p/11455240.html# https://blog.youkuaiyun.com/birdflyinhigh/article/details/79685019# https://www.cnblogs.com/xzjf/p/9339674.htmlimport csvimport pandas as pdfrom urllib import requestimport jsonimport copyimport time

指定最后一个元素是privot [遍历前面的与他比较]，counter表示雄安与privot的元素的个数，如果当前 i 的值小于privot则 交换counter位置与 i 位置的元素[通过这样遍历完毕则前counter全都小于privot]，并且counter++，然后只需要最后一轮交换privot与counter的元素public class QuickSort { public static void sort(int[] input, int begin, int end) {

class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None # 按照中序遍历的方式遍历，中序遍历的顺序是左中右，只要 左面小于中间 # 中间小于右面 就满足条件了class Solution: pre = -sys.maxsize - 1 def isValidBST(self, root: Tre

时间复杂度O(N)空间复杂度O(N)只需要遍历两遍字符串，第一遍用hash表统计每个字母出现的最大下标。就是最晚出现的下标。第二遍分段，每一段都记录一个left，right就是当前下标。用一个max_ind记录当前段遍历过的最大下标，如果当前坐标等于最大下标，就开始下一段的记录。并把当前的结果加入ans结果集。[盗一下大佬的图片。]# 字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一个字母只会出现在其中的一个片段。返回一个表示每个字符串片段的长度的列表。 # # #

# 给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, # ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 # # 说明：你不能倾斜容器，且 n 的值至少为 2。 # # # # # # 图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。 # # #

我的思路：class Solution: def convert(self, s: str, numRows: int) -> str: ans = '' if numRows == 1: return s for i in range(1, numRows + 1): # i是从1到numRows+1 step = i - 1 ind = (numRows - 1) .

一、我的思路：拿一个栈一开始进栈直到遇到正数。然后记录遇到负数的这个坐标，然后依次比较出栈的，和i依次往后迭代的数的大小。from typing import Listclass Solution: def sortedSquares(self, A: List[int]) -> List[int]: ans = [] my_stack = [] # 用来存反序的从小到大 i = 0 while i < len

这道题在leetcode上难度是简单，但是实现起来思路并不太简单。主要就是用一个栈模拟第一个序列进栈，第二个序列如果跟栈里面最后一个元素相同就一直出栈，并把poped坐标加一。# 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈# 的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。 # # # # 示例

记录一个误区：数据结构学的多之后，老是懒得思考，想直接用高级的数据结构解决问题，反而把问题想复杂了。这道题要求最小值，一开始想直接再维护一个优先队列[堆]，每次都能取出最小值。但是维护堆的成本反而增加了。[logn]class MinStack: def __init__(self): """ initialize your data structure here. """ self.A = [] self.B =

思路： 第一个字符串全部字符加入 ans，后面的字符串检测是不是在里面是的话，tmp就+1，并且将这个公共的部分tmp作为ans开始下一次# 给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不# 是 4 次，则需要在最终答案中包含该字符 3 次。 # # 你可以按任意顺序返回答案。 # # # # 示例 1： # # 输入：["bella","label","roller"]

这种设计数据结构的挺难顶的，leetcode还好，给你具体的需求，方法名参数返回值都有了，如果是直接抽象的给你描述，你需要想方法参数返回值，有几个功能(方法)，每个方法细节，最后才是思路。[以前感觉数据结构课很没用，毕竟每个语言里面基本上基本上都封装的有，只需要去掌握他们就可以了，不需要每一个都实现一下，现在感觉掌握一门语言最好的办法还是先手写一遍常用的数据结构，既可以了解语言语法，又可以了解特性]class Node: def __init__(self, key=None, value=No

感觉这种题没多大用，基本上就是锻炼逻辑思维，全靠背题(不是背代码，是背思路，没一点复用性)如何推导出下面的x = (n - 1) (y + z) + z相遇时slow指针走的距离为x+y2 * (x+y) = x+y+n*(y+z) -> x = (n - 1) (y + z) + z解题其实只需要这一个公式x = (n - 1) (y + z) + z然后这个公式的意义是什么？有什么用？没什么意义，我一开始有个误区，认为要求入口节点，就一定要求x的值。所以一直没有思路。.

# 给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。 # # # 如果剩余字符少于 k 个，则将剩余字符全部反转。 # 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。 # # # # # 示例: # # 输入: s = "abcdefg", k = 2# 输出: "bacdfeg"# # # # # 提示： # # # 该字符串只包含小写英文字母。

# 给定一个二叉树，返回它的 后序 遍历。 # # 示例: # # 输入: [1,null,2,3] # 1# \# 2# /# 3 # # 输出: [3,2,1] # # 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ # Related Topics 栈 树 # ???? 438 ???? 0# 145.二叉树的后序遍历# leetcode submit region begin(Prohibit modifi

# 给定一个二叉树，返回它的 前序 遍历。 # # 示例: # # 输入: [1,null,2,3] # 1# \# 2# /# 3 # # 输出: [1,2,3]# # # 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ # Related Topics 栈 树 # ???? 372 ???? 0# 144.二叉树的前序遍历# leetcode submit region begin(Prohibit mod

# 根据单词的每一位来改变,然后每一位变为a->z,判断是否是end是就return 层数+1, # steps里已经存在则证明走长了，就continue，不存在就添加到steps，并入队作为下一层的元素 # 使用一个set记录单词的使用情况# 给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：# # # # 每次转换只能改变一个字母。 # 转换过程中...

挺恶心的一道题。。而且出现频率挺高的。0. 解法零面试最好不要写这种，竞赛赶时间可以写一下。面试想让你写下面的两种 def spiralOrder(self, matrix: List[List[int]]) -> List[int]: ans = [] while matrix: ans.extend(matrix[0]) matrix = list(zip(*matrix[1:]))[::-1]

思路：层次遍历一层之前，先定义一个中间队列，并且记录一下，需要遍历多少个节点。可以反转一下list，或者直接用一个栈。先进去的在里面class Solution: def levelOrderBottom(self, root: TreeNode) -> List[List[int]]: if not root: return [] ans = [] que = collections.deque()

源码：https://github.com/Bit-urd/knowledge-base/tree/master/java-se/src/com/biturd/knowledgebase/thread/pool思路类比数据库连接池。数据库连接池复用的是Connection，池化技术通用的：最小个数、最大个数、活跃时间、线程池容器[核心]:一般为队列。[通用的就不写了，写点特有的]线程池复用的是线程，目的是减少向操作系统申请线程避免上下文切换。正常情况下线程执行完就结束了，就死亡了。无法复用。要.

编辑距离算法被数据科学家广泛应用，是用作机器翻译和语音识别评价标准的基本算法。最直观的方法是暴力检查所有可能的编辑方法，取最短的一个。所有可能的编辑方法达到指数级，但我们不需要进行这么多计算，因为我们只需要找到距离最短的序列而不是所有可能的序列。class Solution: def minDistance(self, word1: str, word2: str) -> int: # leetcode submit region end(Prohibit modifica

重点：if tmp > maxLen and s[i] == s[i-tmp+1]:判断最后一位和第一位是不是相等，相等才是回文串。class Solution: def longestPalindrome(self, s: str) -> str:# leetcode submit region end(Prohibit modification and deletion) # 状态数组 dp[n+1][n+1] n = len(s)

我的代码:思路横向扫描所有的子串，不断的扩展ans，如果某个字符串越界就直接返回，如果不相等也返回。class Solution: def longestCommonPrefix(self, strs: List[str]) -> str: # leetcode submit region end(Prohibit modification and deletion) length = len(i) ans

思路：递归的交换左右子树推出条件：左右子树都为None难点：特殊情况如何处理class Solution: def mirrorTree(self, root: TreeNode) -> TreeNode: if not root: return None return self.recur(root) def recur(self, root: TreeNode) -> TreeNode: #.

感觉有点类似于背包问题，，3是最大的收益先列举一下大概看一下怎么最大 发现 6分为 3 * 3 2 * 2 * 2 3大于2 12分为 3 * 3 * 3 * 3 4 * 4 * 4 3大于4 3以前是大的结果最优 3以后是小的结果最优先按照3分然后 剩下的补2 13 3*3*3*2*2=27*4=108 3*3*3*3*1=81, 然后如果最后剩下1就证明前一轮是个4 分为了 3和1，而2*2收益最大class Solution: def cuttingRope(self

python for遍历怎么带下标。enumerate 内置函数递归的大体思路。找到一个然后，深入。不能进入格子两次 这种条件可以通过在当前层改变当前值的方式来避免重入递归的出口。如果四个有任何一个满足就深入，深入 [深入的结果是一个bool值]，如果长度相等返回true，因为上一层递归 l+1 了，，这个有点难理解。l表示走过的长度生成的字符串是不是已经相等了回溯法，本层做完操作了 要还原，不能影响其他层from typing import Listclass Solution: .

/** * @Program: EasyLeetcode * @Description: MergeSort * @Author: Biturd * @Date: 2020-07-07 22:46 */public class MergeSort { public static void main(String[] args) { int[] input = new int[]{ 3, 5, 4, 1, 2 };

思路：用hash表存储所有值，存储。然后遍历数组，用target-当前位置的值并在hash表中判断是不是存在。[3,3],6 : 注意数组中有重复元素的情况，后面的会覆盖前面的元素，所以从前到后，然后遍历hash表就行。[3, 2, 4],6 : 这种情况，就需要判断当前下标与hash表中的索引是不是一样。如果一样 就证明一个元素用了两次class Solution: def __init__(self): self.my_set = {} def tw

树的问题需要多往递归上想。然后中序遍历是三种遍历中最关键的遍历。中序遍历找到先序遍历后 先序遍历之后的几个 = 中序遍历左边的几个class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = Noneclass Solution: def buildTree(self, preorder, inorder): #

思路：先递归，再优化递归。拖慢递归的原因是重复的底层计算。所以计算过一次就存起来。每次计算就判断是不是已经计算过了class Solution: def __init__(self): self.val = {} self.count = 0 def numWays(self, n: int) -> int: # leetcode submit region end(Prohibit modification and deletion

1.s1负责入队操作2.s2中如果没有元素就从s1中出栈出完，s2再出栈3.处理特殊情况，如果是空队列出队。判断两次是否s2空就行class CQueue: def __init__(self): self.s1 = [] self.s2 = [] def appendTail(self, value: int) -> None: self.s1.append(value) def deleteHead(self) -

思路：从右上角开始往左边下边移动。如果从0，0开始，判断一个数如果处于两个数之间了，向下之后还需要向右。两条路[ 右、下 ]都是比当前大的，但是如果是右上角，左边都是小的，下边都是大的，j=1后j=0就肯定不用看了，因为j=0都小于j=1.同理左移的话，右面的数也都不需要看class Solution: def findNumberIn2DArray(self, matrix, target: int) -> bool: # def findNumberIn2DArray

class Solution: def generateParenthesis(self, n: int): # def generateParenthesis(self, n: int) -> List[str]: # leetcode submit region end(Prohibit modification and deletion) ans = [] self.dfs(n, n, ans, '') # 左右括号、an

最大深度class Solution: def maxDepth(self, root: TreeNode) -> int: # leetcode submit region end(Prohibit modification and deletion) if not root: return 0 return 1 + max(self.maxDepth(root.left), self.maxDepth(root.ri

解法一：将链表缓存出来，然后排序 最后出来class Solution: def mergeKLists(self, lists) -> ListNode: # leetcode submit region end(Prohibit modification and deletion) my_list = [] for thelist in lists: i = thelist while i:

class Solution: def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode: # leetcode submit region end(Prohibit modification and deletion) tmp, tmp.next = ListNode(None), head pre = cur = tmp while n:

class Solution: def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode: # leetcode submit region end(Prohibit modification and deletion) ans = cur = ListNode(None) # return flag = 0 while l1 or l2 or flag: