From 573927c575bc14283d0aa49631f6df6577ef9e98 Mon Sep 17 00:00:00 2001 From: codingzjs Date: Mon, 26 Oct 2020 04:37:54 +0800 Subject: [PATCH 01/11] =?UTF-8?q?=E9=87=8D=E6=96=B0=E4=B8=8A=E4=BC=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_01/README.md | 1 - Week_01/hw_week01.py | 46 +++ ...46\344\271\240\347\254\224\350\256\260.md" | 16 + Week_02/README.md | 1 - Week_02/hw_week02.py | 93 ++++++ ...46\344\271\240\347\254\224\350\256\260.md" | 284 ++++++++++++++++++ Week_03/.Rhistory | 0 Week_03/README.md | 1 - Week_03/hw_week03.md | 45 +++ Week_03/summary.md | 21 ++ Week_04/README.md | 1 - 11 files changed, 505 insertions(+), 4 deletions(-) delete mode 100644 Week_01/README.md create mode 100644 Week_01/hw_week01.py create mode 100644 "Week_01/\345\255\246\344\271\240\347\254\224\350\256\260.md" delete mode 100644 Week_02/README.md create mode 100644 Week_02/hw_week02.py create mode 100644 "Week_02/\347\254\254\344\272\214\345\221\250\345\255\246\344\271\240\347\254\224\350\256\260.md" create mode 100644 Week_03/.Rhistory delete mode 100644 Week_03/README.md create mode 100644 Week_03/hw_week03.md create mode 100644 Week_03/summary.md delete mode 100644 Week_04/README.md diff --git a/Week_01/README.md b/Week_01/README.md deleted file mode 100644 index 50de3041..00000000 --- a/Week_01/README.md +++ /dev/null @@ -1 +0,0 @@ -学习笔记 \ No newline at end of file diff --git a/Week_01/hw_week01.py b/Week_01/hw_week01.py new file mode 100644 index 00000000..a8ac301e --- /dev/null +++ b/Week_01/hw_week01.py @@ -0,0 +1,46 @@ +#-*- encoding:utf-8 -*- + +#作业 + +#26.删除排序数组中对重复项 +class Solution: + def removeDuplicates(self, nums: List[int]) -> int: + nums[:] = list(sorted(set(nums))) + return len(nums) + +#1.两数之和 +class Solution: + def twoSum(self, nums: List[int], target: int) -> List[int]: + dic = {} + for index, nums_one in enumerate(nums): + nums_two = target - nums_one + if nums_two in dic: + return [dic[nums_two], index] + dic[nums_one] = index + return None + +#283.移动零 +class Solution: + def moveZeroes(self, nums: List[int]) -> None: + """ + Do not return anything, modify nums in-place instead. + """ + slow = 0 + for fast in range(len(nums)): + if nums[fast] != 0: + nums[slow], nums[fast] = nums[fast], nums[slow] + slow += 1 + +#66.加一 +class Solution: + def plusOne(self, digits: List[int]) -> List[int]: + nums = 0 + for i in range(len(digits)): + nums += digits[i] * pow(10, (len(digits) - 1 - i)) + return [int(j) for j in str(nums + 1)] + +#189.旋转数组 +#21.合并两个有序链表 +#88.合并两个有序数组 +#641.设计循环双端队列 +#42.接雨水 diff --git "a/Week_01/\345\255\246\344\271\240\347\254\224\350\256\260.md" "b/Week_01/\345\255\246\344\271\240\347\254\224\350\256\260.md" new file mode 100644 index 00000000..7b11ad49 --- /dev/null +++ "b/Week_01/\345\255\246\344\271\240\347\254\224\350\256\260.md" @@ -0,0 +1,16 @@ +# 学习笔记 + +### 数组 + +数组是存放在连续内存空间上的相同类型数据的集合 + +常见解题套路： +- 头尾指针夹逼 +- 快慢指针 +- 倒序遍历 + +### 栈 +先进后出 + +### 队列 +先进先出 diff --git a/Week_02/README.md b/Week_02/README.md deleted file mode 100644 index 50de3041..00000000 --- a/Week_02/README.md +++ /dev/null @@ -1 +0,0 @@ -学习笔记 \ No newline at end of file diff --git a/Week_02/hw_week02.py b/Week_02/hw_week02.py new file mode 100644 index 00000000..be4586a4 --- /dev/null +++ b/Week_02/hw_week02.py @@ -0,0 +1,93 @@ +#-*- encoding:utf-8 -*- + +#作业 + +#242.有效的字母异位词 +class Solution: + def isAnagram(self, s: str, t: str) -> bool: + if len(s) != len(t): + return False + sset = set(s) + if sset == set(t): + for i in sset: + if s.count(i) != t.count(i): + return False + return True + else: + return False + +#1.两数之和 +class Solution: + def twoSum(self, nums: List[int], target: int) -> List[int]: + dic = {} + for index, nums_one in enumerate(nums): + nums_two = target - nums_one + if nums_two in dic: + return [dic[nums_two], index] + dic[nums_one] = index + return None + +#589.N叉树的前序遍历 +class Solution: + def preorder(self, root: 'Node') -> List[int]: + if not root: + return [] + def dfs(root, res): + if not root: + return + res.append(root.val) + if not root.children: + return + for child in root.children: + dfs(child,res) + res = [] + dfs(root, res) + return res + +#49.字母异位词分组 +class Solution: + def groupAnagrams(self, strs: List[str]) -> List[List[str]]: + dic = {} + for s in strs: + key = tuple(sorted(s)) + if key not in dic: + dic[key] = [s] + else: + dic[key].append(s) + return list(dic.values()) + +#94.二叉树的中序遍历 +#递归，时间复杂度较高 +class Solution: + def inorderTraversal(self, root: TreeNode) -> List[int]: + if not root: + return [] + return self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right) + +#144.二叉树的前序遍历 +#递归 +class Solution: + def preorderTraversal(self, root: TreeNode) -> List[int]: + if not root: + return [] + return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right) +#栈 +class Solution: + def preorderTraversal(self, root: TreeNode) -> List[int]: + WHITE, GRAY = 0, 1 + res = [] + stack = [(WHITE, root)] + while stack: + color, node = stack.pop() + if node is None: continue + if color == WHITE: + stack.append((WHITE, node.right)) + stack.append((WHITE, node.left)) + stack.append((GRAY, node)) + else: + res.append(node.val) + return res + +#N叉树的层序遍历 +#丑数 +#前K个高频元素 diff --git "a/Week_02/\347\254\254\344\272\214\345\221\250\345\255\246\344\271\240\347\254\224\350\256\260.md" "b/Week_02/\347\254\254\344\272\214\345\221\250\345\255\246\344\271\240\347\254\224\350\256\260.md" new file mode 100644 index 00000000..b9b503b8 --- /dev/null +++ "b/Week_02/\347\254\254\344\272\214\345\221\250\345\255\246\344\271\240\347\254\224\350\256\260.md" @@ -0,0 +1,284 @@ +# 第二周学习笔记 + +## 借鉴Orust【Python3】二叉树所有遍历模板及知识点总结（参考大佬们） + +```python + +# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + + + +# 递归 +# 时间复杂度：O(n)，n为节点数，访问每个节点恰好一次。 +# 空间复杂度：空间复杂度：O(h)，h为树的高度。最坏情况下需要空间O(n)，平均情况为O(logn) + +# 递归1：二叉树遍历最易理解和实现版本 +class Solution: + def preorderTraversal(self, root: TreeNode) -> List[int]: + if not root: + return [] + # 前序递归 + return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right) + # # 中序递归 + # return self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right) + # # 后序递归 + # return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val] + +# 递归2：通用模板，可以适应不同的题目，添加参数、增加返回条件、修改进入递归条件、自定义返回值 +class Solution: + def preorderTraversal(self, root: TreeNode) -> List[int]: + def dfs(cur): + if not cur: + return + # 前序递归 + res.append(cur.val) + dfs(cur.left) + dfs(cur.right) + # # 中序递归 + # dfs(cur.left) + # res.append(cur.val) + # dfs(cur.right) + # # 后序递归 + # dfs(cur.left) + # dfs(cur.right) + # res.append(cur.val) + res = [] + dfs(root) + return res + + + +# 迭代 +# 时间复杂度：O(n)，n为节点数，访问每个节点恰好一次。 +# 空间复杂度：O(h)，h为树的高度。取决于树的结构，最坏情况存储整棵树，即O(n) + +# 迭代1：前序遍历最常用模板（后序同样可以用） +class Solution: + def preorderTraversal(self, root: TreeNode) -> List[int]: + if not root: + return [] + res = [] + stack = [root] + # # 前序迭代模板：最常用的二叉树DFS迭代遍历模板 + while stack: + cur = stack.pop() + res.append(cur.val) + if cur.right: + stack.append(cur.right) + if cur.left: + stack.append(cur.left) + return res + + # # 后序迭代，相同模板：将前序迭代进栈顺序稍作修改，最后得到的结果反转 + # while stack: + # cur = stack.pop() + # if cur.left: + # stack.append(cur.left) + # if cur.right: + # stack.append(cur.right) + # res.append(cur.val) + # return res[::-1] + +# 迭代1：层序遍历最常用模板 +class Solution: + def levelOrder(self, root: TreeNode) -> List[List[int]]: + if not root: + return [] + cur, res = [root], [] + while cur: + lay, layval = [], [] + for node in cur: + layval.append(node.val) + if node.left: lay.append(node.left) + if node.right: lay.append(node.right) + cur = lay + res.append(layval) + return res + + + +# 迭代2：前、中、后序遍历通用模板（只需一个栈的空间） +class Solution: + def inorderTraversal(self, root: TreeNode) -> List[int]: + res = [] + stack = [] + cur = root + # 中序，模板：先用指针找到每颗子树的最左下角，然后进行进出栈操作 + while stack or cur: + while cur: + stack.append(cur) + cur = cur.left + cur = stack.pop() + res.append(cur.val) + cur = cur.right + return res + + # # 前序，相同模板 + # while stack or cur: + # while cur: + # res.append(cur.val) + # stack.append(cur) + # cur = cur.left + # cur = stack.pop() + # cur = cur.right + # return res + + # # 后序，相同模板 + # while stack or cur: + # while cur: + # res.append(cur.val) + # stack.append(cur) + # cur = cur.right + # cur = stack.pop() + # cur = cur.left + # return res[::-1] + + + +# 迭代3：标记法迭代（需要双倍的空间来存储访问状态）： +# 前、中、后、层序通用模板，只需改变进栈顺序或即可实现前后中序遍历， +# 而层序遍历则使用队列先进先出。0表示当前未访问，1表示已访问。 +class Solution: + def preorderTraversal(self, root: TreeNode) -> List[int]: + res = [] + stack = [(0, root)] + while stack: + flag, cur = stack.pop() + if not cur: continue + if flag == 0: + # 前序，标记法 + stack.append((0, cur.right)) + stack.append((0, cur.left)) + stack.append((1, cur)) + + # # 后序，标记法 + # stack.append((1, cur)) + # stack.append((0, cur.right)) + # stack.append((0, cur.left)) + + # # 中序，标记法 + # stack.append((0, cur.right)) + # stack.append((1, cur)) + # stack.append((0, cur.left)) + else: + res.append(cur.val) + return res + + # # 层序，标记法 + # res = [] + # queue = [(0, root)] + # while queue: + # flag, cur = queue.pop(0) # 注意是队列，先进先出 + # if not cur: continue + # if flag == 0: + # 层序遍历这三个的顺序无所谓，因为是队列，只弹出队首元素 + # queue.append((1, cur)) + # queue.append((0, cur.left)) + # queue.append((0, cur.right)) + # else: + # res.append(cur.val) + # return res + + + +# 莫里斯遍历 +# 时间复杂度：O(n)，n为节点数，看似超过O(n)，有的节点可能要访问两次，实际分析还是O(n)，具体参考大佬博客的分析。 +# 空间复杂度：O(1)，如果在遍历过程中就输出节点值，则只需常数空间就能得到中序遍历结果，空间只需两个指针。 +# 如果将结果储存最后输出，则空间复杂度还是O(n)。 + +# PS：莫里斯遍历实际上是在原有二叉树的结构基础上，构造了线索二叉树， +# 线索二叉树定义为：原本为空的右子节点指向了中序遍历顺序之后的那个节点，把所有原本为空的左子节点都指向了中序遍历之前的那个节点 +# emmmm，好像大学教材学过，还考过 + +# 此处只给出中序遍历，前序遍历只需修改输出顺序即可 +# 而后序遍历，由于遍历是从根开始的，而线索二叉树是将为空的左右子节点连接到相应的顺序上，使其能够按照相应准则输出 +# 但是后序遍历的根节点却已经没有额外的空间来标记自己下一个应该访问的节点， +# 所以这里需要建立一个临时节点dump，令其左孩子是root。并且还需要一个子过程，就是倒序输出某两个节点之间路径上的各个节点。 +# 具体参考大佬博客 + +# 莫里斯遍历，借助线索二叉树中序遍历（附前序遍历） +class Solution: + def inorderTraversal(self, root: TreeNode) -> List[int]: + res = [] + # cur = pre = TreeNode(None) + cur = root + + while cur: + if not cur.left: + res.append(cur.val) + # print(cur.val) + cur = cur.right + else: + pre = cur.left + while pre.right and pre.right != cur: + pre = pre.right + if not pre.right: + # print(cur.val) 这里是前序遍历的代码，前序与中序的唯一差别，只是输出顺序不同 + pre.right = cur + cur = cur.left + else: + pre.right = None + res.append(cur.val) + # print(cur.val) + cur = cur.right + return res + + + +# N叉树遍历 +# 时间复杂度：时间复杂度：O(M)，其中 M 是 N 叉树中的节点个数。每个节点只会入栈和出栈各一次。 +# 空间复杂度：O(M)。在最坏的情况下，这棵 N 叉树只有 2 层，所有第 2 层的节点都是根节点的孩子。 +# 将根节点推出栈后，需要将这些节点都放入栈，共有 M−1个节点，因此栈的大小为 O(M)。 + + +""" +# Definition for a Node. +class Node: + def __init__(self, val=None, children=None): + self.val = val + self.children = children +""" + +# N叉树简洁递归 +class Solution: + def preorder(self, root: 'Node') -> List[int]: + if not root: return [] + res = [root.val] + for node in root.children: + res.extend(self.preorder(node)) + return res + +# N叉树通用递归模板 +class Solution: + def preorder(self, root: 'Node') -> List[int]: + res = [] + def helper(root): + if not root: + return + res.append(root.val) + for child in root.children: + helper(child) + helper(root) + return res + +# N叉树迭代方法 +class Solution: + def preorder(self, root: 'Node') -> List[int]: + if not root: + return [] + s = [root] + # s.append(root) + res = [] + while s: + node = s.pop() + res.append(node.val) + # for child in node.children[::-1]: + # s.append(child) + s.extend(node.children[::-1]) + return res +``` \ No newline at end of file diff --git a/Week_03/.Rhistory b/Week_03/.Rhistory new file mode 100644 index 00000000..e69de29b diff --git a/Week_03/README.md b/Week_03/README.md deleted file mode 100644 index 50de3041..00000000 --- a/Week_03/README.md +++ /dev/null @@ -1 +0,0 @@ -学习笔记 \ No newline at end of file diff --git a/Week_03/hw_week03.md b/Week_03/hw_week03.md new file mode 100644 index 00000000..b628c2ad --- /dev/null +++ b/Week_03/hw_week03.md @@ -0,0 +1,45 @@ + +#### 236. 二叉树的最近公共祖先 +[leetcode#236-lowest-common-ancestor-of-a-binary-tree](http://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/) + + +```python +class Solution: + def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': + if not root or root == p or root == q: return root + left = self.lowestCommonAncestor(root.left, p, q) + right = self.lowestCommonAncestor(root.right, p, q) + if not left: return right + if not right: return left + return root +``` +#### 105. 从前序与中序遍历序列构造二叉树 +[leetcode#105-construct-binary-tree-from-preorder-and-inorder-traversal](https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/) + +```python +class Solution: + def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: + if not preorder: + return None + root = TreeNode(preorder[0]) + i = inorder.index(root.val) + root.left = self.buildTree(preorder[1:i + 1], inorder[:i]) + root.right = self.buildTree(preorder[i + 1:], inorder[i+1:]) + return root +``` +#### 46. 全排列 +[leetcode#46-permutations](https://leetcode-cn.com/problems/permutations/) + +```python +class Solution: + def permute(self, nums: List[int]) -> List[List[int]]: + res = [] + def backtrack(nums, tmp): + if not nums: + res.append(tmp) + return + for i in range(len(nums)): + backtrack(nums[:i] + nums[i+1:], tmp + [nums[i]]) + backtrack(nums, []) + return res +``` \ No newline at end of file diff --git a/Week_03/summary.md b/Week_03/summary.md new file mode 100644 index 00000000..a8e076ad --- /dev/null +++ b/Week_03/summary.md @@ -0,0 +1,21 @@ +## 第三周学习笔记 +[参考题解：扒一扒回溯算法的裤子](https://leetcode-cn.com/problems/permutations/solution/hui-su-suan-fa-xiang-jie-by-labuladong-2/) +### 回溯算法框架 +1、路径：也就是已经做出的选择。 + +2、选择列表：也就是你当前可以做的选择。 + +3、结束条件：也就是到达决策树底层，无法再做选择的条件。 + +```python +result = [] +def backtrack(路径, 选择列表): + if 满足结束条件: + result.add(路径) + return + + for 选择 in 选择列表: + 做选择 + backtrack(路径, 选择列表) + 撤销选择 +``` \ No newline at end of file diff --git a/Week_04/README.md b/Week_04/README.md deleted file mode 100644 index 50de3041..00000000 --- a/Week_04/README.md +++ /dev/null @@ -1 +0,0 @@ -学习笔记 \ No newline at end of file From de6622c07dcccfb612403a6d9684a9e038d1a5b5 Mon Sep 17 00:00:00 2001 From: codingzjs Date: Mon, 26 Oct 2020 04:40:46 +0800 Subject: [PATCH 02/11] =?UTF-8?q?=E7=AC=AC=E5=9B=9B=E5=91=A8=E5=AD=A6?= =?UTF-8?q?=E4=B9=A0=E7=AC=94=E8=AE=B0=E4=B8=8E=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_04/.Rhistory | 0 Week_04/hw_week04.md | 59 ++++++++++++++++++++++++++++++++++++++++ Week_04/summary_week4.md | 25 +++++++++++++++++ 3 files changed, 84 insertions(+) create mode 100644 Week_04/.Rhistory create mode 100644 Week_04/hw_week04.md create mode 100644 Week_04/summary_week4.md diff --git a/Week_04/.Rhistory b/Week_04/.Rhistory new file mode 100644 index 00000000..e69de29b diff --git a/Week_04/hw_week04.md b/Week_04/hw_week04.md new file mode 100644 index 00000000..3007d202 --- /dev/null +++ b/Week_04/hw_week04.md @@ -0,0 +1,59 @@ + +#### 860. 柠檬水找零 +[leetcode#860-lemonade-change](https://leetcode-cn.com/problems/lemonade-change/) + + +```python +#此题思路主要是找零的所有情况理清，找零时10+5优先于3*5 +class Solution: + def lemonadeChange(self, bills: List[int]) -> bool: + five = ten = 0 + for bill in bills: + if bill == 5: + five += 1 + elif bill == 10: + if not five: return False + five -= 1 + ten += 1 + else: + if ten and five: + ten -= 1 + five -= 1 + elif five >= 3: + five -= 3 + else: + return False + return True +``` +#### 122. 买卖股票的最佳时机 II +[leetcode#122-best-time-to-buy-and-sell-stock-ii](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/) + +```python +#主要思路为等价于每天都做买卖：遍历整个股票交易日价格列表price +#所有上涨交易日都买卖（赚到所有利润），所有下降交易日都不买卖（永不亏钱） +class Solution: + def maxProfit(self, prices: List[int]) -> int: + profit = 0 + for i in range(1, len(prices)): + tmp = prices[i] - prices[i-1] + if tmp > 0: profit += tmp + return profit +``` +#### 455. 分发饼干 +[leetcode#455-assign-cookies](https://leetcode-cn.com/problems/assign-cookies/description/) + +```python +#先排序。利用贪心算法的思想：每次都先满足胃口最小的孩子，直到有效饼干分完， +#或者小胃口孩子都被满足则停止分发。 +class Solution: + def findContentChildren(self, g: List[int], s: List[int]) -> int: + g.sort() + s.sort() + n = 0 + for size in s: + if n == len(g): + break + if size >= g[n]: + n += 1 + return n +``` \ No newline at end of file diff --git a/Week_04/summary_week4.md b/Week_04/summary_week4.md new file mode 100644 index 00000000..d5354c5d --- /dev/null +++ b/Week_04/summary_week4.md @@ -0,0 +1,25 @@ +## 第四周学习笔记 + +### 贪心算法和动态规划： +**相同点**：都是一种递推算法 即均由局部最优解来推导全局最优解 + +**不同点**： + +**贪心算法**： 每一步的最优解一定包含上一步的最优解，上一步之前的最优解则不作保留，换句话说就是一开始就定好了最优策略 + +**动态规划**：记录之前的所有的局部最优解，可以列出递归公式。代码非常套路，一般都是设一个二维数组或者一维数组记录中间结果。 + +### 贪心算法题目： + +[122. 买卖股票的最佳时机 II](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/) + +[455. 分发饼干](https://leetcode-cn.com/problems/assign-cookies/) + +[860. 柠檬水找零](https://leetcode-cn.com/problems/lemonade-change/) + +[874. 模拟行走机器人](https://leetcode-cn.com/problems/walking-robot-simulation/) + +[944. 删列造序](https://leetcode-cn.com/problems/delete-columns-to-make-sorted/) + +[1005. K 次取反后最大化的数组和](https://leetcode-cn.com/problems/maximize-sum-of-array-after-k-negations/) + From e8ebc92cd0b718408372d191620144c65cf81e0b Mon Sep 17 00:00:00 2001 From: codingzjs Date: Mon, 26 Oct 2020 04:42:31 +0800 Subject: [PATCH 03/11] =?UTF-8?q?=E7=AC=AC=E4=B8=80=E5=91=A8=E5=AD=A6?= =?UTF-8?q?=E4=B9=A0=E7=AC=94=E8=AE=B0=E4=B8=8E=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../summary_week1.md | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename "Week_01/\345\255\246\344\271\240\347\254\224\350\256\260.md" => Week_01/summary_week1.md (100%) diff --git "a/Week_01/\345\255\246\344\271\240\347\254\224\350\256\260.md" b/Week_01/summary_week1.md similarity index 100% rename from "Week_01/\345\255\246\344\271\240\347\254\224\350\256\260.md" rename to Week_01/summary_week1.md From d86d4a05d12f509972baab33a0db2a6c2a2b3ede Mon Sep 17 00:00:00 2001 From: codingzjs Date: Sun, 8 Nov 2020 23:27:55 +0800 Subject: [PATCH 04/11] =?UTF-8?q?=E7=AC=AC=E5=85=AD=E5=91=A8=E5=AD=A6?= =?UTF-8?q?=E4=B9=A0=E7=AC=94=E8=AE=B0=E4=B8=8E=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_06/README.md | 1 - Week_06/hw_week06.md | 42 ++++++++++++++++++++++++++++++++++++++++ Week_06/summary_week6.md | 17 ++++++++++++++++ 3 files changed, 59 insertions(+), 1 deletion(-) delete mode 100644 Week_06/README.md create mode 100644 Week_06/hw_week06.md create mode 100644 Week_06/summary_week6.md diff --git a/Week_06/README.md b/Week_06/README.md deleted file mode 100644 index 50de3041..00000000 --- a/Week_06/README.md +++ /dev/null @@ -1 +0,0 @@ -学习笔记 \ No newline at end of file diff --git a/Week_06/hw_week06.md b/Week_06/hw_week06.md new file mode 100644 index 00000000..7e1c3642 --- /dev/null +++ b/Week_06/hw_week06.md @@ -0,0 +1,42 @@ + +#### 64. 最小路径和 +[leetcode#64-minimum-path-sum](https://leetcode-cn.com/problems/minimum-path-sum/) + +```python +class Solution: + def minPathSum(self, grid: List[List[int]]) -> int: + if not grid or not grid[0]: + return 0 + + rows, columns = len(grid), len(grid[0]) + dp = [[0] * columns for row in range(rows)] + dp[0][0] = grid[0][0] + for i in range(1, rows): + dp[i][0] = dp[i-1][0] + grid[i][0] + for j in range(1, columns): + dp[0][j] = dp[0][j-1] + grid[0][j] + for i in range(1, rows): + for j in range(1, columns): + dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j] + + return dp[rows - 1][columns - 1] +``` +#### 91. 解码方法 +[leetcode#91-decode-ways](https://leetcode-cn.com/problems/decode-ways/) + +```python +class Solution: + def numDecodings(self, s: str) -> int: + n = len(s) + if n==0: return 0 + dp = [1,0] + dp[1] = 1 if s[0]!='0' else 0 + for i in range(1,n): + dp.append(0) + if s[i]!='0': + dp[i+1] += dp[i] + if s[i-1:i+1]>='10' and s[i-1:i+1]<='26': + dp[i+1] += dp[i-1] + + return dp[-1] +``` diff --git a/Week_06/summary_week6.md b/Week_06/summary_week6.md new file mode 100644 index 00000000..5f47d83d --- /dev/null +++ b/Week_06/summary_week6.md @@ -0,0 +1,17 @@ +## 第六周学习笔记 + +### 贪心算法和动态规划： +**相同点**：都是一种递推算法 即均由局部最优解来推导全局最优解 + +**不同点**： + +**贪心算法**： 每一步的最优解一定包含上一步的最优解，上一步之前的最优解则不作保留，换句话说就是一开始就定好了最优策略 + +**动态规划**：记录之前的所有的局部最优解，可以列出递归公式。代码非常套路，一般都是设一个二维数组或者一维数组记录中间结果。 + +### 动态规划关键点 +1. 最优子结构 opt[n] = best_of(opt[n-1], opt[n-2], ...) +2. 储存中间状态:opt[i] +3. 递推公式(美其名曰:状态转移方程或者 DP 方程) +Fib: opt[i] = opt[n-1] + opt[n-2] +二维路径:opt[i,j] = opt[i+1][j] + opt[i][j+1] (且判断a[i,j]是否空地) \ No newline at end of file From 468a94425b88193b2723356e65f7af0c692e89ad Mon Sep 17 00:00:00 2001 From: codingzjs Date: Sun, 15 Nov 2020 23:33:51 +0800 Subject: [PATCH 05/11] =?UTF-8?q?=E7=AC=AC=E4=B8=83=E5=91=A8=E5=AD=A6?= =?UTF-8?q?=E4=B9=A0=E7=AC=94=E8=AE=B0=E4=B8=8E=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_07/README.md | 1 - Week_07/hw_week07.md | 76 ++++++++++++++++++++++++++++++++++++++++ Week_07/summary_week7.md | 66 ++++++++++++++++++++++++++++++++++ 3 files changed, 142 insertions(+), 1 deletion(-) delete mode 100644 Week_07/README.md create mode 100644 Week_07/hw_week07.md create mode 100644 Week_07/summary_week7.md diff --git a/Week_07/README.md b/Week_07/README.md deleted file mode 100644 index 50de3041..00000000 --- a/Week_07/README.md +++ /dev/null @@ -1 +0,0 @@ -学习笔记 \ No newline at end of file diff --git a/Week_07/hw_week07.md b/Week_07/hw_week07.md new file mode 100644 index 00000000..2e740822 --- /dev/null +++ b/Week_07/hw_week07.md @@ -0,0 +1,76 @@ + +#### 208. 实现 Trie (前缀树) +[leetcode#208-implement-trie-prefix-tree](https://leetcode-cn.com/problems/implement-trie-prefix-tree/submissions/) + +```python +class Trie: + + def __init__(self): + """ + Initialize your data structure here. + """ + self.lookup = {} + + + def insert(self, word: str) -> None: + """ + Inserts a word into the trie. + """ + tree = self.lookup + for a in word: + if a not in tree: + tree[a] = {} + tree = tree[a] + # 单词结束标志 + tree["#"] = "#" + + + def search(self, word: str) -> bool: + """ + Returns if the word is in the trie. + """ + tree = self.lookup + for a in word: + if a not in tree: + return False + tree = tree[a] + if "#" in tree: + return True + return False + + + def startsWith(self, prefix: str) -> bool: + """ + Returns if there is any word in the trie that starts with the given prefix. + """ + tree = self.lookup + for a in prefix: + if a not in tree: + return False + tree = tree[a] + return True +``` +#### 547. 朋友圈 +[leetcode#547-friend-circles](https://leetcode-cn.com/problems/friend-circles/) + +```python +class Solution: + def findCircleNum(self, M: List[List[int]]) -> int: + N = len(M) + count = 0 + visited = set() + + def dfs(i): + for j in range(N): + if M[i][j] and j not in visited: + visited.add(j) + dfs(j) + + for i in range(N): + if i not in visited: + count += 1 + visited.add(i) + dfs(i) + + return count +``` diff --git a/Week_07/summary_week7.md b/Week_07/summary_week7.md new file mode 100644 index 00000000..926ea454 --- /dev/null +++ b/Week_07/summary_week7.md @@ -0,0 +1,66 @@ +## 第七周学习笔记 + +### Trie树的特点 +1. 根节点不包含字符， 除根节点外每一个节点都只包含一个字符。 + +2. 从根节点到某一节点， 路径上经过的字符连接起来， 为该节点对应的字符串。 + +3. 在trie树中查找一个关键字的时间和树中包含的结点数无关， 而取决于组成关键字的字符数。 也就是查找字符串s的时间为O(len(s)) + + +### Trie树的实现 +```python +class Trie: + + def __init__(self): + """ + Initialize your data structure here. + """ + self.lookup = {} + + + def insert(self, word: str) -> None: + """ + Inserts a word into the trie. + """ + tree = self.lookup + for a in word: + if a not in tree: + tree[a] = {} + tree = tree[a] + # 单词结束标志 + tree["#"] = "#" + + + def search(self, word: str) -> bool: + """ + Returns if the word is in the trie. + """ + tree = self.lookup + for a in word: + if a not in tree: + return False + tree = tree[a] + if "#" in tree: + return True + return False + + + def startsWith(self, prefix: str) -> bool: + """ + Returns if there is any word in the trie that starts with the given prefix. + """ + tree = self.lookup + for a in prefix: + if a not in tree: + return False + tree = tree[a] + return True +``` +### 相关题型 + +[211. 添加与搜索单词 - 数据结构设计](https://leetcode-cn.com/problems/design-add-and-search-words-data-structure/) + +[212. 单词搜索 II](https://leetcode-cn.com/problems/word-search-ii/) + +[421. 数组中两个数的最大异或值](https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/) \ No newline at end of file From 6d1a3f283b278fdc388fb2ef958d57aeb144e125 Mon Sep 17 00:00:00 2001 From: codingzjs Date: Sun, 22 Nov 2020 23:54:37 +0800 Subject: [PATCH 06/11] =?UTF-8?q?=E7=AC=AC=E5=85=AB=E5=91=A8=E5=AD=A6?= =?UTF-8?q?=E4=B9=A0=E7=AC=94=E8=AE=B0=E4=B8=8E=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_08/README.md | 1 - Week_08/hw_week08.md | 89 +++++++++++++++++++++++ Week_08/summary_week8.md | 151 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 240 insertions(+), 1 deletion(-) delete mode 100644 Week_08/README.md create mode 100644 Week_08/hw_week08.md create mode 100644 Week_08/summary_week8.md diff --git a/Week_08/README.md b/Week_08/README.md deleted file mode 100644 index 50de3041..00000000 --- a/Week_08/README.md +++ /dev/null @@ -1 +0,0 @@ -学习笔记 \ No newline at end of file diff --git a/Week_08/hw_week08.md b/Week_08/hw_week08.md new file mode 100644 index 00000000..d32a9cd8 --- /dev/null +++ b/Week_08/hw_week08.md @@ -0,0 +1,89 @@ + +#### 146. LRU 缓存机制 +[leetcode#146-lru-cache](https://leetcode-cn.com/problems/lru-cache/) + +```python +class DLinkedNode: + def __init__(self, key=0, value=0): + self.key = key + self.value = value + self.prev = None + self.next = None + + +class LRUCache: + + def __init__(self, capacity: int): + self.cache = dict() + # 使用伪头部和伪尾部节点 + self.head = DLinkedNode() + self.tail = DLinkedNode() + self.head.next = self.tail + self.tail.prev = self.head + self.capacity = capacity + self.size = 0 + + def get(self, key: int) -> int: + if key not in self.cache: + return -1 + # 如果 key 存在，先通过哈希表定位，再移到头部 + node = self.cache[key] + self.moveToHead(node) + return node.value + + def put(self, key: int, value: int) -> None: + if key not in self.cache: + # 如果 key 不存在，创建一个新的节点 + node = DLinkedNode(key, value) + # 添加进哈希表 + self.cache[key] = node + # 添加至双向链表的头部 + self.addToHead(node) + self.size += 1 + if self.size > self.capacity: + # 如果超出容量，删除双向链表的尾部节点 + removed = self.removeTail() + # 删除哈希表中对应的项 + self.cache.pop(removed.key) + self.size -= 1 + else: + # 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部 + node = self.cache[key] + node.value = value + self.moveToHead(node) + + def addToHead(self, node): + node.prev = self.head + node.next = self.head.next + self.head.next.prev = node + self.head.next = node + + def removeNode(self, node): + node.prev.next = node.next + node.next.prev = node.prev + + def moveToHead(self, node): + self.removeNode(node) + self.addToHead(node) + + def removeTail(self): + node = self.tail.prev + self.removeNode(node) + return node +``` +#### 56. 合并区间 +[leetcode#56-merge-interval](https://leetcode-cn.com/problems/merge-intervals/) + +```python +class Solution: + def merge(self, intervals: List[List[int]]) -> List[List[int]]: + if not intervals: return [] + intervals.sort() + res = [intervals[0]] + for x, y in intervals[1:]: + if res[-1][1] < x: + res.append([x, y]) + else: + res[-1][1] = max(y, res[-1][1]) + return res +``` diff --git a/Week_08/summary_week8.md b/Week_08/summary_week8.md new file mode 100644 index 00000000..4cdf1ff4 --- /dev/null +++ b/Week_08/summary_week8.md @@ -0,0 +1,151 @@ +## 第八周学习笔记 + +### 十大经典排序算法python实现 +#### 选择排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + # selection sort + n = len(nums) + for i in range(n): + for j in range(i,n): + if nums[i] > nums[j]: + nums[i],nums[j] = nums[j],nums[i] + #print(nums) + return nums +``` +#### 冒泡排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + # bubble sort + n = len(nums) + # 进行多次循环 + for c in range(n): + for i in range(1, n - c): + if nums[i - 1] > nums[i]: + nums[i - 1], nums[i] = nums[i], nums[i - 1] + return nums +``` +#### 插入排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + # insert sort + n = len(nums) + for i in range(1,n): + while i > 0 and nums[i-1] > nums[i]: + nums[i-1],nums[i] = nums[i],nums[i-1] + i -= 1 + return nums +``` +#### 希尔排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + #shell sort + n = len(nums) + gap = n // 2 + while gap: + for i in range(gap, n): + while i - gap >= 0 and nums[i - gap] > nums[i]: + nums[i - gap], nums[i] = nums[i], nums[i - gap] + i -= gap + gap //= 2 + return nums +``` +#### 归并排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + #merge sort + res = [] + mid = len(nums) //2 + left, right = nums[:mid],nums[mid:] + if len(left) > 1: left = self.sortArray(left) + if len(right) > 1: right = self.sortArray(right) + + while left and right: + if left[-1] >= right[-1]: + res.append(left.pop()) + else: + res.append(right.pop()) + res.reverse() + return (left or right) + res # 将剩余left或right中的数和res合并 +``` +#### 快速排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + #quick sort + n = len(nums) + first = 0 + last = n - 1 + self.quickSorthepler(nums,first,last) + return nums + + def partition(self, alist, first, last): + left = first + right = last + pivot = alist[first] + while left < right: + while left < right and alist[right] >= pivot: + right -= 1 + alist[left] = alist[right] + while left < right and alist[left] <= pivot: + left += 1 + alist[right] = alist[left] + alist[left] = pivot + return left + + def quickSorthepler(self, alist, first,last): + if first < last: + pointmark = self.partition(alist,first,last) + self.quickSorthepler(alist,first,pointmark-1) + self.quickSorthepler(alist, pointmark + 1, last) +``` +#### 堆排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + #heap sort + n = len(nums) + def build_heap(nums, start, end): # 建堆的同时调整堆 + newitem = nums[start] + cur = start + leftpos = 2 * cur + 1 + while leftpos < end: + rightpos = leftpos + 1 + if rightpos < end and nums[rightpos] >= nums[leftpos]: + leftpos = rightpos + if newitem < nums[leftpos]: + nums[cur] = nums[leftpos] + cur = leftpos + leftpos = 2 * cur + 1 + else: + break + nums[cur] = newitem + for i in reversed(range(n//2)): # 建堆+调整 + build_heap(nums, i, n) + for i in range(n-1,-1,-1): + nums[0],nums[i] = nums[i],nums[0] #排序 + build_heap(nums,0,i) #调整 + return nums +``` +#### 计数排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + from collections import defaultdict + + def counter_sort(nums,key=lambda x:x): + #counter sort + B,C = [], defaultdict(list) + for x in nums: + C[key(x)].append(x) # {1:1,2:2,......} + for k in range(min(C), max(C) + 1): + B.extend(C[k]) + return B + res = counter_sort(nums) + return res +``` \ No newline at end of file From bca95d4e7fd1864c105745e3df49c5252f4a5a0f Mon Sep 17 00:00:00 2001 From: codingzjs Date: Mon, 23 Nov 2020 00:02:44 +0800 Subject: [PATCH 07/11] =?UTF-8?q?=E7=AC=AC=E5=85=AB=E5=91=A8=E5=AD=A6?= =?UTF-8?q?=E4=B9=A0=E7=AC=94=E8=AE=B0=E4=B8=8E=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_08/summary_week8.md | 69 +++++++++++++++++++++++++++++++++++----- 1 file changed, 61 insertions(+), 8 deletions(-) diff --git a/Week_08/summary_week8.md b/Week_08/summary_week8.md index 4cdf1ff4..771510a4 100644 --- a/Week_08/summary_week8.md +++ b/Week_08/summary_week8.md @@ -1,7 +1,7 @@ ## 第八周学习笔记 ### 十大经典排序算法python实现 -#### 选择排序 +#### 1.选择排序 ```python class Solution: def sortArray(self, nums: List[int]) -> List[int]: @@ -14,7 +14,7 @@ class Solution: #print(nums) return nums ``` -#### 冒泡排序 +#### 2.冒泡排序 ```python class Solution: def sortArray(self, nums: List[int]) -> List[int]: @@ -27,7 +27,7 @@ class Solution: nums[i - 1], nums[i] = nums[i], nums[i - 1] return nums ``` -#### 插入排序 +#### 3.插入排序 ```python class Solution: def sortArray(self, nums: List[int]) -> List[int]: @@ -39,7 +39,7 @@ class Solution: i -= 1 return nums ``` -#### 希尔排序 +#### 4.希尔排序 ```python class Solution: def sortArray(self, nums: List[int]) -> List[int]: @@ -54,7 +54,7 @@ class Solution: gap //= 2 return nums ``` -#### 归并排序 +#### 5.归并排序 ```python class Solution: def sortArray(self, nums: List[int]) -> List[int]: @@ -73,7 +73,7 @@ class Solution: res.reverse() return (left or right) + res # 将剩余left或right中的数和res合并 ``` -#### 快速排序 +#### 6.快速排序 ```python class Solution: def sortArray(self, nums: List[int]) -> List[int]: @@ -104,7 +104,7 @@ class Solution: self.quickSorthepler(alist,first,pointmark-1) self.quickSorthepler(alist, pointmark + 1, last) ``` -#### 堆排序 +#### 7.堆排序 ```python class Solution: def sortArray(self, nums: List[int]) -> List[int]: @@ -132,7 +132,7 @@ class Solution: build_heap(nums,0,i) #调整 return nums ``` -#### 计数排序 +#### 8.计数排序 ```python class Solution: def sortArray(self, nums: List[int]) -> List[int]: @@ -148,4 +148,57 @@ class Solution: return B res = counter_sort(nums) return res +``` +#### 9.桶排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + #bucket sort + if len(nums) < 2: + return nums + _min = min(nums) + _max = max(nums) + # 需要桶个数 + bucketNum = (_max - _min) // bucketSize + 1 + buckets = [[] for _ in range(bucketNum)] + for num in nums: + # 放入相应的桶中 + buckets[(num - _min) // bucketSize].append(num) + res = [] + + for bucket in buckets: + if not bucket: continue + if bucketSize == 1: + res.extend(bucket) + else: + # 当都装在一个桶里,说明桶容量大了 + if bucketNum == 1: + bucketSize -= 1 + res.extend(bucket_sort(bucket, bucketSize)) + return res +``` +#### 10.基数排序 +```python +class Solution: + def sortArray(self, nums: List[int]) -> List[int]: + #radix sort + if not nums: return [] + _max = max(nums) + # 最大位数 + maxDigit = len(str(_max)) + bucketList = [[] for _ in range(10)] + # 从低位开始排序 + div, mod = 1, 10 + for i in range(maxDigit): + for num in nums: + bucketList[num % mod // div].append(num) + div *= 10 + mod *= 10 + idx = 0 + for j in range(10): + for item in bucketList[j]: + nums[idx] = item + idx += 1 + bucketList[j] = [] + return nums ``` \ No newline at end of file From 6e7de300fd04eeef13bc30b92103a868a09b6d4d Mon Sep 17 00:00:00 2001 From: codingzjs Date: Sun, 29 Nov 2020 23:57:16 +0800 Subject: [PATCH 08/11] =?UTF-8?q?=E7=AC=AC=E4=B9=9D=E5=91=A8=E5=AD=A6?= =?UTF-8?q?=E4=B9=A0=E7=AC=94=E8=AE=B0=E4=B8=8E=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_09/README.md | 1 - Week_09/hw_week09.md | 40 ++++++++++++++++++++++++++++++++++++++++ Week_09/summary_week9.md | 39 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 79 insertions(+), 1 deletion(-) delete mode 100644 Week_09/README.md create mode 100644 Week_09/hw_week09.md create mode 100644 Week_09/summary_week9.md diff --git a/Week_09/README.md b/Week_09/README.md deleted file mode 100644 index 50de3041..00000000 --- a/Week_09/README.md +++ /dev/null @@ -1 +0,0 @@ -学习笔记 \ No newline at end of file diff --git a/Week_09/hw_week09.md b/Week_09/hw_week09.md new file mode 100644 index 00000000..697f0ac8 --- /dev/null +++ b/Week_09/hw_week09.md @@ -0,0 +1,40 @@ + +#### 541. 反转字符串 II +[leetcode#541-reverse-string-ii](https://leetcode-cn.com/problems/reverse-string-ii/) + +```python +class Solution: + def reverseStr(self, s: str, k: int) -> str: + slist = list(s) + for i in range(0, len(slist), 2 * k): + slist[i:i+k] = reversed(slist[i:i+k]) + return "".join(slist) +``` +#### 91. 解码方法 +[leetcode#91-decode-ways](https://leetcode-cn.com/problems/decode-ways/) + +```python +class Solution: + def numDecodings(self, s: str) -> int: + size=len(s) + if not s or s[0]=="0": + return 0 + dp=[0]*(size+1) + dp[0], dp[1] = 1, 1 + #dp[i]表示s[:i-1]的解码方法 + for i in range(1,size): + if s[i]=="0":#如果当前位为0 + if s[i-1] == "1" or s[i-1] == "2":#它最多能与前一位合并，也就是与s[:i-2]的解码方法树相同-->dp[i-1] + dp[i+1] = dp[i-1] + else: + return 0 + else: + #s[i]!='0'说明有可能可以单独解码，也可能与上一个合并后解码 + # s[i]单独解码--> 解码总数与s[:i-1]的解码方法一致 --> dp[i] + # s[i]与s[i-1]合并解码 -->解码总数与s[:i-2]的解码方法总数一致-->dp[i-1] + if '10'<=s[i-1:i+1]<='26': + dp[i+1] = dp[i]+dp[i-1] + else: + dp[i+1] = dp[i] + return dp[-1] +``` diff --git a/Week_09/summary_week9.md b/Week_09/summary_week9.md new file mode 100644 index 00000000..b8c5e3d2 --- /dev/null +++ b/Week_09/summary_week9.md @@ -0,0 +1,39 @@ +## 第九周学习笔记 + +#### 63. 不同路径 II +[leetcode#63-unique-paths-ii](https://leetcode-cn.com/problems/unique-paths-ii/) +```python +#状态转移方程：dp[i][j]=dp[i−1,j]+dp[i,j−1] if(i,j)上无障碍物 +# dp[i][j]= 0 if(i,j)上有障碍物 +# dp[i][j] 表示走到格子(i,j)的方法数 +class Solution(object): + def uniquePathsWithObstacles(self, obstacleGrid): + + r, l = len(obstacleGrid), len(obstacleGrid[0]) + + for i in range(r): + + for j in range(l): + + if obstacleGrid[i][j] != 1: + + if i == 0 and j == 0: + + obstacleGrid[i][j] = 1 + + elif i == 0 and j != 0: + + obstacleGrid[i][j] = obstacleGrid[i][j-1] + + elif i != 0 and j == 0: + + obstacleGrid[i][j] = obstacleGrid[i - 1][j] + + else: + obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1] + + else: + obstacleGrid[i][j] = 0 + + return obstacleGrid[r - 1][l - 1] +``` \ No newline at end of file From 801b8fc281014fa51abfef962150f9f9d8c0b177 Mon Sep 17 00:00:00 2001 From: codingzjs Date: Sun, 13 Dec 2020 23:53:55 +0800 Subject: [PATCH 09/11] =?UTF-8?q?=E6=AF=95=E4=B8=9A=E6=80=BB=E7=BB=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_10/README.md | 1 - Week_10/summary.md | 39 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 1 deletion(-) delete mode 100644 Week_10/README.md create mode 100644 Week_10/summary.md diff --git a/Week_10/README.md b/Week_10/README.md deleted file mode 100644 index 50de3041..00000000 --- a/Week_10/README.md +++ /dev/null @@ -1 +0,0 @@ -学习笔记 \ No newline at end of file diff --git a/Week_10/summary.md b/Week_10/summary.md new file mode 100644 index 00000000..b8c5e3d2 --- /dev/null +++ b/Week_10/summary.md @@ -0,0 +1,39 @@ +## 第九周学习笔记 + +#### 63. 不同路径 II +[leetcode#63-unique-paths-ii](https://leetcode-cn.com/problems/unique-paths-ii/) +```python +#状态转移方程：dp[i][j]=dp[i−1,j]+dp[i,j−1] if(i,j)上无障碍物 +# dp[i][j]= 0 if(i,j)上有障碍物 +# dp[i][j] 表示走到格子(i,j)的方法数 +class Solution(object): + def uniquePathsWithObstacles(self, obstacleGrid): + + r, l = len(obstacleGrid), len(obstacleGrid[0]) + + for i in range(r): + + for j in range(l): + + if obstacleGrid[i][j] != 1: + + if i == 0 and j == 0: + + obstacleGrid[i][j] = 1 + + elif i == 0 and j != 0: + + obstacleGrid[i][j] = obstacleGrid[i][j-1] + + elif i != 0 and j == 0: + + obstacleGrid[i][j] = obstacleGrid[i - 1][j] + + else: + obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1] + + else: + obstacleGrid[i][j] = 0 + + return obstacleGrid[r - 1][l - 1] +``` \ No newline at end of file From 70e0601bf3abfc62df6428f9721135a05faa863f Mon Sep 17 00:00:00 2001 From: codingzjs Date: Mon, 14 Dec 2020 00:21:25 +0800 Subject: [PATCH 10/11] =?UTF-8?q?=E6=AF=95=E4=B8=9A=E6=80=BB=E7=BB=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Week_10/summary.md | 57 +++++++++++++++------------------------------- 1 file changed, 18 insertions(+), 39 deletions(-) diff --git a/Week_10/summary.md b/Week_10/summary.md index b8c5e3d2..eba5eb77 100644 --- a/Week_10/summary.md +++ b/Week_10/summary.md @@ -1,39 +1,18 @@ -## 第九周学习笔记 - -#### 63. 不同路径 II -[leetcode#63-unique-paths-ii](https://leetcode-cn.com/problems/unique-paths-ii/) -```python -#状态转移方程：dp[i][j]=dp[i−1,j]+dp[i,j−1] if(i,j)上无障碍物 -# dp[i][j]= 0 if(i,j)上有障碍物 -# dp[i][j] 表示走到格子(i,j)的方法数 -class Solution(object): - def uniquePathsWithObstacles(self, obstacleGrid): - - r, l = len(obstacleGrid), len(obstacleGrid[0]) - - for i in range(r): - - for j in range(l): - - if obstacleGrid[i][j] != 1: - - if i == 0 and j == 0: - - obstacleGrid[i][j] = 1 - - elif i == 0 and j != 0: - - obstacleGrid[i][j] = obstacleGrid[i][j-1] - - elif i != 0 and j == 0: - - obstacleGrid[i][j] = obstacleGrid[i - 1][j] - - else: - obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1] - - else: - obstacleGrid[i][j] = 0 - - return obstacleGrid[r - 1][l - 1] -``` \ No newline at end of file +## 毕业总结 + +#### 学习要点 +#####五毒神掌 +1. 第一遍 +五分钟：读题 + 思考 +直接看解法：多看几种，比较解法优劣 +背诵、默写好的解法 +2. 第二遍 +马上自己写 ——> Leetcode提交 +多种解法比较、体会 ——> 优化！ +3. 第三遍 +过了一天后，再重复做题 +不同解法的熟练程度——>专项练习 +4. 第四遍 +过了一周后：反复回来练习相同的题目 +5. 第五遍 +面试前一周恢复性训练 \ No newline at end of file From b0b20e7cbbe854d7b1bfbc87d6154cd0b99d037a Mon Sep 17 00:00:00 2001 From: CodingZjs <70746878+codingzjs@users.noreply.github.com> Date: Mon, 20 Mar 2023 15:23:06 +0800 Subject: [PATCH 11/11] Add files via upload --- prediction_pp.ipynb | 2348 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2348 insertions(+) create mode 100644 prediction_pp.ipynb diff --git a/prediction_pp.ipynb b/prediction_pp.ipynb new file mode 100644 index 00000000..87993c78 --- /dev/null +++ b/prediction_pp.ipynb @@ -0,0 +1,2348 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "import pandas as pd\n", + "pd.set_option('max_rows', 200)\n", + "import numpy as np\n", + "from pprint import pprint\n", + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from datetime import datetime, timedelta\n", + "\n", + "\n", + "plt.style.use('ggplot')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "data_dir = './data/'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(702, 7)\n" + ] + } + ], + "source": [ + "df_pred_ori = pd.read_csv(\n", + " os.path.join(data_dir, 'df_bal_target_pred_ori.csv'), \n", + " parse_dates=['DATE', 'DATE_target']\n", + ")\n", + "print(df_pred_ori.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DATEDATE_targetbal_target_pred_cor_currentbal_target_pred_cor_fixedbal_target_pred_idv_currentbal_target_pred_idv_fixedbal_target_pred_ziying_total
02020-04-302020-05-29174751434710477630248949
12020-05-062020-05-29174471422010532625748758
22020-05-072020-05-29174911414010528629848762
32020-05-082020-05-29174151425810639626548833
42020-05-092020-05-29172661426510656626548806
........................
6972023-02-212023-02-282437016182180911108069741
6982023-02-222023-02-282447616173181581109369971
6992023-02-232023-02-282446916665180541108870322
7002023-02-242023-02-282448916213181411111170120
7012023-02-272023-02-282470516315179481111470049
\n", + "

702 rows × 7 columns

\n", + "
" + ], + "text/plain": [ + " DATE DATE_target bal_target_pred_cor_current \\\n", + "0 2020-04-30 2020-05-29 17475 \n", + "1 2020-05-06 2020-05-29 17447 \n", + "2 2020-05-07 2020-05-29 17491 \n", + "3 2020-05-08 2020-05-29 17415 \n", + "4 2020-05-09 2020-05-29 17266 \n", + ".. ... ... ... \n", + "697 2023-02-21 2023-02-28 24370 \n", + "698 2023-02-22 2023-02-28 24476 \n", + "699 2023-02-23 2023-02-28 24469 \n", + "700 2023-02-24 2023-02-28 24489 \n", + "701 2023-02-27 2023-02-28 24705 \n", + "\n", + " bal_target_pred_cor_fixed bal_target_pred_idv_current \\\n", + "0 14347 10477 \n", + "1 14220 10532 \n", + "2 14140 10528 \n", + "3 14258 10639 \n", + "4 14265 10656 \n", + ".. ... ... \n", + "697 16182 18091 \n", + "698 16173 18158 \n", + "699 16665 18054 \n", + "700 16213 18141 \n", + "701 16315 17948 \n", + "\n", + " bal_target_pred_idv_fixed bal_target_pred_ziying_total \n", + "0 6302 48949 \n", + "1 6257 48758 \n", + "2 6298 48762 \n", + "3 6265 48833 \n", + "4 6265 48806 \n", + ".. ... ... \n", + "697 11080 69741 \n", + "698 11093 69971 \n", + "699 11088 70322 \n", + "700 11111 70120 \n", + "701 11114 70049 \n", + "\n", + "[702 rows x 7 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_pred_ori" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2553, 6)\n" + ] + } + ], + "source": [ + "df_gt_ori = pd.read_csv(os.path.join(data_dir, 'df_bal_gt.csv'), parse_dates=['DATE'])\n", + "print(df_gt_ori.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3651, 2)\n" + ] + } + ], + "source": [ + "df_date_off = pd.read_csv(os.path.join(data_dir, 'df_date_off.csv'), parse_dates=['DATE'])\n", + "print(df_date_off.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Select ziying type" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "ziying_type = 'cor_fixed'" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(702, 3)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DATEDATE_targetbal_pred
02020-04-302020-05-2914347
12020-05-062020-05-2914220
22020-05-072020-05-2914140
\n", + "
" + ], + "text/plain": [ + " DATE DATE_target bal_pred\n", + "0 2020-04-30 2020-05-29 14347\n", + "1 2020-05-06 2020-05-29 14220\n", + "2 2020-05-07 2020-05-29 14140" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = df_pred_ori[['DATE', 'DATE_target', f'bal_target_pred_{ziying_type}']].copy()\\\n", + " .rename(columns={f'bal_target_pred_{ziying_type}': 'bal_pred'})\n", + "print(df.shape)\n", + "df.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2553, 2)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DATEcor_fixed_bal
02016-03-049641
12016-03-059626
22016-03-069620
\n", + "
" + ], + "text/plain": [ + " DATE cor_fixed_bal\n", + "0 2016-03-04 9641\n", + "1 2016-03-05 9626\n", + "2 2016-03-06 9620" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_gt = df_gt_ori[['DATE', f'{ziying_type}_bal']].copy()\n", + "print(df_gt.shape)\n", + "df_gt_index = df_gt.set_index(['DATE']).rename(columns={f'{ziying_type}_bal': 'bal'})\n", + "df_gt.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
bal
DATE
2016-03-049641
2016-03-059626
2016-03-069620
\n", + "
" + ], + "text/plain": [ + " bal\n", + "DATE \n", + "2016-03-04 9641\n", + "2016-03-05 9626\n", + "2016-03-06 9620" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_gt_index.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "dict_date_off = dict(zip(df_date_off['DATE'].tolist(), df_date_off['is_off'].tolist()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Preprocess: impute" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "from post_process_ziying import prediction_postprocess_fill_eom" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1045, 9)\n" + ] + } + ], + "source": [ + "\n", + "pred_dts = df[['DATE_target']].drop_duplicates()['DATE_target'].tolist()\n", + "\n", + "df_pred_pp = []\n", + "for pred_dt in pred_dts:\n", + " df_pred_i = df[df['DATE_target'] == pred_dt].reset_index(drop=True)\\\n", + " .rename(columns={'bal_pred': 'bal_target_pred'})\n", + " test_end_date = pred_dt + timedelta(days=(pred_dt.daysinmonth - pred_dt.day))\n", + " df_gt_i = df_gt[df_gt['DATE'] <= test_end_date].reset_index(drop=True)\\\n", + " .rename(columns={f'{ziying_type}_bal': 'bal_day_total'})\n", + " df_pred_pp_i = prediction_postprocess_fill_eom(\n", + " df_pred_i, df_gt_i, dict_date_off, test_end_date, pred_colname='pred',\n", + " process_mode='backtest'\n", + " )\n", + " # display(df_pred_pp_i)\n", + " df_pred_pp.append(df_pred_pp_i)\n", + "df_pred_pp = pd.concat(df_pred_pp, axis=0, ignore_index=True)\n", + "print(df_pred_pp.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DATEbal_currentDATE_targetbal_target_predbal_targetbal_diff_targetpredpred_errorMAE
02020-04-30142862020-05-3114351.013835-45165.0516.0516.0
12020-05-01143012020-05-3114351.013835-46650.0516.0516.0
22020-05-02143182020-05-3114377.013835-48359.0542.0542.0
32020-05-03143222020-05-3114379.013835-48757.0544.0544.0
42020-05-04143282020-05-3114371.013835-49343.0536.0536.0
..............................
10402023-02-23176502023-02-2816665.016765-885-985.0-100.0100.0
10412023-02-24173182023-02-2816213.016765-553-1105.0-552.0552.0
10422023-02-25173342023-02-2816213.016765-569-1121.0-552.0552.0
10432023-02-26173572023-02-2816213.016765-592-1144.0-552.0552.0
10442023-02-27170992023-02-2816315.016765-334-784.0-450.0450.0
\n", + "

1045 rows × 9 columns

\n", + "
" + ], + "text/plain": [ + " DATE bal_current DATE_target bal_target_pred bal_target \\\n", + "0 2020-04-30 14286 2020-05-31 14351.0 13835 \n", + "1 2020-05-01 14301 2020-05-31 14351.0 13835 \n", + "2 2020-05-02 14318 2020-05-31 14377.0 13835 \n", + "3 2020-05-03 14322 2020-05-31 14379.0 13835 \n", + "4 2020-05-04 14328 2020-05-31 14371.0 13835 \n", + "... ... ... ... ... ... \n", + "1040 2023-02-23 17650 2023-02-28 16665.0 16765 \n", + "1041 2023-02-24 17318 2023-02-28 16213.0 16765 \n", + "1042 2023-02-25 17334 2023-02-28 16213.0 16765 \n", + "1043 2023-02-26 17357 2023-02-28 16213.0 16765 \n", + "1044 2023-02-27 17099 2023-02-28 16315.0 16765 \n", + "\n", + " bal_diff_target pred pred_error MAE \n", + "0 -451 65.0 516.0 516.0 \n", + "1 -466 50.0 516.0 516.0 \n", + "2 -483 59.0 542.0 542.0 \n", + "3 -487 57.0 544.0 544.0 \n", + "4 -493 43.0 536.0 536.0 \n", + "... ... ... ... ... \n", + "1040 -885 -985.0 -100.0 100.0 \n", + "1041 -553 -1105.0 -552.0 552.0 \n", + "1042 -569 -1121.0 -552.0 552.0 \n", + "1043 -592 -1144.0 -552.0 552.0 \n", + "1044 -334 -784.0 -450.0 450.0 \n", + "\n", + "[1045 rows x 9 columns]" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_pred_pp" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 1045.000000\n", + "mean 301.636983\n", + "std 257.287667\n", + "min 0.000000\n", + "25% 108.000000\n", + "50% 211.000000\n", + "75% 445.600000\n", + "max 1401.000000\n", + "Name: MAE, dtype: float64" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_pred_pp['MAE'].describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_pred_pp.plot('DATE', 'MAE', figsize=(24, 6))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Postprocess: rules" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "import importlib\n", + "import post_process_ziying\n", + "importlib.reload(post_process_ziying)\n", + "from post_process_ziying import pred_postprocess_cor_current, pred_postprocess_cor_fixed\n", + "from post_process_ziying import pred_postprocess_idv_fixed, pred_postprocess_idv_current" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "34\n" + ] + } + ], + "source": [ + "pred_dts = df_pred_pp[['DATE_target']].drop_duplicates()['DATE_target'].tolist()\n", + "print(len(pred_dts))" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "185\n", + "107\n", + "138\n", + "157\n", + "74\n", + "244\n", + "262\n", + "220\n", + "430\n", + "19\n", + "164\n", + "178\n", + "136\n", + "247\n", + "167\n", + "316\n", + "120\n", + "279\n", + "146\n", + "157\n", + "83\n", + "82\n", + "80\n", + "102\n", + "297\n", + "52\n", + "148\n", + "191\n", + "148\n", + "89\n", + "132\n", + "235\n", + "301\n", + "77\n", + "169.5\n" + ] + } + ], + "source": [ + "# pred_dt = pred_dts[1]\n", + "maes = []\n", + "for pred_dt in pred_dts:\n", + " df_pred = df_pred_pp[df_pred_pp['DATE_target'] == pred_dt].reset_index(drop=True)\n", + " # print(str(pred_dt)[:10], int(df_pred['MAE'].mean()))\n", + " cur_month_dim = pred_dt.daysinmonth\n", + " cur_month = pred_dt.month\n", + " prev_month_dim = (pred_dt - timedelta(days=40)).daysinmonth\n", + " month_prev = (pred_dt - timedelta(days=40)).month\n", + " year_prev = (pred_dt - timedelta(days=40)).year\n", + " # print(pred_dt)\n", + " df_pred = df_pred_pp[df_pred_pp['DATE_target'] == pred_dt].reset_index(drop=True)\n", + " # print(df_pred['MAE'].mean())\n", + " if ziying_type == 'idv_current':\n", + " df_pred_rule = pred_postprocess_idv_current(\n", + " df_pred, df_gt.rename(columns={f'{ziying_type}_bal': 'bal'}), dict_date_off, 'pred', 'backtest')\n", + " elif ziying_type == 'idv_fixed':\n", + " df_pred_rule = pred_postprocess_idv_fixed(\n", + " df_pred, df_gt.rename(columns={f'{ziying_type}_bal': 'bal'}), dict_date_off, 'pred', 'backtest')\n", + " elif ziying_type == 'cor_current':\n", + " df_pred_rule = pred_postprocess_cor_current(\n", + " df_pred, df_gt.rename(columns={f'{ziying_type}_bal': 'bal'}), dict_date_off, 'pred', 'backtest')\n", + " elif ziying_type == 'cor_fixed':\n", + " df_pred_rule = pred_postprocess_cor_fixed(\n", + " df_pred, df_gt.rename(columns={f'{ziying_type}_bal': 'bal'}), dict_date_off, 'pred', 'backtest')\n", + " # print(f\"{str(pred_dt)[:10]}, {int(df_pred_rule['MAE'].mean())}\")\n", + " print(f\"{int(df_pred_rule['MAE'].mean())}\")\n", + " os.makedirs('./pred_res/', exist_ok=True)\n", + " df_pred_rule[['DATE', 'bal_current', 'bal_target_pred', 'bal_target', 'pred_error']]\\\n", + " .to_csv(f'./pred_res/{ziying_type}_{str(pred_dt)[:7]}.csv', index=False)\n", + " maes.append(int(df_pred_rule['MAE'].mean()))\n", + "print(np.mean(maes))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 400, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "272\n", + "134\n", + "147\n", + "292\n", + "234\n", + "283\n", + "1084\n", + "346\n", + "261\n", + "335\n", + "53\n", + "324\n", + "180\n", + "244\n", + "242\n", + "906\n", + "224\n", + "361\n", + "170\n", + "713\n", + "282\n", + "400\n", + "115\n", + "250\n", + "460\n", + "397\n", + "203\n", + "173\n", + "129\n", + "335\n", + "1237\n", + "814\n", + "294\n", + "411\n" + ] + } + ], + "source": [ + "maes = []\n", + "for pred_dt in pred_dts:\n", + " # print(pred_dt)\n", + " dfs = []\n", + " for ty in ['cor_fixed', 'cor_current', 'idv_fixed', 'idv_current']:\n", + " df_i = pd.read_csv(f'./pred_res/{ty}_{str(pred_dt)[:7]}.csv')\n", + " dfs.append(df_i)\n", + " df_ziying_i = pd.concat(dfs, axis=0, ignore_index=True)\n", + " df_ziying_i = df_ziying_i.groupby(['DATE']).sum()\n", + " df_ziying_i['MAE'] = df_ziying_i['pred_error'].abs()\n", + " mae = int(df_ziying_i['MAE'].mean())\n", + " maes.append(mae)\n", + " print(mae)" + ] + }, + { + "cell_type": "code", + "execution_count": 416, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 416, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ziying_type == 'idv_current'" + ] + }, + { + "cell_type": "code", + "execution_count": 417, + "metadata": {}, + "outputs": [], + "source": [ + "for pred_dt in pred_dts:\n", + " df_pred = df_pred_pp[df_pred_pp['DATE_target'] == pred_dt].reset_index(drop=True)\n", + " # print(str(pred_dt)[:10], int(df_pred['MAE'].mean()))\n", + " cur_month_dim = pred_dt.daysinmonth\n", + " cur_month = pred_dt.month\n", + " prev_month_dim = (pred_dt - timedelta(days=40)).daysinmonth\n", + " month_prev = (pred_dt - timedelta(days=40)).month\n", + " year_prev = (pred_dt - timedelta(days=40)).year\n", + " # print(pred_dt)\n", + " df_pred = df_pred_pp[df_pred_pp['DATE_target'] == pred_dt].reset_index(drop=True)\n", + " # print(df_pred['MAE'].mean())\n", + " if ziying_type == 'idv_current':\n", + " df_pred_rule = pred_postprocess_idv_current(\n", + " df_pred, df_gt.rename(columns={f'{ziying_type}_bal': 'bal'}), dict_date_off, 'pred', 'backtest')\n", + " elif ziying_type == 'idv_fixed':\n", + " df_pred_rule = pred_postprocess_idv_fixed(\n", + " df_pred, df_gt.rename(columns={f'{ziying_type}_bal': 'bal'}), dict_date_off, 'pred', 'backtest')\n", + " elif ziying_type == 'cor_current':\n", + " df_pred_rule = pred_postprocess_cor_current(\n", + " df_pred, df_gt.rename(columns={f'{ziying_type}_bal': 'bal'}), dict_date_off, 'pred', 'backtest')\n", + " elif ziying_type == 'cor_fixed':\n", + " df_pred_rule = pred_postprocess_cor_fixed(\n", + " df_pred, df_gt.rename(columns={f'{ziying_type}_bal': 'bal'}), dict_date_off, 'pred', 'backtest')\n", + " if cur_month == 8:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 418, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([282.5, 347.5, 404.4])" + ] + }, + "execution_count": 418, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.percentile(maes, [50, 70, 80])" + ] + }, + { + "cell_type": "code", + "execution_count": 419, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
bal_currentbal_target_predbal_targetpred_errorMAE
DATE
2023-01-316977171092.57570573519.575519.575
2023-02-016994371228.49070573655.490655.490
2023-02-026985271140.81570573567.815567.815
2023-02-036970471157.96570573584.965584.965
2023-02-046987171100.11070573527.110527.110
2023-02-056998771048.90570573475.905475.905
2023-02-066974371030.69070573457.690457.690
2023-02-076964971004.85570573431.855431.855
2023-02-086959970960.06070573387.060387.060
2023-02-096971470917.20070573344.200344.200
2023-02-106952871085.09070573512.090512.090
2023-02-116969671027.23570573454.235454.235
2023-02-126995070974.70070573401.700401.700
2023-02-136958270931.74570573358.745358.745
2023-02-146984670944.13070573371.130371.130
2023-02-156986671100.79570573527.795527.795
2023-02-166978871018.61070573445.610445.610
2023-02-176983970993.50070573420.500420.500
2023-02-186994370943.62570573370.625370.625
2023-02-197014470893.75070573320.750320.750
2023-02-206962670855.83070573282.830282.830
2023-02-216968470895.49070573322.490322.490
2023-02-227004070929.99070573356.990356.990
2023-02-237062870888.18070573315.180315.180
2023-02-247046770927.18070573354.180354.180
2023-02-257052270860.68070573287.680287.680
2023-02-267073670804.82070573231.820231.820
2023-02-277062770812.07570573239.075239.075
\n", + "
" + ], + "text/plain": [ + " bal_current bal_target_pred bal_target pred_error MAE\n", + "DATE \n", + "2023-01-31 69771 71092.575 70573 519.575 519.575\n", + "2023-02-01 69943 71228.490 70573 655.490 655.490\n", + "2023-02-02 69852 71140.815 70573 567.815 567.815\n", + "2023-02-03 69704 71157.965 70573 584.965 584.965\n", + "2023-02-04 69871 71100.110 70573 527.110 527.110\n", + "2023-02-05 69987 71048.905 70573 475.905 475.905\n", + "2023-02-06 69743 71030.690 70573 457.690 457.690\n", + "2023-02-07 69649 71004.855 70573 431.855 431.855\n", + "2023-02-08 69599 70960.060 70573 387.060 387.060\n", + "2023-02-09 69714 70917.200 70573 344.200 344.200\n", + "2023-02-10 69528 71085.090 70573 512.090 512.090\n", + "2023-02-11 69696 71027.235 70573 454.235 454.235\n", + "2023-02-12 69950 70974.700 70573 401.700 401.700\n", + "2023-02-13 69582 70931.745 70573 358.745 358.745\n", + "2023-02-14 69846 70944.130 70573 371.130 371.130\n", + "2023-02-15 69866 71100.795 70573 527.795 527.795\n", + "2023-02-16 69788 71018.610 70573 445.610 445.610\n", + "2023-02-17 69839 70993.500 70573 420.500 420.500\n", + "2023-02-18 69943 70943.625 70573 370.625 370.625\n", + "2023-02-19 70144 70893.750 70573 320.750 320.750\n", + "2023-02-20 69626 70855.830 70573 282.830 282.830\n", + "2023-02-21 69684 70895.490 70573 322.490 322.490\n", + "2023-02-22 70040 70929.990 70573 356.990 356.990\n", + "2023-02-23 70628 70888.180 70573 315.180 315.180\n", + "2023-02-24 70467 70927.180 70573 354.180 354.180\n", + "2023-02-25 70522 70860.680 70573 287.680 287.680\n", + "2023-02-26 70736 70804.820 70573 231.820 231.820\n", + "2023-02-27 70627 70812.075 70573 239.075 239.075" + ] + }, + "execution_count": 419, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_ziying_i" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 420, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 420, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_pred.plot('DATE', ['bal_current', 'bal_target_pred', 'bal_target'], figsize=(16, 4))\n", + "df_pred_rule.plot('DATE', ['bal_current', 'bal_target_pred', 'bal_target'], figsize=(16, 4))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 421, + "metadata": {}, + "outputs": [], + "source": [ + "from post_process_ziying import get_recent_springFestival_dates" + ] + }, + { + "cell_type": "code", + "execution_count": 422, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{2024: '2024-02-10',\n", + " 2023: '2023-01-22',\n", + " 2022: '2022-02-01',\n", + " 2021: '2021-02-12',\n", + " 2020: '2020-01-25',\n", + " 2019: '2019-02-05',\n", + " 2018: '2018-02-16',\n", + " 2017: '2017-01-28',\n", + " 2016: '2016-02-08',\n", + " 2015: '2015-02-19',\n", + " 2014: '2014-01-31'}" + ] + }, + "execution_count": 422, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dict_spring_fest_dates = get_recent_springFestival_dates(2023)\n", + "dict_spring_fest_dates" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "dfs = []\n", + "for y in range(2017, 2024):\n", + " y_prev = y if cur_month != 1 else y - 1\n", + " tmp = df_gt_index.loc[f'{y_prev}-{month_prev}-{prev_month_dim}': f'{y}-{cur_month}-{cur_month_dim}', :]\n", + " diff = int(df_gt_index.loc[f\"{y}-{cur_month}-{cur_month_dim}\", 'bal'] - \\\n", + " df_gt_index.loc[f\"{y_prev}-{month_prev}-{prev_month_dim}\", 'bal'])\n", + " dfs.append(tmp)\n", + " tmp.plot(figsize=(24, 3))\n", + " if cur_month == 1:\n", + " plt.title('*'.join([dict_spring_fest_dates[y], str(diff)]))\n", + " else:\n", + " plt.title(str(diff))" + ] + }, + { + "cell_type": "code", + "execution_count": 254, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(204, 2)\n" + ] + } + ], + "source": [ + "df_gt_m = df_gt[\n", + " (df_gt['DATE'].dt.month == cur_month) | \n", + " ((df_gt['DATE'].dt.month == month_prev) & (df_gt['DATE'].dt.day == prev_month_dim))]\\\n", + " .reset_index(drop=True)\n", + "print(df_gt_m.shape)\n", + "df_gt_m['year'] = df_gt_m['DATE'].dt.year\n", + "df_gt_m['month'] = df_gt_m['DATE'].dt.month\n", + "df_gt_m['day'] = df_gt_m['DATE'].dt.day\n", + "df_gt_m['dow'] = df_gt_m['DATE'].dt.dayofweek\n" + ] + }, + { + "cell_type": "code", + "execution_count": 255, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DATEidv_current_balyearmonthdaydow
02017-01-31826120171311
12017-02-0182152017212
22017-02-0282122017223
32017-02-0383862017234
42017-02-0481442017245
.....................
1992023-02-241788020232244
2002023-02-251778020232255
2012023-02-261769620232266
2022023-02-271769320232270
2032023-02-281791620232281
\n", + "

204 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " DATE idv_current_bal year month day dow\n", + "0 2017-01-31 8261 2017 1 31 1\n", + "1 2017-02-01 8215 2017 2 1 2\n", + "2 2017-02-02 8212 2017 2 2 3\n", + "3 2017-02-03 8386 2017 2 3 4\n", + "4 2017-02-04 8144 2017 2 4 5\n", + ".. ... ... ... ... ... ...\n", + "199 2023-02-24 17880 2023 2 24 4\n", + "200 2023-02-25 17780 2023 2 25 5\n", + "201 2023-02-26 17696 2023 2 26 6\n", + "202 2023-02-27 17693 2023 2 27 0\n", + "203 2023-02-28 17916 2023 2 28 1\n", + "\n", + "[204 rows x 6 columns]" + ] + }, + "execution_count": 255, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_gt_m" + ] + }, + { + "cell_type": "code", + "execution_count": 258, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2017 -139\n", + "2018 439\n", + "2019 -543\n", + "2020 -458\n", + "2021 92\n", + "2022 -952\n", + "2023 -857\n" + ] + } + ], + "source": [ + "for y in range(2017, 2024):\n", + " y_prev = y if cur_month != 1 else y - 1\n", + " diff = int(df_gt_index.loc[f\"{y}-{cur_month}-{cur_month_dim}\", 'bal'] - df_gt_index.loc[f\"{y_prev}-{month_prev}-{prev_month_dim}\", 'bal'])\n", + " # diff2 = int(df_gt_index.loc[f\"{y}-{cur_month}-{cur_month_dim}\", 'bal'] - df_gt_index.loc[f\"{y_prev}-12-31\"])\n", + " print(y, diff)" + ] + }, + { + "cell_type": "code", + "execution_count": 259, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(197, 8)\n" + ] + } + ], + "source": [ + "df_feat = []\n", + "bal_col = f'{ziying_type}_bal'\n", + "\n", + "for y in range(2017, 2024):\n", + " df_sample = df_gt_m[df_gt_m['year'] == y].reset_index(drop=True)\n", + " df_sample['label'] = df_sample[bal_col].tolist()[-1] - df_sample[bal_col].tolist()[0]#df_sample[bal_col]\n", + " df_sample['bal_diff'] = df_sample[bal_col] - df_sample[bal_col].tolist()[0]\n", + " df_feat.append(df_sample[~((df_sample['month'] == cur_month) & (df_sample['day'] == cur_month_dim))])\n", + "df_feat = pd.concat(df_feat, axis=0, ignore_index=True)\n", + "print(df_feat.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 280, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-350.8578680203046\n", + "************************* 2017 176\n", + "************************* 2018 468\n", + "************************* 2019 135\n", + "************************* 2020 160\n", + "************************* 2021 161\n", + "************************* 2022 228\n", + "************************* 2023 164\n" + ] + } + ], + "source": [ + "def pp_month_idv_current(x):\n", + " dt, bal_diff = x\n", + " b = -300\n", + " if dt.month == month_prev:\n", + " return b\n", + " return b + (bal_diff + 100) * 0.7\n", + "\n", + "print(df_feat['label'].mean())\n", + "for y in range(2017, 2024):\n", + " feat = df_feat[df_feat['year'] == y].reset_index(drop=True)\n", + " feat['pred_pp'] = feat[['DATE', 'bal_diff']].apply(pp_month_idv_current, axis=1)\n", + " feat['MAE'] = (feat['label'] - feat['pred_pp']).abs()\n", + " print('*' * 25, y, int(feat['MAE'].mean()))\n", + " # display(feat[['MAE']].describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 278, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DATEidv_current_balyearmonthdaydowlabelbal_diffpred_ppMAE
02023-01-311877320231311-8570-200.0657.0
12023-02-01186942023212-857-79-183.2673.8
22023-02-02184792023223-857-294-355.2501.8
32023-02-03184092023234-857-364-411.2445.8
42023-02-04183222023245-857-451-480.8376.2
52023-02-05182452023256-857-528-542.4314.6
62023-02-06182542023260-857-519-535.2321.8
72023-02-07181552023271-857-618-614.4242.6
82023-02-08180422023282-857-731-704.8152.2
92023-02-09180082023293-857-765-732.0125.0
102023-02-101816420232104-857-609-607.2249.8
112023-02-111807720232115-857-696-676.8180.2
122023-02-121799820232126-857-775-740.0117.0
132023-02-131801120232130-857-762-729.6127.4
142023-02-141796020232141-857-813-770.486.6
152023-02-151816120232152-857-612-609.6247.4
162023-02-161805220232163-857-721-696.8160.2
172023-02-171800820232174-857-765-732.0125.0
182023-02-181793320232185-857-840-792.065.0
192023-02-191785820232196-857-915-852.05.0
202023-02-201791020232200-857-863-810.446.6
212023-02-211789420232211-857-879-823.233.8
222023-02-221791420232222-857-859-807.249.8
232023-02-231783020232233-857-943-874.417.4
242023-02-241788020232244-857-893-834.422.6
252023-02-251778020232255-857-993-914.457.4
262023-02-261769620232266-857-1077-981.6124.6
272023-02-271769320232270-857-1080-984.0127.0
\n", + "
" + ], + "text/plain": [ + " DATE idv_current_bal year month day dow label bal_diff \\\n", + "0 2023-01-31 18773 2023 1 31 1 -857 0 \n", + "1 2023-02-01 18694 2023 2 1 2 -857 -79 \n", + "2 2023-02-02 18479 2023 2 2 3 -857 -294 \n", + "3 2023-02-03 18409 2023 2 3 4 -857 -364 \n", + "4 2023-02-04 18322 2023 2 4 5 -857 -451 \n", + "5 2023-02-05 18245 2023 2 5 6 -857 -528 \n", + "6 2023-02-06 18254 2023 2 6 0 -857 -519 \n", + "7 2023-02-07 18155 2023 2 7 1 -857 -618 \n", + "8 2023-02-08 18042 2023 2 8 2 -857 -731 \n", + "9 2023-02-09 18008 2023 2 9 3 -857 -765 \n", + "10 2023-02-10 18164 2023 2 10 4 -857 -609 \n", + "11 2023-02-11 18077 2023 2 11 5 -857 -696 \n", + "12 2023-02-12 17998 2023 2 12 6 -857 -775 \n", + "13 2023-02-13 18011 2023 2 13 0 -857 -762 \n", + "14 2023-02-14 17960 2023 2 14 1 -857 -813 \n", + "15 2023-02-15 18161 2023 2 15 2 -857 -612 \n", + "16 2023-02-16 18052 2023 2 16 3 -857 -721 \n", + "17 2023-02-17 18008 2023 2 17 4 -857 -765 \n", + "18 2023-02-18 17933 2023 2 18 5 -857 -840 \n", + "19 2023-02-19 17858 2023 2 19 6 -857 -915 \n", + "20 2023-02-20 17910 2023 2 20 0 -857 -863 \n", + "21 2023-02-21 17894 2023 2 21 1 -857 -879 \n", + "22 2023-02-22 17914 2023 2 22 2 -857 -859 \n", + "23 2023-02-23 17830 2023 2 23 3 -857 -943 \n", + "24 2023-02-24 17880 2023 2 24 4 -857 -893 \n", + "25 2023-02-25 17780 2023 2 25 5 -857 -993 \n", + "26 2023-02-26 17696 2023 2 26 6 -857 -1077 \n", + "27 2023-02-27 17693 2023 2 27 0 -857 -1080 \n", + "\n", + " pred_pp MAE \n", + "0 -200.0 657.0 \n", + "1 -183.2 673.8 \n", + "2 -355.2 501.8 \n", + "3 -411.2 445.8 \n", + "4 -480.8 376.2 \n", + "5 -542.4 314.6 \n", + "6 -535.2 321.8 \n", + "7 -614.4 242.6 \n", + "8 -704.8 152.2 \n", + "9 -732.0 125.0 \n", + "10 -607.2 249.8 \n", + "11 -676.8 180.2 \n", + "12 -740.0 117.0 \n", + "13 -729.6 127.4 \n", + "14 -770.4 86.6 \n", + "15 -609.6 247.4 \n", + "16 -696.8 160.2 \n", + "17 -732.0 125.0 \n", + "18 -792.0 65.0 \n", + "19 -852.0 5.0 \n", + "20 -810.4 46.6 \n", + "21 -823.2 33.8 \n", + "22 -807.2 49.8 \n", + "23 -874.4 17.4 \n", + "24 -834.4 22.6 \n", + "25 -914.4 57.4 \n", + "26 -981.6 124.6 \n", + "27 -984.0 127.0 " + ] + }, + "execution_count": 278, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "feat" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python37", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "331ab40046fe85b1955f655ad85db3983bac1ddbc341a1f49d9bccc6c665fd2a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}