AI Generated
Posts whose prose is machine-written rather than mine. Every post is scored with Pangram before it ships; anything over 85% fully AI gets this tag.
Markdown Cheatsheet
A comprehensive reference for every Markdown flavor
This guide covers markdown syntax from basic to advanced, across all major flavors. Whether you're writing documentation, blog posts, or technical notes, this reference has you covered.
| Flavor | Best For |
|---|---|
| CommonMark | Universal compatibility |
| GFM | GitHub repos, issues, wikis |
| Pandoc | Academic papers, books |
| Kramdown | Jekyll/Ruby sites |
| MDX | React documentation |
| Obsidian | Personal knowledge bases |
## 1. Basic Syntax (Original Markdown)
### Headings
```markdown
# Heading 1
## Heading 2
### Heading 3
#### Heading 4
##### Heading 5
###### Heading 6
Alternative H1
==============
Alternative H2
--------------
```
### Emphasis
```markdown
*italic* or _italic_
**bold** or __bold__
***bold italic*** or ___bold italic___
~~strikethrough~~ (GFM extension)
```
### Lists
**Unordered:**
```markdown
* Item 1
* Item 2
* Nested item 2.1
* Nested item 2.2
* Deep nested
- Item with dash
+ Item with plus
```
**Ordered:**
```markdown
1. First item
2. Second item
1. Nested ordered
2. Another nested
3. Third item
1. Numbers don't need to be sequential
```
### Links & Images
```markdown
[Inline link](https://example.com "Optional Title")
[Reference link][ref1]
[Implicit reference][]
<https://automatic-link.com>
<[email protected]>

![Reference image][img-ref]
[ref1]: https://example.com "Reference Title"
[Implicit reference]: https://example.com
[img-ref]: image.jpg "Image Reference"
```
### Blockquotes
```markdown
> Single line quote
> Multi-line quote continues here
> and here
> Nested quotes
>> Can be nested
>>> Multiple levels deep
```
### Code
```markdown
Inline `code` with backticks
Code block with 4 spaces
or tab indentation
```
~~~markdown
```
Fenced code block
Multiple lines
```
```javascript
// Syntax highlighted (GFM)
function hello() {
console.log("Hello, World!");
}
```
~~~
### Horizontal Rules
```markdown
Three or more:
---
Hyphens
***
Asterisks
___
Underscores
```
---
## 2. GitHub Flavored Markdown (GFM)
### Tables
```markdown
| Left-aligned | Center-aligned | Right-aligned |
| :----------- | :------------: | ------------: |
| Cell 1 | Cell 2 | Cell 3 |
| Longer text | **Bold** | *Italic* |
Minimal table:
First Header | Second Header
------------ | -------------
Content Cell | Content Cell
```
**Rendered:**
| Left-aligned | Center-aligned | Right-aligned |
| :----------- | :------------: | ------------: |
| Cell 1 | Cell 2 | Cell 3 |
| Longer text | **Bold** | *Italic* |
### Task Lists
```markdown
- [x] Completed task
- [ ] Uncompleted task
- [ ] Another todo
- [x] Nested completed
- [ ] Nested uncompleted
```
**Rendered:**
- [x] Completed task
- [ ] Uncompleted task
- [ ] Another todo
- [x] Nested completed
- [ ] Nested uncompleted
### Username & Issue Mentions
```markdown
@username (GitHub only)
#123 (Issue reference)
user/repo#123 (Cross-repo issue)
```
### Emoji
```markdown
:smile: :heart: :thumbsup: :100:
:rocket: :octocat: :+1: :-1:
```
### Syntax Highlighting with Language
~~~markdown
```python
def factorial(n):
"""Calculate factorial"""
if n <= 1:
return 1
return n * factorial(n - 1)
```
```diff
- Removed line
+ Added line
! Important change
# Comment
```
~~~
**Rendered:**
```python
def factorial(n):
"""Calculate factorial"""
if n <= 1:
return 1
return n * factorial(n - 1)
```
```diff
- Removed line
+ Added line
! Important change
# Comment
```
### SHA References
```markdown
16c999e8c71134401a78d4d46435517b2271d6ac
mojombo@16c999e8c71134401a78d4d46435517b2271d6ac
mojombo/github-flavored-markdown@16c999e
```
---
## 3. CommonMark Extensions
### Autolinks
```markdown
www.example.com (some parsers)
https://example.com
ftp://files.example.com
```
### Disallowed Raw HTML (optional)
```html
<script>alert('This may be stripped');</script>
<div class="custom">Safe HTML allowed in some flavors</div>
```
### Entity & Numeric Character References
```markdown
& < > " '
A A …
```
---
## 4. MultiMarkdown Extensions
### Metadata Block
```markdown
Title: Document Title
Author: John Doe
Date: 2024-01-01
Tags: markdown, reference
Base Header Level: 2
```
### Footnotes
```markdown
Here's a sentence with a footnote[^1].
Here's another with a longer note[^longnote].
Inline footnote^[This is an inline footnote].
[^1]: This is the footnote.
[^longnote]: Here's one with multiple paragraphs.
Indent paragraphs to include them in the footnote.
> Even blockquotes in footnotes!
```
### Citations
```markdown
This is a statement that needs citation[p. 23][#Doe:2024].
Multiple citations[p. 10][#Smith:2023; p. 24][#Doe:2024].
[#Doe:2024]: John Doe. *Sample Book*. 2024.
[#Smith:2023]: Jane Smith. *Another Book*. 2023.
```
### Math (also Pandoc)
```markdown
Inline math: $E = mc^2$ or \\(a^2 + b^2 = c^2\\)
Display math:
$$
\sum_{i=1}^{n} x_i = \int_{0}^{1} f(x) dx
$$
\\[
\frac{-b \pm \sqrt{b^2 - 4ac}}{2a}
\\]
```
### Abbreviations
```markdown
HTML is great.
CSS is awesome.
*[HTML]: HyperText Markup Language
*[CSS]: Cascading Style Sheets
```
### Definition Lists
```markdown
Term 1
: Definition 1
: Another definition
Term 2
: Definition with *inline* **formatting**
Compact Definition
: Brief description
```
### Smart Typography
```markdown
"Smart quotes" and 'single quotes'
En-dash -- and em-dash ---
Ellipsis...
```
### Cross-references
```markdown
See [](#heading-1) for more info.
As discussed in [](#fig:example).
![Example Figure][fig:example]
[fig:example]: image.jpg "Example" width=500px height=300px
```
---
## 5. Pandoc Markdown Extensions
### Div Blocks
```markdown
::: {.note #special-note}
This is a special note block with class and id.
:::
::: warning
This is a warning block.
:::
::: {.sidebar}
Sidebar content here
:::
```
### Span Elements
```markdown
This is [special text]{.highlight #text-id} inline.
[Small caps]{.smallcaps} text.
```
### Line Blocks
```markdown
| The limerick packs laughs anatomical
| In space that is quite economical.
| But the good ones I've seen
| So seldom are clean
| And the clean ones so seldom are comical
```
### Fancy Lists
```markdown
(1) First item
(2) Second item
a. Sub-item
b. Another sub
i. Deep nesting
#. Auto-numbered
#. Continues numbering
i. Roman numerals
ii. Continue
A. Upper letters
B. More items
Example lists:
(@) First example
(@) Second example
Later reference to example (@).
```
### Grid Tables
```markdown
+---------------+---------------+--------------------+
| Fruit | Price | Advantages |
+===============+===============+====================+
| Bananas | $1.34 | - built-in wrapper |
| | | - bright color |
+---------------+---------------+--------------------+
| Oranges | $2.10 | - cures scurvy |
| | | - tasty |
+---------------+---------------+--------------------+
```
### Pipe Tables (simpler)
```markdown
| Right | Left | Default | Center |
|------:|:-----|---------|:------:|
| 12 | 12 | 12 | 12 |
| 123 | 123 | 123 | 123 |
| 1 | 1 | 1 | 1 |
```
### Superscript and Subscript
```markdown
H~2~O is water.
X^2^ is X squared.
^superscript^ and ~subscript~
```
### Inline Code Attributes
```markdown
`code`{.python}
`var x = 5;`{#mycode .javascript .numberLines startFrom="100"}
```
### Raw Blocks
~~~markdown
```{=html}
<div class="custom-html">
Raw HTML preserved exactly
</div>
```
```{=latex}
\begin{align}
E &= mc^2
\end{align}
```
```{=mediawiki}
{{Template|arg=value}}
```
~~~
### YAML Metadata Block
```yaml
---
title: Complete Reference
subtitle: Every Markdown Feature
author:
- name: John Doe
affiliation: University
- name: Jane Smith
date: 2024-01-01
abstract: |
This is a multi-line
abstract in YAML.
tags: [markdown, documentation]
keywords:
- markdown
- reference
lang: en-US
toc: true
toc-depth: 3
numbersections: true
---
```
### Native Spans and Divs
```html
<div custom="attribute">
Native div with attributes
</div>
<span class="custom">Native span</span>
```
---
## 6. Extended Features (Various Flavors)
### Admonitions/Callouts
```markdown
!!! note "Optional Title"
This is a note admonition.
!!! warning
This is a warning without title.
!!! danger "Critical"
Important danger message.
!!! tip
Helpful tip here.
!!! important
Important information.
!!! example "Code Example"
```python
print("Hello")
```
```
**GitHub-style callouts:**
```markdown
> [!NOTE]
> GitHub-style callout
> [!WARNING]
> Another style of callout
> [!TIP]
> Helpful information
> [!IMPORTANT]
> Crucial information
> [!CAUTION]
> Be careful here
```
### Keyboard Keys
```html
Press <kbd>Ctrl</kbd> + <kbd>C</kbd> to copy.
<kbd>⌘</kbd> + <kbd>V</kbd> on Mac.
++ctrl+alt+del++ (some flavors)
```
**Rendered:**
Press <kbd>Ctrl</kbd> + <kbd>C</kbd> to copy.
<kbd>⌘</kbd> + <kbd>V</kbd> on Mac.
### Mark/Highlight
```markdown
==Highlighted text== (some flavors)
<mark>HTML mark element</mark>
{==highlighted==} (critic markup)
```
**Rendered:**
<mark>HTML mark element</mark>
### Insert/Delete (Critic Markup)
```markdown
{++inserted text++}
{--deleted text--}
{~~old~>new~~}
{>>comment<<}
{==highlight==}{>>with comment<<}
```
### Details/Summary
```html
<details>
<summary>Click to expand</summary>
Hidden content here with:
- Lists
- **Formatting**
- Etc.
</details>
<details open>
<summary>Expanded by default</summary>
This is visible initially.
</details>
```
**Rendered:**
<details>
<summary>Click to expand</summary>
Hidden content here with:
- Lists
- **Formatting**
- Etc.
</details>
### Table of Contents
```markdown
[[TOC]] (some flavors)
[TOC] (other flavors)
{:toc} (kramdown)
```
### Include Files
```markdown
<<[file.md]
<<(file.md)
{{file.md}}
!include file.md
{! file.md !}
```
### Diagrams
~~~markdown
```mermaid
graph LR
A[Start] --> B{Decision}
B -->|Yes| C[Do this]
B -->|No| D[Do that]
C --> E[End]
D --> E
```
```plantuml
@startuml
Alice -> Bob: Hello
Bob --> Alice: Hi!
@enduml
```
```graphviz
digraph G {
A -> B;
B -> C;
C -> A;
}
```
~~~
### Custom Containers
```markdown
::: {.theorem #pythagorean}
**Pythagorean Theorem**: $a^2 + b^2 = c^2$
:::
::: note
Custom note container
:::
::: {.callout-note}
## Note Title
Note content
:::
```
### Attributes on Elements
```markdown
{width=50% height=30px}
[Link](url.com){.external target="_blank"}
Paragraph with attributes.
{: .custom-class #custom-id}
```
### Hard Line Breaks
```markdown
Line ending with two spaces
creates a hard break.
Line ending with backslash\
also creates a hard break (some flavors).
```
### Video Embeds (Some Flavors)
```markdown


@[youtube](dQw4w9WgXcQ)
```
### Special Lists
```markdown
Term
~ Definition using tilde
Tight list:
* item1
* item2
Loose list:
* item1
* item2
```
---
## 7. Edge Cases & Special Characters
### Escaping
```markdown
\*Not italic\*
\`Not code\`
\[Not a link\](not a url)
\# Not a heading
\| Not a table
\1. Not a list
```
### Special Characters
```markdown
© ™ ® ° ± ≠ ≤ ≥
→ ← ↑ ↓ ↔
½ ¾ ∞ ∑ ∏
```
**Rendered:**
© ™ ® ° ± ≠ ≤ ≥
→ ← ↑ ↓ ↔
½ ¾ ∞ ∑ ∏
### Zero-Width Characters
```markdown
Zero​Width​Space
Word­Break­Hint
```
### Nested Structures
```markdown
> Blockquote with:
> - List item 1
> - List item 2
> ```python
> # code in list in quote
> print("nested")
> ```
> > Nested quote in list
>
> 1. Ordered in quote
> 2. More ordered
>
> | Table | In | Quote |
> |-------|----|----|
> | Works | In | Some |
```
### Complex Nesting
```markdown
1. List with paragraph
Multiple paragraph in list item.
> Quote in list
```
code in list
```
2. Another item
- [ ] Task in ordered list
- [x] Completed
```
### Unicode & Emoji
```markdown
📝 ✨ 🚀 💻 🎯 ⚡ 🔥 ✅ ❌ ⚠️
α β γ δ ε ζ η θ
© ® ™ • · × ÷ ±
```
### Comments
```markdown
<!-- HTML comment -->
[//]: # (This is also a comment)
[//]: <> (Another comment style)
[comment]: <> (Yet another)
```
---
## 8. Kramdown Specific
### Block Attributes
```markdown
{: .class #id key="value"}
This paragraph has attributes.
> Block quote with attributes.
{: .pullquote}
```
### Options
```markdown
{::options parse_block_html="true" /}
{::options auto_ids="false" /}
```
### No Markdown
```markdown
{::nomarkdown}
This *won't* be **parsed**.
{:/}
```
### Comments
```markdown
{::comment}
This is a kramdown comment.
{:/comment}
```
---
## 9. Markdown Extra
### Special Attributes
```markdown
Header {#header-id .header-class}
================================
[link](url){#link-id .link-class}
```
### Fenced Code Attributes
~~~markdown
~~~ {.python #mycode .numberLines startFrom="10"}
def hello():
print("Hi")
~~~
~~~
### Markdown Inside HTML
```html
<div markdown="1">
This is *markdown* inside **HTML**.
</div>
<div markdown="block">
- List inside HTML
- Another item
</div>
```
### Backslash Escapes
```markdown
\\ \` \* \_ \{ \} \[ \] \( \) \# \+ \- \. \!
```
---
## 10. R Markdown / Quarto
### Code Chunks
~~~markdown
```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```
```{python}
#| label: fig-plot
#| fig-cap: "Sample Plot"
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [1, 4, 9])
```
~~~
### Inline R Code
```markdown
The mean is `r mean(c(1,2,3))`.
```
### Chunk Options
~~~markdown
```{r, echo=FALSE, fig.width=6, fig.height=4}
plot(cars)
```
~~~
---
## 11. Wiki-Style Links & Knowledge Base Features
### Wiki Links (Obsidian/Roam/Foam)
```markdown
[[Page Name]]
[[Page Name|Custom Display Text]]
[[Page Name#Heading]]
[[Page Name^block-id]]
![[Embedded Page]]
![[image.png|300x200]]
```
### Block References
```markdown
^unique-block-id
Reference to [[Page#^unique-block-id]]
```
### Tags
```markdown
#tag #multi-word-tag #nested/tag #2024/01/projects
#[[Complex Tag Name]]
```
### Dataview (Obsidian)
~~~markdown
```dataview
TABLE author, rating, finished
FROM #books
WHERE rating > 4
SORT finished DESC
```
`= this.file.name`
`= date(now)`
~~~
---
## 12. MDX (Markdown + JSX)
```jsx
import Button from './Button'
import { Chart } from './Chart'
export const meta = {
title: 'MDX Document',
author: 'John'
}
# {meta.title}
<Button onClick={() => alert('Clicked!')}>
Click me
</Button>
<Chart data={[1, 2, 3]} />
Regular markdown with *React components*.
```
---
## 13. AsciiDoc-Influenced Features
### Admonition Blocks (Alternative Syntax)
```markdown
NOTE: This is a note.
TIP: Helpful tip here.
IMPORTANT: Don't forget this.
WARNING: Be careful!
CAUTION: Critical warning.
```
### Include Directives
```markdown
include::chapter1.md[]
include::code.js[lines=5..10]
```
### Conditional Directives
```markdown
ifdef::env-github[]
This only shows on GitHub.
endif::[]
ifndef::env-github[]
This shows everywhere except GitHub.
endif::[]
```
---
## 14. Mathematical Notation (Extended)
### Display Math Environments
```latex
$$
\begin{align}
a &= b + c \\
d &= e + f + g \\
h &= i
\end{align}
$$
$$
\begin{matrix}
a & b & c \\
d & e & f \\
g & h & i
\end{matrix}
$$
$$
\begin{cases}
x + y = 5 \\
2x - y = 1
\end{cases}
$$
```
### Chemical Equations
```latex
$\ce{2H2 + O2 -> 2H2O}$
$\ce{SO4^2- + Ba^2+ -> BaSO4 v}$
```
### Physics Notation
```latex
$\ket{\psi} = \alpha\ket{0} + \beta\ket{1}$
$\bra{\phi}\ket{\psi}$
```
---
## 15. Diagram Extensions
### PlantUML
~~~markdown
```plantuml
@startuml
!theme plain
actor User
participant "Web Browser" as Browser
participant "Web Server" as Server
database "Database" as DB
User -> Browser: Enter URL
Browser -> Server: HTTP Request
Server -> DB: Query
DB -> Server: Results
Server -> Browser: HTTP Response
Browser -> User: Display Page
@enduml
```
~~~
### Ditaa
~~~markdown
```ditaa
+--------+ +-------+ +-------+
| | --+ ditaa +--> | |
| Text | +-------+ |diagram|
|Document| |!magic!| | |
| {d}| | | | |
+---+----+ +-------+ +-------+
: ^
| Lots of work |
+-------------------------+
```
~~~
### Graphviz DOT
~~~markdown
```dot
digraph finite_state_machine {
rankdir=LR;
size="8,5"
node [shape = doublecircle]; S;
node [shape = point ]; qi
node [shape = circle];
qi -> S;
S -> q1 [ label = "a" ];
S -> S [ label = "a" ];
q1 -> S [ label = "a" ];
q1 -> q2 [ label = "b" ];
q2 -> q1 [ label = "b" ];
q2 -> q2 [ label = "b" ];
}
```
~~~
### Vega-Lite
~~~markdown
```vega-lite
{
"$schema": "https://vega.github.io/schema/vega-lite/v5.json",
"data": {"url": "data.csv"},
"mark": "bar",
"encoding": {
"x": {"field": "category", "type": "nominal"},
"y": {"field": "value", "type": "quantitative"}
}
}
```
~~~
---
## 16. Scholarly Markdown
### Abstract Block
```markdown
{abstract}
This paper presents a comprehensive overview of markdown
flavors and their features. We examine standard syntax
and extended capabilities across implementations.
{/abstract}
```
### Author Block
```markdown
{authors}
John Doe^1^, Jane Smith^2^
^1^ University of Examples
^2^ Institute of Documentation
{/authors}
```
### Keywords
```markdown
{keywords}
markdown, documentation, syntax, reference
{/keywords}
```
### DOI/Bibliography
```markdown
[@doi:10.1000/xyz123] shows that markdown is effective.
See [@smith2024; @doe2023] for more information.
```
### Glossary
```markdown
{glossary}
GFM
: GitHub Flavored Markdown
MMD
: MultiMarkdown
{/glossary}
```
---
## 17. Hugo/Jekyll/Static Site Features
### Front Matter (TOML)
```toml
+++
title = "Post Title"
date = 2024-01-01T10:00:00Z
draft = false
tags = ["markdown", "hugo"]
categories = ["documentation"]
+++
```
### Shortcodes
```markdown
{{</* youtube w7Ft2ymGmfc */>}}
{{</* tweet user="xxx" id="xxx" */>}}
{{</* gist user="xxx" id="xxx" */>}}
{{</* figure src="image.jpg" title="Figure 1" */>}}
{{</* highlight go "linenos=table" */>}}
package main
import "fmt"
func main() {
fmt.Println("Hello")
}
{{</* /highlight */>}}
```
### Jekyll Includes
```liquid
{% include header.html %}
{% include_relative file.md %}
```
### Liquid Templates
```liquid
{% for post in site.posts %}
- [{{ post.title }}]({{ post.url }})
{% endfor %}
{% if page.comments %}
{% include comments.html %}
{% endif %}
```
---
## 18. Markua (LeanPub)
### Aside
```markdown
A> This is an aside (sidebar).
A> It can span multiple lines.
```
### Blurb
```markdown
B> This is a blurb - a textbox with special styling.
```
### Discussion
```markdown
D> This is a discussion box for exercises or questions.
```
### Error/Warning/Information
```markdown
E> This is an error message.
W> This is a warning.
I> This is an information box.
```
### Quiz
```markdown
{quiz, id: quiz1}
? What is 2 + 2?
a) 3
B) 4
c) 5
d) 6
? Which are markdown flavors?
[X] GFM
[X] CommonMark
[ ] XML
[X] Pandoc
{/quiz}
```
---
## 19. Advanced Table Features
### Column Spanning (some flavors)
```markdown
| Column 1 | Column 2 | Column 3 |
|----------|:--------:|---------:|
| span=2 | | Right |
| Left | Center | Right |
```
### MultiMarkdown Tables
```markdown
| | Grouping ||
| First Header | Second Header | Third Header |
| ------------ | :-----------: | -----------: |
| Content | *Long Cell* ||
| Content | **Cell** | Cell |
| New section | More | Data |
| And more | With an escaped '\|' ||
[Table caption, works in MD Extra too]
```
### Grid Table with Alignment
```markdown
+:-----+:-----:+-----:+
| Left |Center |Right |
+======+=======+======+
| L | C | R |
+------+-------+------+
| Left |Center |Right |
+------+-------+------+
```
---
## 20. Custom HTML with Markdown
### Details with Markdown
```html
<details markdown="1">
<summary>Click for markdown content</summary>
- This is a **list**
- With _formatting_
- Inside HTML details
```python
# Even code blocks work
print("Hello from details")
```
</details>
```
### Ruby Annotations
```html
<ruby>
漢字<rt>かんじ</rt>
</ruby>
<ruby>
WWW<rt>World Wide Web</rt>
</ruby>
```
### Progress Bars
```html
<progress value="70" max="100">70%</progress>
<meter value="6" min="0" max="10">6 out of 10</meter>
```
---
## 21. Extended Link Features
### Link Attributes
```markdown
[External Link](https://example.com){:target="_blank" rel="noopener"}
[Download](file.pdf){:download="filename.pdf"}
```
### Anchor Links with IDs
```markdown
{#custom-anchor}
### Heading with Custom ID
Jump to [custom anchor](#custom-anchor)
```
### Protocol Links
```markdown
[Email](mailto:[email protected]?subject=Hello)
[Phone](tel:+1234567890)
[SMS](sms:+1234567890?body=Hello)
[FTP](ftp://files.example.com)
```
---
## 22. Typography Extensions
### Small Caps
```html
<span style="font-variant: small-caps;">Small Caps Text</span>
```
```markdown
%{Small Caps}% (some flavors)
```
### Fractions
```markdown
1/2 1/3 2/3 1/4 3/4 1/8 3/8 5/8 7/8
```
### Ordinals
```markdown
1st 2nd 3rd 4th 21st 42nd
```
### Smart Punctuation
```markdown
"Curly quotes" and 'apostrophes'...
— Em dash and – en dash
(C) (R) (TM) (P) +-
```
---
## 23. Metadata & Processing Instructions
### Processing Instructions
```markdown
{frontmatter}
toc: true
numbered: true
lang: en
{/frontmatter}
{mainmatter}
{backmatter}
```
### Parser Directives
~~~markdown
~~~~~~~~~~~~~~~~~~~~~{.python .numberLines startFrom="100"}
def process():
return "Code with attributes"
~~~~~~~~~~~~~~~~~~~~~
~~~
### Raw LaTeX
```latex
\newpage
\tableofcontents
\listoffigures
\listoftables
```
---
## 24. List Extensions
### Alphabetical Lists
```markdown
a. First item
b. Second item
c. Third item
A. Upper case
B. Continues
C. Through alphabet
```
### Definition Lists (Extended)
```markdown
Apple
: A fruit
: A company
- Makes phones
- Makes computers
: A symbolic object
Orange
Citrus
: Multiple terms, one definition
```
### Interrupted Lists
```markdown
1. First item
<!-- comment breaks list -->
1. New list starts
1. First item
{:.continue}
2. Continues previous list
```
---
## 25. Special Blocks & Environments
### Theorem Environment
```markdown
::: theorem
Let $f$ be a continuous function on $[a,b]$. Then $f$
attains its maximum and minimum values.
:::
::: proof
By the extreme value theorem...
:::
::: lemma
Supporting result here.
:::
::: corollary
Following from the theorem...
:::
```
### Exercise Blocks
```markdown
::: exercise
Prove that $\sqrt{2}$ is irrational.
:::
::: solution
Assume $\sqrt{2} = p/q$ where $p,q$ are integers...
:::
```
---
## 26. Accessibility Features
### Image Descriptions
```markdown
{longdesc="Extended description for screen readers"}
```
### Abbreviation Definitions
```markdown
The HTML specification is maintained by W3C.
*[HTML]: HyperText Markup Language
*[W3C]: World Wide Web Consortium
```
### Language Marking
```html
This is English text. <span lang="es">Esto es español.</span>
<span lang="ja">これは日本語です。</span>
```
---
## 27. Version Control Integration
### Diff Syntax
~~~markdown
```diff
@@ -1,3 +1,3 @@
Line 1
-Line 2 (removed)
+Line 2 (added)
Line 3
```
~~~
### Merge Conflicts
```
<<<<<<< HEAD
Current change
=======
Incoming change
>>>>>>> branch-name
```
### Blame Annotations
```
e83c516 (John 2024-01-01) Initial commit
a4f9b32 (Jane 2024-01-02) Fix typo
```
---
## 28. Additional Special Characters
### Box Drawing
```
┌─────────┬─────────┐
│ Cell 1 │ Cell 2 │
├─────────┼─────────┤
│ Cell 3 │ Cell 4 │
└─────────┴─────────┘
```
### Arrows & Symbols
```
← → ↑ ↓ ↔ ↕ ⇐ ⇒ ⇑ ⇓ ⇔ ⇕
✓ ✗ ✔ ✖ ✚ ★ ☆ ♠ ♣ ♥ ♦
① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩
```
### Math Symbols
```
∀ ∃ ∅ ∇ ∈ ∉ ∋ ∏ ∑ ∞
⊂ ⊃ ⊆ ⊇ ∪ ∩ ∧ ∨ ¬ ⊕
```
---
## Summary: Feature Support by Flavor
| Feature | Original | CommonMark | GFM | MMD | Pandoc | Kramdown |
|---------|:--------:|:----------:|:---:|:---:|:------:|:--------:|
| Headings | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Emphasis | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Lists | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Links | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Images | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Code blocks | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Tables | – | – | ✓ | ✓ | ✓ | ✓ |
| Task lists | – | – | ✓ | – | ✓ | – |
| Strikethrough | – | – | ✓ | ✓ | ✓ | ✓ |
| Footnotes | – | – | – | ✓ | ✓ | ✓ |
| Math | – | – | – | ✓ | ✓ | ✓ |
| Definition lists | – | – | – | ✓ | ✓ | ✓ |
| Abbreviations | – | – | – | ✓ | ✓ | ✓ |
| Attributes | – | – | – | ✓ | ✓ | ✓ |
| Div blocks | – | – | – | – | ✓ | – |
| Span elements | – | – | – | – | ✓ | – |
| Superscript | – | – | – | ✓ | ✓ | – |
| Subscript | – | – | – | ✓ | ✓ | – |
---
## Quick Reference Card
| Category | Syntax | Result |
|----------|--------|--------|
| **Headings** | `# H1` `## H2` `### H3` | Heading levels 1-6 |
| **Bold** | `**text**` or `__text__` | **text** |
| **Italic** | `*text*` or `_text_` | *text* |
| **Bold + Italic** | `***text***` | ***text*** |
| **Strikethrough** | `~~text~~` | ~~text~~ |
| **Inline code** | `` `code` `` | `code` |
| **Link** | `[text](url)` | [text](https://example.com) |
| **Image** | `` | Embedded image |
| **Blockquote** | `> quote` | Indented quote |
| **Unordered list** | `- item` or `* item` | Bullet list |
| **Ordered list** | `1. item` | Numbered list |
| **Task list** | `- [ ]` / `- [x]` | Checkbox |
| **Horizontal rule** | `---` or `***` | Divider line |
| **Code block** | ` ``` ` or indent 4 spaces | Code block |
| **Table** | `\| col \| col \|` | Table |
| **Footnote** | `[^1]` | Superscript reference |
---
**The golden rule:** Headings, emphasis, lists, links, images, code blocks, and blockquotes work everywhere. Everything else depends on your processor.
1. Basic Syntax (Original Markdown)
Headings
# Heading 1
## Heading 2
### Heading 3
#### Heading 4
##### Heading 5
###### Heading 6
Alternative H1
==============
Alternative H2
--------------
Emphasis
*italic* or _italic_
**bold** or __bold__
***bold italic*** or ___bold italic___
~~strikethrough~~ (GFM extension)
Lists
Unordered:
* Item 1
* Item 2
* Nested item 2.1
* Nested item 2.2
* Deep nested
- Item with dash
+ Item with plus
Ordered:
1. First item
2. Second item
1. Nested ordered
2. Another nested
3. Third item
1. Numbers don't need to be sequential
Links & Images
[Inline link](https://example.com "Optional Title")
[Reference link][ref1]
[Implicit reference][]
<https://automatic-link.com>
<[email protected]>

![Reference image][img-ref]
[ref1]: https://example.com "Reference Title"
[Implicit reference]: https://example.com
[img-ref]: image.jpg "Image Reference"
Blockquotes
> Single line quote
> Multi-line quote continues here
> and here
> Nested quotes
>> Can be nested
>>> Multiple levels deep
Code
Inline `code` with backticks
Code block with 4 spaces
or tab indentation
```
Fenced code block
Multiple lines
```
```javascript
// Syntax highlighted (GFM)
function hello() {
console.log("Hello, World!");
}
```
Horizontal Rules
Three or more:
---
Hyphens
***
Asterisks
___
Underscores
2. GitHub Flavored Markdown (GFM)
Tables
| Left-aligned | Center-aligned | Right-aligned |
| :----------- | :------------: | ------------: |
| Cell 1 | Cell 2 | Cell 3 |
| Longer text | **Bold** | *Italic* |
Minimal table:
First Header | Second Header
------------ | -------------
Content Cell | Content Cell
Rendered:
| Left-aligned | Center-aligned | Right-aligned |
|---|---|---|
| Cell 1 | Cell 2 | Cell 3 |
| Longer text | Bold | Italic |
Task Lists
- [x] Completed task
- [ ] Uncompleted task
- [ ] Another todo
- [x] Nested completed
- [ ] Nested uncompleted
Rendered:
- [x] Completed task
- [ ] Uncompleted task
- [ ] Another todo
- [x] Nested completed
- [ ] Nested uncompleted
Username & Issue Mentions
@username (GitHub only)
#123 (Issue reference)
user/repo#123 (Cross-repo issue)
Emoji
:smile: :heart: :thumbsup: :100:
:rocket: :octocat: :+1: :-1:
Syntax Highlighting with Language
```python
def factorial(n):
"""Calculate factorial"""
if n <= 1:
return 1
return n * factorial(n - 1)
```
```diff
- Removed line
+ Added line
! Important change
# Comment
```
Rendered:
def factorial(n):
"""Calculate factorial"""
if n <= 1:
return 1
return n * factorial(n - 1)
- Removed line
+ Added line
! Important change
# Comment
SHA References
16c999e8c71134401a78d4d46435517b2271d6ac
mojombo@16c999e8c71134401a78d4d46435517b2271d6ac
mojombo/github-flavored-markdown@16c999e
3. CommonMark Extensions
Autolinks
www.example.com (some parsers)
https://example.com
ftp://files.example.com
Disallowed Raw HTML (optional)
<script>alert('This may be stripped');</script>
<div class="custom">Safe HTML allowed in some flavors</div>
Entity & Numeric Character References
& < > " '
A A …
4. MultiMarkdown Extensions
Metadata Block
Title: Document Title
Author: John Doe
Date: 2024-01-01
Tags: markdown, reference
Base Header Level: 2
Footnotes
Here's a sentence with a footnote[^1].
Here's another with a longer note[^longnote].
Inline footnote^[This is an inline footnote].
[^1]: This is the footnote.
[^longnote]: Here's one with multiple paragraphs.
Indent paragraphs to include them in the footnote.
> Even blockquotes in footnotes!
Citations
This is a statement that needs citation[p. 23][#Doe:2024].
Multiple citations[p. 10][#Smith:2023; p. 24][#Doe:2024].
[#Doe:2024]: John Doe. *Sample Book*. 2024.
[#Smith:2023]: Jane Smith. *Another Book*. 2023.
Math (also Pandoc)
Inline math: $E = mc^2$ or \\(a^2 + b^2 = c^2\\)
Display math:
$$
\sum_{i=1}^{n} x_i = \int_{0}^{1} f(x) dx
$$
\\[
\frac{-b \pm \sqrt{b^2 - 4ac}}{2a}
\\]
Abbreviations
HTML is great.
CSS is awesome.
*[HTML]: HyperText Markup Language
*[CSS]: Cascading Style Sheets
Definition Lists
Term 1
: Definition 1
: Another definition
Term 2
: Definition with *inline* **formatting**
Compact Definition
: Brief description
Smart Typography
"Smart quotes" and 'single quotes'
En-dash -- and em-dash ---
Ellipsis...
Cross-references
See [](#heading-1) for more info.
As discussed in [](#fig:example).
![Example Figure][fig:example]
[fig:example]: image.jpg "Example" width=500px height=300px
5. Pandoc Markdown Extensions
Div Blocks
::: {.note #special-note}
This is a special note block with class and id.
:::
::: warning
This is a warning block.
:::
::: {.sidebar}
Sidebar content here
:::
Span Elements
This is [special text]{.highlight #text-id} inline.
[Small caps]{.smallcaps} text.
Line Blocks
| The limerick packs laughs anatomical
| In space that is quite economical.
| But the good ones I've seen
| So seldom are clean
| And the clean ones so seldom are comical
Fancy Lists
(1) First item
(2) Second item
a. Sub-item
b. Another sub
i. Deep nesting
#. Auto-numbered
#. Continues numbering
i. Roman numerals
ii. Continue
A. Upper letters
B. More items
Example lists:
(@) First example
(@) Second example
Later reference to example (@).
Grid Tables
+---------------+---------------+--------------------+
| Fruit | Price | Advantages |
+===============+===============+====================+
| Bananas | $1.34 | - built-in wrapper |
| | | - bright color |
+---------------+---------------+--------------------+
| Oranges | $2.10 | - cures scurvy |
| | | - tasty |
+---------------+---------------+--------------------+
Pipe Tables (simpler)
| Right | Left | Default | Center |
|------:|:-----|---------|:------:|
| 12 | 12 | 12 | 12 |
| 123 | 123 | 123 | 123 |
| 1 | 1 | 1 | 1 |
Superscript and Subscript
H~2~O is water.
X^2^ is X squared.
^superscript^ and ~subscript~
Inline Code Attributes
`code`{.python}
`var x = 5;`{#mycode .javascript .numberLines startFrom="100"}
Raw Blocks
```{=html}
<div class="custom-html">
Raw HTML preserved exactly
</div>
```
```{=latex}
\begin{align}
E &= mc^2
\end{align}
```
```{=mediawiki}
{{Template|arg=value}}
```
YAML Metadata Block
---
title: Complete Reference
subtitle: Every Markdown Feature
author:
- name: John Doe
affiliation: University
- name: Jane Smith
date: 2024-01-01
abstract: |
This is a multi-line
abstract in YAML.
tags: [markdown, documentation]
keywords:
- markdown
- reference
lang: en-US
toc: true
toc-depth: 3
numbersections: true
---
Native Spans and Divs
<div custom="attribute">
Native div with attributes
</div>
<span class="custom">Native span</span>
6. Extended Features (Various Flavors)
Admonitions/Callouts
!!! note "Optional Title"
This is a note admonition.
!!! warning
This is a warning without title.
!!! danger "Critical"
Important danger message.
!!! tip
Helpful tip here.
!!! important
Important information.
!!! example "Code Example"
```python
print("Hello")
```
GitHub-style callouts:
> [!NOTE]
> GitHub-style callout
> [!WARNING]
> Another style of callout
> [!TIP]
> Helpful information
> [!IMPORTANT]
> Crucial information
> [!CAUTION]
> Be careful here
Keyboard Keys
Press <kbd>Ctrl</kbd> + <kbd>C</kbd> to copy.
<kbd>⌘</kbd> + <kbd>V</kbd> on Mac.
++ctrl+alt+del++ (some flavors)
Rendered:
Press Ctrl + C to copy.
⌘ + V on Mac.
Mark/Highlight
==Highlighted text== (some flavors)
<mark>HTML mark element</mark>
{==highlighted==} (critic markup)
Rendered:
HTML mark element
Insert/Delete (Critic Markup)
{++inserted text++}
{--deleted text--}
{~~old~>new~~}
{>>comment<<}
{==highlight==}{>>with comment<<}
Details/Summary
<details>
<summary>Click to expand</summary>
Hidden content here with:
- Lists
- **Formatting**
- Etc.
</details>
<details open>
<summary>Expanded by default</summary>
This is visible initially.
</details>
Rendered:
Click to expand
Hidden content here with:
- Lists
- Formatting
- Etc.
Table of Contents
[[TOC]] (some flavors)
[TOC] (other flavors)
{:toc} (kramdown)
Include Files
<<[file.md]
<<(file.md)
{{file.md}}
!include file.md
{! file.md !}
Diagrams
```mermaid
graph LR
A[Start] --> B{Decision}
B -->|Yes| C[Do this]
B -->|No| D[Do that]
C --> E[End]
D --> E
```
```plantuml
@startuml
Alice -> Bob: Hello
Bob --> Alice: Hi!
@enduml
```
```graphviz
digraph G {
A -> B;
B -> C;
C -> A;
}
```
Custom Containers
::: {.theorem #pythagorean}
**Pythagorean Theorem**: $a^2 + b^2 = c^2$
:::
::: note
Custom note container
:::
::: {.callout-note}
## Note Title
Note content
:::
Attributes on Elements
{width=50% height=30px}
[Link](url.com){.external target="_blank"}
Paragraph with attributes.
{: .custom-class #custom-id}
Hard Line Breaks
Line ending with two spaces
creates a hard break.
Line ending with backslash\
also creates a hard break (some flavors).
Video Embeds (Some Flavors)


@[youtube](dQw4w9WgXcQ)
Special Lists
Term
~ Definition using tilde
Tight list:
* item1
* item2
Loose list:
* item1
* item2
7. Edge Cases & Special Characters
Escaping
\*Not italic\*
\`Not code\`
\[Not a link\](not a url)
\# Not a heading
\| Not a table
\1. Not a list
Special Characters
© ™ ® ° ± ≠ ≤ ≥
→ ← ↑ ↓ ↔
½ ¾ ∞ ∑ ∏
Rendered:
© ™ ® ° ± ≠ ≤ ≥
→ ← ↑ ↓ ↔
½ ¾ ∞ ∑ ∏
Zero-Width Characters
Zero​Width​Space
Word­Break­Hint
Nested Structures
> Blockquote with:
> - List item 1
> - List item 2
> ```python
> # code in list in quote
> print("nested")
> ```
> > Nested quote in list
>
> 1. Ordered in quote
> 2. More ordered
>
> | Table | In | Quote |
> |-------|----|----|
> | Works | In | Some |
Complex Nesting
1. List with paragraph
Multiple paragraph in list item.
> Quote in list
code in list
2. Another item
- [ ] Task in ordered list
- [x] Completed
Unicode & Emoji
📝 ✨ 🚀 💻 🎯 ⚡ 🔥 ✅ ❌ ⚠️
α β γ δ ε ζ η θ
© ® ™ • · × ÷ ±
Comments
<!-- HTML comment -->
[//]: # (This is also a comment)
[//]: <> (Another comment style)
[comment]: <> (Yet another)
8. Kramdown Specific
Block Attributes
{: .class #id key="value"}
This paragraph has attributes.
> Block quote with attributes.
{: .pullquote}
Options
{::options parse_block_html="true" /}
{::options auto_ids="false" /}
No Markdown
{::nomarkdown}
This *won't* be **parsed**.
{:/}
Comments
{::comment}
This is a kramdown comment.
{:/comment}
9. Markdown Extra
Special Attributes
Header {#header-id .header-class}
================================
[link](url){#link-id .link-class}
Fenced Code Attributes
~~~ {.python #mycode .numberLines startFrom="10"}
def hello():
print("Hi")
### Markdown Inside HTML
```html
<div markdown="1">
This is *markdown* inside **HTML**.
</div>
<div markdown="block">
- List inside HTML
- Another item
</div>
```
### Backslash Escapes
```markdown
\\ \` \* \_ \{ \} \[ \] \( \) \# \+ \- \. \!
```
---
## 10. R Markdown / Quarto
### Code Chunks
~~~markdown
```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```
```{python}
#| label: fig-plot
#| fig-cap: "Sample Plot"
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [1, 4, 9])
```
Inline R Code
The mean is `r mean(c(1,2,3))`.
Chunk Options
```{r, echo=FALSE, fig.width=6, fig.height=4}
plot(cars)
```
11. Wiki-Style Links & Knowledge Base Features
Wiki Links (Obsidian/Roam/Foam)
[[Page Name]]
[[Page Name|Custom Display Text]]
[[Page Name#Heading]]
[[Page Name^block-id]]
![[Embedded Page]]
![[image.png|300x200]]
Block References
^unique-block-id
Reference to [[Page#^unique-block-id]]
Tags
#tag #multi-word-tag #nested/tag #2024/01/projects
#[[Complex Tag Name]]
Dataview (Obsidian)
```dataview
TABLE author, rating, finished
FROM #books
WHERE rating > 4
SORT finished DESC
```
`= this.file.name`
`= date(now)`
12. MDX (Markdown + JSX)
import Button from './Button'
import { Chart } from './Chart'
export const meta = {
title: 'MDX Document',
author: 'John'
}
# {meta.title}
<Button onClick={() => alert('Clicked!')}>
Click me
</Button>
<Chart data={[1, 2, 3]} />
Regular markdown with *React components*.
13. AsciiDoc-Influenced Features
Admonition Blocks (Alternative Syntax)
NOTE: This is a note.
TIP: Helpful tip here.
IMPORTANT: Don't forget this.
WARNING: Be careful!
CAUTION: Critical warning.
Include Directives
include::chapter1.md[]
include::code.js[lines=5..10]
Conditional Directives
ifdef::env-github[]
This only shows on GitHub.
endif::[]
ifndef::env-github[]
This shows everywhere except GitHub.
endif::[]
14. Mathematical Notation (Extended)
Display Math Environments
$$
\begin{align}
a &= b + c \\
d &= e + f + g \\
h &= i
\end{align}
$$
$$
\begin{matrix}
a & b & c \\
d & e & f \\
g & h & i
\end{matrix}
$$
$$
\begin{cases}
x + y = 5 \\
2x - y = 1
\end{cases}
$$
Chemical Equations
$\ce{2H2 + O2 -> 2H2O}$
$\ce{SO4^2- + Ba^2+ -> BaSO4 v}$
Physics Notation
$\ket{\psi} = \alpha\ket{0} + \beta\ket{1}$
$\bra{\phi}\ket{\psi}$
15. Diagram Extensions
PlantUML
```plantuml
@startuml
!theme plain
actor User
participant "Web Browser" as Browser
participant "Web Server" as Server
database "Database" as DB
User -> Browser: Enter URL
Browser -> Server: HTTP Request
Server -> DB: Query
DB -> Server: Results
Server -> Browser: HTTP Response
Browser -> User: Display Page
@enduml
```
Ditaa
```ditaa
+--------+ +-------+ +-------+
| | --+ ditaa +--> | |
| Text | +-------+ |diagram|
|Document| |!magic!| | |
| {d}| | | | |
+---+----+ +-------+ +-------+
: ^
| Lots of work |
+-------------------------+
```
Graphviz DOT
```dot
digraph finite_state_machine {
rankdir=LR;
size="8,5"
node [shape = doublecircle]; S;
node [shape = point ]; qi
node [shape = circle];
qi -> S;
S -> q1 [ label = "a" ];
S -> S [ label = "a" ];
q1 -> S [ label = "a" ];
q1 -> q2 [ label = "b" ];
q2 -> q1 [ label = "b" ];
q2 -> q2 [ label = "b" ];
}
```
Vega-Lite
```vega-lite
{
"$schema": "https://vega.github.io/schema/vega-lite/v5.json",
"data": {"url": "data.csv"},
"mark": "bar",
"encoding": {
"x": {"field": "category", "type": "nominal"},
"y": {"field": "value", "type": "quantitative"}
}
}
```
16. Scholarly Markdown
Abstract Block
{abstract}
This paper presents a comprehensive overview of markdown
flavors and their features. We examine standard syntax
and extended capabilities across implementations.
{/abstract}
Author Block
{authors}
John Doe^1^, Jane Smith^2^
^1^ University of Examples
^2^ Institute of Documentation
{/authors}
Keywords
{keywords}
markdown, documentation, syntax, reference
{/keywords}
DOI/Bibliography
[@doi:10.1000/xyz123] shows that markdown is effective.
See [@smith2024; @doe2023] for more information.
Glossary
{glossary}
GFM
: GitHub Flavored Markdown
MMD
: MultiMarkdown
{/glossary}
17. Hugo/Jekyll/Static Site Features
Front Matter (TOML)
+++
title = "Post Title"
date = 2024-01-01T10:00:00Z
draft = false
tags = ["markdown", "hugo"]
categories = ["documentation"]
+++
Shortcodes
{{</* youtube w7Ft2ymGmfc */>}}
{{</* tweet user="xxx" id="xxx" */>}}
{{</* gist user="xxx" id="xxx" */>}}
{{</* figure src="image.jpg" title="Figure 1" */>}}
{{</* highlight go "linenos=table" */>}}
package main
import "fmt"
func main() {
fmt.Println("Hello")
}
{{</* /highlight */>}}
Jekyll Includes
{% include header.html %}
{% include_relative file.md %}
Liquid Templates
{% for post in site.posts %}
- [{{ post.title }}]({{ post.url }})
{% endfor %}
{% if page.comments %}
{% include comments.html %}
{% endif %}
18. Markua (LeanPub)
Aside
A> This is an aside (sidebar).
A> It can span multiple lines.
Blurb
B> This is a blurb - a textbox with special styling.
Discussion
D> This is a discussion box for exercises or questions.
Error/Warning/Information
E> This is an error message.
W> This is a warning.
I> This is an information box.
Quiz
{quiz, id: quiz1}
? What is 2 + 2?
a) 3
B) 4
c) 5
d) 6
? Which are markdown flavors?
[X] GFM
[X] CommonMark
[ ] XML
[X] Pandoc
{/quiz}
19. Advanced Table Features
Column Spanning (some flavors)
| Column 1 | Column 2 | Column 3 |
|----------|:--------:|---------:|
| span=2 | | Right |
| Left | Center | Right |
MultiMarkdown Tables
| | Grouping ||
| First Header | Second Header | Third Header |
| ------------ | :-----------: | -----------: |
| Content | *Long Cell* ||
| Content | **Cell** | Cell |
| New section | More | Data |
| And more | With an escaped '\|' ||
[Table caption, works in MD Extra too]
Grid Table with Alignment
+:-----+:-----:+-----:+
| Left |Center |Right |
+======+=======+======+
| L | C | R |
+------+-------+------+
| Left |Center |Right |
+------+-------+------+
20. Custom HTML with Markdown
Details with Markdown
<details markdown="1">
<summary>Click for markdown content</summary>
- This is a **list**
- With _formatting_
- Inside HTML details
```python
# Even code blocks work
print("Hello from details")
```
Ruby Annotations
<ruby>
漢字<rt>かんじ</rt>
</ruby>
<ruby>
WWW<rt>World Wide Web</rt>
</ruby>
Progress Bars
<progress value="70" max="100">70%</progress>
<meter value="6" min="0" max="10">6 out of 10</meter>
21. Extended Link Features
Link Attributes
[External Link](https://example.com){:target="_blank" rel="noopener"}
[Download](file.pdf){:download="filename.pdf"}
Anchor Links with IDs
{#custom-anchor}
### Heading with Custom ID
Jump to [custom anchor](#custom-anchor)
Protocol Links
[Email](mailto:[email protected]?subject=Hello)
[Phone](tel:+1234567890)
[SMS](sms:+1234567890?body=Hello)
[FTP](ftp://files.example.com)
22. Typography Extensions
Small Caps
<span style="font-variant: small-caps;">Small Caps Text</span>
%{Small Caps}% (some flavors)
Fractions
1/2 1/3 2/3 1/4 3/4 1/8 3/8 5/8 7/8
Ordinals
1st 2nd 3rd 4th 21st 42nd
Smart Punctuation
"Curly quotes" and 'apostrophes'...
— Em dash and – en dash
(C) (R) (TM) (P) +-
23. Metadata & Processing Instructions
Processing Instructions
{frontmatter}
toc: true
numbered: true
lang: en
{/frontmatter}
{mainmatter}
{backmatter}
Parser Directives
~~~~~~~~~~~~~~~~~~~~~{.python .numberLines startFrom="100"}
def process():
return "Code with attributes"
### Raw LaTeX
```latex
\newpage
\tableofcontents
\listoffigures
\listoftables
```
---
## 24. List Extensions
### Alphabetical Lists
```markdown
a. First item
b. Second item
c. Third item
A. Upper case
B. Continues
C. Through alphabet
```
### Definition Lists (Extended)
```markdown
Apple
: A fruit
: A company
- Makes phones
- Makes computers
: A symbolic object
Orange
Citrus
: Multiple terms, one definition
```
### Interrupted Lists
```markdown
1. First item
<!-- comment breaks list -->
1. New list starts
1. First item
{:.continue}
2. Continues previous list
```
---
## 25. Special Blocks & Environments
### Theorem Environment
```markdown
::: theorem
Let $f$ be a continuous function on $[a,b]$. Then $f$
attains its maximum and minimum values.
:::
::: proof
By the extreme value theorem...
:::
::: lemma
Supporting result here.
:::
::: corollary
Following from the theorem...
:::
```
### Exercise Blocks
```markdown
::: exercise
Prove that $\sqrt{2}$ is irrational.
:::
::: solution
Assume $\sqrt{2} = p/q$ where $p,q$ are integers...
:::
```
---
## 26. Accessibility Features
### Image Descriptions
```markdown
{longdesc="Extended description for screen readers"}
```
### Abbreviation Definitions
```markdown
The HTML specification is maintained by W3C.
*[HTML]: HyperText Markup Language
*[W3C]: World Wide Web Consortium
```
### Language Marking
```html
This is English text. <span lang="es">Esto es español.</span>
<span lang="ja">これは日本語です。</span>
```
---
## 27. Version Control Integration
### Diff Syntax
~~~markdown
```diff
@@ -1,3 +1,3 @@
Line 1
-Line 2 (removed)
+Line 2 (added)
Line 3
```
Merge Conflicts
<<<<<<< HEAD
Current change
=======
Incoming change
>>>>>>> branch-name
Blame Annotations
e83c516 (John 2024-01-01) Initial commit
a4f9b32 (Jane 2024-01-02) Fix typo
28. Additional Special Characters
Box Drawing
┌─────────┬─────────┐
│ Cell 1 │ Cell 2 │
├─────────┼─────────┤
│ Cell 3 │ Cell 4 │
└─────────┴─────────┘
Arrows & Symbols
← → ↑ ↓ ↔ ↕ ⇐ ⇒ ⇑ ⇓ ⇔ ⇕
✓ ✗ ✔ ✖ ✚ ★ ☆ ♠ ♣ ♥ ♦
① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩
Math Symbols
∀ ∃ ∅ ∇ ∈ ∉ ∋ ∏ ∑ ∞
⊂ ⊃ ⊆ ⊇ ∪ ∩ ∧ ∨ ¬ ⊕
Summary: Feature Support by Flavor
| Feature | Original | CommonMark | GFM | MMD | Pandoc | Kramdown |
|---|---|---|---|---|---|---|
| Headings | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Emphasis | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Lists | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Links | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Images | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Code blocks | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Tables | – | – | ✓ | ✓ | ✓ | ✓ |
| Task lists | – | – | ✓ | – | ✓ | – |
| Strikethrough | – | – | ✓ | ✓ | ✓ | ✓ |
| Footnotes | – | – | – | ✓ | ✓ | ✓ |
| Math | – | – | – | ✓ | ✓ | ✓ |
| Definition lists | – | – | – | ✓ | ✓ | ✓ |
| Abbreviations | – | – | – | ✓ | ✓ | ✓ |
| Attributes | – | – | – | ✓ | ✓ | ✓ |
| Div blocks | – | – | – | – | ✓ | – |
| Span elements | – | – | – | – | ✓ | – |
| Superscript | – | – | – | ✓ | ✓ | – |
| Subscript | – | – | – | ✓ | ✓ | – |
Quick Reference Card
| Category | Syntax | Result |
|---|---|---|
| Headings | # H1 ## H2 ### H3 |
Heading levels 1-6 |
| Bold | **text** or __text__ |
text |
| Italic | *text* or _text_ |
text |
| Bold + Italic | ***text*** |
text |
| Strikethrough | ~~text~~ |
|
| Inline code | `code` |
code |
| Link | [text](url) |
text |
| Image |  |
Embedded image |
| Blockquote | > quote |
Indented quote |
| Unordered list | - item or * item |
Bullet list |
| Ordered list | 1. item |
Numbered list |
| Task list | - [ ] / - [x] |
Checkbox |
| Horizontal rule | --- or *** |
Divider line |
| Code block | ``` or indent 4 spaces |
Code block |
| Table | | col | col | |
Table |
| Footnote | [^1] |
Superscript reference |
The golden rule: Headings, emphasis, lists, links, images, code blocks, and blockquotes work everywhere. Everything else depends on your processor.
Sorting Algorithms
sort<Algorithm>(from: bubble, to: Tim)
When I was a Teacher Assistant (TA) in Intro To Computer Science lab, fellow TA
Ian and I were showing off our programming prowess. I thought I had it in the bag: I had solved a competitive programming problem in compile-time (C++ templates are Turing-complete!) and a Space Invaders clone for a class.
But Ian was more clever than I, and showed me something that fundamentally changed how I saw a core-component of programming: a terminal-based (ncurses) sorting algorithm visualizers.
It was the first time I had ever seen these algorithms graphed like this — ever! And, yes, I blame my Algorithm instructor. I finally could see all the hypothetical sorting in a real-life application.
With the power of LLMs in hand, and a website as my canvas, I wanted to see if I could recreate this. Kudos to you, Ian.
Sorting algorithms form the backbone of computer science, serving as fundamental building blocks for countless applications from database management to search engines. This comprehensive guide examines the 25 most important sorting algorithms, organized by type, with detailed analysis of their performance, implementation, and practical applications.
1. Basic Comparison-Based Algorithms
These fundamental algorithms serve as the foundation for understanding sorting concepts, though they generally have O(n²) time complexity.
1.1 Bubble Sort
Complexity Analysis:
- Best Case: O(n) / Ω(n) - when array is already sorted
- Average Case: O(n²) / Θ(n²)
- Worst Case: O(n²)
- Space: O(1)
Properties: Stable, In-place, Adaptive
def bubble_sort(arr):
"""
Bubble Sort with optimization
Time: O(n²) average/worst, O(n) best
Space: O(1)
"""
n = len(arr)
for i in range(n):
swapped = False
# Last i elements are already sorted
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
swapped = True
# If no swapping occurred, array is sorted
if not swapped:
break
return arr
When to Use:
- Small datasets (< 50 elements)
- Educational purposes - excellent for teaching
- Nearly sorted data
- Memory-constrained environments
Step-by-Step Example:
Array: [64, 34, 25, 12, 22, 11, 90]
Pass 1: [34, 25, 12, 22, 11, 64, 90] - Largest element "bubbles" to end
Pass 2: [25, 12, 22, 11, 34, 64, 90]
... continues until sorted
History: First described by Edward Harry Friend in 1956. The name "bubble sort" was coined by Kenneth E. Iverson due to how smaller elements "bubble" to the top.
Notable Trivia: Donald Knuth famously stated "bubble sort seems to have nothing to recommend it, except a catchy name." Despite criticism, it remains the most taught sorting algorithm due to its simplicity.
1.2 Selection Sort
Complexity Analysis:
- Best/Average/Worst Case: O(n²) - always makes same comparisons
- Space: O(1)
Properties: Unstable, In-place, Not adaptive
def selection_sort(arr):
"""
Selection Sort implementation
Time: O(n²) for all cases
Space: O(1)
"""
n = len(arr)
for i in range(n):
# Find minimum element in remaining unsorted array
min_idx = i
for j in range(i + 1, n):
if arr[j] < arr[min_idx]:
min_idx = j
# Swap the found minimum element
arr[i], arr[min_idx] = arr[min_idx], arr[i]
return arr
When to Use:
- When memory write operations are expensive (e.g., flash memory)
- Small datasets where simplicity matters
- When the number of swaps needs to be minimized
Key Advantage: Performs only O(n) swaps compared to O(n²) for bubble sort.
History: Has ancient origins in manual sorting processes. Formalized in the 1950s as one of the fundamental sorting methods.
1.3 Insertion Sort
Complexity Analysis:
- Best Case: O(n) - already sorted
- Average/Worst Case: O(n²)
- Space: O(1)
Properties: Stable, In-place, Adaptive, Online
def insertion_sort(arr):
"""
Insertion Sort implementation
Time: O(n²) average/worst, O(n) best
Space: O(1)
"""
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr
When to Use:
- Small datasets (typically < 50 elements)
- Nearly sorted data - performs in O(n) time
- Online algorithms - when data arrives sequentially
- As a subroutine in quicksort and mergesort for small subarrays
Notable Use: Used in Timsort (Python's built-in sort) for small runs. Often faster than O(n log n) algorithms for arrays with fewer than 10-20 elements.
1.4 Shell Sort
Complexity Analysis:
- Best Case: O(n log n)
- Average Case: O(n^1.25) to O(n^1.5) depending on gap sequence
- Worst Case: O(n²) for Shell's original sequence
- Space: O(1)
Properties: Unstable, In-place, Adaptive
def shell_sort(arr):
"""
Shell Sort using Shell's original sequence
Time: O(n²) worst case, O(n log n) average
Space: O(1)
"""
n = len(arr)
gap = n // 2
while gap > 0:
# Perform gapped insertion sort
for i in range(gap, n):
temp = arr[i]
j = i
while j >= gap and arr[j - gap] > temp:
arr[j] = arr[j - gap]
j -= gap
arr[j] = temp
gap //= 2
return arr
When to Use:
- Medium-sized datasets (100-5000 elements)
- When recursion should be avoided
- Embedded systems - simple and efficient
History: Invented by Donald L. Shell in 1959, it was one of the first algorithms to break the O(n²) barrier.
1.5 Cocktail Shaker Sort (Bidirectional Bubble Sort)
Complexity Analysis:
- Best Case: O(n)
- Average/Worst Case: O(n²)
- Space: O(1)
Properties: Stable, In-place, Adaptive, Bidirectional
def cocktail_shaker_sort(arr):
"""
Cocktail Shaker Sort (Bidirectional Bubble Sort)
Time: O(n²) average/worst, O(n) best
Space: O(1)
"""
n = len(arr)
start = 0
end = n - 1
while start < end:
swapped = False
# Forward pass
for i in range(start, end):
if arr[i] > arr[i + 1]:
arr[i], arr[i + 1] = arr[i + 1], arr[i]
swapped = True
if not swapped:
break
end -= 1
swapped = False
# Backward pass
for i in range(end, start, -1):
if arr[i] < arr[i - 1]:
arr[i], arr[i - 1] = arr[i - 1], arr[i]
swapped = True
if not swapped:
break
start += 1
return arr
Advantage: Better than bubble sort at moving small elements (turtles) to the beginning.
2. Efficient Comparison-Based Algorithms
These algorithms achieve O(n log n) average performance and form the backbone of many practical sorting implementations.
2.1 Quick Sort
Complexity Analysis:
- Best/Average Case: O(n log n)
- Worst Case: O(n²) - when pivot is always minimum/maximum
- Space: O(log n) - recursion stack
Properties: Unstable, In-place, Not adaptive
def quicksort(arr, low=0, high=None):
"""
Quicksort with Hoare partition scheme
Time: O(n log n) average, O(n²) worst
Space: O(log n)
"""
if high is None:
high = len(arr) - 1
if low < high:
pivot_idx = partition(arr, low, high)
quicksort(arr, low, pivot_idx)
quicksort(arr, pivot_idx + 1, high)
return arr
def partition(arr, low, high):
"""Hoare partition scheme"""
pivot = arr[low]
i = low - 1
j = high + 1
while True:
i += 1
while arr[i] < pivot:
i += 1
j -= 1
while arr[j] > pivot:
j -= 1
if i >= j:
return j
arr[i], arr[j] = arr[j], arr[i]
Why It's Preferred Despite O(n²) Worst Case:
- Excellent average-case performance with good constant factors
- Cache-friendly sequential access patterns
- In-place sorting
- Modern implementations use introsort to guarantee O(n log n)
History: Invented by Tony Hoare in 1959 while working on machine translation at Moscow State University.
2.2 Merge Sort
Complexity Analysis:
- All Cases: O(n log n) - guaranteed performance
- Space: O(n) - requires additional space for merging
Properties: Stable, Not in-place, Not adaptive
def merge_sort(arr):
"""
Merge Sort implementation
Time: O(n log n) guaranteed
Space: O(n)
"""
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
"""Merge two sorted arrays"""
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
When to Use:
- When stability is required
- External sorting (large datasets that don't fit in memory)
- Linked lists (efficient with O(1) extra space)
- Parallel processing
History: Invented by John von Neumann in 1945, with detailed analysis published in 1948.
2.3 Heap Sort
Complexity Analysis:
- All Cases: O(n log n) - guaranteed performance
- Space: O(1) - true in-place sorting
Properties: Unstable, In-place, Not adaptive
def heap_sort(arr):
"""
Heap Sort implementation
Time: O(n log n) guaranteed
Space: O(1)
"""
n = len(arr)
# Build max heap
for i in range(n // 2 - 1, -1, -1):
heapify(arr, n, i)
# Extract elements from heap
for i in range(n - 1, 0, -1):
arr[0], arr[i] = arr[i], arr[0]
heapify(arr, i, 0)
return arr
def heapify(arr, n, i):
"""Maintain heap property"""
largest = i
left = 2 * i + 1
right = 2 * i + 2
if left < n and arr[left] > arr[largest]:
largest = left
if right < n and arr[right] > arr[largest]:
largest = right
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
When to Use:
- Memory-constrained environments
- Real-time systems (guaranteed performance)
- Systems concerned with malicious input
History: Invented by J. W. J. Williams in 1964, with in-place version by Robert Floyd.
2.4 Binary Tree Sort
Complexity Analysis:
- Best/Average Case: O(n log n) - with balanced tree
- Worst Case: O(n²) - with unbalanced tree
- Space: O(n) - for tree structure
Properties: Can be stable, Not in-place
When to Use:
- Educational purposes
- When tree structure is needed for other operations
- Online sorting
Note: Self-balancing trees (AVL, Red-Black) guarantee O(n log n) performance.
2.5 Smooth Sort
Complexity Analysis:
- Best Case: O(n) - for sorted data
- Average/Worst Case: O(n log n)
- Space: O(1)
Properties: Unstable, In-place, Adaptive
History: Invented by Edsger W. Dijkstra in 1981 as an improvement over heapsort for partially sorted data.
Notable Use: Used in musl C library's qsort() implementation.
3. Non-Comparison Based Algorithms
These algorithms achieve linear O(n) time complexity by exploiting specific properties of the data rather than comparing elements.
3.1 Counting Sort
Complexity Analysis:
- All Cases: O(n + k) where k is the range of values
- Space: O(n + k)
Properties: Stable, Not in-place
def counting_sort(arr):
"""
Counting Sort for non-negative integers
Time: O(n + k)
Space: O(n + k)
"""
if not arr:
return arr
max_val = max(arr)
count = [0] * (max_val + 1)
# Count occurrences
for num in arr:
count[num] += 1
# Calculate cumulative count
for i in range(1, len(count)):
count[i] += count[i - 1]
# Build output array
output = [0] * len(arr)
for i in range(len(arr) - 1, -1, -1):
output[count[arr[i]] - 1] = arr[i]
count[arr[i]] -= 1
return output
When to Use:
- Sorting integers in a small range
- As a subroutine in radix sort
- When k is O(n) or smaller
History: Invented by Harold H. Seward in 1954 at MIT.
3.2 Radix Sort
Complexity Analysis:
- All Cases: O(d × (n + k)) where d is number of digits
- Space: O(n + k)
Properties:
- LSD (Least Significant Digit): Stable
- MSD (Most Significant Digit): Can be stable
def radix_sort_lsd(arr):
"""
LSD Radix Sort implementation
Time: O(d × (n + k))
Space: O(n + k)
"""
if not arr:
return arr
max_val = max(arr)
exp = 1
while max_val // exp > 0:
counting_sort_for_radix(arr, exp)
exp *= 10
return arr
def counting_sort_for_radix(arr, exp):
n = len(arr)
output = [0] * n
count = [0] * 10
for i in range(n):
index = arr[i] // exp
count[index % 10] += 1
for i in range(1, 10):
count[i] += count[i - 1]
i = n - 1
while i >= 0:
index = arr[i] // exp
output[count[index % 10] - 1] = arr[i]
count[index % 10] -= 1
i -= 1
for i in range(n):
arr[i] = output[i]
When to Use:
- Sorting integers with many digits
- String sorting (MSD variant)
- When d is small compared to log n
History: Dates back to 1887 with Herman Hollerith's tabulating machines.
3.3 Bucket Sort
Complexity Analysis:
- Best/Average Case: O(n + k) for uniform distribution
- Worst Case: O(n²) when all elements fall into one bucket
- Space: O(n + k)
Properties: Stable (if sub-sorting is stable), Not in-place
def bucket_sort(arr):
"""
Bucket Sort for floating-point number
Time: O(n + k) average
Space: O(n + k)
"""
if not arr:
return arr
min_val, max_val = min(arr), max(arr)
bucket_count = len(arr)
buckets = [[] for _ in range(bucket_count)]
# Distribute elements into buckets
for num in arr:
if max_val == min_val:
index = 0
else:
index = int((num - min_val) / (max_val - min_val) * (bucket_count - 1))
buckets[index].append(num)
# Sort individual buckets
result = []
for bucket in buckets:
if bucket:
bucket.sort() # Can use insertion sort
result.extend(bucket)
return result
When to Use:
- Uniformly distributed floating-point numbers
- Large datasets with known range
- When memory is not a constraint
3.4 Pigeonhole Sort
Complexity Analysis:
- All Cases: O(n + range) where range = max - min + 1
- Space: O(range)
Properties: Stable, Not in-place
When to Use:
- Small range of integer values
- When range is comparable to n
- Simple counting applications
History: Based on the pigeonhole principle, formally described by A.J. Lotka (1926).
3.5 Flash Sort
Complexity Analysis:
- Best/Average Case: O(n) for uniform distribution
- Worst Case: O(n²)
- Space: O(m) where m is number of classes
Properties: Unstable, In-place (major advantage)
When to Use:
- Large uniformly distributed datasets
- When memory is limited
- When O(n) average performance is critical
History: Invented by Karl-Dietrich Neubert in 1998 as an efficient in-place implementation of bucket sort.
4. Modern Hybrid Algorithms
These algorithms represent the state-of-the-art in practical sorting, combining multiple techniques for superior performance.
4.1 Timsort
Complexity Analysis:
- Best Case: O(n) - already sorted
- Average/Worst Case: O(n log n)
- Space: O(n)
Properties: Stable, Not in-place
Key Innovations:
- Run Detection: Identifies naturally occurring sorted subsequences
- Minimum Run Size: Calculates optimal minrun (32-64 elements)
- Galloping Mode: Switches to exponential search when one run consistently "wins"
Where It's Used:
- Python's default sort since version 2.3
- Java for sorting objects (Java 7+)
- Android, V8, Swift, Rust
History: Created in 2002 by Tim Peters for Python. A critical bug was discovered and fixed in 2015 through formal verification.
4.2 Introsort (Introspective Sort)
Complexity Analysis:
- All Cases: O(n log n) - guaranteed by heapsort fallback
- Space: O(log n)
Properties: Unstable, In-place
Techniques Combined:
- Quicksort for main sorting
- Heapsort when recursion depth exceeds 2×log₂(n)
- Insertion sort for small subarrays (< 16 elements)
Where It's Used:
- C++ STL's std::sort() in GCC and LLVM
- Microsoft .NET Framework 4.5+
History: Created by David Musser in 1997 to provide guaranteed O(n log n) performance while maintaining quicksort's average-case speed.
4.3 Block Sort (WikiSort)
Complexity Analysis:
- Best Case: O(n)
- Average/Worst Case: O(n log n)
- Space: O(1) - constant space!
Properties: Stable, In-place
Key Innovation: Achieves stable merge sort performance with O(1) space by using internal buffering.
When to Use: When O(1) space complexity and stability are both required.
4.4 Pattern-defeating Quicksort (pdqsort)
Complexity Analysis:
- Best Case: O(n) for specific patterns
- Average/Worst Case: O(n log n)
- Space: O(log n)
Properties: Unstable, In-place
Key Innovations:
- Pattern detection and optimization
- Branchless partitioning
- Adaptive strategy based on input characteristics
Where It's Used:
- Rust's default unstable sort
- C++ Boost libraries
History: Created by Orson Peters in 2016 to improve upon introsort with better pattern handling.
4.5 Dual-Pivot Quicksort
Complexity Analysis:
- Best Case: O(n) when all elements equal
- Average Case: O(n log n) - 5% fewer comparisons than single-pivot
- Worst Case: O(n²) - still possible but less likely
- Space: O(log n)
Properties: Unstable, In-place
Key Innovation: Uses two pivots to partition array into three parts, reducing comparisons.
Where It's Used: Java's default algorithm for primitive arrays since Java 7.
History: Created by Vladimir Yaroslavskiy in 2009, adopted by Java in 2011.
5. Specialized and Educational Algorithms
These algorithms serve specific purposes or demonstrate important concepts in computer science education.
5.1 Comb Sort
Complexity Analysis:
- Best Case: O(n log n)
- Average Case: O(n²/2^p) where p is number of increments
- Worst Case: O(n²)
- Space: O(1)
Properties: Unstable, In-place
Key Feature: Improves upon bubble sort using variable gap with shrink factor of 1.3.
History: Developed by Włodzimierz Dobosiewicz in 1980 to address bubble sort's inefficiency.
5.2 Gnome Sort (Stupid Sort)
Complexity Analysis:
- Best Case: O(n)
- Average/Worst Case: O(n²)
- Space: O(1)
Properties: Stable, In-place, Adaptive
Unique Feature: Uses only a single while loop - inspired by garden gnomes sorting flower pots.
5.3 Cycle Sort
Complexity Analysis:
- All Cases: O(n²)
- Space: O(1)
Properties: Unstable, In-place
Key Feature: Minimizes memory writes - each element is written at most once to its correct position.
When to Use: When memory write operations are expensive (EEPROM, Flash memory).
5.4 Pancake Sort
Complexity Analysis:
- Best Case: O(n)
- Average/Worst Case: O(n²)
- Space: O(1)
Properties: Unstable, In-place
Unique Constraint: Only allowed operation is "flip" (reverse prefix).
Historical Note: Bill Gates' only published academic paper was on this problem (1979), providing a (5n+5)/3 upper bound algorithm.
5.5 Bogo Sort
Complexity Analysis:
- Best Case: O(n) - already sorted
- Average Case: O(n·n!) - expected permutations
- Worst Case: O(∞) - theoretically unbounded
- Space: O(1)
Properties: Unstable, In-place
Educational Value:
- Demonstrates worst-case analysis
- Teaches randomized algorithms
- Shows importance of algorithm selection
import random
def bogo_sort(arr):
"""The worst sorting algorithm ever conceived"""
def is_sorted(arr):
return all(arr[i] <= arr[i+1] for i in range(len(arr)-1))
while not is_sorted(arr):
random.shuffle(arr)
return arr
Trivia: "Quantum Bogo Sort" hypothetically destroys universes where array isn't sorted, leaving only sorted universes.
Summary and Recommendations
Performance Comparison Table
| Algorithm | Best Case | Average Case | Worst Case | Space | Stable | In-Place |
|---|---|---|---|---|---|---|
| Bubble Sort | O(n) | O(n²) | O(n²) | O(1) | Yes | Yes |
| Selection Sort | O(n²) | O(n²) | O(n²) | O(1) | No | Yes |
| Insertion Sort | O(n) | O(n²) | O(n²) | O(1) | Yes | Yes |
| Quick Sort | O(n log n) | O(n log n) | O(n²) | O(log n) | No | Yes |
| Merge Sort | O(n log n) | O(n log n) | O(n log n) | O(n) | Yes | No |
| Heap Sort | O(n log n) | O(n log n) | O(n log n) | O(1) | No | Yes |
| Counting Sort | O(n+k) | O(n+k) | O(n+k) | O(n+k) | Yes | No |
| Radix Sort | O(d(n+k)) | O(d(n+k)) | O(d(n+k)) | O(n+k) | Yes | No |
| Timsort | O(n) | O(n log n) | O(n log n) | O(n) | Yes | No |
When to Use Which Algorithm
For Small Datasets (< 50 elements):
- Insertion Sort - simple and efficient
- Selection Sort - when minimizing swaps matters
For General Purpose:
- Timsort (Python) or Introsort (C++) - best overall performance
- Quick Sort with good pivot selection - excellent average case
For Guaranteed Performance:
- Merge Sort - stable and predictable
- Heap Sort - when O(1) space is required
For Special Data Types:
- Counting Sort - small integer ranges
- Radix Sort - large integers or strings
- Bucket Sort - uniformly distributed floats
For Educational Purposes:
- Start with Bubble Sort for simplicity
- Progress to Quick Sort and Merge Sort
- Use Bogo Sort to demonstrate algorithm analysis
Key Takeaways
- No single best algorithm - choice depends on data characteristics, constraints, and requirements
- Modern algorithms are hybrids - combining techniques yields superior performance
- Stability matters for sorting complex objects where maintaining relative order is important
- Space-time tradeoffs are crucial - some algorithms trade memory for speed
- Real-world performance often differs from theoretical complexity due to cache effects, data patterns, and implementation details
Understanding these 25 algorithms provides a comprehensive foundation for tackling sorting problems in any context, from embedded systems to large-scale data processing.
Peg Solitaire
Leave The Last Peg Standing
Peg Solitaire is a classic single-player puzzle game where you jump pegs to remove them from the board, aiming to leave as few pegs as possible.
How To Play
Jump pegs over adjacent pegs to remove them from the board. Your goal is to end with as few pegs as possible - ideally just one.
Basic Rules
- Click a peg to select it (it will bounce)
- Click an empty hole to jump there
- You can only jump over one adjacent peg into an empty hole
- The jumped peg is removed
- Jumps must be horizontal or vertical (no diagonals)
- Game ends when no valid moves remain
Controls
- Click pegs - Select and move
- Undo/Redo - Take back or replay moves
- Ctrl+Z/Y - Keyboard shortcuts for undo/redo
- Theme Nine color themes: Sapphire, Ocean, Mint, Forest, Sunset, Lavender, Cherry, Slate, Honey
- Max Score - Shows the best possible outcome from current position
- Autosolve - Watch the computer find an optimal solution
- New Game - Start fresh
- Esc - Stop autosolve or close end screen
Game Modes
Board Types
- Triangular (15 holes) - Classic Cracker Barrel puzzle
- English Cross (33 holes) - Traditional European board
- French/European (37 holes) - Octagonal variant
- Diamond (41 holes) - Diamond-shaped challenge
- Wiegleb German (45 holes) - Extended cross pattern
- Asymmetrical (39 holes) - Unique irregular layout
Starting Positions
Choose where to place the initial empty hole:
- Center (most common)
- Corner (varies by board)
- Edge/Other positions
Note: Some boards have mathematically unsolvable starting positions. The game will warn you.
Achievements
Achievement tiers scale with board complexity, the fewer pegs left standing the better:
- Small Boards (15-20 holes)
1Perfect/Genius2-3Excellent4-5Good6+Keep Trying
- Medium Boards (33-37 holes)
1Perfect2-5Excellent to Very Good6-12Good to Fair13+Need Practice
- Large Boards (41-45 holes)
1-2Master3-5Expert6-14Advanced to Intermediate15+Beginner
Tips
- Plan ahead - think 2-3 moves in advance
- Try to avoid isolating pegs in corners
- Creating long chains of jumps is key to low scores
- The triangular board has over 6,000 winning sequences
- Perfect games aren't always possible from every starting position
Tea Brewing Guide
If you are cold, tea will warm you; if you are too heated, it will cool you; if you are depressed, it will cheer you; if you are excited, it will calm you.
The gap between a good cup of tea and a bitter one is usually ten degrees of water, or thirty seconds of steeping. People have been drinking tea for thousands of years and most of us still get it wrong: water straight off the boil poured over green leaves, a bag left in long enough to turn the cup to tannin. The leaf is rarely the problem. The water and the clock are.
The tool below handles the part that is just numbers. Pick a tea and it gives you the water temperature, the steeping time, how many times the leaves will keep giving, the caffeine, what it pairs with, and a timer keyed to the steep that chimes when the cup is ready. Toggle between Fahrenheit and Celsius, and, where a tea supports it, between a Western mug and gongfu's short repeated infusions. Start there.
That gets you a correct cup. The rest of this is why the numbers are what they are.
The two things that matter
Temperature and time. Everything else is refinement.
Heat is the bigger lever. Delicate leaves, white and green and yellow, scald in water near boiling: the result is bitter and flat, and no amount of sweetener brings it back. They want water that has come off the boil and rested, somewhere around 175°F. Fully oxidized leaves, black and pu-erh, and every herbal infusion, want the opposite, a hard boil to pull the flavor out at all. Oolong sits in the middle and shifts with the roast.
Time is the lever you keep your hand on. The timer starts at the short end of the recommended range on purpose. Taste it there, then extend. A cup steeped thirty seconds too long cannot be walked back; one pulled early can always go in again.
Why one leaf becomes six teas
White, yellow, green, oolong, black, and pu-erh all come from the same plant, Camellia sinensis. What separates them is oxidation, the slow browning that happens when a picked leaf meets air, the same reaction that darkens a cut apple.
White tea is the leaf barely touched, withered and dried and nothing more. Green tea is heat-fixed within hours of picking, the oxidation stopped before it starts, which is why it stays grassy and bright. Yellow is green tea given an extra sealed, slow yellowing that most producers no longer bother with, which is why you have probably never had it. Oolong is caught in the middle, anywhere from lightly to mostly oxidized, which makes it the widest category of all. Black tea is taken the whole way. Pu-erh is the outlier: not oxidized but fermented, aged for years or decades by live microbes, the only tea that genuinely improves in storage.
Six teas, one bush, one variable turned up by degrees.
Gongfu versus the mug
There are two ways to brew, and the tool will time either.
The Western way is one long steep: a teaspoon of leaf, a full mug, three to five minutes, done. It is simple, and it is most of how tea gets drunk in the world.
Gongfu is the opposite bet. A lot of leaf, a small pot, and a run of very short infusions, the first sometimes only ten seconds. You pour, drink, and pour again, and the tea changes cup to cup as the leaves open. It asks more of you, and it is the right tool for a good oolong or an aged pu-erh, which can give a dozen infusions or more before they are spent. The gongfu mode counts the steeps and adds a little time with each round, the way you would by hand.
Re-steeping, and when a leaf is done
Cheap, broken-leaf tea gives one cup and quits. Whole-leaf tea gives many, and the good ones get more interesting partway through rather than weaker. A quality oolong is often best on its third or fourth infusion; aged pu-erh can run past twenty.
Rolled and compressed teas, ball-rolled oolong and pressed pu-erh cakes, want a quick rinse first: a few seconds of hot water poured over and thrown away, which wakes the leaves and washes off storage. After that, keep going until the cup tastes thin. The leaf will tell you it is finished before any clock does.
Herbal infusions are not tea
Chamomile, rooibos, peppermint, ginger, hibiscus, lavender: none of them contain a tea leaf. They are tisanes, brewed from flowers, leaves, and roots, and the category is older than tea itself. Because there is no Camellia sinensis in the cup, they are all caffeine-free, which is most of the reason people reach for them at night.
They are also forgiving. A full boil and a long steep, five to ten minutes, will not turn them bitter the way it would a green tea, and several hold their heat and flavor long after a true tea would fade. The popular ones are in the tool above, brewed by the same two numbers as everything else.
Background Eraser
Remove white backgrounds from your images; background be gone!
Welcome! This free tool helps you remove white backgrounds from your images in seconds, right here in your browser.
What can I use this for?
- Product photos - Perfect for online stores or portfolios
- Logos and graphics - Make them work on any background
- Profile pictures - Remove distracting backgrounds
- Design assets - Create transparent PNGs for your projects
How to use
1. Upload your image
Click the camera icon or drag your image into the upload area. We support JPG, PNG, GIF, and WebP files.
2. Adjust if needed
Use the threshold slider to control how much white to remove. The default setting (30) works great for most images.
- Lower values (0-20): Only removes pure white or very close to white
- Medium values (20-50): Removes most white and light gray backgrounds
- Higher values (50-100): More aggressive, may remove light colored parts of your image
3. Download
Click "Download PNG" to save your image with a transparent background. Your new file will be ready to use anywhere!
Tips for best results
- Clean white backgrounds work best
- High contrast between your subject and background gives cleaner edges
- Adjust the threshold - move the slider left for less aggressive removal, right for more
- Preview first - you'll see the result before downloading
Good to know
- ✅ Completely free - No watermarks, no sign-ups
- ✅ Private & secure - Your images stay on your device
- ✅ Instant results - No waiting or processing queues
- ✅ Original quality - We preserve your image quality
Having trouble?
If the tool isn't removing the background well:
- Try adjusting the threshold slider
- Make sure your background is mostly white
- Images with shadows or gradients may need a higher threshold
Examples of what works well
- Product photos on white backgrounds
- Scanned documents or drawings
- Screenshots with white backgrounds
- Simple graphics and icons
Questions or feedback? Feel free to reach out. Happy creating! 🎨