From 3c2474117c3e6fec291933438a57d20fa1062392 Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Sun, 14 Nov 2021 20:39:31 +0800 Subject: [PATCH 01/19] Schrieffer 2021-11-14 --- README.md | 122 ------------------ ...45\351\227\250\345\237\272\347\241\200.md" | 117 +++++++++++++++++ 2 files changed, 117 insertions(+), 122 deletions(-) delete mode 100644 README.md create mode 100644 "docs/2020-11-05-python\345\205\245\351\227\250\345\237\272\347\241\200.md" diff --git a/README.md b/README.md deleted file mode 100644 index ad347fab..00000000 --- a/README.md +++ /dev/null @@ -1,122 +0,0 @@ -# SWUFE 奇点工作室学习博客交换站 - -[![Netlify Status](https://api.netlify.com/api/v1/badges/d58e035c-e6cf-4912-8fe7-82265d2d30ee/deploy-status)](https://app.netlify.com/sites/singularitylab/deploys) - -为切实提高工作室成员的学习积极性、涉猎宽度及思考的深度，从本学期开始，奇点工作室倡议每位成员 **每周至少完成一篇** 博客的写作及分享。涉及计算机基础理论、数学学习、数据分析、网站开发、网页设计、金融科技等等方面的学习经历和收获，也有相互之间的交流与讨论。当然，我们非常欢迎工作室之外的朋友们对我们的思考和学习笔记提出指正意见，也希望更多志同道合的朋友可以参与到我们这一次的尝试与努力中来，我们愿意相信，**一个人走得快，一群人走得远**，希望我们可以在柳湖旁一起建造一片 GEEK 之林！ - -博客地址：[SWUFE 奇点工作室学习博客交换站](https://singularitylab.netlify.app/) - -## 内容及形式 - -每一篇博客可以是分享自己的项目，也可以是某个知识点的总结回顾，也可以是学习笔记，也可以是一周之内遇到的细碎问题合集或是重构笔记等等。 - -或许这是一个可供参考的例子：[Javascript Fetch API to send data](https://medium.com/@whole9681/8c2b1dedaba) - -**感谢我院优秀学姐学长对奇点工作室的大力支持！** - -## 格式规范 - -1. 每篇博文中都有一个 `header` 部分，其中包含：名字或昵称、类别（设计部，开发部，数据分析部）、日期、标签（如：Django，网络协议，机器学习算法，数据分析实践，Python 等等） - - ```markdown - --- - layout: post - title: JavaScript 异步 - date: 2019-05-05 - author: Hivol - categories: - - 开发部 - tags: - - 前端 - - JavaScript - --- - ``` - -2. 文章命名： `{日期yyyy-mm-dd}-{文章标题}` ，如： `2019-03-04-在Console中添加字符画`，文章放在`docs/views/[部门data/design/dev]`目录下 - -3. 图片等静态资源请放置于： `docs/views/imgs/[年月]/[周数]/[名字/昵称]` ，如： `imgs/1903/04/Hivol/` - - ```bash - imgs - └── 1903 -    ├── 03 -    │   ├── Hivol -    │   ├── YanYijun -    │   ├── iyiniyin -    │   ├── lxy -    │   └── th -    └── 04 -    ├── Hivol -    ├── Mialia -    ├── iyin -    ├── lxy -    └── shuangmulin - ``` - -4. Markdown 文件中引用图片时，请使用相对路径。一般为如： `../imgs/1903/04/Hivol/hello.png` - -5. Markdown 文件中也请注意可读性与美观性，建议在标题前后、段落前后和图片前后均空一行，建议使用 [Prettier](https://prettier.io/) - - ```bash - yarn add prettier --dev --exact - - yarn prettier --write docs/views/dev/2019-05-05-图表征学习算法_node2vec.md - ``` - -6. 使用 UTF-8 编码 - -7. Pull Request 三要素：Theme, Summary and Details。Pull Request Summary 的格式为： `{年月周}-{文章标题}-{姓名/昵称}` ，如：190304-Django 项目上线部署全流程-LKX - -8. **文末请注明参考文章及链接** - -## 怎样上传新文章？ - -Step 1. Fork 本项目得到 `nickname/singularity-lab-blog` （此处的“nickname”即是各位自己的用户名） - -Step 2. Clone 你的仓库到你自己的电脑 - -Step 3. 在本地仓库中编写你的文章，写完后 commit（ ⚠️ 注意：文章在 `docs/views/[dev/data/design]` 文件夹下，图片在 `imgs` 文件夹下） - -Step 4. 获取本项目最新内容，与本项目进行同步： - -- 确认本地仓库中已设置好 upstream 为本项目地址（ `git remote -v` 查看），正常情况下与下图一致（"Hivol"应该是自己 GitHub 的用户名），如果没有请使用 `git remote add upstream https://github.com/singularity-lab/blog.git` 添加。 - - ![readme-img1](docs/views/imgs/git_remote.png) - -- 使用 `git status` 检查本地是否有未提交的修改，如果有，请先 commit 你的提交，并 push 到 上文提到的 `nickname/singularity-lab-blog` - -- 执行命令 `git fetch upstream` 获取本项目的最新更新内容 - -- 执行命令 `git checkout master` 切换到 master 分支（或你的默认分支下，如 gh-pages） - -- 执行命令 `git merge upstream/master` ，把本项目的最新内容合并到你的本地仓库的 master 分支（或你的默认分支下，如 gh-pages）中 - -- 执行命令 `git push` 把合并后的内容 push 到你的远程仓库 `nickname/singularity-lab-blog` - -Step 5. 提交一个 pull request，等待 review - -Step 6. 关注自己的邮箱，若有收到修改要求请及时修改 - -Step 7. 合并完成 - -## 本地运行调试 - -**npm** - -```bash -# install -npm install - -# run -npm run dev - -# build -npm run build -``` - -（由于安装 vue-router 时会产生 bug，暂时未使用 yarn，详见 [vuepress/issues/2656](https://github.com/vuejs/vuepress/issues/2656#issuecomment-708890727) - -## 转载须知 - -1. 转载请联系（Email: Singularitylab@163.com） -2. 转载请注明奇点工作室和个人署名 diff --git "a/docs/2020-11-05-python\345\205\245\351\227\250\345\237\272\347\241\200.md" "b/docs/2020-11-05-python\345\205\245\351\227\250\345\237\272\347\241\200.md" new file mode 100644 index 00000000..7667d4bd --- /dev/null +++ "b/docs/2020-11-05-python\345\205\245\351\227\250\345\237\272\347\241\200.md" @@ -0,0 +1,117 @@ +--- +layout: post +title: python入门基础 +date: 2021-11-05 +author: Schrieffer +categories: + - 数据分析部 +tags: + - 数据结构 +--- + +# python 介绍 + +python 的创始人 Guido van Rossum，1989 年在荷兰创造了 python，网络流传是因为他喜欢英国肥皂剧《Monty Python 飞行马戏团》，所以用 python 来命名。语言分为编译型语言和解释型语言，python 是一门解释型语言，可跨平台、开发效率高，但运行效率低。 + +### 变量 + +编程语言最强大的功能之一是操作变量的能力。 + +变量是指向一个值的名称，变量的首位为字母或者下划线，不能为数字。 + +赋值语句可以建立新的变量，并给他们赋值。如*x=500*(将 500 赋给 x) + +### 两项基本操作 + +**基本的输入和输出** 可以在 python 中+、-、\*、/直接进行四则运算 + +**导入模块** 使用 import 可以导入模块,导入后可以使用这个模块下的函数 + +# 数据类型 + +## 什么是数据结构？ + +python 中有一种名为容器的数据结构，即装数据的容器，它主要包括**序列**（sequence)和**字典**(dictionary)，其中序列又主要包括**列表**（list)、**元组**(tuple)和**字符串**(string)等。 + +_列表的基本形式比如：[1,3,5,6]或者['yes','no','ok']_ + +_元组的基本形式比如：(1,3,5,6)或者('yes','no','ok')_ + +_字符串的基本形式比如：'hello'_ + +列表和元组的区别在于，列表可以修改，而元组不能（注意列表用中括号而元组用括号）。 + +序列的这个特点，使得我们可以利用索引来访问序列中的某个或几个元素。 + +而与序列对应的字典是一个无序容器，是”键-值“映射的结构，需要根据键来访问其中的元素，即 key 不可重复，不可变。 + +## 序列的一些通用操作 + +### 索引 + +数列中的每一个元素都被分配一个序号——即元素的位置，也称为”索引“，第一个索引，即第一个元素的位置是 0，第二个是 1，以此类推。序列的最后一个元素的索引，也可以是-1，倒数第二个也可以是-2，以此类推。 + +### 分片 + +使用分片操作来访问一定范围内的元素，它的格式为：**a[开始索引:结束索引:步长]** + +那么，访问的是从开始索引的那个元素，到结束索引的那个元素，每间隔步长个元素访问一次，步长可以忽略，默认步长为 1。 + +### 序列相加 + +只有两种相同的类型的序列才能相加。 + +### 成员资格 + +为了检查一个值是否在序列中，可以用 in 运算符。 + +## 列表操作 + +### list 函数 + +可以通过 list 函数把一个序列转化成一个列表 + +### 元素赋值与删除 + +元素删除——**del a[索引号]** + +元素赋值——**a[索引号]=值** + +分片赋值——**a[开始索引号：结束索引号]=list(值)** + +_注意：python 中索引号是左闭右开的，另外 list()要用小括号_ + +### 列表方法 + +python 中的方法，是一个”与某些对象有紧密联系的”函数，所以列表方法，就是属于列表的函数，它可以对列表实现一些比较深入的操作，方法这样调用：对象.方法（参数），那么列表方法的调用就理所当然是：**列表.方法（参数）** + +给列表 a 的 n 索引位置插入一个元素 m：**a.insert(n,m)** + +给列表 a 的最后添加元素 m:**a.append(m)** + +返回 a 列表中，元素 m 第一次出现的索引位置：**a.index(m)** + +删除 a 中的 m 元素：**a.remove(m)** + +将列表 a 从大到小排列：**a.sort()** + +## 字典操作 + +### dict 函数 + +dict 函数可以通过关键字来创建字典，格式为：**dict(参数 1=值 1,参数 2=值 2,...)={参数 1:值 1,参数 2:值 2,...}** + +### 基本操作 + +对于初学者而言，应牢记字典包含多个 key-value 对，而 key 是字典的关键数据，因此程序对字典的操作都是基于 key 的。基本操作如下： + +- 通过 key 访问 value 。 +- 通过 key 添加 key-value 对。 +- 通过 key 删除 key-value 对。 +- 通过 key 修改 key-value 对。 +- 通过 key 判断指定 key-value 对是否存在。 +- 通过 key 访问 value 使用的也是方括号语法，就像前面介绍的列表和元组一样，只是此时在方括号中放的是 key，而不是列表或元组中的索引。 + +> 参考 +> +> [python 中的导入模块](https://blog.csdn.net/sunybl/article/details/80530559?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160457342719195264719871%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=160457342719195264719871&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v28-3-80530559.first_rank_ecpm_v3_pc_rank_v2&utm_term=python%E4%B8%AD%E5%AF%BC%E5%85%A5%E6%A8%A1%E5%9D%97&spm=1018.2118.3001.4449) >[python 字典及基本操作](https://blog.csdn.net/sadhsj/article/details/94184529?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160457284519725266961155%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=160457284519725266961155&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v28-2-94184529.first_rank_ecpm_v3_pc_rank_v2&utm_term=python+%E5%AD%97%E5%85%B8%E6%93%8D%E4%BD%9C&spm=1018.2118.3001.4449) From ee1d1dd136c11f98f59cda7eae84aa5ab19c3d86 Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Fri, 19 Nov 2021 17:29:54 +0800 Subject: [PATCH 02/19] Create blog11.18.md --- blog11.18.md | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 blog11.18.md diff --git a/blog11.18.md b/blog11.18.md new file mode 100644 index 00000000..5f9a6d85 --- /dev/null +++ b/blog11.18.md @@ -0,0 +1,97 @@ +--- +layout: post +title: +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 动态规划的python实现 +--- +## ***动态规划*** +#### 例题 +一条包含字母 A-Z 的消息通过以下映射进行了编码 ： +> A => 1 +> B => 2 +> ... +> Z => 26 + +要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 +例如，"11106" 可以映射为： +* "AAJF" ，将消息分组为 (1 1 10 6) +* "KJF" ，将消息分组为 (11 10 6) + +注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 +给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 +题目数据保证答案肯定是一个 32 位 的整数。 + +*** +#### 题解 +> ###***Step 1*** +> Definition of dp[i] +> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** +> +> ###***Step 2*** +> Set up of ***state transition fumula*** +> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] +> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 +> 比如，若s[i]=="0",则它只能与前一位组合解码 +> 而s[i]为其他时，则有分别解码的可能 + +* ***Case one*** +> When ***s[i] == "0"*** +> 由于它必须与前一位联合解码，所以有： +> If ***s[i-1] == "1” or "2"***, +>   +> ***dp[i] = dp[i-2]*** +> else +>   +> ***dp[i] = 0*** +* ***Case two*** +> When ***s[i] == "1" or "2" or ... "6"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1]=="1" or "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** +* ***Case three*** +> When ***s[i] == "6" or "7" or ... "9"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1] == "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** + +*** +#### 优化部分 +> 由于求解 ***dp[i]*** 只用到了前两位的数据， +> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : +> cur,pre1,pre2交错覆盖 + + +--- +代码如下： +```python +class Solution: + def numDecodings(self, s: str) -> int: + n = len(s) + s = ' ' + s + f = [0] * 3 + f[0] = 1 + for i in range(1,n + 1): + f[i % 3] = 0 + a = ord(s[i]) - ord('0') + b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') + if 1 <= a <= 9: + f[i % 3] = f[(i - 1) % 3] + if 10 <= b <= 26: + f[i % 3] += f[(i - 2) % 3] + return f[n % 3] From 66f00e96647c8db65da9e9087d3f180100a23864 Mon Sep 17 00:00:00 2001 From: Schrieffer <93866494+Schrieffer@users.noreply.github.com> Date: Wed, 24 Nov 2021 23:11:48 +0800 Subject: [PATCH 03/19] Add files via upload --- blog11.18.md | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 blog11.18.md diff --git a/blog11.18.md b/blog11.18.md new file mode 100644 index 00000000..7f4366c7 --- /dev/null +++ b/blog11.18.md @@ -0,0 +1,97 @@ +--- +layout: post +title: +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 动态规划的python实现 +--- +## ***动态规划*** +#### 例题 +一条包含字母 A-Z 的消息通过以下映射进行了编码 ： +> A => 1 +> B => 2 +> ... +> Z => 26 + +要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 +例如，"11106" 可以映射为： +* "AAJF" ，将消息分组为 (1 1 10 6) +* "KJF" ，将消息分组为 (11 10 6) + +注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 +给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 +题目数据保证答案肯定是一个 32 位 的整数。 + +*** +#### 题解 +> ###***Step 1*** +> Definition of dp[i] +> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** +> +> ###***Step 2*** +> Set up of ***state transition fumula*** +> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] +> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 +> 比如，若s[i]=="0",则它只能与前一位组合解码 +> 而s[i]为其他时，则有分别解码的可能 + +* ***Case one*** +> When ***s[i] == "0"*** +> 由于它必须与前一位联合解码，所以有： +> If ***s[i-1] == "1” or "2"***, +>   +> ***dp[i] = dp[i-2]*** +> else +>   +> ***dp[i] = 0*** +* ***Case two*** +> When ***s[i] == "1" or "2" or ... "6"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1]=="1" or "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** +* ***Case three*** +> When ***s[i] == "6" or "7" or ... "9"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1] == "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** + +*** +#### 优化部分 +> 由于求解 ***dp[i]*** 只用到了前两位的数据， +> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : +> cur,pre1,pre2交错覆盖 + + +--- +代码如下： +```python +class Solution: + def numDecodings(self, s: str) -> int: + n = len(s) + s = ' ' + s + f = [0] * 3 + f[0] = 1 + for i in range(1,n + 1): + f[i % 3] = 0 + a = ord(s[i]) - ord('0') + b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') + if 1 <= a <= 9: + f[i % 3] = f[(i - 1) % 3] + if 10 <= b <= 26: + f[i % 3] += f[(i - 2) % 3] + return f[n % 3] From 6f104ae7705a8269a73658c00d5bf03900b90ef8 Mon Sep 17 00:00:00 2001 From: Schrieffer <93866494+Schrieffer@users.noreply.github.com> Date: Wed, 24 Nov 2021 23:14:30 +0800 Subject: [PATCH 04/19] Add files via upload --- docs/views/data/blog11.18.md | 97 ++++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 docs/views/data/blog11.18.md diff --git a/docs/views/data/blog11.18.md b/docs/views/data/blog11.18.md new file mode 100644 index 00000000..7f4366c7 --- /dev/null +++ b/docs/views/data/blog11.18.md @@ -0,0 +1,97 @@ +--- +layout: post +title: +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 动态规划的python实现 +--- +## ***动态规划*** +#### 例题 +一条包含字母 A-Z 的消息通过以下映射进行了编码 ： +> A => 1 +> B => 2 +> ... +> Z => 26 + +要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 +例如，"11106" 可以映射为： +* "AAJF" ，将消息分组为 (1 1 10 6) +* "KJF" ，将消息分组为 (11 10 6) + +注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 +给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 +题目数据保证答案肯定是一个 32 位 的整数。 + +*** +#### 题解 +> ###***Step 1*** +> Definition of dp[i] +> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** +> +> ###***Step 2*** +> Set up of ***state transition fumula*** +> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] +> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 +> 比如，若s[i]=="0",则它只能与前一位组合解码 +> 而s[i]为其他时，则有分别解码的可能 + +* ***Case one*** +> When ***s[i] == "0"*** +> 由于它必须与前一位联合解码，所以有： +> If ***s[i-1] == "1” or "2"***, +>   +> ***dp[i] = dp[i-2]*** +> else +>   +> ***dp[i] = 0*** +* ***Case two*** +> When ***s[i] == "1" or "2" or ... "6"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1]=="1" or "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** +* ***Case three*** +> When ***s[i] == "6" or "7" or ... "9"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1] == "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** + +*** +#### 优化部分 +> 由于求解 ***dp[i]*** 只用到了前两位的数据， +> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : +> cur,pre1,pre2交错覆盖 + + +--- +代码如下： +```python +class Solution: + def numDecodings(self, s: str) -> int: + n = len(s) + s = ' ' + s + f = [0] * 3 + f[0] = 1 + for i in range(1,n + 1): + f[i % 3] = 0 + a = ord(s[i]) - ord('0') + b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') + if 1 <= a <= 9: + f[i % 3] = f[(i - 1) % 3] + if 10 <= b <= 26: + f[i % 3] += f[(i - 2) % 3] + return f[n % 3] From ed7c7574249ebc479405a93c91503062b9b96f14 Mon Sep 17 00:00:00 2001 From: Schrieffer <93866494+Schrieffer@users.noreply.github.com> Date: Wed, 24 Nov 2021 23:15:33 +0800 Subject: [PATCH 05/19] Delete blog11.18.md --- docs/views/data/blog11.18.md | 97 ------------------------------------ 1 file changed, 97 deletions(-) delete mode 100644 docs/views/data/blog11.18.md diff --git a/docs/views/data/blog11.18.md b/docs/views/data/blog11.18.md deleted file mode 100644 index 7f4366c7..00000000 --- a/docs/views/data/blog11.18.md +++ /dev/null @@ -1,97 +0,0 @@ ---- -layout: post -title: -date: 2021-11-19 -author: 张书翌 -categories: - - 数据分析部 -tags: - - 动态规划的python实现 ---- -## ***动态规划*** -#### 例题 -一条包含字母 A-Z 的消息通过以下映射进行了编码 ： -> A => 1 -> B => 2 -> ... -> Z => 26 - -要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 -例如，"11106" 可以映射为： -* "AAJF" ，将消息分组为 (1 1 10 6) -* "KJF" ，将消息分组为 (11 10 6) - -注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 -给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 -题目数据保证答案肯定是一个 32 位 的整数。 - -*** -#### 题解 -> ###***Step 1*** -> Definition of dp[i] -> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** -> -> ###***Step 2*** -> Set up of ***state transition fumula*** -> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] -> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 -> 比如，若s[i]=="0",则它只能与前一位组合解码 -> 而s[i]为其他时，则有分别解码的可能 - -* ***Case one*** -> When ***s[i] == "0"*** -> 由于它必须与前一位联合解码，所以有： -> If ***s[i-1] == "1” or "2"***, ->   -> ***dp[i] = dp[i-2]*** -> else ->   -> ***dp[i] = 0*** -* ***Case two*** -> When ***s[i] == "1" or "2" or ... "6"*** -> 由于它可以单独解码，所以有： -> ***dp[i] += dp[i-1]*** -> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 -> ***( i )*** ->  如果***s[i-1]=="1" or "2"***, ->  那么***dp[i] += dp[i-2]*** -> ***( ii )*** ->  如果是其他情况， ->  那么***dp[i] remain unchanged*** -* ***Case three*** -> When ***s[i] == "6" or "7" or ... "9"*** -> 由于它可以单独解码，所以有： -> ***dp[i] += dp[i-1]*** -> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 -> ***( i )*** ->  如果***s[i-1] == "2"***, ->  那么***dp[i] += dp[i-2]*** -> ***( ii )*** ->  如果是其他情况， ->  那么***dp[i] remain unchanged*** - -*** -#### 优化部分 -> 由于求解 ***dp[i]*** 只用到了前两位的数据， -> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : -> cur,pre1,pre2交错覆盖 - - ---- -代码如下： -```python -class Solution: - def numDecodings(self, s: str) -> int: - n = len(s) - s = ' ' + s - f = [0] * 3 - f[0] = 1 - for i in range(1,n + 1): - f[i % 3] = 0 - a = ord(s[i]) - ord('0') - b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') - if 1 <= a <= 9: - f[i % 3] = f[(i - 1) % 3] - if 10 <= b <= 26: - f[i % 3] += f[(i - 2) % 3] - return f[n % 3] From 0a9b7c28eb445a6f07e879066c782effc4995c6a Mon Sep 17 00:00:00 2001 From: Schrieffer <93866494+Schrieffer@users.noreply.github.com> Date: Wed, 24 Nov 2021 23:18:19 +0800 Subject: [PATCH 06/19] Delete blog11.18.md --- blog11.18.md | 97 ---------------------------------------------------- 1 file changed, 97 deletions(-) delete mode 100644 blog11.18.md diff --git a/blog11.18.md b/blog11.18.md deleted file mode 100644 index 7f4366c7..00000000 --- a/blog11.18.md +++ /dev/null @@ -1,97 +0,0 @@ ---- -layout: post -title: -date: 2021-11-19 -author: 张书翌 -categories: - - 数据分析部 -tags: - - 动态规划的python实现 ---- -## ***动态规划*** -#### 例题 -一条包含字母 A-Z 的消息通过以下映射进行了编码 ： -> A => 1 -> B => 2 -> ... -> Z => 26 - -要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 -例如，"11106" 可以映射为： -* "AAJF" ，将消息分组为 (1 1 10 6) -* "KJF" ，将消息分组为 (11 10 6) - -注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 -给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 -题目数据保证答案肯定是一个 32 位 的整数。 - -*** -#### 题解 -> ###***Step 1*** -> Definition of dp[i] -> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** -> -> ###***Step 2*** -> Set up of ***state transition fumula*** -> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] -> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 -> 比如，若s[i]=="0",则它只能与前一位组合解码 -> 而s[i]为其他时，则有分别解码的可能 - -* ***Case one*** -> When ***s[i] == "0"*** -> 由于它必须与前一位联合解码，所以有： -> If ***s[i-1] == "1” or "2"***, ->   -> ***dp[i] = dp[i-2]*** -> else ->   -> ***dp[i] = 0*** -* ***Case two*** -> When ***s[i] == "1" or "2" or ... "6"*** -> 由于它可以单独解码，所以有： -> ***dp[i] += dp[i-1]*** -> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 -> ***( i )*** ->  如果***s[i-1]=="1" or "2"***, ->  那么***dp[i] += dp[i-2]*** -> ***( ii )*** ->  如果是其他情况， ->  那么***dp[i] remain unchanged*** -* ***Case three*** -> When ***s[i] == "6" or "7" or ... "9"*** -> 由于它可以单独解码，所以有： -> ***dp[i] += dp[i-1]*** -> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 -> ***( i )*** ->  如果***s[i-1] == "2"***, ->  那么***dp[i] += dp[i-2]*** -> ***( ii )*** ->  如果是其他情况， ->  那么***dp[i] remain unchanged*** - -*** -#### 优化部分 -> 由于求解 ***dp[i]*** 只用到了前两位的数据， -> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : -> cur,pre1,pre2交错覆盖 - - ---- -代码如下： -```python -class Solution: - def numDecodings(self, s: str) -> int: - n = len(s) - s = ' ' + s - f = [0] * 3 - f[0] = 1 - for i in range(1,n + 1): - f[i % 3] = 0 - a = ord(s[i]) - ord('0') - b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') - if 1 <= a <= 9: - f[i % 3] = f[(i - 1) % 3] - if 10 <= b <= 26: - f[i % 3] += f[(i - 2) % 3] - return f[n % 3] From aa6b052ca109f435beee77cc65b6f39cf3005cbd Mon Sep 17 00:00:00 2001 From: Schrieffer <93866494+Schrieffer@users.noreply.github.com> Date: Wed, 24 Nov 2021 23:20:47 +0800 Subject: [PATCH 07/19] Add files via upload --- ...13\351\242\230\351\242\230\350\247\243.md" | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 "docs/views/data/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" diff --git "a/docs/views/data/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" "b/docs/views/data/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" new file mode 100644 index 00000000..79e54722 --- /dev/null +++ "b/docs/views/data/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" @@ -0,0 +1,97 @@ +--- +layout: post +title: 算法-动态规划 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 动态规划的python实现 +--- +## ***动态规划*** +#### 例题 +一条包含字母 A-Z 的消息通过以下映射进行了编码 ： +> A => 1 +> B => 2 +> ... +> Z => 26 + +要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 +例如，"11106" 可以映射为： +* "AAJF" ，将消息分组为 (1 1 10 6) +* "KJF" ，将消息分组为 (11 10 6) + +注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 +给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 +题目数据保证答案肯定是一个 32 位 的整数。 + +*** +#### 题解 +> ###***Step 1*** +> Definition of dp[i] +> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** +> +> ###***Step 2*** +> Set up of ***state transition fumula*** +> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] +> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 +> 比如，若s[i]=="0",则它只能与前一位组合解码 +> 而s[i]为其他时，则有分别解码的可能 + +* ***Case one*** +> When ***s[i] == "0"*** +> 由于它必须与前一位联合解码，所以有： +> If ***s[i-1] == "1” or "2"***, +>   +> ***dp[i] = dp[i-2]*** +> else +>   +> ***dp[i] = 0*** +* ***Case two*** +> When ***s[i] == "1" or "2" or ... "6"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1]=="1" or "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** +* ***Case three*** +> When ***s[i] == "6" or "7" or ... "9"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1] == "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** + +*** +#### 优化部分 +> 由于求解 ***dp[i]*** 只用到了前两位的数据， +> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : +> cur,pre1,pre2交错覆盖 + + +--- +代码如下： +```python +class Solution: + def numDecodings(self, s: str) -> int: + n = len(s) + s = ' ' + s + f = [0] * 3 + f[0] = 1 + for i in range(1,n + 1): + f[i % 3] = 0 + a = ord(s[i]) - ord('0') + b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') + if 1 <= a <= 9: + f[i % 3] = f[(i - 1) % 3] + if 10 <= b <= 26: + f[i % 3] += f[(i - 2) % 3] + return f[n % 3] From 43fb3e0b05998376195b57f3cc742a4d4c52b90f Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Thu, 25 Nov 2021 20:45:25 +0800 Subject: [PATCH 08/19] =?UTF-8?q?Create=202021-11-24=20=E5=8A=A8=E6=80=81?= =?UTF-8?q?=E8=A7=84=E5=88=92=E4=BE=8B=E9=A2=98=E9=A2=98=E8=A7=A3.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...13\351\242\230\351\242\230\350\247\243.md" | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 "2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" diff --git "a/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" "b/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" new file mode 100644 index 00000000..5ddbb047 --- /dev/null +++ "b/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" @@ -0,0 +1,97 @@ +--- +layout: post +title: 算法-动态规划 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 动态规划的python实现 +--- +## ***动态规划*** +#### 例题 +一条包含字母 A-Z 的消息通过以下映射进行了编码 ： +> A => 1 +> B => 2 +> ... +> Z => 26 + +要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 +例如，"11106" 可以映射为： +* "AAJF" ，将消息分组为 (1 1 10 6) +* "KJF" ，将消息分组为 (11 10 6) + +注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 +给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 +题目数据保证答案肯定是一个 32 位 的整数。 + +*** +#### 题解 +> ###***Step 1*** +> Definition of dp[i] +> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** +> +> ###***Step 2*** +> Set up of ***state transition fumula*** +> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] +> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 +> 比如，若s[i]=="0",则它只能与前一位组合解码 +> 而s[i]为其他时，则有分别解码的可能 + +* ***Case one*** +> When ***s[i] == "0"*** +> 由于它必须与前一位联合解码，所以有： +> If ***s[i-1] == "1” or "2"***, +>   +> ***dp[i] = dp[i-2]*** +> else +>   +> ***dp[i] = 0*** +* ***Case two*** +> When ***s[i] == "1" or "2" or ... "6"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1]=="1" or "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** +* ***Case three*** +> When ***s[i] == "6" or "7" or ... "9"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1] == "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** + +*** +#### 优化部分 +> 由于求解 ***dp[i]*** 只用到了前两位的数据， +> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : +> cur,pre1,pre2交错覆盖 + + +--- +代码如下： +```python +class Solution: + def numDecodings(self, s: str) -> int: + n = len(s) + s = ' ' + s + f = [0] * 3 + f[0] = 1 + for i in range(1,n + 1): + f[i % 3] = 0 + a = ord(s[i]) - ord('0') + b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') + if 1 <= a <= 9: + f[i % 3] = f[(i - 1) % 3] + if 10 <= b <= 26: + f[i % 3] += f[(i - 2) % 3] + return f[n % 3] From e7002859256af7a7fc2b6ddd87d97ef5ceaa6328 Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Thu, 25 Nov 2021 20:58:33 +0800 Subject: [PATCH 09/19] =?UTF-8?q?Delete=202021-11-24=20=E5=8A=A8=E6=80=81?= =?UTF-8?q?=E8=A7=84=E5=88=92=E4=BE=8B=E9=A2=98=E9=A2=98=E8=A7=A3.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...13\351\242\230\351\242\230\350\247\243.md" | 97 ------------------- 1 file changed, 97 deletions(-) delete mode 100644 "2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" diff --git "a/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" "b/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" deleted file mode 100644 index 5ddbb047..00000000 --- "a/2021-11-24 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" +++ /dev/null @@ -1,97 +0,0 @@ ---- -layout: post -title: 算法-动态规划 -date: 2021-11-19 -author: 张书翌 -categories: - - 数据分析部 -tags: - - 动态规划的python实现 ---- -## ***动态规划*** -#### 例题 -一条包含字母 A-Z 的消息通过以下映射进行了编码 ： -> A => 1 -> B => 2 -> ... -> Z => 26 - -要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 -例如，"11106" 可以映射为： -* "AAJF" ，将消息分组为 (1 1 10 6) -* "KJF" ，将消息分组为 (11 10 6) - -注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 -给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 -题目数据保证答案肯定是一个 32 位 的整数。 - -*** -#### 题解 -> ###***Step 1*** -> Definition of dp[i] -> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** -> -> ###***Step 2*** -> Set up of ***state transition fumula*** -> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] -> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 -> 比如，若s[i]=="0",则它只能与前一位组合解码 -> 而s[i]为其他时，则有分别解码的可能 - -* ***Case one*** -> When ***s[i] == "0"*** -> 由于它必须与前一位联合解码，所以有： -> If ***s[i-1] == "1” or "2"***, ->   -> ***dp[i] = dp[i-2]*** -> else ->   -> ***dp[i] = 0*** -* ***Case two*** -> When ***s[i] == "1" or "2" or ... "6"*** -> 由于它可以单独解码，所以有： -> ***dp[i] += dp[i-1]*** -> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 -> ***( i )*** ->  如果***s[i-1]=="1" or "2"***, ->  那么***dp[i] += dp[i-2]*** -> ***( ii )*** ->  如果是其他情况， ->  那么***dp[i] remain unchanged*** -* ***Case three*** -> When ***s[i] == "6" or "7" or ... "9"*** -> 由于它可以单独解码，所以有： -> ***dp[i] += dp[i-1]*** -> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 -> ***( i )*** ->  如果***s[i-1] == "2"***, ->  那么***dp[i] += dp[i-2]*** -> ***( ii )*** ->  如果是其他情况， ->  那么***dp[i] remain unchanged*** - -*** -#### 优化部分 -> 由于求解 ***dp[i]*** 只用到了前两位的数据， -> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : -> cur,pre1,pre2交错覆盖 - - ---- -代码如下： -```python -class Solution: - def numDecodings(self, s: str) -> int: - n = len(s) - s = ' ' + s - f = [0] * 3 - f[0] = 1 - for i in range(1,n + 1): - f[i % 3] = 0 - a = ord(s[i]) - ord('0') - b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') - if 1 <= a <= 9: - f[i % 3] = f[(i - 1) % 3] - if 10 <= b <= 26: - f[i % 3] += f[(i - 2) % 3] - return f[n % 3] From 9e64506216fd702a0785939b4cb33d0dcbe77446 Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Fri, 26 Nov 2021 17:02:02 +0800 Subject: [PATCH 10/19] =?UTF-8?q?Create=202021-11-26=20=E5=8A=A8=E6=80=81?= =?UTF-8?q?=E8=A7=84=E5=88=92=E4=BE=8B=E9=A2=98=E9=A2=98=E8=A7=A3.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...13\351\242\230\351\242\230\350\247\243.md" | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 "2021-11-26 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" diff --git "a/2021-11-26 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" "b/2021-11-26 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" new file mode 100644 index 00000000..06ed824e --- /dev/null +++ "b/2021-11-26 \345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" @@ -0,0 +1,97 @@ +--- +layout: post +title: 算法-动态规划 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 动态规划的python实现 +--- +## ***动态规划*** +#### 例题 +一条包含字母 A-Z 的消息通过以下映射进行了编码 ： +> A => 1 +> B => 2 +> ... +> Z => 26 + +要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 +例如，"11106" 可以映射为： +* "AAJF" ，将消息分组为 (1 1 10 6) +* "KJF" ，将消息分组为 (11 10 6) + +注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 +给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 +题目数据保证答案肯定是一个 32 位 的整数。 + +*** +#### 题解 +> ### ***Step 1*** +> Definition of dp[i] +> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** +> +> ### ***Step 2*** +> Set up of ***state transition fumula*** +> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] +> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 +> 比如，若s[i]=="0",则它只能与前一位组合解码 +> 而s[i]为其他时，则有分别解码的可能 + +* ***Case one*** +> When ***s[i] == "0"*** +> 由于它必须与前一位联合解码，所以有： +> If ***s[i-1] == "1” or "2"***, +>   +> ***dp[i] = dp[i-2]*** +> else +>   +> ***dp[i] = 0*** +* ***Case two*** +> When ***s[i] == "1" or "2" or ... "6"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1]=="1" or "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** +* ***Case three*** +> When ***s[i] == "6" or "7" or ... "9"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1] == "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** + +*** +#### 优化部分 +> 由于求解 ***dp[i]*** 只用到了前两位的数据， +> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : +> 使用滚动数组的形式，具体地，cur,pre1,pre2交错覆盖 + + +--- +代码如下： +```python +class Solution: + def numDecodings(self, s: str) -> int: + n = len(s) + s = ' ' + s + f = [0] * 3 + f[0] = 1 + for i in range(1,n + 1): + f[i % 3] = 0 + a = ord(s[i]) - ord('0') + b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') + if 1 <= a <= 9: + f[i % 3] = f[(i - 1) % 3] + if 10 <= b <= 26: + f[i % 3] += f[(i - 2) % 3] + return f[n % 3] From 93978bbea53391eb494fc3f34d83907a206d526b Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Sat, 27 Nov 2021 00:10:02 +0800 Subject: [PATCH 11/19] first week blog --- ...13\351\242\230\351\242\230\350\247\243.md" | 98 +++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 "2021-11-26-\345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" diff --git "a/2021-11-26-\345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" "b/2021-11-26-\345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" new file mode 100644 index 00000000..00d3a706 --- /dev/null +++ "b/2021-11-26-\345\212\250\346\200\201\350\247\204\345\210\222\344\276\213\351\242\230\351\242\230\350\247\243.md" @@ -0,0 +1,98 @@ +--- +layout: post +title: 算法-动态规划 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 动态规划的python实现 +--- +## ***动态规划*** +#### 例题 +一条包含字母 A-Z 的消息通过以下映射进行了编码 ： +> A => 1 +> B => 2 +> ... +> Z => 26 + +要解码已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。 +例如，"11106" 可以映射为： +* "AAJF" ，将消息分组为 (1 1 10 6) +* "KJF" ，将消息分组为 (11 10 6) + +注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。 +给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。 +题目数据保证答案肯定是一个 32 位 的整数。 + +*** + +#### 题解 +> ### ***Step 1*** +> Definition of dp[i] +> 我们将dp[i]定义为，字符串自0至i号位，有多少种***解码方式*** +> +> ### ***Step 2*** +> Set up of ***state transition fumula*** +> 即 如何用以前dp中 *0到 i-1* 中储存的数据，以求解dp[i] +> 由于数字位数的特殊性，dp[i]的求解显然需要分类讨论 +> 比如，若s[i]=="0",则它只能与前一位组合解码 +> 而s[i]为其他时，则有分别解码的可能 + +* ***Case one*** +> When ***s[i] == "0"*** +> 由于它必须与前一位联合解码，所以有： +> If ***s[i-1] == "1” or "2"***, +>   +> ***dp[i] = dp[i-2]*** +> else +>   +> ***dp[i] = 0*** +* ***Case two*** +> When ***s[i] == "1" or "2" or ... "6"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1]=="1" or "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** +* ***Case three*** +> When ***s[i] == "6" or "7" or ... "9"*** +> 由于它可以单独解码，所以有： +> ***dp[i] += dp[i-1]*** +> 还需要进一步细分，关于s[i]能否与s[i-1]联合解码 +> ***( i )*** +>  如果***s[i-1] == "2"***, +>  那么***dp[i] += dp[i-2]*** +> ***( ii )*** +>  如果是其他情况， +>  那么***dp[i] remain unchanged*** + +*** +#### 优化部分 +> 由于求解 ***dp[i]*** 只用到了前两位的数据， +> 所以使用如下方式，将 ***空间复杂度*** 从O(n) 优化到 O(1) : +> 我们可以使用滚动数组，即cur,pre1,pre2交错覆盖 + + +--- +代码如下： +```python +class Solution: + def numDecodings(self, s: str) -> int: + n = len(s) + s = ' ' + s + f = [0] * 3 + f[0] = 1 + for i in range(1,n + 1): + f[i % 3] = 0 + a = ord(s[i]) - ord('0') + b = ( ord(s[i - 1]) - ord('0') ) * 10 + ord(s[i]) - ord('0') + if 1 <= a <= 9: + f[i % 3] = f[(i - 1) % 3] + if 10 <= b <= 26: + f[i % 3] += f[(i - 2) % 3] + return f[n % 3] From e9fa29ce5733b46bb1077d310280c877c9f983d1 Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Sat, 27 Nov 2021 00:10:28 +0800 Subject: [PATCH 12/19] Second week blog --- "\345\210\227\350\241\250.md" | 174 ++++++++++++++++++++++++++++++++++ 1 file changed, 174 insertions(+) create mode 100644 "\345\210\227\350\241\250.md" diff --git "a/\345\210\227\350\241\250.md" "b/\345\210\227\350\241\250.md" new file mode 100644 index 00000000..0874ef03 --- /dev/null +++ "b/\345\210\227\350\241\250.md" @@ -0,0 +1,174 @@ +--- +layout: post +title: Python学习-列表学习笔记 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 列表学习笔记 +--- + + +# **3 · 列表** +> * ***列表的 创建*** +> 使用方括号把需要囊括的元素加入，例如： +>      +> *motorcycles = ['trek', 'cannondale', 'redline', 'specialized']* + +> * ***列表元素的 访问*** +> 元素序号从零开始，将需要访问的元素序号放入方括号中，例如： +>      +> *print(motorcycles[i])* +> 表示，将会打印 *motorcycles* 中的第 i+1 个元素 +> 且 *motorcycles[i]* 具有变量的所有性质 + +> * ***列表元素的 修改*** +> 由于 *motorcycles[i]* 具有变量的性质，所以可以做出如下操作以修改其值： +>      +> *motorcycles[i]=ducati* +> 这样之后，再次打印其值，会发现已被更改 + +> * ***列表元素的 添加*** +> 在列表的末尾添加元素，如下： +>      +> *print(motorcycles)* +>      +> *motorcycles.append('ducati')* +>      +> *print(motorcycles)* +>      +> 得：*['honda', 'yamaha', 'suzuki', 'ducati']* +>          +> *['honda', 'yamaha', 'suzuki']* + +> * ***列表元素的 插入*** +> *motorcycles = ['honda', 'yamaha', 'suzuki']* +> *motorcycles.insert(0, 'ducati')* +> *print(motorcycles)* +> 得：*['ducati', 'honda', 'yamaha', 'suzuki']* + +> * ***列表元素的 删除*** +>> * ***根据位置删除元素*** +>> *del motocycles[i]* +>> 或者使用*motocycles.pop(i)* 来删除 *i* 号元素 +>> * ***根据值删除元素*** +>> *motocycles.remove('ducati')* +>> 表示删除列表中，值为 *'ducati'* 的元素 + +> * ***列表 排序*** +> 函数介绍： +> **1. sort()** +> 该函数会对列表变量本身造成改变，是一个行为函数 +> 其默认顺序为：由小到大 +> 如果想改变其顺序，则可以： +>     *motocycles.sort(reverse=True)* +> 来调整*motocycles*变为逆序排列 +>
+> **2. sorted()** +> 它是一个有返回值的函数，返回一个排序后的数组，而不对原数组做出改变 +>      +> *sorted_motocycles=motocycles.sorted()* +> 而这个*sorted_motocycles*正是排序后的*motocycles*， +> 而赋值的过程中motocycles并无改变 +>
+> **3. reverse()** +> 该函数会对列表变量本身造成改变，是一个行为函数 +>      +> *motocycles.reverse()* +> 这段语句被执行后，*motocycles*将会被倒置 +> 这会改变列表本身 + +> * ***列表 长度*** +> **len()** +> 返回传入参数的长度，例如： +>     *len(motocycles)* +> 会返回*motocycles*列表的长度 + +> * ***列表 遍历*** +> **1. 直接遍历所有值** +> 如下： +>     *for item in motocycles:* +>         *print(item)* +>
+> **2. 按照序号遍历列表** +>     *n=len(motocycles)* +>     *for i in range(0,n):* +>         *print( motocycles[i] )* + +> * ***列表 解析*** +> 欲生成1至100的平方组成的列表，如下： +>     *square=[ i**2 for i in range(1,101) ]* +> 这样就会生成所需的列表了 + +> * ***列表 切片*** +>
+> 主要方法是，在访问数组元素的时候，加入***冒号*** +> 形如： +>> +>> *motocycles[ i : j ]* +>> 表示，由 i 号元素到 j-1 号元素所组成的列表 +> +>> *motocycles[ : j ]* +>> 表示，由 0 到 j-1 号元素所组成的列表 +> +>> *motocycles[ i : ]* +>> 表示，由 i 到 末尾元素所组成的列表 + + +> * ***列表 拷贝*** +> **1. 浅拷贝** +>     *copy=motocycles[ : ]* +> 这种拷贝方式，不会使两者产生关联，只是使两者具有相同的元素 +>
+> **2. 深拷贝** +>     *copy=motocycles* +> 这种拷贝方式的实质是，将*copy*定义为*motocycles*的别名， +> 那么，此时如果我们改变*copy*，将会发现*motocycles*也会被改变， +> 这是因为，*copy*与*motocycles*已经指向了同一块内存空间 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From deed1edce22fe4e931bd418c6e388cd236c2822e Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Tue, 30 Nov 2021 22:41:51 +0800 Subject: [PATCH 13/19] second blog --- "second bolg \345\210\227\350\241\250.md" | 126 ++++++++++++++++++++++ 1 file changed, 126 insertions(+) create mode 100644 "second bolg \345\210\227\350\241\250.md" diff --git "a/second bolg \345\210\227\350\241\250.md" "b/second bolg \345\210\227\350\241\250.md" new file mode 100644 index 00000000..3b73879a --- /dev/null +++ "b/second bolg \345\210\227\350\241\250.md" @@ -0,0 +1,126 @@ +--- +layout: post +title: Python学习-列表学习笔记 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 列表学习笔记 +--- + + +# **3 · 列表** +> * ***列表的 创建*** +> 使用方括号把需要囊括的元素加入，例如： +>      +> *motorcycles = ['trek', 'cannondale', 'redline', 'specialized']* + +> * ***列表元素的 访问*** +> 元素序号从零开始，将需要访问的元素序号放入方括号中，例如： +>      +> *print(motorcycles[i])* +> 表示，将会打印 *motorcycles* 中的第 i+1 个元素 +> 且 *motorcycles[i]* 具有变量的所有性质 + +> * ***列表元素的 修改*** +> 由于 *motorcycles[i]* 具有变量的性质，所以可以做出如下操作以修改其值： +>      +> *motorcycles[i]=ducati* +> 这样之后，再次打印其值，会发现已被更改 + +> * ***列表元素的 添加*** +> 在列表的末尾添加元素，如下： +>      +> *print(motorcycles)* +>      +> *motorcycles.append('ducati')* +>      +> *print(motorcycles)* +>      +> 得：*['honda', 'yamaha', 'suzuki', 'ducati']* +>          +> *['honda', 'yamaha', 'suzuki']* + +> * ***列表元素的 插入*** +> *motorcycles = ['honda', 'yamaha', 'suzuki']* +> *motorcycles.insert(0, 'ducati')* +> *print(motorcycles)* +> 得：*['ducati', 'honda', 'yamaha', 'suzuki']* + +> * ***列表元素的 删除*** +>> * ***根据位置删除元素*** +>> *del motocycles[i]* +>> 或者使用*motocycles.pop(i)* 来删除 *i* 号元素 +>> * ***根据值删除元素*** +>> *motocycles.remove('ducati')* +>> 表示删除列表中，值为 *'ducati'* 的元素 + +> * ***列表 排序*** +> 函数介绍： +> **1. sort()** +> 该函数会对列表变量本身造成改变，是一个行为函数 +> 其默认顺序为：由小到大 +> 如果想改变其顺序，则可以： +>     *motocycles.sort(reverse=True)* +> 来调整*motocycles*变为逆序排列 + +> **2. sorted()** +> 它是一个有返回值的函数，返回一个排序后的数组，而不对原数组做出改变 +>      +> *sorted_motocycles=motocycles.sorted()* +> 而这个*sorted_motocycles*正是排序后的*motocycles*， +> 而赋值的过程中motocycles并无改变 + +> **3. reverse()** +> 该函数会对列表变量本身造成改变，是一个行为函数 +>      +> *motocycles.reverse()* +> 这段语句被执行后，*motocycles*将会被倒置 +> 这会改变列表本身 + +> * ***列表 长度*** +> **len()** +> 返回传入参数的长度，例如： +>     *len(motocycles)* +> 会返回*motocycles*列表的长度 + +> * ***列表 遍历*** +> **1. 直接遍历所有值** +> 如下： +>     *for item in motocycles:* +>         *print(item)* + +> **2. 按照序号遍历列表** +>     *n=len(motocycles)* +>     *for i in range(0,n):* +>         *print( motocycles[i] )* + +> * ***列表 解析*** +> 欲生成1至100的平方组成的列表，如下： +>     *square=[ i**2 for i in range(1,101) ]* +> 这样就会生成所需的列表了 + +> * ***列表 切片*** + +> 主要方法是，在访问数组元素的时候，加入 ***冒号*** +> 形如： +> +>> *motocycles[ i : j ]* +>> 表示，由 i 号元素到 j-1 号元素所组成的列表 +> +>> *motocycles[ : j ]* +>> 表示，由 0 到 j-1 号元素所组成的列表 +> +>> *motocycles[ i : ]* +>> 表示，由 i 到 末尾元素所组成的列表 + +> * ***列表 拷贝*** +> **1. 浅拷贝** +>     *copy=motocycles[ : ]* +> 这种拷贝方式，不会使两者产生关联，只是使两者具有相同的元素 +> **2. 深拷贝** +>     *copy=motocycles* +> 这种拷贝方式的实质是，将*copy*定义为*motocycles*的别名， +> 那么，此时如果我们改变*copy*，将会发现*motocycles*也会被改变， +> 这是因为，*copy*与*motocycles*已经指向了同一块内存空间 \ No newline at end of file From a924e4721396ee42953403a220d2f28fffa121da Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Wed, 1 Dec 2021 11:44:15 +0800 Subject: [PATCH 14/19] =?UTF-8?q?Create=20=E5=85=83=E7=BB=84=E4=B8=8E?= =?UTF-8?q?=E5=AD=97=E5=85=B8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\344\270\216\345\255\227\345\205\270.md" | 110 ++++++++++++++++++ 1 file changed, 110 insertions(+) create mode 100644 "\345\205\203\347\273\204\344\270\216\345\255\227\345\205\270.md" diff --git "a/\345\205\203\347\273\204\344\270\216\345\255\227\345\205\270.md" "b/\345\205\203\347\273\204\344\270\216\345\255\227\345\205\270.md" new file mode 100644 index 00000000..b3909053 --- /dev/null +++ "b/\345\205\203\347\273\204\344\270\216\345\255\227\345\205\270.md" @@ -0,0 +1,110 @@ +--- +layout: post +title: python学习-元组与字典 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 元组,字典 +--- + +* # ***元组*** +要定义一个元组，须使用 **圆括号** 括住元组内元素， +特点：元组定义之后，元素不能再改变 +另外元组并没有提供添加，删除新元素的方法 +例如， +```python +items=(1,[1,2,34],'asdas',(1,2,'a')) +item[0]=12 +#系统报错，示意禁止修改 +``` +```python +items=(1,[1,2,34],'asdas',(1,2,'a')) +print(items[1]) +items[1].append(12) +items.insert('zsy',1) +print(items[1]) +print(items) +""" +虽然元组元素身不能修改，但是可以对作为元组元素的列表进行修改 +系统正常运行，程序输出如下： +[1, 2, 34] +[1, 10086, 2, 34, 12] +--------------------------------- +(1, [1, 10086, 2, 34, 12], 'asdas', (1, 2, 'a')) +""" +``` +```python +#元组的遍历十分简单，和列表一致 +items=(1,[1,2,34],'asdas',(1,2,'a')) +for item in items: + print(item) +''' +会得到如下输出： +1 +[1, 2, 34] +asdas +(1, 2, 'a') +''' +``` + +* # ***字典*** +## 字典的定义 +```python +#访问字典，使用键来访问值，用[]访问 +#用 : 来连接键与值，（键:值）作为一个整体，叫做键值对 +alien_0 = {'color': 'green', 'points': 5} +print(alien_0['color']) +print(alien_0['points']) +''' +得到： +green +5 +''' +``` +## 字典中键值对的添加，修改 +```python +#当中括号中的键在字典中已存在，则会修改键的值 +#若不存在，则会添加一个新键值对 +alien_0 = {'color': 'green', 'points': 5,'name':'0号'} +print(alien_0) +alien_0['x cordinate']=3 +alien_0['y cordinate']=4 +print(alien_0) +''' +得到： +{'color': 'green', 'points': 5, 'name': '0号'} +{'color': 'green', 'points': 5, 'name': '0号', 'x cordinate': 3, 'y cordinate': 4} +''' + +``` + +## 字典中键值对的删除 +```python +alien_0 = {'color': 'green', 'points': 5,'name':'0号'} +print(alien_0) +del alien_0['color'] +print(alien_0) +''' +得到： +{'color': 'green', 'points': 5, 'name': '0号'} +{'points': 5, 'name': '0号'} +''' +``` + +## 扩展 +```python +#字典中键的值，可以是列表，当然这个列表是可以扩展、更改的 +alien_0 = {'color': 'green', 'points': 5,'name':'0号','favorate food':['bug','human']} +print(alien_0) +alien_0['favorate food'].append('hotdog') +print(alien_0) + +''' +得到： +{'color': 'green', 'points': 5, 'name': '0号', 'favorate food': ['bug', 'human']} +{'color': 'green', 'points': 5, 'name': '0号', 'favorate food': ['bug', 'human', 'hotdog']} +''' +# 同样地，也可以有，字典列表、以及字典字典 +``` From 7159e6f25bdb7d9a4164add088bbd6cfe234fa09 Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Wed, 1 Dec 2021 21:10:37 +0800 Subject: [PATCH 15/19] fourth blog --- "\345\207\275\346\225\260.md" | 129 ++++++++++++++++++++++++++++++++++ 1 file changed, 129 insertions(+) create mode 100644 "\345\207\275\346\225\260.md" diff --git "a/\345\207\275\346\225\260.md" "b/\345\207\275\346\225\260.md" new file mode 100644 index 00000000..fa725dd0 --- /dev/null +++ "b/\345\207\275\346\225\260.md" @@ -0,0 +1,129 @@ +--- +layout: post +title: python学习-函数 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 函数 +--- + +# 函数 +## ***函数的定义*** +```python +def myprint(): + print('hello world') +#像这样完成函数的定义之后， +#就可以在之后的程序里自由且不限次数地调用了，例如： +myprint() +myprint() +``` +```python +def myprint(name,age=0): + print('name=',name) + print('age=',age) +''' +函数地调用可能需要一些参数 +而这些参数需要等到调用时才出现 +在此之前暂用形参为例，以之代表调用函数时会对实参做出的操作 +''' +#如上所示，我们可以为函数的形参赋默认值， +#这样即使调用时缺少参数 +#python也会对缺少的参数赋默认值，不会报错 +``` +## ***函数的关键字调用*** +```python +def myprint(name,age,size): + print('name=',name) + print('age=',age) + print('size=',size) +#这种函数参数较多，参数错位会使函数做出非预期的操作 +#为避免之，可以如下调用： +myprint(size=37, name='张三', age=21) +''' +调用之后会发现： +程序正常运行，尽管我们使用了完全错误的顺序 +''' +``` + +## ***传递任意数量的实参*** +```python +#当函数需要传递的参数未知时， +#可以使用如下操作： +def myprint(*tp): + for item in tp: + print(item) +''' +有趣的是，直接打印变量tp， +会发现tp是一个元组， +这意味着我们传递的实参可以是不同的数据类型 +''' +``` + +## ***函数的返回值*** +函数不仅可以完成特定的操作 +还可以返回值（包括数值，字符串，字典，乃至列表等等) +```python +#例如返回列表元素的平方和函数： +def square_sum(lt): + k=[i**2 for i in lt] + return sum(k) +def square_list(lt): + k=[i**2 for i in lt] + return k +lit=[1,2,3,4,5] +ans=square_sum(lit) +ans_list=square_list(lit) +print(ans) +print(ans_list) +#如我们所料，得到了 +#1至5的平方和： 55 +#以及平方和列表： [1, 4, 9, 16, 25] +``` + +## ***在函数中修改列表、以及禁止对列表的修改*** + +```python +#以排序函数为例， +#我们希望排序函数调用后，使作为实参的列表得以排序 +def mysort(lt): + for i in range(0,len(lt)): + for j in range(i+1,len(lt)): + if lt[j] Date: Wed, 1 Dec 2021 21:11:36 +0800 Subject: [PATCH 16/19] third blog --- ...04\344\270\216\345\255\227\345\205\270.md" | 27 ++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git "a/\345\205\203\347\273\204\344\270\216\345\255\227\345\205\270.md" "b/\345\205\203\347\273\204\344\270\216\345\255\227\345\205\270.md" index b3909053..371c1158 100644 --- "a/\345\205\203\347\273\204\344\270\216\345\255\227\345\205\270.md" +++ "b/\345\205\203\347\273\204\344\270\216\345\255\227\345\205\270.md" @@ -23,7 +23,6 @@ item[0]=12 items=(1,[1,2,34],'asdas',(1,2,'a')) print(items[1]) items[1].append(12) -items.insert('zsy',1) print(items[1]) print(items) """ @@ -93,6 +92,32 @@ print(alien_0) ''' ``` +## 字典的遍历 +```python +user_0 = { +'username': 'efermi', +'first': 'enrico', +'last': 'fermi', +} + +# 遍历所有键 +for key in user_0: #法一 + print(key) +for key in user_0.keys(): #法二 + print(key) + +# 遍历所有值 +for value in user_0.values(): + print(value) + +# 遍历所有键值对 +for key, value in user_0.items(): + print("Key=",key) + print("Value=",value) + +#当然也可以通过遍历键的方式，来完成键值对或值的遍历 +``` + ## 扩展 ```python #字典中键的值，可以是列表，当然这个列表是可以扩展、更改的 From 12331f336f68be98726a0e01f36abccf8ea57955 Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Thu, 2 Dec 2021 13:38:44 +0800 Subject: [PATCH 17/19] Fourth Blog --- "\346\250\241\345\235\227.md" | 69 +++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 "\346\250\241\345\235\227.md" diff --git "a/\346\250\241\345\235\227.md" "b/\346\250\241\345\235\227.md" new file mode 100644 index 00000000..c84f67bd --- /dev/null +++ "b/\346\250\241\345\235\227.md" @@ -0,0 +1,69 @@ +--- +layout: post +title: python学习-模块 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 模块 +--- + +# 模块 +函数的定义可能比较长，而我们调用它时，其实只需要知道它的功能。 +因此，为使主函数区更加简洁明了，我们可以把函数写在区块。 +```python +#文件名：module-1.py +def make_pizza(size, *toppings): + #概述要制作的比萨 + print("\nMaking a " + str(size) + + "-inch pizza with the following toppings:") + for topping in toppings: + print("- " + topping) +``` +完成函数在模块文件中的定义之后， +我们可以在需要的文件中进行调用，有多种方法 + +## ***法一：直接引用模块*** +```python +import module-1 + +module-1.make_pizza(16, 'pepperoni') +module-1.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese') +``` + +```python +#有时候当模块名过长，我们可以使用 as给这个模块起别名 +import module-1 as m1 + +m1.make_pizza(16, 'pepperoni') +m1.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese') +``` +## ***法二：从模块中引用需要的函数*** +函数之间逗号连接不限个数 + +```python +from module-1 import make_pizza,describe + +make_pizza(16, 'pepperoni') +make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese') +``` + +```python +#同样地，具有较多描述的函数名过长时，我们也可以使用 as给函数起别名 +from module-1 import make_pizza as mp + +mp(16, 'pepperoni') +mp(12, 'mushrooms', 'green peppers', 'extra cheese') +``` +## 法三：***从模块中引用所有函数*** +```python +from module-1 import * + +make_pizza(16, 'pepperoni') +make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese') +''' +此方法存在，但通常不用， +因为引用之后，可能会引发函数名冲突的问题，会使我们的程序做出非预期的行为 +''' +``` \ No newline at end of file From 401f55b38eb689d983f3faf64a2184635081a46f Mon Sep 17 00:00:00 2001 From: Schrieffer <42034081@smail.swufe.edu.cn> Date: Sun, 12 Dec 2021 19:13:33 +0800 Subject: [PATCH 18/19] =?UTF-8?q?=E7=AC=AC5=E6=AC=A1blog?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...66\346\200\201\345\216\213\347\274\251.md" | 146 ++++++++++++++++++ 1 file changed, 146 insertions(+) create mode 100644 "\345\212\250\346\200\201\350\247\204\345\210\222\351\242\230\350\247\243---\347\212\266\346\200\201\345\216\213\347\274\251.md" diff --git "a/\345\212\250\346\200\201\350\247\204\345\210\222\351\242\230\350\247\243---\347\212\266\346\200\201\345\216\213\347\274\251.md" "b/\345\212\250\346\200\201\350\247\204\345\210\222\351\242\230\350\247\243---\347\212\266\346\200\201\345\216\213\347\274\251.md" new file mode 100644 index 00000000..824a52c1 --- /dev/null +++ "b/\345\212\250\346\200\201\350\247\204\345\210\222\351\242\230\350\247\243---\347\212\266\346\200\201\345\216\213\347\274\251.md" @@ -0,0 +1,146 @@ +--- +layout: post +title: 算法-动态规划 +date: 2021-11-19 +author: 张书翌 +categories: + - 数据分析部 +tags: + - 动态规划 + - 状态压缩 + - 子集枚举 +--- + + +# ***动态规划题解*** + +## ***题目：*** + +给你一个长度为 n 的整数数组 nums ，这个数组中至多有 50 个不同的值。同时你有 m 个顾客的订单 quantity ，其中，整数 quantity[i] 是第 i 位顾客订单的数目。请你判断是否能将 nums 中的整数分配给这些顾客，且满足： +* 第 i 位顾客 恰好 有 quantity[i] 个整数。 +* 第 i 位顾客拿到的整数都是相同的 。 +* 每位顾客都满足上述两个要求。 + +如果你可以分配 nums 中的整数满足上面的要求，那么请返回 true ，否则返回 false。 + +
+ +数据信息： +* n == nums.length +* 1 <= n <= 100000 +* 1 <= nums[i] <= 1000 +* m == quantity.length +* 1 <= m <= 10 +* 1 <= quantity[i] <= 105 +* nums 中至多有 50 个不同的数字。 + + +## ***题解：*** +可以看到数据量很大，仅靠暴力dfs，n多达100000的量级，必然超时，这时就可以使用动态规划。 +而题目的解决还需要一个重要的算法：状态压缩 +***状态压缩是什么：*** +比如有7个客户： +我们可以用一个二进制数来表示7个客户的满意状况 +当只有两种情况时， +例如，我们可以用 001011 来表示： +0，1，3号位顾客未被满足，而2，4，5号位上的客人已被满足。 +这种做法有一个好处在于，天然地为状况分类完成了编号 + + +### Step One: ***对数据预处理*** + +主要是将零散的数字，集中成为具有分布特点的数组 +因为我们无需知道该数字是什么，只需将不同数字的个数信息统计出来就好了 +在这一步中，若假设nums种有34个不同的数字， +则cnt表示，这34个各不相同的数字，各自在nums中出现了多少次 +加之，cnt中的一个数字具有一次满足多个顾客的可能，我们创建sum来描述，以j为排列方式的顾客所需要的数字个数总和， +其中，sum[13]即sum[1101]，来表示 0、2、3 号位顾客的需求总和， +```C++ +class Solution { +public: + bool canDistribute(vector& nums, vector& quantity) { + unordered_map cache; + for (int x: nums) { + cache[x]++; + } + vector cnt; + for (auto& kv: cache) { + cnt.push_back(kv.second); + } + + int m=quantity.size(),n=cnt.size(); + vector sum(1<=sum[j-s] +当然，若dp[i-1][j]已经能成立，那么dp[i][j]当然也成立 +```C++ +class Solution { +public: + bool canDistribute(vector& nums, vector& quantity) { + unordered_map cache; + for (int x: nums) { + cache[x]++; + } + vector cnt; + for (auto& kv: cache) { + cnt.push_back(kv.second); + } + + int m=quantity.size(),n=cnt.size(); + vector sum(1<> dp(n,vector(1<=sum[j]; + } + + for(int i=1;i0; s=((s - 1) & j) ){ + if(dp[i-1][j-s] && cnt[i]>= sum[s]){ + dp[i][j]=true; + break; + } + } + } + } + + return dp[n-1][(1< Date: Sun, 12 Dec 2021 20:04:01 +0800 Subject: [PATCH 19/19] =?UTF-8?q?update=20=E7=AC=AC=E4=BA=94=E6=AC=A1blog?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...66\346\200\201\345\216\213\347\274\251.md" | 56 ++++++++++--------- 1 file changed, 30 insertions(+), 26 deletions(-) diff --git "a/\345\212\250\346\200\201\350\247\204\345\210\222\351\242\230\350\247\243---\347\212\266\346\200\201\345\216\213\347\274\251.md" "b/\345\212\250\346\200\201\350\247\204\345\210\222\351\242\230\350\247\243---\347\212\266\346\200\201\345\216\213\347\274\251.md" index 824a52c1..caf6b765 100644 --- "a/\345\212\250\346\200\201\350\247\204\345\210\222\351\242\230\350\247\243---\347\212\266\346\200\201\345\216\213\347\274\251.md" +++ "b/\345\212\250\346\200\201\350\247\204\345\210\222\351\242\230\350\247\243---\347\212\266\346\200\201\345\216\213\347\274\251.md" @@ -67,14 +67,19 @@ public: for (auto& kv: cache) { cnt.push_back(kv.second); } - - int m=quantity.size(),n=cnt.size(); - vector sum(1< sum(1 << m, 0); + for (int i = 1; i < (1 << m); i++) { + for (int j = 0; j < m; j++) { + if ((i & (1 << j)) != 0) { + int left = i - (1 << j); + sum[i] = sum[left] + quantity[j]; + break; + } } } + } }; ``` @@ -103,10 +108,10 @@ public: for (auto& kv: cache) { cnt.push_back(kv.second); } - - int m=quantity.size(),n=cnt.size(); - vector sum(1< sum(1 << m, 0); + for (int i = 1; i < (1 << m); i++) { for (int j = 0; j < m; j++) { if ((i & (1 << j)) != 0) { int left = i - (1 << j); @@ -115,32 +120,31 @@ public: } } } - //上面代码同上 - //-------------------------------------------------------- - vector> dp(n,vector(1<=sum[j]; + + vector> dp(n, vector(1 << m, false)); + for (int i = 0; i < n; i++) { + dp[i][0] = true; } - - for(int i=1;i 0 && dp[i-1][j]) { + dp[i][j] = true; continue; } - - //一种快速穷举子集的方法：s=((s - 1) & j) - for(int s=j;j>0; s=((s - 1) & j) ){ - if(dp[i-1][j-s] && cnt[i]>= sum[s]){ - dp[i][j]=true; + for (int s = j; s != 0; s = ((s - 1) & j)) { // 子集枚举，详见 https://oi-wiki.org/math/bit/#_14 + int prev = j - s; // 前 i-1 个元素需要满足子集 prev = j-s + bool last = (i == 0) ? (prev == 0): dp[i-1][prev]; // cnt[0..i-1] 能否满足子集 prev + bool need = sum[s] <= cnt[i]; // cnt[i] 能否满足子集 s + if (last && need) { + dp[i][j] = true; break; } } } } - return dp[n-1][(1<