# permutations

Published articles for permutations.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Too big to draw, but yet drawable

DevFeed: [Too big to draw, but yet drawable](<https://devfeed.tech/articles/too-big-to-draw-but-yet-drawable-37564.md>)

Original publisher: [Read original article](<https://blog.klipse.tech/aboulafia/2026/07/06/too-big-to-draw-but-yet-drawable.html>)

Author: Yehonathan Sharvit

Published: 2026-07-06T09:00:00Z

Content type: article

Language: en

Sources: [Klipse](<https://devfeed.tech/sources/klipse.md>)

Topics: [ordering](<https://devfeed.tech/topics/ordering.md>), [structure](<https://devfeed.tech/topics/structure.md>)

Tags: [aboulafia](<https://devfeed.tech/tags/aboulafia.md>), [caustics](<https://devfeed.tech/tags/caustics.md>), [generative](<https://devfeed.tech/tags/generative.md>), [math](<https://devfeed.tech/tags/math.md>), [permutation](<https://devfeed.tech/tags/permutation.md>), [permutations](<https://devfeed.tech/tags/permutations.md>), [random](<https://devfeed.tech/tags/random.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [visualization](<https://devfeed.tech/tags/visualization.md>)

### AI overview

The third article in a series explains how Aboulafia's tserouf orders all permutations of a word and visualizes them by placing the permutations around a circle and connecting each word to its reversal. Because the full permutation space becomes too large to draw, the article samples chords and shows that they form recurring caustic curves visible at multiple scales.

### Source excerpt

Aboulafia's Tserouf - Part 3 of 4 <- Previous: An elegant formulation, inspired by Bill Gates - Next: A wheel, the same forwards and backwards ->

## Zaks's suffix-reversal algorithm for generating permutations

DevFeed: [Zaks's suffix-reversal algorithm for generating permutations](<https://devfeed.tech/articles/an-elegant-formulation-inspired-by-the-one-and-only-paper-bill-gates-ever-wrote-37563.md>)

Original publisher: [Read original article](<https://blog.klipse.tech/aboulafia/2026/07/06/an-elegant-formulation-inspired-by-bill-gates.html>)

Author: Yehonathan Sharvit

Published: 2026-07-06T08:00:00Z

Content type: article

Language: en

Sources: [Klipse](<https://devfeed.tech/sources/klipse.md>)

Topics: [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [ordering](<https://devfeed.tech/topics/ordering.md>)

Tags: [aboulafia](<https://devfeed.tech/tags/aboulafia.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [math](<https://devfeed.tech/tags/math.md>), [permutations](<https://devfeed.tech/tags/permutations.md>), [reversing](<https://devfeed.tech/tags/reversing.md>), [sequence](<https://devfeed.tech/tags/sequence.md>), [sorting](<https://devfeed.tech/tags/sorting.md>)

### AI overview

This second article in a series connects Aboulafia's recursive Tserouf permutation algorithm with Shimon Zaks's 1984 algorithm. It explains how Zaks generates permutations by repeatedly reversing suffixes and describes the recursive sequence of suffix lengths behind the ordering.

### Source excerpt

Aboulafia's Tserouf - Part 2 of 4 <- Previous: An algorithm ignored for 700 years - Next: Too big to draw, but yet drawable ->

## A 13th-Century Enumeration Algorithm, Ignored for 700 Years

DevFeed: [A 13th-Century Enumeration Algorithm, Ignored for 700 Years](<https://devfeed.tech/articles/a-13th-century-enumeration-algorithm-ignored-for-700-years-37561.md>)

Original publisher: [Read original article](<https://blog.klipse.tech/aboulafia/2026/07/06/a-13th-century-enumeration-algorithm-ignored-for-700-years.html>)

Author: Yehonathan Sharvit

Published: 2026-07-06T07:00:00Z

Content type: article

Language: en

Sources: [Klipse](<https://devfeed.tech/sources/klipse.md>)

Topics: [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [structure](<https://devfeed.tech/topics/structure.md>)

Tags: [aboulafia](<https://devfeed.tech/tags/aboulafia.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [kabbalah](<https://devfeed.tech/tags/kabbalah.md>), [math](<https://devfeed.tech/tags/math.md>), [order](<https://devfeed.tech/tags/order.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [permutations](<https://devfeed.tech/tags/permutations.md>)

### AI overview

The article examines a systematic method for enumerating permutations described by the 13th-century Kabbalist Abraham Aboulafia in his account of Tserouf. It explains rules for ordering three-letter permutations and a rotation-based method for extending the ordering to longer words.

### Source excerpt

Aboulafia's Tserouf - Part 1 of 4 Next: An elegant formulation, inspired by Bill Gates ->

## Four variants of array-shuffle algorithms

DevFeed: [Four variants of array-shuffle algorithms](<https://devfeed.tech/articles/doubly-dual-shuffles-36225.md>)

Original publisher: [Read original article](<https://dotat.at/@/2025-12-25-shuffle.html>)

Published: 2025-12-25T23:45:02Z

Content type: tutorial

Language: en

Sources: [Tony Finch's blog](<https://devfeed.tech/sources/tony-finch-s-blog.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Algorithms, Complexity](<https://devfeed.tech/topics/algorithms-complexity.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [permutations](<https://devfeed.tech/tags/permutations.md>)

### AI overview

The article examines four symmetric variants of an array-shuffling algorithm. It distinguishes sampling-based and permutation-based approaches, and places the common Durstenfeld shuffle among the variants.

### Source excerpt

Here's a pearlescent winter holiday gift for you! There are four variants of the algorithm for shuffling an array, arising from two independent choices: whether to swap elements in the higher or lower parts of the array whether the boundary between the parts moves upwards or downwards The variants are perfectly symmetrical, but they work in two fundamentally different ways: sampling or permutation. The most common variant is Richard Durstenfeld's shuffle algorithm, which moves the boundary downwards and swaps elements in the lower part of the array. Knuth describes it in TAOCP vol. 2 sect. 3.4.2; TAOCP doesn't discuss the other variants. (Obeying Stigler's law, it is often called a "Fisher-Yates" shuffle, but their pre-computer algorithm is arguably different from the modern algorithm.) the four variants In the pseudocode below, min and max are the inclusive bounds on the array to be shuffled; the arguments to rand() are the inclusive bounds on its return value; and the loop bounds are inclusive too. I chose this style to make the symmetries more obvious. In all variants, it's possible for the indexes this (the boundary between the parts of the array) and that (chosen at random) to be the same, in which case the swap is a no-op. I could have written the loop bounds as min and max instead of min+1 and max-1 to make the variants look as similar as possible, but it's more realistic to omit the loop iterations when this and that are guaranteed to be equal. It should be clear that rand() is invoked for spans of each size between 2 and N (where N = max - min + 1) so the algorithms produce N! possible permutations as expected. boundary moves down, pick from lower shuffle(a, min, max) for this = max to min+1 step -1 that = rand(min, this) swap a[this] and a[that] boundary moves up, pick from higher shuffle(a, min, max) for this = min to max-1 step +1 that = rand(this, max) swap a[this] and a[that] boundary moves down, pick from higher shuffle(a, min, max) for this = max-1 t

## Optimally Stacking the Deck--Texas Hold 'Em

DevFeed: [Optimally Stacking the Deck--Texas Hold 'Em](<https://devfeed.tech/articles/optimally-stacking-the-deck-texas-hold-em-40269.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2012/04/09/optimal-stacking-hold-em/>)

Published: 2012-04-09T09:00:26Z

Content type: article

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [math](<https://devfeed.tech/topics/math.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [card-games](<https://devfeed.tech/tags/card-games.md>), [fairness](<https://devfeed.tech/tags/fairness.md>), [gambling](<https://devfeed.tech/tags/gambling.md>), [permutations](<https://devfeed.tech/tags/permutations.md>), [poker](<https://devfeed.tech/tags/poker.md>), [steepest-ascent](<https://devfeed.tech/tags/steepest-ascent.md>), [texas-hold-em](<https://devfeed.tech/tags/texas-hold-em.md>)

### AI overview

The article solves a combinatorial puzzle about arranging a standard two-player Texas Hold 'Em deck so that one player wins regardless of where the deck is cut. It explains how cutting the deck normally supports fairness and frames optimal stackings as a measure of game complexity.

### Source excerpt

Main Theorem: There exist optimal stackings for standard two-player Texas Hold 'Em. A Puzzle is Solved (and then some!) It's been quite a while since we first formulated the idea of an optimal stacking. In the mean time, we've gotten distracted with graduate school, preliminary exams, and the host of other interesting projects that have been going on here at Math ∩ Programming. And so months later, after traversing the homotopic hills of topology and projective plains of algebra, we've finally found time to solve the problem.

## In Place Uniform Shuffle

DevFeed: [In Place Uniform Shuffle](<https://devfeed.tech/articles/in-place-uniform-shuffle-40266.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2012/03/18/in-place-uniform-shuffle/>)

Published: 2012-03-18T20:33:42Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [fairness](<https://devfeed.tech/tags/fairness.md>), [permutations](<https://devfeed.tech/tags/permutations.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

A Python implementation of an in-place uniform shuffle is presented. The article explains why uniform randomness matters for shuffling and derives a process that selects a random remaining element at each position, using constant extra space and linear time.

### Source excerpt

Problem: Write a program that shuffles a list. Do so without using more than a constant amount of extra space and linear time in the size of the list. Solution: (in Python) import random random.seed() def shuffle(myList): n = len(myList) for i in xrange(0, n): j = random.randint(i, n-1) # randint is inclusive myList[i], myList[j] = myList[j], myList[i] Discussion: Using a computer to shuffle a deck of cards is nontrivial at first glance for the following reasons.