${lb}

2d:null 2e:["$","title",null,{"children":"Mahjong Math - Introduction | randName() | Observable"}] 33:Tc3e,There are ${tex`{34\choose 2}`} ways of choosing 2 different tiles, and ${tex`{34\choose 1}`} ways of choosing a pair of the same tile, for a total of ${tex`{34\choose 2} + {34\choose 1} = 595`} #### 3 tiles, 4 tiles Now it gets more complicated because there are multiple ways of choosing a few different tiles. The sum still starts with ${tex`{34\choose n}`} and ends with ${tex`{34\choose 1}`}, which represent the ways to choose "all different tiles" and "all the same tile" respectively. For 3 tiles, there are 2 ways to choose 2 different tiles (*aab* and *abb*), and so the total is ${tex`{34\choose 3} + 2{34\choose 2} + {34\choose 1} = 7140`} For 4 tiles, there are - 3 ways to choose 3 different tiles (*aabc*, *abbc*, *abcc*) - 3 ways to choose 2 different tiles (*aaab*, *aabb*, *abbb*) so the total is ${tex`{34\choose 4} + 3{34\choose 3} + 3{34\choose 2} + {34\choose 1} = 66045`} #### 5 tiles Sharp-eyed amongst you might have noticed the Pascal's triangle appearing. Indeed, there are - 4 ways to choose 4 different tiles (*i.e.* ${tex`{4\choose 1}`} ways to choose a tile to be a pair) - 6 ways to choose 3 different tiles (try to list them all!) - 4 ways to choose 2 different tiles (*aaaab*, *aaabb*, *aabbb*, *abbbb*) ... but unfortunately, there is no way to choose 5 of the same tile and the nice pattern we had so far breaks down. #### *n* tiles As the composition of tiles is the core issue, the only way to get around it is to handle each case seperately. And so, the general equation is ${tex.block`\begin{aligned} \sum^{\lfloor{\frac{n}{4}}\rfloor}_{q=0} \sum^{\lfloor{\frac{n-4q}{3}}\rfloor}_{t=0} \sum^{\lfloor{\frac{n-4q-3t}{2}}\rfloor}_{p=0} {34\choose q}{{34-q}\choose t}{{34-q-t}\choose p}{{34-q-t-p}\choose{n-4q-3t-2p}}\\ \text{where } n - 3q - 2t - p \leq 34 \end{aligned}`} *Source*: [麻雀の数学](http://www10.plala.or.jp/rascalhp/mjmath.htm#2) That is quite a mouthful, so in plain language: - *n* is the total number of tiles we want to choose - *q*, *t*, *p* represent the number of **q**uads, **t**riplets and **p**airs of tiles in our final mix - The upper bound of the summations are the maximum number of groups that can be made with the remaining tiles. - e.g. with 13 tiles, we can make a maximum of ${tex`\lfloor{\frac{13}{4}}\rfloor = \lfloor{3.25}\rfloor = 3`} quads. If we then choose ${tex`q=1`}, then the maximum number of triplets that can be made is ${tex`\lfloor{\frac{13 - 4\times 1}{3}}\rfloor = \lfloor{\frac{9}{3}}\rfloor = 3`}. - The product can be intepreted as - Of 34 tiles, choose *q* to be quads - ${tex`{34 - q}`} and ${tex`{34 - q - t}`} tiles remain to be chosen for *t* and *p* - Finally, ${tex`{n - 4q - 3t - 2p}`} tiles need to be chosen to get a total of *n* - The constraint is because are only 34 types of tiles, i.e. ${tex.block`q + t + p + (n - 4q - 3t - 2p) = n - 3q - 2t - p \leq 34`} which is important when ${tex`n\gt34`} Enumerating the possible values of *q*, *t* and *p* is not straightforward, but thankfully only a few lines of code. We can see a breakdown of different groupings and the number of combinations they generate.34:Tbd0,#### Generating functions There is actually another way to compute the tile combinations, and it involves tricking the equation to do all the crazy enumeration for you. Let's multiply out ${tex`(x^2 + x + 1)^{3} = x^6 + 3x^5 + 6x^4 + 7x^3 + 6x^2 + 3x + 1`} So, how did we get ${tex`6x^4`} ? These are the products that contributed to that term ${(() => { const label = html`

1:

` const mials = range(3, () => { const xs = [tex`1`, tex`x`, tex`x^2`] const el = html`${tex`(`}${xs[2]} ${tex`+`} ${xs[1]} ${tex`+`} ${xs[0]}${tex`)`}` const h = async (a, b) => { xs[a].classList.add('fades') xs[b].classList.add('fades') await Promises.delay(4010) xs[a].classList.remove('fades') xs[b].classList.remove('fades') await Promises.delay(20) } return Object.assign(el, { h }) }) visibility().then(async () => { await Promises.delay(100) while (true) { label.innerText = '1: ' await Promise.all([mials[0].h(0, 1) , mials[1].h(0, 1), mials[2].h(1, 2)]) label.innerText = '2: ' await Promise.all([mials[0].h(0, 1) , mials[1].h(0, 2), mials[2].h(0, 2)]) label.innerText = '3: ' await Promise.all([mials[0].h(0, 1) , mials[1].h(1, 2), mials[2].h(0, 1)]) label.innerText = '4: ' await Promise.all([mials[0].h(0, 2) , mials[1].h(0, 1), mials[2].h(0, 2)]) label.innerText = '5: ' await Promise.all([mials[0].h(0, 2) , mials[1].h(0, 2), mials[2].h(0, 1)]) label.innerText = '6: ' await Promise.all([mials[0].h(1, 2) , mials[1].h(0, 1), mials[2].h(0, 1)]) await Promises.delay(3000) await visibility() } }) return html` ${label} ${mials}

` })()} If we have 2 each of 3 different characters (e.g. *aabbcc*) and wanted to choose 4 of them, there are also 6 ways (*aabb*, *aabc*, *aacc*, *abbc*, *abcc*, *bbcc*). Drawing parallels, the exponent can be seen as the number of a certain item we select (remembering that ${tex`1=x^0`}). As the expansion "collects" terms with the same exponent, the coefficient is our desired quantity. This is a [generating function](https://en.wikipedia.org/wiki/Generating_function) as the coefficients "generate" a sequence of numbers. The generating function for the combinations of Mahjong tiles is ${tex.block`(x^4 + x^3 + x^2 + x + 1)^{34}`} which can be intepreted as "*for each of the 34 types of tiles, 0 to 4 can be chosen*". To get the number of combinations of *n* tiles, we need to find the coefficient of ${tex`x^n`}. After writing some code to multiply polynomials, we get ${tex.block`1+... + ${tileCombinations.slice(0, 15).map((n, i) => `${n}x^{${i}}`).slice(12).join('+')} + ...`} checking the ${tex`x^{14}`} entry, we get the same result as before. For convenience, let us denote this sequence ${tex`H`}, *i.e.* ${tex`H_{14}=${tileCombinations[14]}`}35:T485,### How many wall arrangements are there? In the case of the wall, the order is important. However, the limit on repetition is once again a tricky problem. Let's cut to the general formula. For a set of *n* items, the number of *r*-length permutations with max *s* repeats is ${tex.block`f(n,r,s)=\begin{cases} n^r & (r\leq s)\\ 0 & (n=1)\\ n\left[f(n,r-1,s)-{r-1\choose s}\cdot f(n-1,r-s-1,s)\right] & (n>1)\\ \end{cases}`} ${tex`\text{for } n,r,s\in\mathbb N`} *Source: [On permutations with limited repetition](https://www.sciencedirect.com/science/article/pii/0097316581900340) by Haim Mendelson* - When ${tex`r\leq s`}, the limit of *s* does not matter and we can pick from *n* freely - When ${tex`n=1`} it is not possible to create a sequence with repeats - The recurrence is explained in more detail in the source We need only ${tex`W_r = f(34,r,4)`}, but we can [memoise the recursion to save on some computation](https://en.wikipedia.org/wiki/Dynamic_programming). And thus the number of possible arrangements of the wall is ${tex.block`W_{84} = f(34,84,4) \approx 2.82\times 10^{127}`} which is the lower bound of the number of possible games.36:T60e,### How many possible games are there? The big question. But why are the earlier numbers just bounds for the actual value? - The lower bound (wall permutations) neglects the tiles dealt out to players, which could be allocated in a few different ways. - The upper bound (complete permutations) over-counts the different order of tiles that each player could have, when it technically does not affect the game. The truth is, computing the actual value would involve enumerating the *q*, *t*, *p* values for each player (which also determines the values for the wall), and summing up all of them. In fact, it becomes more of a [partition](https://en.wikipedia.org/wiki/Partition_(number_theory%29) problem. ${tex.block`{34\choose q_1}{{34-q_1}\choose q_2} ...{{34-\sum{(q_i+t_i+p_i)...}}\choose{136-\sum{(4q_i+3t_i+2p_i)}...}}{\frac{84!}{(4!)^{q_w}(3!)^{t_w}(2!)^{p_w}}}`} But even before getting into all of that, it might not be the "actual" result. If we consider the order of [uradora](https://riichi.wiki/Dora#Uradora) indicators in the [dead wall](https://riichi.wiki/Wanpai) unimportant (they only affect scoring), then we have to bring out another set of terms from the wall permutation. Hence, if we are satisfied with just improving our upper bound, we can neglect the proper distribution of tiles amongst the players and simply compute ${tex.block`W_{84}\cdot(H_{13})^4 \approx 2.6\times 10^{171}`} We are over-counting some combination of player hands that are impossible, but we did reduce the upper bound by a factor of ${tex`10^{14}`}37:T899,## Mahjong 101 Since there is already a lot of great resources out there that cover this in detail, this primer will just be the bare minimum to understand this series, which are *the tiles* and *how the game works*. ### Tiles There are a few kinds of tiles used in Mahjong. Firstly, there are 3 "suits" of tiles. |${range(10, (i) => `${i || 'suit'}`).join('|')}| |-|-|-|-|-|-|-|-|-|-| | \`pinzu\` (coins) |${[...'🀙🀚🀛🀜🀝🀞🀟🀠🀡'].join('|')}| | \`souzu\` (bamboo) |${[...'🀐🀑🀒🀓🀔🀕🀖🀗🀘'].join('|')}| | \`manzu\` (myriad) |${[...'🀇🀈🀉🀊🀋🀌🀍🀎🀏'].join('|')}| Similar to playing cards, they go from 1 to 9 (without the face cards). Outside of the suits, there are some "word" tiles (honour tiles): - 🀀 East - 🀁 South - 🀂 West - 🀃 North - 🀄 ~~Center~~ Red - 🀅 ~~Fortune (??)~~ Green - 🀆 ~~Blank (???)~~ White There are 4 copies of each tile used during play. ### Gameplay (very roughly. A lot of details are dropped and glossed over.) 1. 4 players sit around a square table, one on each side 2. One of the player is chosen to start first ("the dealer") 3. All the tiles are shuffled, then arranged in neat walls to fix the order 4. **Each player draws 13 tiles** 5. Player turn starts (from the dealer) 1. **draw one tile from the wall** 2. if some conditions are met, perform special actions 3. **choose one tile to discard** 6. **Play continues anticlockwise** (to the right) 7. When a tile is discarded, it may be claimed by other players to form a group. Then: - it switches to the claimers turn - the claimer does not draw from the wall - play continues as usual after discarding (step 6) 8. Once a player has a ready hand, they are able to **declare a win** on either - another player's discard, or - a tile drawn on their turn 9. Play continues until a win is declared or the wall runs out of tiles Variations of mahjong usually involve different hand sizes and/or different win conditions. ### External - [A Beginner's Guide to Riichi Mahjong](https://mahjong.guide/a-beginners-guide-to-riichi-mahjong/) - [Riichi Mahjong Wiki](https://riichi.wiki/Japanese_mahjong)38:[] 31:{"id":"af094facd19a1910","slug":"mahjong-math-intro","title":"Mahjong Math - Introduction","thumbnail":"7b007f42202fd11ea8426b76305e7e548689f4bc0c8c7e37b46a1aa21635c09e","access_level":"public","create_time":"$D2021-10-24T08:57:58.418Z","update_time":"$D2021-12-28T15:44:15.954Z","view_time":null,"first_public_time":"$D2021-11-06T16:21:11.515Z","has_unpublished_edits":null,"fork":false,"stars":1,"starred":false,"owner":{"type":"team","id":"af680361d1ea8ba5","login":"randname","name":"randName()","avatar_url":"https://avatars-next.observableusercontent.com/f16c819c73deae04aebd89cd214320d2b848d288cea0ed4487f835cc1b3e9c04","tier":"starter_2024"},"version":2246,"publish_version":2246,"role":null,"authored":false,"authors":[{"type":"individual","id":"6af62fd51a9b60df","login":"randname","name":"randName()","avatar_url":"https://avatars-next.observableusercontent.com/f16c819c73deae04aebd89cd214320d2b848d288cea0ed4487f835cc1b3e9c04","tier":null}],"members":[{"type":"individual","id":"6af62fd51a9b60df","login":"randname","name":"randName()","avatar_url":"https://avatars-next.observableusercontent.com/f16c819c73deae04aebd89cd214320d2b848d288cea0ed4487f835cc1b3e9c04","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":{"id":"4fdfecbc27fc15ca","slug":"math-of-mahjong","title":"The Math of Mahjong","owner":{"id":"af680361d1ea8ba5","login":"randname","name":"randName()"}},"type":"notebook","body":{"title":"Mahjong Math - Introduction","cells":[{"id":0,"value":"# Mahjong Math - Introduction\n\nThis is a little exploration into some mathematical curiosities regarding the game of Mahjong (no, not the matching one).\n\nMost of these were stepping stones in my quest to build a bot that plays reasonably well, but doesn't involve any deep learning or neural networks. So, instead of just letting a reinforcement learning system like [AlphaGo](https://en.wikipedia.org/wiki/AlphaGo) play thousands of games, I tried to code the basic heuristics that humans use to play.\n\n1. [Introduction (this notebook)](#introduction)\n2. Enumerating Groupings\n3. Evaluating Readiness\n4. Winning Probabilities\n5. Limit Hands","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":54,"value":"## What is Mahjong?\nThere are actually many variants of Mahjong that exist, but the one that this series will focus on is [Riichi Mahjong](https://riichi.wiki/). However, the base game is largely the same, which is also where all the juicy math bits come in.\n\n*※ For those who don't know the mechanics, the [appendix](#tutorial) has a mini explainer and a few links that do a better job than I can.*\n\nFrom a game-theoretical standpoint, Mahjong is:\n\n- multiplayer\n- symmetric\n- zero-sum\n- discrete, sequential turn-based\n- imperfect information\n\nIn plain language:\n- it needs 4 (or 3, depending on the variant) players\n- it doesn't matter which player you are (except for scoring purposes)\n- one player's gain is another player's loss\n- each player takes turns performing actions in sequence\n- some tiles (and hence the complete game state) are not visible\n\nThose properties contribute to the luck and skill that is involved while playing.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"introduction","database":"$undefined"},{"id":187,"value":"md`## Game Space\nThe most basic question to ask is, how many games are possible?\n\nWhile the evolution of each game depends on the players, the initial shuffle state persists and plays a large role in the \"luck\" aspect.\n\nAs there are **4 copies** of **34 types of tiles** (for a total of 136), the number of permutations (with repetition) is ${tex.block`\\frac{136!}{(4!)^{34}} \\approx 4.327 \\times 10^{185}`}\n\nFor comparison,\n- a 3x3x3 Rubik's cube has ${tex`8!\\times3^7\\times\\frac{12!}{2}\\times2^{11}\\approx4.3\\times10^{19}`} arrangements\n- a deck of cards has ${tex`52! \\approx 8 \\times 10^{67}`} permutations\n- approximate number of atoms in the universe ${tex`\\approx 10^{80}`}\n\nOf course, that was just the upper limit, and the actual number is much lower. This is because the first 52 tiles are dealt out to 4 players, where order does not matter.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1658,"value":"### How many hand combinations are there?\nThe size of a Mahjong hand is 14 (or 13 outside a player's turn). Since order does not matter, we are looking for the number of combinations. However, since there are only 4 copies of a tile, the usual methods do not work.\n\nLet's start with choosing just a few tiles\n\n#### 0 tiles, 1 tile\nThere is 1 way of choosing 0 tiles, and 34 ways of choosing 1 tile. Yay.\n\n#### 2 tiles\nIf we wanted to choose 2 of the same tile, it would be the same 34 ways.\n\n*If you know how combinations ${tex`({{}^{n}C_r})`} work, you can skip the next paragraph*\n\nHow many ways are there of choosing 2 different tiles? There are 34 choices for the \"first\" and 33 remaining choices for the \"second\" tile, so we can just multiply those 2 numbers together. However, we don't care about the order (i.e. *ab* and *ba*), so we will need to divide by 2. This is a [combination](https://en.wikipedia.org/wiki/Combination), ${tex`{34\\choose 2} = \\frac{34 \\times 33}{2!} = 561`}.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1568,"value":"{\n const tiles = range(34, (i) => svg``)\n const count = svg`0`\n const el = svg``\n const bounce = async (a, b) => {\n tiles[a].classList.add('bounce')\n tiles[b].classList.add('bounce')\n await Promises.delay(205)\n tiles[a].classList.remove('bounce')\n tiles[b].classList.remove('bounce')\n await Promises.delay(20)\n }\n visibility().then(async () => {\n await Promises.delay(100)\n let total = 0\n for (let i = 0; i < 33; ++i) {\n for (let j = i + 1; j < 34; ++j) {\n count.textContent = `${++total}`\n await bounce(i, j)\n }\n }\n })\n return el\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":207,"value":"$33","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1832,"value":"{\n const label = [...'qtps']\n const cqtp = ([q, t, p, s]) => choose(34, q) * choose(34 - q, t) * choose(34 - q - t, p) * choose(34 - q - t - p, s)\n const combs = [...enumerateQTP(13)].map((g) => [g, cqtp(g)]).sort((a, b) => Number(b[1] - a[1]))\n const scaling = width / Number(combs[0][1])\n const cutoff = width > 600 ? 350 : 200\n const bar = ([grp, val], pos) => {\n const w = Math.max(Number(val) * scaling, 2)\n const lb = label.map((c, i) => grp[i] ? `${c}=${grp[i]}` : '').filter((i) => i).join(', ')\n const text = w > cutoff ? `x=\"${w - 5}\" text-anchor=\"end\" fill=\"white\"` : `x=\"${w + 5}\" fill=\"black\"`\n return svg`\n \n ${val}\n ${lb}\n `\n }\n \n return html``\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2215,"value":"md`This gives us a total of ${tex`326520504500`} different 14-tile hands.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1212,"value":"$34","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":556,"value":"$35","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1478,"value":"$36","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1448,"value":"## Conclusion\nThe initial game space of Mahjong is large. However, that is literally only the beginning. The game is made much more interesting by the dynamics of each player choosing to make different actions over the course of a round.\n\nIn the following parts, we shall explore some of those decisions.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":712,"value":"md`## Appendix`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":711,"value":"range = (n, f) => Array.from({ length: n }, (_, i) => f ? f(i) : i)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":767,"value":"choose = {\n const cache = new Map()\n const store = (k, v) => (cache.set(k, v), v)\n const ch = (n, c) => {\n if (c === 0 || n === c) return 1n\n if (c === 1 || (c + 1 === n)) return BigInt(n)\n const key = `${n}:${c}`\n return cache.get(key) || store(key, factorial(n) / factorial(c) / factorial(n - c))\n }\n return Object.assign(ch, { cache })\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":813,"value":"factorial = {\n const cache = range(137, (i) => BigInt(i + 1))\n for (let i = 1n; i < cache.length; ++i) cache[i] = i * cache[i - 1n]\n return (n) => cache[n]\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1459,"value":"function * enumerateQTP (n) {\n for (let q = Math.floor(n / 4); q + 1; --q) {\n const rq = n - 4 * q // remaining after quads\n for (let t = Math.floor(rq / 3); t + 1; --t) {\n const rt = rq - 3 * t // remaining after triplets\n for (let p = Math.floor(rt / 2); p + 1; --p) {\n // q + t + p + s <= 34, but without computing s\n if ((rt + q + t - p) < 35) yield [q, t, p, rt - 2 * p]\n // but still return s for convenience\n }\n }\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":255,"value":"// To save on some computation, it can be noted that the list of coefficients is symmetric (why?)\n// This means we can discard any power above 136/2 = 68\n// multiply one set at a time\ntileCombinations = range(34, () => [1n, 1n, 1n, 1n, 1n]).reduce((a, b) => {\n // truncate high powers (>68), +1 for constant term\n const la = Math.min(69, a.length)\n const lb = Math.min(69, b.length)\n \n // create array of coefficients (-1 for constant term)\n const c = range(la + lb - 1, () => 0n)\n\n // compute and store coeffs\n for (let i = 0; i < la; ++i) {\n for (let j = 0; j < lb; ++j) {\n c[i + j] += a[i] * b[j]\n }\n }\n return c\n}).slice(0, 69)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":611,"value":"limitedPerms = {\n const max = 4\n const cache = new Map()\n const store = (k, v) => (cache.set(k, v), v)\n const p = (n, r) => {\n if (n === 1 && r > max) return 0n\n const key = `${n}:${r}`\n return cache.get(key) || store(key, (r <= max)\n ? (BigInt(n) ** BigInt(r))\n : (BigInt(n) * (p(n, r - 1) - p(n - 1, r - 1 - max) * choose(r - 1, max)))\n )\n }\n return (n) => p(34, n)\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":990,"value":"{\n /*\n tex`\n{34 \\choose n} + {{n-1} \\choose 1}{34 \\choose {n-1}} + ({{n - 2} \\choose 1} + {{n - 2} \\choose 2}){34 \\choose {n-2}} + ({{n - 3} \\choose 1} + {}){34 \\choose {n-3}} + ... + k{34 \\choose 2}\\\\\n`\n const gkek = (g) => (7n ** BigInt(g[0])) * (5n ** BigInt(g[1])) * (3n ** BigInt(g[2])) * (2n ** BigInt(g[3]))\n const main = new Map()\n const reve = new Map()\n const both = new Map()\n for (const g of generateQTP(84)) main.set(gkek(g), g)\n for (const g of generateQTP(52)) {\n const [q, t, p, s] = g\n const asdf = [34 - q - t - p - s, s, p ,t]\n const key = gkek(asdf)\n if (main.has(key)) {\n both.set(key, main.get(key))\n main.delete(key)\n } else {\n reve.set(key, [asdf, g])\n }\n }\n return { main, reve, both }\n */\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2024,"value":"{\n return md`${[icon(4),icon(3),icon(2),icon(1)]}`\n /*\n while (true) {\n for (const groups of enumerateQTP(13)) {\n yield md`

${groups.map((n) => `${n}`.padStart(2, ' ')).join(' ')}

\n ${groups.flatMap((g, i) => Array.from({ length: g }, () => icon(4 - i)))}`\n await Promises.delay(500)\n }\n }\n */\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1982,"value":"icon = (n) => {\n switch (n) {\n case 4: return svg``\n case 3: return svg``\n case 2: return svg``\n case 1: return svg``\n default:\n return svg``\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":72,"value":"$37","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"tutorial","database":"$undefined"}],"files":"$W38","stdlib":"1","titling":"auto"}} 32:"$31:body"