街角の风铃

马尔可夫决策过程

Mon, 25 May 2026 00:00:00 GMT

提要

马尔科夫决策过程 是 马尔科夫奖励过程 加上 智能体 的动作得到的

马尔科夫决策过程

具有 马尔科夫性质 的 随机过程

随机过程

以我的理解，就是以条件概率描述一种状态，指当前状态受历史影响。

下一个状态取决于 $t$ 时刻之前的状态。我们将已知历史信息 $(S_1, \ldots, S_t)$ 时，下一个时刻状态为 $S_{t+1}$ 的概率表示为 $P(S_{t+1} \mid S_1, \ldots, S_t)$。

马尔科夫性质

一个随机过程某时刻的状态 只取决于 上一时刻的状态

$$ P(S_{t+1} \mid S_t) = P(S_{t+1} \mid S_1, \ldots, S_t) $$

再回到马尔科夫过程

马尔科夫过程也叫做马尔科夫链，可以由元组描述$\langle S, P \rangle$描述。关于转移矩阵，感觉其实有点像有向图，跟那个思想很像，就是把边权重改成状态转移概率了，有关变换如下图注意啊，状态集合记为 $\mathcal{S} = {s_1, s_2, \ldots, s_n}$。它是一个集合，不是指某一个状态。

有了这个过程，我们就可以进行从一个状态变到另一个状态了，从头变到尾就可以生成一个序列也叫采样。换个名字更熟悉episode/sampling(话说这两个单词在代码里面真的蛮常见的)

马尔科夫奖励过程

马尔科夫奖励过程可以用元组 $\langle \mathcal{S}, \mathcal{P}, r, \gamma \rangle$ 描述，其中：

$\mathcal{S}$ 是有限状态的集合。
$\mathcal{P}$ 是状态转移矩阵。
$r$ 是奖励函数，某个状态 $s$ 的奖励 $r(s)$ 指转移到该状态时可以获得奖励的期望。
$\gamma$ 是折扣因子（discount factor），$\gamma$ 的取值范围为 $[0, 1)$。
- 引入折扣因子的理由为远期利益具有一定不确定性，有时我们更希望能够尽快获得一些奖励，所以我们需要对远期利益打一些折扣。接近 $1$ 的 $\gamma$ 更关注长期的累计奖励，接近 $0$ 的 $\gamma$ 更考虑短期奖励。

回报

在某一状态时，所有奖励的衰减之和称为回报 $G_t$（Return），公式如下：

$$ G_t = R_t + \gamma R_{t+1} + \gamma^2 R_{t+2} + \cdots = \sum_{k=0}^{\infty} \gamma^k R_{t+k} $$

这个不用纠结，知道是啥就好了，都是人为定义的。不过这个跟后面的状态价值函数有密切联系。还有这个公式本身也是个数列递推式，后面会有很奇特的展开来简化算法复杂度的。

状态价值函数

有了回报 $G_t$ 之后，就可以定义状态价值函数 $V(s)$。

我的理解是，状态价值函数就是在某个状态 $s$ 出发时，对未来回报的期待。也就是说，未来可能会采样出很多条不同的轨迹，每条轨迹都有自己的回报 $G_t$，而 $V(s)$ 关心的是这些回报的期望值。

从这个角度看，$V(s)$ 有点像回报 $G_t$ 的某种统计学参数，更准确地说，它是“在当前状态为 $s$ 的条件下，回报的期望”：

$$ V(s) = \mathbb{E}[G_t \mid S_t = s] $$

结合马尔科夫奖励过程，状态价值函数也可以写成下面的递推形式：

$$ V(s) = r(s) + \gamma \sum_{s' \in \mathcal{S}} p(s' \mid s) V(s') $$

这个公式对写代码很重要。它可以理解成：

当前状态 $s$ 的价值，等于当前能获得的奖励 $r(s)$；
再加上从当前状态转移到所有可能的下一个状态 $s'$ 后，那些状态价值的加权平均；
权重就是状态转移概率 $p(s' \mid s)$；
未来价值还要乘上折扣因子 $\gamma$。

如果用代码思维来看，$V(s)$ 可以理解成一个表：

V = {
    s1: value1,
    s2: value2,
    s3: value3,
}

马尔科夫决策过程

简单来说，马尔科夫决策过程（Markov Decision Process，MDP）本质上就是在马尔科夫奖励过程（MRP）的基础上，加上了智能体的动作。

也就是说，MRP 里状态怎么转移、得到什么奖励，基本是环境自己随机决定的；而 MDP 里多了一个智能体，智能体可以在某个状态下选择动作 $a$，动作会影响后续的状态转移和奖励。

所以马尔科夫决策过程可以用下面这个元组描述：

$$ \langle \mathcal{S}, \mathcal{A}, \mathcal{P}, r, \gamma \rangle $$

其中相比 MRP，多出来的就是动作集合 $\mathcal{A}$：

策略

策略 $\pi$：给定状态 $s$，决定选择哪个动作 $a$。

$$ \pi(a \mid s) = P(A_t = a \mid S_t = s) $$

代码里可以理解成：

状态价值函数

状态价值函数 $V^\pi(s)$：状态 $s$ 在策略 $\pi$ 下的长期价值。

$$ V^\pi(s) = \mathbb{E}_\pi[G_t \mid S_t = s] $$

动作价值函数

动作价值函数 $Q^\pi(s, a)$：在状态 $s$ 下执行动作 $a$ 的长期价值。

$$ Q^\pi(s, a) = \mathbb{E}_\pi[G_t \mid S_t = s, A_t = a] $$

贝尔曼方程

贝尔曼方程：用“当前奖励 + 折扣后的未来价值”更新当前价值。

$$ V(s) = r(s) + \gamma \sum_{s'} p(s' \mid s) V(s') $$

git by 技术爬爬虾

Thu, 21 May 2026 00:00:00 GMT

1.git的作用

版本控制，多人协同巴拉巴拉，还有避免被ai炸仓库

2.git分区的概念

工作区就是写代码的地方
暂存区 add就是这样加进去的，不过现阶段概念比较淡了
本地仓库 commit的主战场，保存代码的主力点
远程仓库 github托管仓库，云端备份，分享代码，合作开发等

3.git常用指令

命令	用途
git init	初始化项目
git status	查看状态
git add .	加入暂存区
git commit -m	保存版本
git log --oneline	看历史
git restore .	撤销修改
git branch	看分支
git checkout -b	新分支
git checkout main	切回主线
git push	上传 GitHub
git pull	拉代码

4.我感觉很有用的地方

第一肯定是随时备份啦，ai炸代码我也遇见过，一开始我是点vscode行号左边的绿的红的，感觉挺好用，现在了解到这些命令可以更好地用和理解那些杠杠是啥了（其实直接交给ai恢复更好，把提交的id给agent哈哈哈哈哈）
分支我感觉也是很有用的一个地方（虽然我暂时还没实践过），就像就开发某个东西不想影响现在，直接拉个分支就好啦。
多人协同，开元分享这些内容应该也是git大放异彩的地方

5.碎碎念

现阶段学习3具体代码都可以放放了，在agent的相关开发学习中，发现真的是这样的（感觉好像啥都会其实都是不精也好焦虑哈哈哈）

[V0.1.1]评论区Demo版本

Tue, 28 Apr 2026 00:00:00 GMT

V0.1.1

完成了评论区的demo版本测试，使用express+sqlite完成做了一些基础的防护

背景页面的更改

把原本的banner换成了background，长图支持随页面转换线性变化（虽然有些不跟手，等我完成了更重要的任我我再回来改这个）

TODO

页面浏览量计数功能

b站视频链接解析

开发一个功能，来用百度网盘定时分享新番

强化学习环境/多臂老虎机

Mon, 20 Apr 2026 00:00:00 GMT

前言

本博客参考学习张伟楠老师的动手学强化学习代码来自相关教程，本人仅做一些注释，部分由于解释器抽风导致的警告修改，还有一些年久失修的库的替换。

多臂老虎机

2.2.4 估计期望奖励

import gymnasium as gym
import numpy as np

# 初始化环境
env = gym.make("CartPole-v1")
state, _ = env.reset()
total_reward = 0

# 智能体与环境交互
for _ in range(100):
    action = env.action_space.sample()  # 随机动作
    next_state, reward, done, truncated, info = env.step(action)
    total_reward += float(reward)
    state = next_state
    if done or truncated:
        break

print(f"总奖励：{total_reward}")
env.close()

# 导入需要使用的库,其中numpy是支持数组和矩阵运算的科学计算库,而matplotlib是绘图库
import numpy as np
import matplotlib.pyplot as plt


class BernoulliBandit:
    """ 伯努利多臂老虎机,输入K表示拉杆个数 """
    def __init__(self, K:int):
        self.probs = np.random.uniform(size=K)  # 随机生成K个0～1的数,作为拉动每根拉杆的获奖概率
        # 概率
        self.best_idx = np.argmax(self.probs)  # 获奖概率最大的拉杆
        self.best_prob = self.probs[self.best_idx]   # 最大的获奖概率
        self.K = K

    def step(self, k):
        # 当玩家选择了k号拉杆后,根据拉动该老虎机的k号拉杆获得奖励的概率返回1（获奖）或0（未
        # 获奖）
        if np.random.rand() < self.probs[k]:
            return 1
        else:
            return 0


np.random.seed(1)  # 设定随机种子,使实验具有可重复性
K = 10
bandit_10_arm = BernoulliBandit(K)
print("随机生成了一个%d臂伯努利老虎机" % K)
print("获奖概率最大的拉杆为%d号,其获奖概率为%.4f" %
      (bandit_10_arm.best_idx, bandit_10_arm.best_prob))

class Solver:
    """ 多臂老虎机算法基本框架 """
    def __init__(self, bandit): #bandit：BernoulliBandit 的实例
        self.bandit = bandit
        self.counts = np.zeros(self.bandit.K)  # 每根拉杆的尝试次数 
        self.regret = 0.  # 当前步的累积懊悔
        self.actions = []  # 维护一个列表,记录每一步的动作
        self.regrets = []  # 维护一个列表,记录每一步的累积懊悔

    def update_regret(self, k):
        # 计算累积懊悔并保存,k为本次动作选择的拉杆的编号
        self.regret += self.bandit.best_prob - self.bandit.probs[k]
        self.regrets.append(self.regret)

    def run_one_step(self):
        # 返回当前动作选择哪一根拉杆,由每个具体的策略实现
        raise NotImplementedError

    def run(self, num_steps):
        # 运行一定次数,num_steps为总运行次数
        for _ in range(num_steps):
            k = self.run_one_step()
            self.counts[k] += 1
            self.actions.append(k)
            self.update_regret(k)

2.4 ϵ-贪心算法

class EpsilonGreedy(Solver):
    """ epsilon贪婪算法,继承Solver类 """
    def __init__(self, bandit, epsilon=0.01, init_prob=1.0):
        super(EpsilonGreedy, self).__init__(bandit)
        self.epsilon = epsilon
        #初始化拉动所有拉杆的期望奖励估值
        self.estimates = np.array([init_prob] * self.bandit.K)

    def run_one_step(self):
        if np.random.random() < self.epsilon:
            k = np.random.randint(0, self.bandit.K)  # 随机选择一根拉杆 随机抽取[0,K]的一个整数
        else:
            k = np.argmax(self.estimates)  # 选择期望奖励估值最大的拉杆
        r = self.bandit.step(k)  # 得到本次动作的奖励
        '''
        Q_old:self.estimates[k]
        N:self.counts[k] + 1(本次算进去后的第 N 次）
        r:这次奖励 r
        Q_new=Q_old+1/N(r-Q_old)
        '''
        self.estimates[k] += 1. / (self.counts[k] + 1) * (r - self.estimates[k]) 
        return k

def plot_results(solvers, solver_names):
    """生成累积懊悔随时间变化的图像。输入solvers是一个列表,列表中的每个元素是一种特定的策略。
    而solver_names也是一个列表,存储每个策略的名称"""
    for idx, solver in enumerate(solvers):
        time_list = range(len(solver.regrets))
        plt.plot(time_list, solver.regrets, label=solver_names[idx])
    plt.xlabel('Time steps')
    plt.ylabel('Cumulative regrets')
    plt.title('%d-armed bandit' % solvers[0].bandit.K)
    plt.legend()
    plt.show()

np.random.seed(1)
epsilon_greedy_solver = EpsilonGreedy(bandit_10_arm, epsilon=0.01)
epsilon_greedy_solver.run(5000)
print('epsilon-贪婪算法的累积懊悔为：', epsilon_greedy_solver.regret)
plot_results([epsilon_greedy_solver], ["EpsilonGreedy"])

np.random.seed(0)
epsilons = [1e-4, 0.01, 0.1, 0.25, 0.5]
epsilon_greedy_solver_list = [
    EpsilonGreedy(bandit_10_arm, epsilon=e) for e in epsilons
]
epsilon_greedy_solver_names = ["epsilon={}".format(e) for e in epsilons]
for solver in epsilon_greedy_solver_list:
    solver.run(5000)

plot_results(epsilon_greedy_solver_list, epsilon_greedy_solver_names)

碎碎念：这本书是真不错，虽然我们没买实体书，但pdf，电子书都蛮好找的，而且学习官网竟然贴着现成的代码，实验课难度大大降低，而且大部分都不用改动（毕竟强化学习也比较新吧）。虽然但是吧，本人数学一坨，与数学有关的天书部分是真难搞。

[V0.1.0]个人博客正式上线啦

Sat, 18 Apr 2026 00:00:00 GMT

哈哈哈哈

本博客的demo版本源自于github的开源项目Fuwari. 云服务器采用腾讯云，还有要感谢Coedx的支持，也感谢老师给出的一条指导道路

ToDo

背景滑动

b站视频链接解析

尝试着连载番剧

学习web的搭建

Thu, 16 Apr 2026 00:00:00 GMT

1. Astro 官方文档（核心）

总入口: https://docs.astro.build/
项目结构: https://docs.astro.build/en/basics/project-structure/
路由: https://docs.astro.build/en/guides/routing/
内容集合（写博客最常用）: https://docs.astro.build/en/guides/content-collections/
部署指南总览: https://docs.astro.build/en/guides/deploy/

2. Tailwind CSS（样式）

总入口: https://tailwindcss.com/docs
响应式断点: https://tailwindcss.com/docs/responsive-design
状态与伪类（hover/focus/group）: https://tailwindcss.com/docs/hover-focus-and-other-states

3. Astro 生态里你项目常用库

astro-icon: https://www.astroicon.dev/
Iconify 图标检索: https://icon-sets.iconify.design/
KaTeX（数学公式）: https://katex.org/docs/
PhotoSwipe（图片灯箱）: https://photoswipe.com/

4. 部署平台官方文档（选一个主平台）

Vercel + Astro: https://docs.astro.build/en/guides/deploy/vercel/
Netlify + Astro: https://docs.astro.build/en/guides/deploy/netlify/
Cloudflare Pages + Astro: https://docs.astro.build/en/guides/deploy/cloudflare/

5. 域名与 DNS（上线必看）

Cloudflare DNS: https://developers.cloudflare.com/dns/
Vercel 自定义域名: https://vercel.com/docs/domains
Netlify 自定义域名: https://docs.netlify.com/domains-https/custom-domains/

6. 搜索与站点可见性（博客常用）

Google Search Console: https://support.google.com/webmasters/
robots.txt 说明: https://developers.google.com/search/docs/crawling-indexing/robots/intro
sitemap 说明: https://developers.google.com/search/docs/crawling-indexing/sitemaps/overview

Markdown Extended Features

Wed, 01 May 2024 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Spoiler

You can add spoilers to your text. The text also supports Markdown syntax.

The content :spoiler[is hidden ayyy]!

The content :spoiler[is hidden **ayyy**]!

Expressive Code Example

Wed, 10 Apr 2024 00:00:00 GMT

Here, we'll explore how code blocks look using Expressive Code. The provided examples are based on the official documentation, which you can refer to for further details.

Expressive Code

Syntax Highlighting

Regular syntax highlighting

console.log('This code is syntax highlighted!')

Rendering ANSI escape sequences

ANSI colors:
- Regular: [31mRed[0m [32mGreen[0m [33mYellow[0m [34mBlue[0m [35mMagenta[0m [36mCyan[0m
- Bold:    [1;31mRed[0m [1;32mGreen[0m [1;33mYellow[0m [1;34mBlue[0m [1;35mMagenta[0m [1;36mCyan[0m
- Dimmed:  [2;31mRed[0m [2;32mGreen[0m [2;33mYellow[0m [2;34mBlue[0m [2;35mMagenta[0m [2;36mCyan[0m

256 colors (showing colors 160-177):
[38;5;160m160 [38;5;161m161 [38;5;162m162 [38;5;163m163 [38;5;164m164 [38;5;165m165[0m
[38;5;166m166 [38;5;167m167 [38;5;168m168 [38;5;169m169 [38;5;170m170 [38;5;171m171[0m
[38;5;172m172 [38;5;173m173 [38;5;174m174 [38;5;175m175 [38;5;176m176 [38;5;177m177[0m

Full RGB colors:
[38;2;34;139;34mForestGreen - RGB(34, 139, 34)[0m

Text formatting: [1mBold[0m [2mDimmed[0m [3mItalic[0m [4mUnderline[0m

Editor & Terminal Frames

Code editor frames

console.log('Title attribute example')

<!-- src/content/index.html -->
<div>File name comment example</div>

Terminal frames

echo "This terminal frame has no title"

Write-Output "This one has a title!"

Overriding frame types

echo "Look ma, no frame!"

# Without overriding, this would be a terminal frame
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
New-Alias tail Watch-Tail

Text & Line Markers

Marking full lines & line ranges

// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range "7-8"
// Line 8 - targeted by range "7-8"

Selecting line marker types (mark, ins, del)

function demo() {
  console.log('this line is marked as deleted')
  // This line and the next one are marked as inserted
  console.log('this is the second inserted line')

  return 'this line uses the neutral default marker type'
}

Adding labels to line markers

// labeled-line-markers.jsx
<button
  role="button"
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
>
  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Adding long labels on their own lines

// labeled-line-markers.jsx
<button
  role="button"
  {...props}

  value={value}
  className={buttonClassName}

  disabled={disabled}
  active={active}
>

  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Using diff-like syntax

+this line will be marked as inserted
-this line will be marked as deleted
this is a regular line

--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+this is an actual diff file
-all contents will remain unmodified
 no whitespace will be removed either

Combining syntax highlighting with diff-like syntax

  function thisIsJavaScript() {
    // This entire block gets highlighted as JavaScript,
    // and we can still add diff markers to it!
-   console.log('Old code to be removed')
+   console.log('New and shiny code!')
  }

Marking individual text inside lines

function demo() {
  // Mark any given text inside lines
  return 'Multiple matches of the given text are supported';
}

Regular expressions

console.log('The words yes and yep will be marked.')

Escaping forward slashes

echo "Test" > /home/test.txt

Selecting inline marker types (mark, ins, del)

function demo() {
  console.log('These are inserted and deleted marker types');
  // The return statement uses the default marker type
  return true;
}

Word Wrap

Configuring word wrap per block

// Example with wrap
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with wrap=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Configuring indentation of wrapped lines

// Example with preserveIndent (enabled by default)
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with preserveIndent=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Collapsible Sections

// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from '@example/some-boilerplate'
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: 'End of example boilerplate code' })

Line Numbers

Displaying line numbers per block

// This code block will show line numbers
console.log('Greetings from line 2!')
console.log('I am on line 3')

// Line numbers are disabled for this block
console.log('Hello?')
console.log('Sorry, do you know what line I am on?')

Changing the starting line number

console.log('Greetings from line 5!')
console.log('I am on line 6')

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown Example

Sun, 01 Oct 2023 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 uncover pot
 stir
 cover pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Include Video in the Posts

Tue, 01 Aug 2023 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili