improvements in the last post

Author: vchernoy

404.html

@@ -570,7 +570,7 @@ <h2>Latest</h2>
 
       <li><a href="/post/">Posts</a></li>
 
-      <li><a href="/post/perfect-distribution/">Perfect Distribution Based on GCD</a></li>
+      <li><a href="/post/perfect-distribution/">Perfect Distribution: GCD in Disguise</a></li>
 
       <li><a href="/post/binomial-modulo-prime/">Binomial Coefficients Modulo a Prime: Fermat&#39;s Theorem and the Non-Adjacent Selection Problem</a></li>
 

content/post/perfect-distribution.md

@@ -3,7 +3,7 @@ date = "2017-08-01T07:29:43Z"
 math = true
 highlight = true
 tags = ["math","python", "recursion", "recursive functions", "gcd", "uniform distribution"]
-title = "Perfect Distribution Based on GCD"
+title = "Perfect Distribution: GCD in Disguise"
 draft = false
 
 # Optional featured image (relative to `static/img/` folder).
@@ -13,9 +13,11 @@ caption = ""
 
 +++
 
-## Perfect Distribution Based on GCD
+## Perfect Distribution: GCD in Disguise
 
-We discuss an algorithm that distributes $a$ ones among $n$ positions so that the gaps between consecutive ones differ by at most one—a **perfect distribution**. The examples below are software engineering use cases for this algorithm.
+We discuss an algorithm that distributes $a$ ones among $n$ positions so that the gaps between consecutive ones differ by at most one—a **perfect distribution**. I developed it while working on profiling, stress, and negative testing of a system that needed exactly this kind of uniform spread. I am not aware of prior art; if you know of related work, I would be interested to hear.
+
+The examples below are software engineering use cases for this algorithm.
 
 ### Use Case 0: Text spacing
 
@@ -48,6 +50,10 @@ Suppose we specify $230$ requests per second: then during every part, $2.3$ requ
 In other words, the tool must send 2 requests in most parts and 3 in some parts.
 We need to choose which $30$ parts get the extra request; ${\cal PD}(30, 100)$ yields that array (a $1$ in cell $i$ means part $i$ gets 3 requests).
 
+### Why naive approaches fail
+
+A natural idea is to place ones at multiples of $n/a$, e.g. `[1 if (i * a) % n < a else 0 for i in range(n)]`, or to use `round(i * a / n)` to decide. Such formulas can produce wrong counts (off-by-one), clusters at the boundaries, or gaps that differ by more than one. Another approach—repeatedly choosing the “emptiest” gap—avoids clustering but is harder to implement correctly and lacks the clean recurrence we want. ${\cal PD}$ gives the exact, unique fairest distribution in a few lines.
+
 We present the general solution ${\cal PD}$ to the problem—for any specified input in the above examples, ${\cal PD}$ produces the exact solution.
 Any probabilistic or approximation solutions do not achieve the required exactness and are usually more complicated.
 The algorithm ${\cal PD}$ is simple, has a clear correctness proof, and admits $O(n)$ time and space complexity.
@@ -62,7 +68,7 @@ Moreover, it has a direct relation to Euclid's algorithm for computing the Great
 * POST: $res = {\cal GCD}(a, n)$.
 
 ```python
-def gcd(a, n):
+def gcd(a: int, n: int) -> int:
     assert 0 <= a <= n
 
     res = n
@@ -82,7 +88,7 @@ The recurrence mirrors Euclid's algorithm: ${\cal PD}(a, n)$ calls ${\cal PD}(n
 * POST: $res$ is perfectly distributed (gaps between consecutive ones differ by at most 1).
 
 ```python
-def pd(a, n):
+def pd(a: int, n: int) -> list[int]:
     assert 0 <= a <= n
 
     res = [0] * n
@@ -97,6 +103,10 @@ def pd(a, n):
     return res
 ```
 
+**Why it works.** The algorithm treats $n$ positions as $a$ “blocks” of size $\lfloor n/a \rfloor$ or $\lceil n/a \rceil$. The recursive call ${\cal PD}(n \bmod a, a)$ decides which blocks get the extra slot (the remainder). Each block is filled by either repeating a perfect distribution of ones in a sub-interval (when $a \le n/2$) or by inverting zeros when $a > n/2$. The recurrence ensures that at every level, the pattern stays uniform—no block gets more than one extra slot, so gaps never differ by more than one.
+
+**Optimality.** The perfect distribution (gaps differ by at most 1) is unique up to the choice of which gaps are $\lfloor (n-a)/a \rfloor$ and which are $\lceil (n-a)/a \rceil$. The algorithm constructs this by induction: the base case $a=0$ is trivial; for $a>0$, the recursive call yields a perfect distribution for the “remainder” subproblem, and the interleaving step preserves the gap invariant.
+
 ### Example. ${\cal PD}(2, 10)$: $a = 2$, $n = 10$, so $n - a = 8$ zeros
 We want to mix $2$ ones and $8$ zeros.
 The recursive call ${\cal PD}(0, 2)$ returns $[0, 0] = 0^2$, which is assigned to $arr$.
@@ -111,7 +121,7 @@ Then the array $res$ is filled as follows: $[(1, 0, 1, 1, 1), (1, 0, 1, 1, 1)] =
 
 * ${\cal PD}(1, 10) : [1, 0, \ldots, 0] = 1, 0^9$
 * ${\cal PD}(2, 10) : [1, 0, 0, 0, 0, 1, 0, 0, 0, 0] = 1, 0^4 , 1, 0^4$
-* ${\cal PD}(3, 10) : [1, 0, 0, 1, 0, 0, 1, 0, 0, 0] = 1, 0^2 , 1, 0^2 , 1, 0^3$
+* ${\cal PD}(3, 10) : [1, 0, 0, 1, 0, 0, 1, 0, 0, 0] = 1, 0^2 , 1, 0^2 , 1, 0^3$ — visual: `1 _ _ 1 _ _ 1 _ _ _` (gaps between 1s: 2, 2, 3)
 * ${\cal PD}(4, 10) : [1, 0, 0, 1, 0, 1, 0, 0, 1, 0] = 1, 0^2 , 1, 0, 1, 0^2 , 1, 0$ $= (1, 0^2 , 1, 0)^2$
 * ${\cal PD}(5, 10) : [1, 0, 1, 0, 1, 0, 1, 0, 1, 0] = (1, 0)^5$
 * ${\cal PD}(6, 10) : [1, 0, 1, 1, 0, 1, 0, 1, 1, 0] = 1, 0, 1^2 , 0, 1, 0, 1^2 , 0$ $ = (1, 0, 1^2 , 0)^2$
@@ -128,7 +138,7 @@ The same recurrence can be expressed using subtraction instead of modulo, which
 **Slow GCD (subtraction-based):**
 
 ```python
-def gcd(a, n):
+def gcd(a: int, n: int) -> int:
     assert 0 <= a <= n
 
     res = n
@@ -145,7 +155,7 @@ def gcd(a, n):
 **Slow PD (subtraction-based):**
 
 ```python
-def pd(a, n):
+def pd(a: int, n: int) -> list[int]:
     assert 0 <= a <= n
 
     res = [0] * n

index.html

@@ -341,7 +341,7 @@
 <meta property="og:description" content="Software Engineer" /><meta property="og:image" content="/media/icon_hu_43cf117bf1a42c34.png" /><meta property="og:locale" content="en-us" />
 
 
-    <meta property="og:updated_time" content="2017-08-02T07:29:43&#43;00:00" />
+    <meta property="og:updated_time" content="2026-02-08T19:47:43&#43;00:00" />
 
 
 
@@ -975,18 +975,14 @@ <h1 class="mb-0">Recent Posts</h1>
   <div class="media-body">
 
     <div class="section-subheading article-title mb-0 mt-0">
-      <a href="/post/perfect-distribution/" >Perfect Distribution Based on GCD</a>
+      <a href="/post/perfect-distribution/" >Perfect Distribution: GCD in Disguise</a>
     </div>
 
 
     <a href="/post/perfect-distribution/"  class="summary-link">
       <div class="article-style">
-        <h2 id="perfect-distribution-based-on-gcd">Perfect Distribution Based on GCD</h2>
-<p>We discuss an algorithm that distributes $a$ ones among $n$ positions so that the gaps between consecutive ones differ by at most one—a <strong>perfect distribution</strong>. The examples below are software engineering use cases for this algorithm.</p>
-<h3 id="use-case-0-text-spacing">Use Case 0: Text spacing</h3>
-<p>Given a string of characters $s$ and a number $n$ greater than the length of $s$,
-extend the string $s$ to length $n$ by inserting spaces between the words.
-The key requirement is that the distances between two consecutive words be uniform.</p>
+        <h2 id="perfect-distribution-gcd-in-disguise">Perfect Distribution: GCD in Disguise</h2>
+<p>We discuss an algorithm that distributes $a$ ones among $n$ positions so that the gaps between consecutive ones differ by at most one—a <strong>perfect distribution</strong>. I developed it while working on profiling, stress, and negative testing of a system that needed exactly this kind of uniform spread. I am not aware of prior art; if you know of related work, I would be interested to hear.</p>
       </div>
     </a>
 
@@ -1019,7 +1015,7 @@ <h3 id="use-case-0-text-spacing">Use Case 0: Text spacing</h3>
 
   <span class="middot-divider"></span>
   <span class="article-reading-time">
-    6 min read
+    7 min read
   </span>