The Forced Indentation Of Code
The Forced Resumption Of Memes
You can't parse [X]HTML with regex. Because HTML can't be parsed by regex. Regex is not a tool that can be used to correctly parse HTML. As I have answered in HTML-and-regex questions here so many times before, the use of regex will not allow you to consume HTML. Regular expressions are a tool that is insufficiently sophisticated to understand the constructs employed by HTML. HTML is not a regular language and hence cannot be parsed by regular expressions. Regex queries are not equipped to break down HTML into its meaningful parts. so many times but it is not getting to me. Even enhanced irregular regular expressions as used by Perl are not up to the task of parsing HTML. You will never make me crack. HTML is a language of sufficient complexity that it cannot be parsed by regular expressions. Even Jon Skeet cannot parse HTML using regular expressions. Every time you attempt to parse HTML with regular expressions, the unholy child weeps the blood of virgins, and Russian hackers pwn your webapp. Parsing HTML with regex summons tainted souls into the realm of the living. HTML and regex go together like love, marriage, and ritual infanticide. The <center> cannot hold it is too late. The force of regex and HTML together in the same conceptual space will destroy your mind like so much watery putty. If you parse HTML with regex you are giving in to Them and their blasphemous ways which doom us all to inhuman toil for the One whose Name cannot be expressed in the Basic Multilingual Plane, he comes. HTML-plus-regexp will liquify the nerves of the sentient whilst you observe, your psyche withering in the onslaught of horror. Rege̿̔̉x-based HTML parsers are the cancer that is killing StackOverflow it is too late it is too late we cannot be saved the trangession of a chi͡ld ensures regex will consume all living tissue (except for HTML which it cannot, as previously prophesied) dear lord help us how can anyone survive this scourge using regex to parse HTML has doomed humanity to an eternity of dread torture and security holes using regex as a tool to process HTML establishes a breach between this world and the dread realm of c͒ͪo͛ͫrrupt entities (like SGML entities, but more corrupt) a mere glimpse of the world of regex parsers for HTML will instantly transport a programmer's consciousness into a world of ceaseless screaming, he comes, the pestilent slithy regex-infection will devour your HTML parser, application and existence for all time like Visual Basic only worse he comes he comes do not fight he com̡e̶s, ̕h̵is un̨ho͞ly radiańcé destro҉ying all enli̍̈́̂̈́ghtenment, HTML tags lea͠ki̧n͘g fr̶ǫm ̡yo͟ur eye͢s̸ ̛l̕ik͏e liquid pain, the song of re̸gular expression parsing will extinguish the voices of mortal man from the sphere I can see it can you see ̲͚̖͔̙î̩́t̲͎̩̱͔́̋̀ it is beautiful the final snuffing of the lies of Man ALL IS LOŚ͖̩͇̗̪̏̈́T ALL IS LOST the pon̷y he comes he c̶̮omes he comes the ichor permeates all MY FACE MY FACE ᵒh god no NO NOO̼OO NΘ stop the an*̶͑̾̾̅ͫ͏̙̤g͇̫͛͆̾ͫ̑͆l͖͉̗̩̳̟̍ͫͥͨe̠̅s ͎a̧͈͖r̽̾̈́͒͑e not rè̑ͧ̌aͨl̘̝̙̃ͤ͂̾̆ ZA̡͊͠͝LGΌ ISͮ̂҉̯͈͕̹̘̱ TO͇̹̺ͅƝ̴ȳ̳ TH̘Ë͖́̉ ͠P̯͍̭O̚N̐Y̡ H̸̡̪̯ͨ͊̽̅̾̎Ȩ̬̩̾͛ͪ̈́̀́͘ ̶̧̨̱̹̭̯ͧ̾ͬC̷̙̲̝͖ͭ̏ͥͮ͟Oͮ͏̮̪̝͍M̲̖͊̒ͪͩͬ̚̚͜Ȇ̴̟̟͙̞ͩ͌͝S̨̥̫͎̭ͯ̿̔̀ͅ
The Forced Resurrection of Threads
The Forced Resurrection of Lisp Machines
The Forced Redemption of Mankind
The forced insertion of the penis.
The Forced Reevaluation of Life Decisions leading to me reading >>7.
The Forced Indentation Of Code
The Forced Resumption Of Memes
>>> print ((lambda Y, xjoin, n, s: (lambda z: Y (xjoin) (n, lambda k: Y (xjoin) (n - 1 - k, lambda x: z + ' ', '') + Y (xjoin) (2 * k + 1, lambda x: s, ' '), '\n')) (Y (xjoin) (len (s), lambda x: ' ', ''))) (lambda f: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args))), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), 7, "memes"))
memes
memes memes memes
memes memes memes memes memes
memes memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes memes memes memes memes
>>> The Forced Indentation Of Code
The Forced Resumption Of Memes
scheme@(guile-user)> (display ((lambda (rec xjoin n s) ((lambda (z) (rec xjoin (- (* 2 n) 1) (lambda (k) (string-append (rec xjoin (- (* 2 n) 1) (lambda (j) (if (< (abs (- n 1 j)) (- n 1 (abs (- n 1 k)))) z s)) " ") "\n")) "")) (rec xjoin (string-length s) (lambda (k) " ") ""))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep) (if (<= n 0) "" (if (= n 1) (fun 0) (string-append (self self (- n 1) fun sep) sep (fun (- n 1)))))) 7 "memes"))
memes memes memes memes memes memes memes memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes memes
memes memes memes memes memes memes memes memes
memes memes memes memes memes memes
memes memes memes memes
memes memes
memes memes memes memes
memes memes memes memes memes memes
memes memes memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes memes memes memes memes
scheme@(guile-user)> The Forced Indentation Of Code
The Forced Resumption Of Memes
>> console.log (((self, xjoin, pred, n, s) => (z => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (2 * n - 1, " ", j => pred (n, k, j) ? s : z))) (self (xjoin) (s.length, "", k => " "))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (abs => (n, k, j) => ((k, j) => ((kev, jev) => kev ? jev || j < k : jev && j > k) (k % 2 == 0, j % 2 == 0)) (abs (n - 1 - k), abs (n - 1 - j))) (Math.abs), 7, "memes"))
memes memes memes memes memes memes memes memes memes memes memes memes memes
memes memes
memes memes memes memes memes memes memes memes memes memes memes
memes memes memes memes
memes memes memes memes memes memes memes memes memes
memes memes memes memes memes memes
memes memes memes memes memes memes memes
memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes
memes memes memes memes
memes memes memes memes memes memes memes memes memes memes memes
memes memes
memes memes memes memes memes memes memes memes memes memes memes memes memes
<- undefined
>> Now do a spiral!
😵 The Spiraling Out of Hand of Memes 🐚
>> console.log (((self, xjoin, pred, patch, n, s) => (z => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (2 * n - 1, " ", j => (patch (n, k, j) ?? pred (n, k, j)) ? s : z))) (self (xjoin) (s.length, "", k => " "))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (abs => (n, k, j) => ((k, j) => ((kev, jev) => kev ? jev || j < k : jev && j > k) (k % 2 == 0, j % 2 == 0)) (abs (n - 1 - k), abs (n - 1 - j))) (Math.abs), (n, k, j) => (k > n - 1) || (j > n - 1) ? null : ((k, j) => k + 1 == j ? k % 2 == 0 : null) (n - 1 - k, n - 1 - j), 7, "memes"))
memes memes memes memes memes memes memes memes memes memes memes memes memes
memes
memes memes memes memes memes memes memes memes memes memes memes memes
memes memes memes
memes memes memes memes memes memes memes memes memes memes
memes memes memes memes memes
memes memes memes memes memes memes memes memes
memes memes memes memes memes memes
memes memes memes memes memes memes memes memes memes
memes memes memes memes
memes memes memes memes memes memes memes memes memes memes memes
memes memes
memes memes memes memes memes memes memes memes memes memes memes memes memes
<- undefined
>> 🔶 The Forced Indentation Of Code
🔷 The Forced Resumption Of Memes
>> console.log (((self, xjoin, pred, patch, n, s) => (z => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (2 * n - 1, "", j => (patch (n, k, j) ?? pred (n, k, j)) ? s : z))) (self (xjoin) (s.length, "", k => " "))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (abs => (n, k, j) => ((k, j) => (k + j) % 3 == 0) (abs (n - 1 - k), abs (n - 1 - j))) (Math.abs), (n, k, j) => null, 7, "memes"))
memes memes memes memes memes
memes memes memes memes
memes memes memes memes
memes memes memes memes memes
memes memes memes memes
memes memes memes memes
memes memes memes memes memes
memes memes memes memes
memes memes memes memes
memes memes memes memes memes
memes memes memes memes
memes memes memes memes
memes memes memes memes memes
<- undefined
>> What on earth is going on here.
🔷🔶🔷🔶🔷🔷🔶🔶🔶🔶🔶🔷🔷🔶🔷🔶🔷🔷🔶🔶🔶🔶🔶🔷🔷🔶🔶🔶🔶
🔶🔷🔶🔷🔶🔷🔶🔷🔷🔷🔷🔷🔶🔷🔶🔷🔶🔷🔶🔷🔷🔷🔷🔷🔶🔷🔷🔷🔷
🔶🔷🔶🔷🔶🔷🔶🔶🔶🔶🔷🔷🔶🔷🔶🔷🔶🔷🔶🔶🔶🔶🔷🔷🔷🔶🔶🔶🔷
🔶🔷🔷🔷🔶🔷🔶🔷🔷🔷🔷🔷🔶🔷🔷🔷🔶🔷🔶🔷🔷🔷🔷🔷🔷🔷🔷🔷🔶
🔶🔷🔷🔷🔶🔷🔶🔶🔶🔶🔶🔷🔶🔷🔷🔷🔶🔷🔶🔶🔶🔶🔶🔷🔶🔶🔶🔶🔷but with the meme combinator instead of meme loops. Feel free to contribute code.
🕳 The Forced Indentation Of Code
🕳 The Forced Resumption Of Memes
>>> print ((lambda Y, xjoin, size, pred, n, s: (lambda z, n, pred: Y (xjoin) (n, lambda k: Y (xjoin) (n, lambda j: s if pred (k, j) else z, ''), '\n')) (Y (xjoin) (len (s), lambda x: ' ', ''), size (n), Y (pred))) (lambda f: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args))), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), lambda n: 3 ** n, lambda f: lambda k, j: ((k == 0) or (j == 0)) or (not ((k % 3 == 1) and (j % 3 == 1)) and f (k // 3, j // 3)), 3, "me"))
mememememememememememememememememememememememememememe
me meme meme meme meme meme meme meme meme me
mememememememememememememememememememememememememememe
mememe memememememe memememememe mememe
me me me meme me me meme me me me
mememe memememememe memememememe mememe
mememememememememememememememememememememememememememe
me meme meme meme meme meme meme meme meme me
mememememememememememememememememememememememememememe
mememememememememe mememememememememe
me meme meme me me meme meme me
mememememememememe mememememememememe
mememe mememe mememe mememe
me me me me me me me me
mememe mememe mememe mememe
mememememememememe mememememememememe
me meme meme me me meme meme me
mememememememememe mememememememememe
mememememememememememememememememememememememememememe
me meme meme meme meme meme meme meme meme me
mememememememememememememememememememememememememememe
mememe memememememe memememememe mememe
me me me meme me me meme me me me
mememe memememememe memememememe mememe
mememememememememememememememememememememememememememe
me meme meme meme meme meme meme meme meme me
mememememememememememememememememememememememememememe
>>> Where's the code for the forced insertion of penis?
>>18
That's in the penal code.
hell yeah son
◢◣ pointwise cartesian Sierpinski triangle with customized Y combinator ◢◣
>>> print ((lambda mY, xjoin, size, half, cell, boot, n, E, L, R: (lambda xjoin, cell, char, n: xjoin (n, lambda k: xjoin (2 * n, lambda j: char (boot (cell, n, k, j)), ''), '\n')) (mY (xjoin), mY (cell, mY (half)), lambda c: E if c == 0 else L if c < 0 else R, size (n))) (lambda f, *more: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args), *more)), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), lambda n: 2 ** n, lambda f: lambda n, p: p >> 1 if p > n else f (n, p << 1), lambda f, half: lambda lr, k, j: 0 if j > k else lr if k == 0 else (lambda h: f (-lr, k - h, h - 1 - j) if j < h else f (lr, k - h, j - h)) (half (k, 2)), lambda cell, n, k, j: cell (-1, k, n - 1 - j) if j < n else cell (1, k, j - n), 5, " ", "◢", "◣"))
◢◣
◢◣◢◣
◢◣ ◢◣
◢◣◢◣◢◣◢◣
◢◣ ◢◣
◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣
◢◣ ◢◣
◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣
◢◣ ◢◣
◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣
>>> Λ crude lambda counts λ
$ wget -O 22.html 'https://textboard.org/prog/22'
$ f () { gawk -v "id=$1" '/ id="t[0-9]+p[0-9]+"/ { if (keep) { keep = 0 } else { match ($0, / id="t[0-9]+p([0-9]+)"/, a); keep = a [1] == id } } keep == 1' "$2" | grep -E -oe '\blambda | => ' | wc -l; }
$ g () { for k in $1; do printf '%3d %3d\n' $k $(f $k "$2"); done; }
$ g '9 10 11 13 14 17 21' 22.html
9 12
10 7
11 13
13 15
14 13
17 14
21 18
$ This thread humiliates me.
Switched the guile xjoin to tail-recursive. The Bs are in columns since they divide the line length. The Fs are on receding diagonals since their multiple is one below the line length.
scheme@(guile-user)> (display ((lambda (rec xjoin empty pad n spec) ((lambda (xjoin) ((lambda (pad fb) ((lambda (cell) (xjoin n (lambda (k) (string-append (xjoin n (lambda (j) (cell (+ (* n k) j 1))) " ") "\n")) "")) (lambda (n) (pad (empty (fb n) n))))) (lambda (s) (if (>= (string-length s) pad) s (string-append (xjoin (- pad (string-length s)) (lambda (k) " ") "") s))) (lambda (n) (xjoin (vector-length spec) (lambda (k) (if (= (remainder n (car (vector-ref spec k))) 0) (cadr (vector-ref spec k)) "")) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (s n) (if (= (string-length s) 0) (number->string n) s)) 2 10 #((3 "F") (5 "B"))))
1 2 F 4 B F 7 8 F B
11 F 13 14 FB 16 17 F 19 B
F 22 23 F B 26 F 28 29 FB
31 32 F 34 B F 37 38 F B
41 F 43 44 FB 46 47 F 49 B
F 52 53 F B 56 F 58 59 FB
61 62 F 64 B F 67 68 F B
71 F 73 74 FB 76 77 F 79 B
F 82 83 F B 86 F 88 89 FB
91 92 F 94 B F 97 98 F B
scheme@(guile-user)> Since comparison operators in scheme are plain procedures rather than syntax, they can be passed around as needed and output by other expressions.
scheme@(guile-user)> (display ((lambda (rec xjoin pred n s) ((lambda (xjoin) ((lambda (z) (xjoin (* 2 n) (lambda (k) (string-append (xjoin (* 2 n) (lambda (j) (if (pred n k j) s z)) " ") "\n")) "")) (xjoin (string-length s) (lambda (k) " ") ""))) (lambda (n fun sep) (rec xjoin n fun sep "")))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) ((lambda (split) (lambda (n k j) (apply (lambda (k up j left) ((if (eq? up left) >= <=) k j)) `(,@(split n k) ,@(split n j))))) (lambda (n x) (if (< x n) `(,(- n 1 x) #t) `(,(- x n) #f)))) 8 "wind"))
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
wind wind wind wind wind wind wind wind wind
scheme@(guile-user)> scheme@(guile-user)> ((λ (a) (let ((A (λ (n) (modulo n a))) (B (λ (n) (floor (/ n a)))) (M (floor (/ a 2)))) (for-each (λ (n) (display (if (or (= (A n) M) (= (B n) M) (and (= (A n) 0) (<= (B n) M)) (and (= (A n) (- a 1)) (> (B n) M)) (and (= (B n) 0) (>= (A n) M)) (and (= (B n) (- a 1)) (< (A n) M))) "lol" " ")) (if (= (modulo n a) (- a 1)) (newline) (display " "))) (iota (* a a))))) 15)
lol lol lol lol lol lol lol lol lol
lol lol
lol lol
lol lol
lol lol
lol lol
lol lol
lol lol lol lol lol lol lol lol lol lol lol lol lol lol lol
lol lol
lol lol
lol lol
lol lol
lol lol
lol lol
lol lol lol lol lol lol lol lol lol>>26
💡 using looping construct in the meme thread
💡 modulo in the newline condition instead of A
💡 manually matching the empty cell length to "lol"
💡 10 conditions instead of reflecting the coordinates around the center
💡 repeated calls to (A n) and (B n) instead of let*
💡 using assignment at all in the meme thread
💡🤡🤡🤡🤡🤡🤡💡💡💡🤡🤡💡🤡🤡🤡🤡
💡🤡🤡🤡🤡🤡💡🤡🤡🤡💡🤡💡🤡🤡🤡🤡
💡🤡🤡🤡🤡🤡💡🤡🤡🤡💡🤡💡🤡🤡🤡🤡
💡🤡🤡🤡🤡🤡💡🤡🤡🤡💡🤡💡🤡🤡🤡🤡
💡💡💡💡💡🤡🤡💡💡💡🤡🤡💡💡💡💡💡┌─┐ pointwise Hilbert curve with the same >>21 custom Y combinator └─┘
>>> print ((lambda mY, xjoin, size, getch, patch, cell, expand, cellx, celly, cells, chars, start, n: (lambda xjoin, cell, n, symbol: (lambda boot: xjoin (celly * n, lambda k: xjoin (cellx * n, lambda j: boot (n, k, j), ''), '\n')) (lambda n, k, j: (lambda dk, mk, dj, mj: (lambda cin, key, cout: symbol (cin, key, cout, mk, mj)) (* cell (start [0], start [1 : 3], start [3], dk, dj, n >> 1))) (* (divmod (k, celly) + divmod (j, cellx))))) (mY (xjoin), mY (cell, expand, patch), size (n), lambda cin, key, cout, dk, dj: (lambda idx: (lambda key: getch (chars, patch (key [0], cin, cout) + key [1])) (cells [key] [idx : idx + 2])) (2 * (cellx * dk + dj)))) (lambda f, *more: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args), *more)), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), lambda n: 2 ** n, lambda chars, key: chars.get (key) or chars [key [::-1]], lambda ch, cin, cout: cin if ch == 'i' else cout if ch == 'o' else ch, lambda f, expand, patch: lambda cin, key, cout, k, j, n: (cin, key, cout) if n == 0 else (lambda dk, mk, dj, mj: (lambda idx: (lambda iko: f (patch (iko [0], cin, cout), iko [1 : 3], patch (iko [3], cin, cout), mk, mj, n >> 1)) (expand [key] [idx : idx + 4])) (4 * (2 * dk + dj))) (* (divmod (k, n) + divmod (j, n))), {"nw": "ewnosnwwiesewnwn", "wn": "snwoisesewnnnwnw", "es": "sesewessinwnnseo", "se": "esesiwnwnseeweso"}, 3, 2, {"nw": "oeewswieewnw", "wn": "os isneewnw", "es": "seewswin on", "se": "esewiwneewow"}, {"ns": '│', "ne": '└', "nw": '┘', "se": '┌', "sw": '┐', "ew": '─', " ": ' '}, "nwnw", 3))
──┐┌──┐ ┌──┐┌──┐ ┌──┐┌─┘
┌─┘└─┐└─┘┌─┘└─┐└─┘┌─┘└─┐
│ ┌┐ │┌─┐└─┐┌─┘┌─┐│ ┌┐ │
└─┘└─┘│ └──┘└──┘ │└─┘└─┘
┌─┐┌─┐│ ┌──┐┌──┐ │┌─┐┌─┐
│ └┘ │└─┘┌─┘└─┐└─┘│ └┘ │
└─┐┌─┘┌─┐└─┐┌─┘┌─┐└─┐┌─┘
┌─┘└──┘ └──┘└──┘ └──┘└─┐
│ ┌──┐┌──┐ ┌┐ ┌──┐┌──┐ │
└─┘┌─┘└─┐└─┘└─┘┌─┘└─┐└─┘
┌─┐└─┐┌─┘┌─┐┌─┐└─┐┌─┘┌─┐
│ └──┘└──┘ ││ └──┘└──┘ │
└─┐┌────┐┌─┘└─┐┌────┐┌─┘
┌─┘└─┐┌─┘└─┐┌─┘└─┐┌─┘└─┐
│ ┌┐ ││ ┌┐ ││ ┌┐ ││ ┌┐ │
└─┘└─┘└─┘└─┘└─┘└─┘└─┘└─┘
>>> level 4:
413 Request Entity Too Large
If you see vertical gaps:
dd pre { line-height: 1em; }
level 5: http://paste.textboard.org/af475455/raw
updated lambda counts >>22
$ g '9 10 11 13 14 17 21 24 25 28' 22.html
9 12
10 7
11 13
13 15
14 13
17 14
21 18
24 15
25 13
28 25├─┤ The Forced Indentation Of Maze Tiles
├─┤ The Forced Resumption Of Tile Mazes
>> console.log (((self, xjoin, symbol, tile, n) => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (4 * n - 1, "", j => symbol (tile, n, k, j)))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (mod => (tile, n, k, j) => tile [mod (k - n + 1, tile.length)] [mod (j - 2 * n + 1, tile [0].length)]) ((a, p) => ((a % p) + p) % p), ["───┤ ├──", " │ │ ", " │ │ │ │", " │ │", " ├─────┤", " │ │", " │ │ │ │", " │ │ "], 15))
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │
────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├────
│ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │
────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├────
│ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │
────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├────
│ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │
────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├─────┤ ├────
│ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
<- undefined
>>vertical gaps: >>28
Can we make a rule that all code posted must be in MIT Scheme?
Javascript hurts my eyes
>>31 /prog/ doesn't work like that and yes my eyes hurt too
>>31
First class functions and lexical scoping are sufficient characteristics, which the existing code adheres to. No looping constructs or assignments are merely recommended characteristics, which all but >>26 follow.
㉈ binary tile version of >>30
>> console.log (((self, xjoin, pred, tile, tilex, s, n) => (z => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (2 * n - 1, "", j => pred (tile, tilex, n, k, j) ? s : z))) (self (xjoin) (s.length, "", k => " "))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (mod => (tile, tilex, n, k, j) => ((k, j) => tile [k] & (1 << (tilex - 1 - j))) (mod (k - n + 1, tile.length), mod (j - n + 1, tilex))) ((a, p) => ((a % p) + p) % p), [170, 130, 254, 130, 170, 40, 239, 40], 8, "me", 20))
me me me me me me me me me
memememememe mememememememe mememememememe mememememememe mememememememe
me me me me me me me me me
me me me me me me me me me me me me me me me me me me me
me me me me me me me me me me
meme mememememememe mememememememe mememememememe mememememememe memememe
me me me me me me me me me me
me me me me me me me me me me me me me me me me me me me
me me me me me me me me me
memememememe mememememememe mememememememe mememememememe mememememememe
me me me me me me me me me
me me me me me me me me me me me me me me me me me me me
me me me me me me me me me me
meme mememememememe mememememememe mememememememe mememememememe memememe
me me me me me me me me me me
me me me me me me me me me me me me me me me me me me me
me me me me me me me me me
memememememe mememememememe mememememememe mememememememe mememememememe
me me me me me me me me me
me me me me me me me me me me me me me me me me me me me
me me me me me me me me me me
meme mememememememe mememememememe mememememememe mememememememe memememe
me me me me me me me me me me
me me me me me me me me me me me me me me me me me me me
me me me me me me me me me
memememememe mememememememe mememememememe mememememememe mememememememe
me me me me me me me me me
me me me me me me me me me me me me me me me me me me me
me me me me me me me me me me
meme mememememememe mememememememe mememememememe mememememememe memememe
me me me me me me me me me me
me me me me me me me me me me me me me me me me me me me
me me me me me me me me me
memememememe mememememememe mememememememe mememememememe mememememememe
me me me me me me me me me
me me me me me me me me me me me me me me me me me me me
me me me me me me me me me me
meme mememememememe mememememememe mememememememe mememememememe memememe
me me me me me me me me me me
<- undefined
>>https://en.wikipedia.org/wiki/Sauwastika
The compact swastika can be seen as a chiral irregular icosagon (20-sided polygon) with fourfold (90°) rotational symmetry. Such a swastika proportioned on a 5 × 5 square grid and with the broken portions of its legs shortened by one unit can tile the plane by translation alone.
scheme@(guile-user)> (display ((lambda (rec xjoin reduce symbol home moves cell chars n) ((lambda (xjoin reduce cycle) ((lambda (chars) (xjoin (- (* 2 n) 1) (lambda (k) (string-append (xjoin (- (* 2 n) 1) (lambda (j) (symbol (reduce k j) chars cell cycle)) "") "\n")) "")) (xjoin (* cell cycle) (lambda (k) ((lambda (idx) (substring chars idx (+ idx 1))) (quotient k cell))) ""))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (k j) (rec reduce home moves (- k (- n 1)) (- j (- n 1)) 0)) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) ((lambda (done last move) (lambda (self home moves k j acc) (if (done k j) (+ acc (last home k j)) (apply (lambda (dk dj) (self self home moves (+ k dk) (+ j dj) (+ acc 1))) (vector-ref moves (move k j)))))) (lambda (k j) (and (<= -2 k) (<= k 2) (<= -2 j) (<= j 2))) (lambda (home k j) (if (logbit? (- 2 j) (vector-ref home (+ k 2))) 1 0)) (lambda (k j) (if (zero? k) (if (positive? j) 1 2) (if (zero? j) (if (positive? k) 0 3) (+ (if (positive? k) 0 1) (if (positive? j) 0 2)))))) (lambda (count chars cell cycle) ((lambda (idx) (substring chars idx (+ idx cell))) (* cell (modulo count cycle)))) #(19 26 0 11 25) #((-3 -2) (2 -3) (-2 3) (3 2)) 2 "█░" 10))
██░░░░░░░░░░████░░██░░██░░░░██████████
██░░██░░████░░░░░░░░░░████░░██░░██░░░░
██████░░░░██░░██░░████░░░░░░░░░░████░░
██░░░░██████████░░░░██░░██░░████░░░░░░
████░░██░░██░░░░██████████░░░░██░░██░░
░░░░░░░░░░████░░██░░██░░░░██████████░░
░░██░░████░░░░░░░░░░████░░██░░██░░░░██
████░░░░██░░██░░████░░░░░░░░░░████░░██
░░░░██████████░░░░██░░██░░████░░░░░░░░
██░░██░░██░░░░██████████░░░░██░░██░░██
░░░░░░░░████░░██░░██░░░░██████████░░░░
██░░████░░░░░░░░░░████░░██░░██░░░░████
██░░░░██░░██░░████░░░░░░░░░░████░░██░░
░░██████████░░░░██░░██░░████░░░░░░░░░░
░░██░░██░░░░██████████░░░░██░░██░░████
░░░░░░████░░██░░██░░░░██████████░░░░██
░░████░░░░░░░░░░████░░██░░██░░░░██████
░░░░██░░██░░████░░░░░░░░░░████░░██░░██
██████████░░░░██░░██░░████░░░░░░░░░░██
scheme@(guile-user)> pointwise generation by walking to the home position, for memes over efficiency
old vertical gaps: >>28
larger version cycling three colors to see the ring pattern: http://paste.textboard.org/e4345d14/raw
updated lambda counts >>22
$ g '9 10 11 13 14 17 21 24 25 28 30 34 35' 22.html
9 12
10 7
11 13
13 15
14 13
17 14
21 18
24 15
25 13
28 25
30 10
34 13
35 19
$ 😵😵 double spiral >>13 🐚🐚
>> console.log (((self, xjoin, pred, patch, n, s) => (z => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (2 * n - 1, " ", j => (patch (n, k, j) ?? pred (n, k, j)) ? s : z))) (self (xjoin) (s.length, "", k => " "))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (abs => (n, k, j) => ((k, j) => ((kev, jev) => kev ? jev || j < k : jev && j > k) (k % 2 == 0, j % 2 == 0)) (abs (n - 1 - k), abs (n - 1 - j))) (Math.abs), (abs => (n, k, j) => ((k == j + 1) && (k <= n - 1)) || ((k + 1 == j) && (k >= n - 1)) ? abs (n - 1 - k) % 2 == 0 : null) (Math.abs), 9, "rep"))
rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep
rep
rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep
rep rep rep
rep rep rep rep rep rep rep rep rep rep rep rep rep rep
rep rep rep rep rep
rep rep rep rep rep rep rep rep rep rep rep rep
rep rep rep rep rep rep rep
rep rep rep rep rep rep rep rep rep rep rep
rep rep rep rep rep rep rep
rep rep rep rep rep rep rep rep rep rep rep rep
rep rep rep rep rep
rep rep rep rep rep rep rep rep rep rep rep rep rep rep
rep rep rep
rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep
rep
rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep rep
<- undefined
>> Ident this! *whips out dick*
🐚🐚 double spiral >>37 with per-path characters 😵😵
>> console.log (((self, xjoin, vec, base, patch, pad, cell, chars, n) => (chars => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (2 * n - 1, pad, j => chars [patch (n, k, j) ?? base (n, k, j)]))) ((a => self (vec) (a.length - 1, a, s => self (xjoin) (cell, "", k => s))) ([...chars]))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (push => me => (n, vec, f) => n == 0 ? [f (vec [0])] : push (me (me) (n - 1, vec, f), f (vec [n]))) ((a, x) => (dis => a) (a.push (x))), (quart => (n, k, j) => (([ks, k], [js, j]) => ((k == 0) && (j == 0)) ? 4 : j <= k ? (k + 2 - ks) % 4 : (j + 2 + js) % 4) (quart (n, k), quart (n, j))) ((n, k) => k < n - 1 ? [-1, n - 1 - k] : [1, k - (n - 1)]), (n, k, j) => (k == j + 1) && (k <= n - 1) ? (n - 1 - k + 3) % 4 : (k + 1 == j) && (k >= n - 1) ? (k - (n - 1) + 1) % 4 : null, " ", 3, "-L+R:", 9))
RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR
+++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ RRR
LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL +++ RRR
LLL --- --- --- --- --- --- --- --- --- --- --- --- --- LLL +++ RRR
LLL --- RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR --- LLL +++ RRR
LLL --- RRR +++ +++ +++ +++ +++ +++ +++ +++ +++ RRR --- LLL +++ RRR
LLL --- RRR +++ LLL LLL LLL LLL LLL LLL LLL +++ RRR --- LLL +++ RRR
LLL --- RRR +++ LLL --- --- --- --- --- LLL +++ RRR --- LLL +++ RRR
LLL --- RRR +++ LLL --- RRR RRR ::: LLL LLL +++ RRR --- LLL +++ RRR
LLL --- RRR +++ LLL --- RRR +++ +++ +++ +++ +++ RRR --- LLL +++ RRR
LLL --- RRR +++ LLL --- RRR RRR RRR RRR RRR RRR RRR --- LLL +++ RRR
LLL --- RRR +++ LLL --- --- --- --- --- --- --- --- --- LLL +++ RRR
LLL --- RRR +++ LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL +++ RRR
LLL --- RRR +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ +++ RRR
LLL --- RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR RRR
LLL --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL LLL
<- undefined
>> pointwise generation without path walking, for efficiency over memes
larger version with colors to see the winding pattern: http://paste.textboard.org/226f0704/raw
Draw something on pixelcanvas.
Erischan has an innovative new feature that you might like: https://erischan.org/aes/res/647.html
wall of memes
>> console.log (((self, xjoin, symbol, tile, n) => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (4 * n - 1, "", j => symbol (tile, n, k, j)))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (mod => (tile, n, k, j) => tile [mod (k - n + 1, tile.length)] [mod (j - 2 * n + 1, tile [0].length)]) ((a, p) => ((a % p) + p) % p), ["memes║", "══╦══╩", "es║mem", "══╩══╦"], 10))
╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══
║memes║memes║memes║memes║memes║memes║me
╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══
mes║memes║memes║memes║memes║memes║memes
╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══
║memes║memes║memes║memes║memes║memes║me
╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══
mes║memes║memes║memes║memes║memes║memes
╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══
║memes║memes║memes║memes║memes║memes║me
╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══
mes║memes║memes║memes║memes║memes║memes
╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══
║memes║memes║memes║memes║memes║memes║me
╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══
mes║memes║memes║memes║memes║memes║memes
╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══
║memes║memes║memes║memes║memes║memes║me
╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══╦══╩══
<- undefined
>> using the generic tile support from >>30
old vertical gaps: >>28
>>40
I won't be posting that in this thread, but feel free to make a dedicated thread and post the first working example yourself, after which I'll participate.
wall of memes >>42 stacked the wrong way
>> console.log (((self, xjoin, symbol, tile, n) => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (4 * n - 1, "", j => symbol (tile, n, k, j)))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (mod => (tile, n, k, j) => tile [mod (k - n + 1, tile.length)] [mod (j - 2 * n + 1, tile [0].length)]) ((a, p) => ((a % p) + p) % p), ["memes╠═════╣", "═════╣memes╠"], 10))
╣memes╠═════╣memes╠═════╣memes╠═════╣me
╠═════╣memes╠═════╣memes╠═════╣memes╠══
╣memes╠═════╣memes╠═════╣memes╠═════╣me
╠═════╣memes╠═════╣memes╠═════╣memes╠══
╣memes╠═════╣memes╠═════╣memes╠═════╣me
╠═════╣memes╠═════╣memes╠═════╣memes╠══
╣memes╠═════╣memes╠═════╣memes╠═════╣me
╠═════╣memes╠═════╣memes╠═════╣memes╠══
╣memes╠═════╣memes╠═════╣memes╠═════╣me
╠═════╣memes╠═════╣memes╠═════╣memes╠══
╣memes╠═════╣memes╠═════╣memes╠═════╣me
╠═════╣memes╠═════╣memes╠═════╣memes╠══
╣memes╠═════╣memes╠═════╣memes╠═════╣me
╠═════╣memes╠═════╣memes╠═════╣memes╠══
╣memes╠═════╣memes╠═════╣memes╠═════╣me
╠═════╣memes╠═════╣memes╠═════╣memes╠══
╣memes╠═════╣memes╠═════╣memes╠═════╣me
╠═════╣memes╠═════╣memes╠═════╣memes╠══
╣memes╠═════╣memes╠═════╣memes╠═════╣me
<- undefined
>> Would you mind VIP'ing your posts?
Would you mind VIP'ing your posts?
tower of memel
>>> print ((lambda mY, xjoin, pred, s, n: (lambda xjoin: (lambda z: xjoin (2 * n - 1, lambda k: xjoin (2 * n - 1, lambda j: s if pred (n, k, j) else z, ''), '\n')) (xjoin (len (s), lambda x: ' ', ''))) (mY (xjoin))) (lambda f, *more: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args), *more)), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), (lambda side, fold, diag: lambda n, k, j: (lambda k, j: side (k, j) or side (j, k) or fold (k, j) or fold (j, k) or diag (k, j)) (abs (n - 1 - k), abs (n - 1 - j))) (lambda k, j: (k % 2 == 1) and (j <= k - 2), lambda k, j: (k == j + 1) and (j % 2 == 1), lambda k, j: (k == j) and (k % 2 == 1)), "me", 10))
me mememememememememememememememe me
me me
mememe mememememememememememe mememe
me me me me
me mememe mememememememe mememe me
me me me me me me
me me mememe mememe mememe me me
me me me me me me me me
me me me mememe mememe me me me
me me me me me me me me
me me me mememe mememe me me me
me me me me me me me me
me me mememe mememe mememe me me
me me me me me me
me mememe mememememememe mememe me
me me me me
mememe mememememememememememe mememe
me me
me mememememememememememememememe me
>>> top-down view
what the fuck
>>47 outsider
per-layer characters for >>46
>>> print ((lambda mY, xjoin, level, symbol, cell, E, chars, n: (lambda xjoin, cycle: (lambda chars, E: (lambda symbol: xjoin (2 * n - 1, lambda k: xjoin (2 * n - 1, lambda j: symbol (level (n, k, j)), ''), '\n')) (lambda key: symbol (key, cell, E, chars, cycle))) (xjoin (cell * cycle, lambda x: chars [x // cell], ''), xjoin (cell, lambda x: E, ''))) (mY (xjoin), len (chars))) (lambda f, *more: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args), *more)), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), (lambda side, fold, diag: lambda n, k, j: (lambda k, j: (side (k, j) or side (j, k) or fold (k, j) or fold (j, k) or diag (k, j)) - 1) (abs (n - 1 - k), abs (n - 1 - j))) (lambda k, j: (k - 1) // 2 if (k % 2 == 1) and (j <= k - 2) else 0, lambda k, j: (j + 1) // 2 if (k == j + 1) and (j % 2 == 1) else 0, lambda k, j: (k + 1) // 2 if (k == j) and (k % 2 == 1) else 0), lambda key, cell, E, chars, cycle: E if key < 0 else (lambda idx: chars [idx : idx + cell]) (key % cycle * cell), 2, " ", "▓▒░▒", 10))
▓▓ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▓▓
▒▒ ▒▒
▒▒▒▒▒▒ ░░░░░░░░░░░░░░░░░░░░░░ ▒▒▒▒▒▒
▒▒ ░░ ░░ ▒▒
▒▒ ░░░░░░ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ░░░░░░ ▒▒
▒▒ ░░ ▒▒ ▒▒ ░░ ▒▒
▒▒ ░░ ▒▒▒▒▒▒ ▓▓▓▓▓▓ ▒▒▒▒▒▒ ░░ ▒▒
▒▒ ░░ ▒▒ ▓▓ ▓▓ ▒▒ ░░ ▒▒
▒▒ ░░ ▒▒ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▒▒ ░░ ▒▒
▒▒ ░░ ▒▒ ▓▓ ▓▓ ▒▒ ░░ ▒▒
▒▒ ░░ ▒▒ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▒▒ ░░ ▒▒
▒▒ ░░ ▒▒ ▓▓ ▓▓ ▒▒ ░░ ▒▒
▒▒ ░░ ▒▒▒▒▒▒ ▓▓▓▓▓▓ ▒▒▒▒▒▒ ░░ ▒▒
▒▒ ░░ ▒▒ ▒▒ ░░ ▒▒
▒▒ ░░░░░░ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ░░░░░░ ▒▒
▒▒ ░░ ░░ ▒▒
▒▒▒▒▒▒ ░░░░░░░░░░░░░░░░░░░░░░ ▒▒▒▒▒▒
▒▒ ▒▒
▓▓ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▓▓
>>> larger version with colors: http://paste.textboard.org/1c49afd4/raw
I agree with >>47, this has gone too far. Get your own blog.
>>47
Don't get your own blog under any circumstances.
I agree with >>51, blogs are the original sin.
upgrade of the Sierpinski carpet >>17 with the custom >>21 Y combinator and a coordinate painting function
>>> print ((lambda mY, xjoin, size, pred, symbol, index, n, cell, E, chars: (lambda n, cycle, xjoin, pred: (lambda E, chars: (lambda symbol: xjoin (n, lambda k: xjoin (n, lambda j: symbol (k, j), ''), '\n')) (lambda k, j: symbol (index (k, j), cell, cycle, chars) if pred (k, j) else E)) (xjoin (cell, lambda x: E, ''), xjoin (cell * cycle, lambda x: chars [x // cell], ''))) (size (n), len (chars), mY (xjoin), mY (pred))) (lambda f, *more: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args), *more)), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), lambda n: 3 ** n, lambda f: lambda k, j: ((k == 0) or (j == 0)) or (not ((k % 3 == 1) and (j % 3 == 1)) and f (k // 3, j // 3)), lambda idx, cell, cycle, chars: (lambda idx: chars [idx : idx + cell]) (idx % cycle * cell), lambda k, j: k + j, 3, 2, " ", "█▓▒░▒▓"))the output takes the post over the 413 Request Entity Too Large limit so it goes up separately
larger version with colors: http://paste.textboard.org/904316a1/raw
credit for the pattern: https://leftychan.net/meta/res/979.html#10617
██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒
▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░
▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒
░░▒▒▓▓ ░░▒▒▓▓██▓▓▒▒ ██▓▓▒▒░░▒▒▓▓ ░░▒▒▓▓
▒▒ ██ ▒▒ ██▓▓ ░░ ▓▓ ░░▒▒ ██ ▒▒ ██
▓▓██▓▓ ▓▓██▓▓▒▒░░▒▒ ▒▒░░▒▒▓▓██▓▓ ▓▓██▓▓
██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒
▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░
▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒
░░▒▒▓▓██▓▓▒▒░░▒▒▓▓ ░░▒▒▓▓██▓▓▒▒░░▒▒▓▓
▒▒ ██▓▓ ░░▒▒ ██ ▒▒ ██▓▓ ░░▒▒ ██
▓▓██▓▓▒▒░░▒▒▓▓██▓▓ ▓▓██▓▓▒▒░░▒▒▓▓██▓▓
██▓▓▒▒ ██▓▓▒▒ ██▓▓▒▒ ██▓▓▒▒
▓▓ ░░ ▓▓ ░░ ▓▓ ░░ ▓▓ ░░
▒▒░░▒▒ ▒▒░░▒▒ ▒▒░░▒▒ ▒▒░░▒▒
░░▒▒▓▓██▓▓▒▒░░▒▒▓▓ ░░▒▒▓▓██▓▓▒▒░░▒▒▓▓
▒▒ ██▓▓ ░░▒▒ ██ ▒▒ ██▓▓ ░░▒▒ ██
▓▓██▓▓▒▒░░▒▒▓▓██▓▓ ▓▓██▓▓▒▒░░▒▒▓▓██▓▓
██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒
▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░
▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒
░░▒▒▓▓ ░░▒▒▓▓██▓▓▒▒ ██▓▓▒▒░░▒▒▓▓ ░░▒▒▓▓
▒▒ ██ ▒▒ ██▓▓ ░░ ▓▓ ░░▒▒ ██ ▒▒ ██
▓▓██▓▓ ▓▓██▓▓▒▒░░▒▒ ▒▒░░▒▒▓▓██▓▓ ▓▓██▓▓
██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒
▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░▒▒ ██▓▓ ░░
▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒zigzag meme traversal
scheme@(guile-user)> (display ((lambda (rec xjoin pred s separ step lines columns) ((lambda (xjoin lines columns bottom right) ((lambda (z pred) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (if (pred k j) s z)) separ) "\n")) "")) (xjoin (string-length s) (lambda (k) " ") "") ((lambda (lines columns) (lambda (k j) (pred step lines columns bottom right k j))) (- lines 1) (- columns 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ 1 (* step lines)) (+ 1 (* step columns)) (if (even? lines) odd? even?) (if (odd? columns) odd? even?))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) ((lambda (test) (lambda (step lines columns bottom right k j) (or (zero? (modulo (+ k j) step)) (test step j even? k 0) (test step k odd? j 0) (test step j bottom k lines) (test step k right j columns)))) (lambda (step var test fix limit) (and (= fix limit) (test (quotient var step))))) "me" "" 3 6 12))
memememe memememe memememe memememe memememe memememe me
me me me me me me me me me me me meme
me me me me me me me me me me me me me
me me me me me me me me me me me me me
me me me me me me me me me me me me me
meme me me me me me me me me me me me
me me me me me me me me me me me me me
me me me me me me me me me me me meme
me me me me me me me me me me me me me
me me me me me me me me me me me me me
me me me me me me me me me me me me me
meme me me me me me me me me me me me
me me me me me me me me me me me me me
me me me me me me me me me me me meme
me me me me me me me me me me me me me
me me me me me me me me me me me me me
me me me me me me me me me me me me me
meme me me me me me me me me me me me
me memememe memememe memememe memememe memememe memememe
scheme@(guile-user)> updated lambda counts >>22
$ g '9 10 11 13 14 17 21 24 25 28 30 34 35 37 39 42 43 46 49 53 55' 22.html
9 12
10 7
11 13
13 15
14 13
17 14
21 18
24 15
25 13
28 25
30 10
34 13
35 19
37 15
39 21
42 10
43 10
46 18
49 23
53 21
55 14
$ >>55
Changing offset makes some animation.
switched the lambda counter >>22 to property extractors, added language prompt
>> console.log (((id2code, extractors, formatters, thread, magic) => magic.split (" ").map (id => [id, id2code (thread, id)]).filter (p => p [1] !== null).map (([id, code]) => (text => id.padStart (3, " ") + " " + extractors.map (ex => formatters [ex ["format"]] (ex ["fun"] (text), ex ["fmthow"])).join (" ")) (code.innerText)).join ("\n")) ((thread, id) => document.getElementById ("t" + thread + "p" + id).parentNode.nextElementSibling.querySelector ("code"), [{"fun": s => [...s.matchAll (/\blambda | => /g)].length, "format": "right", "fmthow": {"length": 3, "pad": " "}}, {"fun": s => (m => m ? m [0] : "?") (s.match (/^(>>> |>> |scheme@\(guile-user\)> )/m)), "format": "id", "fmthow": null}], {"id": (x, how) => x, "right": (x, how) => x.toString ().padStart (how ["length"], how ["pad"])}, 22, "9 10 11 13 14 17 21 24 25 28 30 34 35 37 39 42 43 46 49 53 55"))
9 12 >>>
10 7 scheme@(guile-user)>
11 13 >>
13 15 >>
14 13 >>
17 14 >>>
21 18 >>>
24 15 scheme@(guile-user)>
25 13 scheme@(guile-user)>
28 25 >>>
30 10 >>
34 13 >>
35 19 scheme@(guile-user)>
37 15 >>
39 21 >>
42 10 >>
43 10 >>
46 18 >>>
49 23 >>>
53 21 >>>
55 14 scheme@(guile-user)>
<- undefined
>> upgrade of >>55 with a coordinate painting function
scheme@(guile-user)> (display ((lambda (rec xjoin pred symbol index cell E chars band separ step lines columns) ((lambda (xjoin lines columns bottom right cycle) ((lambda (E chars pred) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) separ) "\n")) "")) (lambda (k j) (if (pred k j) E (symbol chars cell cycle (index band k j)))))) (xjoin cell (lambda (k) E) "") (xjoin (* cell cycle) (lambda (x) ((lambda (idx) (substring chars idx (+ idx 1))) (quotient x cell))) "") ((lambda (lines columns) (lambda (k j) (pred step lines columns bottom right k j))) (- lines 1) (- columns 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ 1 (* step lines)) (+ 1 (* step columns)) (if (even? lines) odd? even?) (if (odd? columns) odd? even?) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) ((lambda (test) (lambda (step lines columns bottom right k j) (or (zero? (modulo (+ k j) step)) (test step j even? k 0) (test step k odd? j 0) (test step j bottom k lines) (test step k right j columns)))) (lambda (step var test fix limit) (and (= fix limit) (test (quotient var step))))) (lambda (chars cell cycle index) ((lambda (idx) (substring chars idx (+ idx cell))) (* cell (modulo index cycle)))) (lambda (band k j) (quotient j band)) 2 "❀" "░▒▓█▓▒" 3 "" 3 6 11))the output takes the post over the 413 Request Entity Too Large limit so it goes up separately
larger version with colors: http://paste.textboard.org/2651c14c/raw
this >>59 is 3903 bytes and gets 413, so here's a paste: http://paste.textboard.org/6c616dda/raw
smaller version
❀❀❀❀❀❀❀❀▒▒▒▒❀❀❀❀❀❀❀❀████❀❀❀❀❀❀❀❀▒▒▒▒❀❀❀❀❀❀❀❀▒▒▒▒❀❀❀❀❀❀❀❀████❀❀
░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓▓▓❀❀▒▒▒▒❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀❀❀
░░❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██▓▓❀❀▓▓▒▒❀❀▒▒░░❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██❀❀
❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓▓▓❀❀▒▒▒▒❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀
❀❀░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓▓▓❀❀▒▒▒▒❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓
❀❀❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██▓▓❀❀▓▓▒▒❀❀▒▒░░❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██▓▓
❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓▓▓❀❀▒▒▒▒❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀
░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓▓▓❀❀▒▒▒▒❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀❀❀
░░❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██▓▓❀❀▓▓▒▒❀❀▒▒░░❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██❀❀
❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓▓▓❀❀▒▒▒▒❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀
❀❀░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓▓▓❀❀▒▒▒▒❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓
❀❀❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██▓▓❀❀▓▓▒▒❀❀▒▒░░❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██▓▓
❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓▓▓❀❀▒▒▒▒❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀
░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀▓▓▓▓❀❀▒▒▒▒❀❀░░░░❀❀▒▒▒▒❀❀▓▓▓▓❀❀████❀❀❀❀
░░❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██▓▓❀❀▓▓▒▒❀❀▒▒░░❀❀░░▒▒❀❀▒▒▓▓❀❀▓▓██❀❀██❀❀
❀❀❀❀❀❀❀❀▒▒▒▒❀❀❀❀❀❀❀❀████❀❀❀❀❀❀❀❀▒▒▒▒❀❀❀❀❀❀❀❀▒▒▒▒❀❀❀❀❀❀❀❀████❀❀Scheme is a language for designing carpets.
That carpet looks pretty trippy on my phone!
Your phone would look pretty trippy on my carpet.
added longest line's length to the >>58 property extractors
>> console.log (((id2code, extractors, formatters, thread, magic) => magic.split (" ").map (id => [id, id2code (thread, id)]).filter (p => p [1] !== null).map (([id, code]) => (text => id.padStart (3, " ") + " " + extractors.map (ex => formatters [ex ["format"]] (ex ["fun"] (text), ex ["fmthow"])).join (" ")) (code.innerText)).join ("\n")) ((thread, id) => document.getElementById ("t" + thread + "p" + id).parentNode.nextElementSibling.querySelector ("code"), [{"fun": s => [...s.matchAll (/\blambda | => /g)].length, "format": "right", "fmthow": {"length": 3, "pad": " "}}, {"fun": (max => s => s.split ("\n").map (s => s.length).reduce ((acc, item) => max (acc, item), 0)) (Math.max), "format": "right", "fmthow": {"length": 5, "pad": " "}}, {"fun": s => (m => m ? m [0] : "?") (s.match (/^(>>> |>> |scheme@\(guile-user\)> )/m)), "format": "id", "fmthow": null}], {"id": (x, how) => x, "right": (x, how) => x.toString ().padStart (how ["length"], how ["pad"])}, 22, "9 10 11 13 14 17 21 24 25 28 30 34 35 37 39 42 43 46 49 53 55 59"))
9 12 391 >>>
10 7 461 scheme@(guile-user)>
11 13 483 >>
13 15 627 >>
14 13 471 >>
17 14 524 >>>
21 18 789 >>>
24 15 851 scheme@(guile-user)>
25 13 692 scheme@(guile-user)>
28 25 1599 >>>
30 10 508 >>
34 13 560 >>
35 19 1375 scheme@(guile-user)>
37 15 642 >>
39 21 909 >>
42 10 452 >>
43 10 444 >>
46 18 707 >>>
49 23 1070 >>>
53 21 873 >>>
55 14 1066 scheme@(guile-user)>
59 21 1475 scheme@(guile-user)>
<- undefined
>> upgrade of >>25 with a coordinate painting function
scheme@(guile-user)> (display ((lambda (rec xjoin index symbol band E cell chars separ n) ((lambda (xjoin cycle) ((lambda (E chars) ((lambda (symbol) (xjoin (* 2 n) (lambda (k) (string-append (xjoin (* 2 n) (lambda (j) (symbol k j)) separ) "\n")) "")) (lambda (k j) (symbol E chars cell cycle band (index n k j))))) (xjoin cell (lambda (x) E) "") (xjoin (* cell cycle) (lambda (x) ((lambda (idx) (substring chars idx (+ idx 1))) (quotient x cell))) ""))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) ((lambda (split) (lambda (n k j) (apply (lambda (k up j left) (if ((if (eq? up left) >= <=) k j) (+ k j) -1)) `(,@(split n k) ,@(split n j))))) (lambda (n x) (if (< x n) `(,(- n 1 x) #t) `(,(- x n) #f)))) (lambda (E chars cell cycle band index) (if (< index 0) E ((lambda (idx) (substring chars idx (+ idx cell))) (* cell (modulo (quotient index band) cycle))))) 1 " " 2 "█▓▒░▒▓" "" 11))
▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒ ▒▒
██▓▓▒▒░░▒▒▓▓██▓▓▒▒░░ ██▓▓
▒▒░░▒▒▓▓██▓▓▒▒░░▒▒ ▒▒▓▓██
▒▒▓▓██▓▓▒▒░░▒▒▓▓ ▒▒░░▒▒▓▓
██▓▓▒▒░░▒▒▓▓██ ██▓▓▒▒░░▒▒
▒▒░░▒▒▓▓██▓▓ ▒▒▓▓██▓▓▒▒░░
▒▒▓▓██▓▓▒▒ ▒▒░░▒▒▓▓██▓▓▒▒
██▓▓▒▒░░ ██▓▓▒▒░░▒▒▓▓██▓▓
▒▒░░▒▒ ▒▒▓▓██▓▓▒▒░░▒▒▓▓██
▒▒▓▓ ▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓
████▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒
▒▒░░▒▒▓▓██▓▓▒▒░░▒▒▓▓████
▓▓▒▒░░▒▒▓▓██▓▓▒▒░░▒▒ ▓▓▒▒
██▓▓▒▒░░▒▒▓▓██▓▓▒▒ ▒▒░░▒▒
▓▓██▓▓▒▒░░▒▒▓▓██ ░░▒▒▓▓██
▒▒▓▓██▓▓▒▒░░▒▒ ▒▒▓▓██▓▓▒▒
░░▒▒▓▓██▓▓▒▒ ▓▓██▓▓▒▒░░▒▒
▒▒░░▒▒▓▓██ ██▓▓▒▒░░▒▒▓▓██
▓▓▒▒░░▒▒ ▓▓▒▒░░▒▒▓▓██▓▓▒▒
██▓▓▒▒ ▒▒░░▒▒▓▓██▓▓▒▒░░▒▒
▓▓██ ░░▒▒▓▓██▓▓▒▒░░▒▒▓▓██
▒▒ ▒▒▓▓██▓▓▒▒░░▒▒▓▓██▓▓▒▒
scheme@(guile-user)> larger version with colors and wider bands: http://paste.textboard.org/0956d33d/raw
removed fixed column widths, added autosizing columns, added incipient sorting support on the numeric columns >>64
>> console.log (((id2code, extractors, formatters, pads, stringify, layout, sort, thread, magic) => ((table, aligns, strs) => layout (stringify (sort (table), strs, formatters), aligns, pads)) (magic.split (" ").map (id => [id, id2code (thread, id)]).filter (p => p [1] !== null).map (([id, code], index) => (text => [index + 1, parseInt (id, 10)].concat (extractors.map (ex => ex ["fun"] (text)))) (code.innerText)), ["right", "right"].concat (extractors.map (ex => ex ["align"])), ["tostring", "tostring"].concat (extractors.map (ex => ex ["str"])))) ((thread, id) => document.getElementById ("t" + thread + "p" + id).parentNode.nextElementSibling.querySelector ("code"), [{"fun": s => [...s.matchAll (/\blambda | => /g)].length, "align": "right", "str": "tostring"}, {"fun": (max => s => s.split ("\n").reduce ((acc, item) => max (acc, item.length), 0)) (Math.max), "align": "right", "str": "tostring"}, {"fun": s => (m => m ? m [0] : "?") (s.match (/^(>>> |>> |scheme@\(guile-user\)> )/m)), "align": "left", "str": "id"}], {"id": x => x, "tostring": x => x.toString ()}, {"left": (s, n, pad) => s.padEnd (n, pad), "right": (s, n, pad) => s.padStart (n, pad)}, (rows, how, formatters) => rows.map (r => r.map ((c, index) => formatters [how [index]] (c))), (lengths => (rows, how, pads) => (lengths => rows.map (r => r.map ((c, index) => pads [how [index]] (c, lengths [index], " ")).join (" ")).join ("\n")) (lengths (rows))) ((max => rows => rows.reduce ((acc, r) => acc.map ((a, index) => max (a, r [index].length)), rows [0].map (x => 0))) (Math.max)), (column => table => table.sort ((a, b) => a [column] - b [column])) (0), 22, "9 10 11 13 14 17 21 24 25 28 30 34 35 37 39 42 43 46 49 53 55 59 65"))
1 9 12 391 >>>
2 10 7 461 scheme@(guile-user)>
3 11 13 483 >>
4 13 15 627 >>
5 14 13 471 >>
6 17 14 524 >>>
7 21 18 789 >>>
8 24 15 851 scheme@(guile-user)>
9 25 13 692 scheme@(guile-user)>
10 28 25 1599 >>>
11 30 10 508 >>
12 34 13 560 >>
13 35 19 1375 scheme@(guile-user)>
14 37 15 642 >>
15 39 21 909 >>
16 42 10 452 >>
17 43 10 444 >>
18 46 18 707 >>>
19 49 23 1070 >>>
20 53 21 873 >>>
21 55 14 1066 scheme@(guile-user)>
22 59 21 1475 scheme@(guile-user)>
23 65 19 1110 scheme@(guile-user)>
<- undefined
>> While the structure of the Hilbert >>28 and Peano curves is different, the structure of their structure is the same, and to underscore this point the only changes are in the constants used by the lambdas.
>>> print ((lambda mY, xjoin, size, getch, patch, cell, expand, cellx, celly, cells, chars, start, n: (lambda xjoin, cell, n, symbol: (lambda boot: xjoin (celly * n, lambda k: xjoin (cellx * n, lambda j: boot (n, k, j), ''), '\n')) (lambda n, k, j: (lambda dk, mk, dj, mj: (lambda cin, key, cout: symbol (cin, key, cout, mk, mj)) (* cell (start [0], start [1 : 3], start [3], dk, dj, n // 3))) (* (divmod (k, celly) + divmod (j, cellx))))) (mY (xjoin), mY (cell, expand, patch), size (n), lambda cin, key, cout, dk, dj: (lambda idx: (lambda key: getch (chars, patch (key [0], cin, cout) + key [1])) (cells [key] [idx : idx + 2])) (2 * (cellx * dk + dj)))) (lambda f, *more: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args), *more)), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), lambda n: 3 ** n, lambda chars, key: chars.get (key) or chars [key [::-1]], lambda ch, cin, cout: cin if ch == 'i' else cout if ch == 'o' else ch, lambda f, expand, patch: lambda cin, key, cout, k, j, n: (cin, key, cout) if n == 0 else (lambda dk, mk, dj, mj: (lambda idx: (lambda iko: f (patch (iko [0], cin, cout), iko [1 : 3], patch (iko [3], cin, cout), mk, mj, n // 3)) (expand [key] [idx : idx + 4])) (4 * (3 * dk + dj))) (* (divmod (k, n) + divmod (j, n))), {"en": "ienewesewensewnsewswnwnwneneweseweno", "es": "sesewenewesoewsnewnwswswiesewenewesn", "wn": "ewnsewswiwnwnenewesewensewnoewswnwnw", "ws": "ewsoewnwswswsesewenewesnewsnewnwiwsw"}, 4, 3, {"en": "ieewewwsesewewwnneewewow", "es": "seewewowneewewswieewewnw", "wn": "seewewiwneewewswoeewewnw", "ws": "oeewewwsesewewwnneewewiw"}, {"ns": '│', "ne": '└', "nw": '┘', "se": '┌', "sw": '┐', "ew": '─'}, "wens", 2))separate output for 413
larger version: http://paste.textboard.org/15be4df1/raw
───┐┌──────┐┌──────┐┌──────┐┌──────┐
┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘
└──────┘└──┐┌──┘└──────┘└──────┘└──┐
┌──────┐┌──┘└──┐┌──────┐┌──────┐┌──┘
└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐
┌──┘└──────┘└──────┘└──┐┌──┘└──────┘
└──┐┌──────┐┌──────┐┌──┘└──┐┌──────┐
┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘
└──────┘└──────┘└──────┘└──────┘└──┐
┌──────┐┌──────┐┌──────┐┌──────┐┌──┘
└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐
┌──┘└──────┘└──────┘└──┐┌──┘└──────┘
└──┐┌──────┐┌──────┐┌──┘└──┐┌──────┐
┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘
└──────┘└──┐┌──┘└──────┘└──────┘└──┐
┌──────┐┌──┘└──┐┌──────┐┌──────┐┌──┘
└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐
┌──┘└──────┘└──────┘└──────┘└──────┘
└──┐┌──────┐┌──────┐┌──────┐┌──────┐
┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘
└──────┘└──┐┌──┘└──────┘└──────┘└──┐
┌──────┐┌──┘└──┐┌──────┐┌──────┐┌──┘
└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐
┌──┘└──────┘└──────┘└──┐┌──┘└──────┘
└──┐┌──────┐┌──────┐┌──┘└──┐┌──────┐
┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘└──┐┌──┘
└──────┘└──────┘└──────┘└──────┘└──┐3x3 diagonal tiles with 1-gaps
>> console.log (((self, xjoin, symbol, tile, n) => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (4 * n - 1, "", j => symbol (tile, n, k, j)))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (mod => (tile, n, k, j) => tile [mod (k - n + 1, tile.length)] [mod (j - 2 * n + 1, tile [0].length)]) ((a, p) => ((a % p) + p) % p), ["▓▓▒▒▓▓▒▒", "▒▒▒▒▒▒░░", "▓▓▒▒▓▓▒▒", "▒▒░░▒▒▒▒"], 11))
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░▒▒▒▒▒▒
▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓
<- undefined
>> using the generic tile support from >>30
fractal tiling with a 1x2 seed rectangle and an expansion pattern of [[A B B D] [A C C D]]
scheme@(guile-user)> (display ((lambda (rec xjoin index symbol size chars start level) ((lambda (xjoin lines columns) ((lambda (index) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (symbol chars (index k j))))) (lambda (k j) (rec index k j lines columns start)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (size level start #t) (size level start #f))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (self k j lin col hv) (if hv (if (= lin 1) `(#t ,j) ((lambda (c4) ((lambda (jd jm) (if (or (= jd 0) (= jd 3)) (self self k jm lin c4 #f) ((lambda (l2) (self self (modulo k l2) (- j c4) l2 (ash c4 1) #t)) (ash lin -1)))) (quotient j c4) (modulo j c4))) (ash col -2))) (if (= col 1) `(#f ,k) ((lambda (l4) ((lambda (kd km) (if (or (= kd 0) (= kd 3)) (self self km j l4 col #t) ((lambda (c2) (self self (- k l4) (modulo j c2) (ash l4 1) c2 #f)) (ash col -1)))) (quotient k l4) (modulo k l4))) (ash lin -2))))) (lambda (chars index) (vector-ref chars (+ (if (car index) 0 2) (cadr index)))) (lambda (level horver lincol) (ash (if (eq? horver lincol) 1 2) level)) #("⋐≣" "≣⋑" "╭╮" "╰╯") #t 4))separate output for 413
⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑
╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮
╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯⋐≣≣⋑⋐≣≣⋑╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯⋐≣≣⋑⋐≣≣⋑╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯
⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╭╮╭╮╭╮╭╮⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╭╮╭╮╭╮╭╮⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑
╭╮⋐≣≣⋑╭╮╭╮⋐≣≣⋑╭╮╰╯╰╯╰╯╰╯⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╰╯╰╯╰╯╰╯╭╮⋐≣≣⋑╭╮╭╮⋐≣≣⋑╭╮
╰╯⋐≣≣⋑╰╯╰╯⋐≣≣⋑╰╯⋐≣≣⋑⋐≣≣⋑╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮⋐≣≣⋑⋐≣≣⋑╰╯⋐≣≣⋑╰╯╰╯⋐≣≣⋑╰╯
⋐≣≣⋑⋐≣≣⋑⋐≣≣⋑⋐≣≣⋑╭╮⋐≣≣⋑╭╮╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯╭╮⋐≣≣⋑╭╮⋐≣≣⋑⋐≣≣⋑⋐≣≣⋑⋐≣≣⋑
╭╮╭╮╭╮╭╮╭╮╭╮╭╮╭╮╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯╭╮╭╮╭╮╭╮╭╮╭╮╭╮╭╮
╰╯╰╯╰╯╰╯╰╯╰╯╰╯╰╯╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╭╮╰╯╰╯╰╯╰╯╰╯╰╯╰╯╰╯
⋐≣≣⋑⋐≣≣⋑⋐≣≣⋑⋐≣≣⋑╰╯⋐≣≣⋑╰╯╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮╰╯⋐≣≣⋑╰╯⋐≣≣⋑⋐≣≣⋑⋐≣≣⋑⋐≣≣⋑
╭╮⋐≣≣⋑╭╮╭╮⋐≣≣⋑╭╮⋐≣≣⋑⋐≣≣⋑╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯⋐≣≣⋑⋐≣≣⋑╭╮⋐≣≣⋑╭╮╭╮⋐≣≣⋑╭╮
╰╯⋐≣≣⋑╰╯╰╯⋐≣≣⋑╰╯╭╮╭╮╭╮╭╮⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╭╮╭╮╭╮╭╮╰╯⋐≣≣⋑╰╯╰╯⋐≣≣⋑╰╯
⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╰╯╰╯╰╯╰╯⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑╰╯╰╯╰╯╰╯⋐≣≣⋑╭╮⋐≣≣⋑╭╮⋐≣≣⋑
╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮⋐≣≣⋑⋐≣≣⋑╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮⋐≣≣⋑⋐≣≣⋑╭╮╭╮╰╯⋐≣≣⋑╰╯╭╮╭╮
╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯╭╮⋐≣≣⋑╭╮╰╯╰╯
⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑╰╯⋐≣≣⋑upgrade of >>70 that tracks one level up the derivation tree and hands that information to a painter
scheme@(guile-user)> (display ((lambda (rec xjoin index symbol size chars cell start level) ((lambda (xjoin lines columns) ((lambda (index expand) ((lambda (chars) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (apply symbol cell chars (index k j))))) (expand chars (* 2 cell)))) (lambda (k j) (rec index k j lines columns start 0 (not start))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (x) ((lambda (idx) (substring chars idx (+ 1 idx))) (quotient x n))) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")) (size level start #t) (size level start #f))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (self k j lin col hv uppos uphv) (if hv (if (= lin 1) `(,j #t ,uppos ,uphv) ((lambda (c4) ((lambda (jd jm) (if (or (= jd 0) (= jd 3)) (self self k jm lin c4 #f (if (= jd 0) 0 1) #t) ((lambda (l2) (self self (modulo k l2) (- j c4) l2 (ash c4 1) #t (quotient k l2) #t)) (ash lin -1)))) (quotient j c4) (modulo j c4))) (ash col -2))) (if (= col 1) `(,k #f ,uppos ,uphv) ((lambda (l4) ((lambda (kd km) (if (or (= kd 0) (= kd 3)) (self self km j l4 col #t (if (= kd 0) 0 1) #f) ((lambda (c2) (self self (- k l4) (modulo j c2) (ash l4 1) c2 #f (quotient j c2) #f)) (ash col -1)))) (quotient k l4) (modulo k l4))) (ash lin -2))))) (lambda (cell chars pos hv uppos uphv) ((lambda (idx) (substring chars idx (+ idx cell))) (* cell (+ pos (* 2 uppos) (if (eq? hv uphv) 4 0))))) (lambda (level horver lincol) (ash (if (eq? horver lincol) 1 2) level)) "█░▓▒" 2 #t 4))separate output for 413
██████▓▓▓▓░░██████▓▓▓▓░░██████▓▓▓▓░░██████▓▓▓▓░░██████▓▓▓▓░░████
▓▓▒▒██▒▒▒▒░░▓▓▒▒██▒▒▒▒░░▓▓▒▒██▒▒▒▒░░▓▓▒▒██▒▒▒▒░░▓▓▒▒██▒▒▒▒░░▓▓▒▒
▓▓▒▒██▓▓▓▓░░▓▓▒▒████████▓▓▒▒██▓▓▓▓░░▓▓▒▒████████▓▓▒▒██▓▓▓▓░░▓▓▒▒
░░░░██▒▒▒▒░░░░░░▓▓▒▒▓▓▒▒░░░░██▒▒▒▒░░░░░░▓▓▒▒▓▓▒▒░░░░██▒▒▒▒░░░░░░
██▓▓▓▓░░██▓▓▓▓░░▓▓▒▒▓▓▒▒██████▓▓▓▓░░████▓▓▒▒▓▓▒▒██▓▓▓▓░░██▓▓▓▓░░
██▒▒▒▒░░██▒▒▒▒░░░░░░░░░░▓▓▒▒██▒▒▒▒░░▓▓▒▒░░░░░░░░██▒▒▒▒░░██▒▒▒▒░░
██████████████████▓▓▓▓░░▓▓▒▒██▓▓▓▓░░▓▓▒▒██▓▓▓▓░░████████████████
▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒██▒▒▒▒░░░░░░██▒▒▒▒░░░░░░██▒▒▒▒░░▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒
▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒██▓▓▓▓░░██████▓▓▓▓░░██████▓▓▓▓░░▓▓▒▒▓▓▒▒▓▓▒▒▓▓▒▒
░░░░░░░░░░░░░░░░██▒▒▒▒░░▓▓▒▒██▒▒▒▒░░▓▓▒▒██▒▒▒▒░░░░░░░░░░░░░░░░░░
██▓▓▓▓░░██▓▓▓▓░░████████▓▓▒▒██▓▓▓▓░░▓▓▒▒██████████▓▓▓▓░░██▓▓▓▓░░
██▒▒▒▒░░██▒▒▒▒░░▓▓▒▒▓▓▒▒░░░░██▒▒▒▒░░░░░░▓▓▒▒▓▓▒▒██▒▒▒▒░░██▒▒▒▒░░
██████▓▓▓▓░░████▓▓▒▒▓▓▒▒██████▓▓▓▓░░████▓▓▒▒▓▓▒▒██████▓▓▓▓░░████
▓▓▒▒██▒▒▒▒░░▓▓▒▒░░░░░░░░▓▓▒▒██▒▒▒▒░░▓▓▒▒░░░░░░░░▓▓▒▒██▒▒▒▒░░▓▓▒▒
▓▓▒▒██▓▓▓▓░░▓▓▒▒██▓▓▓▓░░▓▓▒▒██▓▓▓▓░░▓▓▒▒██▓▓▓▓░░▓▓▒▒██▓▓▓▓░░▓▓▒▒
░░░░██▒▒▒▒░░░░░░██▒▒▒▒░░░░░░██▒▒▒▒░░░░░░██▒▒▒▒░░░░░░██▒▒▒▒░░░░░░>>72
You know SchemeBBS allows for code to be written in more than one line, right? What you are currently posting is borderline unreadable (or is that the intention)?
You know SchemeBBS allows for code to be written in more than one line, right?
There are multiline code boxes containing the output both above and below that post.
What you are currently posting is borderline unreadable (or is that the intention)?
The code is laid out as a single expression on one line as a play on the thread title. One way to see that unreadability is not a goal in itself is to note that parameter names are unobfuscated. The goal is simply intellectual amusement and recreation, with a secondary benefit of serving as a reminder that this a /prog/ board, not a /tech/ board, and those who can only participate in /tech/ threads are merely guests on our board.
removed >>66 incipient sorting support on the numeric columns, added autogenerated ranking columns on the lambda and character counts
>> console.log (((repeat, thread, magic) => ((id2code, extractors, formatters, pads, stringify, layout, synthesize, synthspec) => ((table, aligns, strs) => ((table, aligns, strs) => layout (stringify (table, strs, formatters), aligns, pads)) (...synthesize (synthspec, table, aligns, strs))) (magic.split (" ").map (id => [id, id2code (thread, id)]).filter (p => p [1] !== null).map (([id, code], index) => (text => [index + 1, parseInt (id, 10)].concat (extractors.map (ex => ex ["fun"] (text)))) (code.innerText)), repeat (2, "right").concat (extractors.map (ex => ex ["align"])), repeat (2, "tostring").concat (extractors.map (ex => ex ["str"])))) ((thread, id) => document.getElementById ("t" + thread + "p" + id).parentNode.nextElementSibling.querySelector ("code"), [{"fun": s => [...s.matchAll (/\blambda | => /g)].length, "align": "right", "str": "tostring"}, {"fun": (max => s => s.split ("\n").reduce ((acc, item) => max (acc, item.length), 0)) (Math.max), "align": "right", "str": "tostring"}, {"fun": s => (m => m ? m [1] : "?") (s.match (/^(>>>|>>|scheme@\(guile-user\)>) /m)), "align": "left", "str": "id"}], {"id": x => x, "tostring": x => x.toString ()}, {"left": (s, n, pad) => s.padEnd (n, pad), "right": (s, n, pad) => s.padStart (n, pad)}, (rows, how, formatters) => rows.map (r => r.map ((c, index) => formatters [how [index]] (c))), (lengths => (rows, how, pads) => (lengths => rows.map (r => r.map ((c, index) => pads [how [index]] (c, lengths [index], " ")).join (" ")).join ("\n")) (lengths (rows))) ((max => rows => rows.reduce ((acc, r) => acc.map ((a, index) => max (a, r [index].length)), rows [0].map (x => 0))) (Math.max)), ((extend, addcolumns, orderof) => (spec, table, aligns, strs) => [addcolumns (table, spec.map (s => orderof (table, s.column, s.up))), extend (aligns, spec.length, "right"), extend (strs, spec.length, "tostring")]) ((arr, n, item) => arr.concat (repeat (n, item)), (table, columns) => table.map ((r, index) => r.concat (columns.map (c => c [index]))), (table, col, up) => table.map ((r, index) => [r [col], index]).sort (up ? ((a, b) => a [0] - b [0]) : ((a, b) => b [0] - a [0])).map (([val, pos], index) => [pos, index]).sort ((a, b) => a [0] - b [0]).map (a => 1 + a [1])), [{"column": 2, "up": false}, {"column": 3, "up": false}])) ((n, item) => Array.from ({length: n}, (dis, k) => item), 22, "9 10 11 13 14 17 21 24 25 28 30 34 35 37 39 42 43 46 49 53 55 59 65 67 69 70 72"))
1 9 12 391 >>> 22 27
2 10 7 461 scheme@(guile-user)> 27 23
3 11 13 483 >> 18 21
4 13 15 627 >> 13 17
5 14 13 471 >> 19 22
6 17 14 524 >>> 16 19
7 21 18 789 >>> 11 13
8 24 15 851 scheme@(guile-user)> 14 12
9 25 13 692 scheme@(guile-user)> 20 15
10 28 25 1599 >>> 1 3
11 30 10 508 >> 23 20
12 34 13 560 >> 21 18
13 35 19 1375 scheme@(guile-user)> 9 5
14 37 15 642 >> 15 16
15 39 21 909 >> 5 10
16 42 10 452 >> 24 25
17 43 10 444 >> 25 26
18 46 18 707 >>> 12 14
19 49 23 1070 >>> 4 8
20 53 21 873 >>> 6 11
21 55 14 1066 scheme@(guile-user)> 17 9
22 59 21 1475 scheme@(guile-user)> 7 4
23 65 19 1110 scheme@(guile-user)> 10 7
24 67 25 1716 >>> 2 2
25 69 10 460 >> 26 24
26 70 20 1333 scheme@(guile-user)> 8 6
27 72 25 1717 scheme@(guile-user)> 3 1
<- undefined
>> upgrade of >>72 that tracks two levels up the derivation tree, which allows symmetry to be restored in the painter
scheme@(guile-user)> (display ((lambda (rec xjoin firstpred index size chars cell start level) ((lambda (xjoin firstpred lines columns) ((lambda (index expand symbol) ((lambda (chars) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (apply symbol cell chars (index k j))))) (expand chars (* 2 cell)))) (lambda (k j) (rec index k j lines columns start 0 (not start) 0 start)) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (x) ((lambda (idx) (substring chars idx (+ 1 idx))) (quotient x n))) "")) ((lambda (preds typetable) (lambda (cell chars pos hv uppos uphv gpos ghv) ((lambda (idx) (substring chars idx (+ idx cell))) (* cell (+ pos (* 2 (vector-ref typetable (firstpred (list hv uppos uphv gpos ghv) preds)))))))) (list (lambda (hv uppos uphv gpos ghv) (and (or (and hv uphv ghv) (and (not hv) (not uphv) (not ghv))) (= uppos gpos))) (lambda (hv uppos uphv gpos ghv) (and (or (and (not hv) (not uphv) ghv) (and hv uphv (not ghv))) (= uppos gpos))) (lambda (hv uppos uphv gpos ghv) (and (or (and hv uphv ghv) (and (not hv) (not uphv) (not ghv))) (not (= uppos gpos)))) (lambda (hv uppos uphv gpos ghv) (and (or (and (not hv) (not uphv) ghv) (and hv uphv (not ghv))) (not (= uppos gpos)))) (lambda (hv uppos uphv gpos ghv) (or (and hv (not uphv) ghv) (and (not hv) uphv (not ghv))))) #(4 4 1 3 0 2)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (args preds) (rec firstpred 0 args preds)) (size level start #t) (size level start #f))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (self n args preds) (if (null? preds) n (if (apply (car preds) args) n (self self (+ n 1) args (cdr preds))))) (lambda (self k j lin col hv uppos uphv gpos ghv) (if hv (if (= lin 1) `(,j #t ,uppos ,uphv ,gpos ,ghv) ((lambda (c4) ((lambda (jd jm) (if (or (= jd 0) (= jd 3)) (self self k jm lin c4 #f (if (= jd 0) 0 1) #t uppos uphv) ((lambda (l2) (self self (modulo k l2) (- j c4) l2 (ash c4 1) #t (quotient k l2) #t uppos uphv)) (ash lin -1)))) (quotient j c4) (modulo j c4))) (ash col -2))) (if (= col 1) `(,k #f ,uppos ,uphv ,gpos ,ghv) ((lambda (l4) ((lambda (kd km) (if (or (= kd 0) (= kd 3)) (self self km j l4 col #t (if (= kd 0) 0 1) #f uppos uphv) ((lambda (c2) (self self (- k l4) (modulo j c2) (ash l4 1) c2 #f (quotient j c2) #f uppos uphv)) (ash col -1)))) (quotient k l4) (modulo k l4))) (ash lin -2))))) (lambda (level horver lincol) (ash (if (eq? horver lincol) 1 2) level)) "█▓▒░ " 2 #t 4))separate output for 413
level 6 with colors: http://paste.textboard.org/a5764149/raw
████▒▒ ▒▒██████ ██████▒▒ ▒▒██████ ██████▒▒ ▒▒████
░░▒▒▓▓▓▓▒▒░░ ██░░░░██ ░░▒▒▓▓▓▓▒▒░░ ██░░░░██ ░░▒▒▓▓▓▓▒▒░░
░░▒▒▓▓▓▓▒▒░░ ▒▒▒▒▒▒▒▒ ░░▒▒▓▓▓▓▒▒░░ ▒▒▒▒▒▒▒▒ ░░▒▒▓▓▓▓▒▒░░
████▒▒ ▒▒████ ▓▓▓▓ ████▒▒ ▒▒████ ▓▓▓▓ ████▒▒ ▒▒████
██ ████ ██ ▓▓▓▓ ████▒▒ ▒▒████ ▓▓▓▓ ██ ████ ██
██░░░░████░░░░██▒▒▒▒▒▒▒▒ ░░▒▒▓▓▓▓▒▒░░ ▒▒▒▒▒▒▒▒██░░░░████░░░░██
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒██░░░░██ ░░▒▒▓▓▓▓▒▒░░ ██░░░░██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▓▓▓▓ ▓▓▓▓ ██ ██████▒▒ ▒▒██████ ██ ▓▓▓▓ ▓▓▓▓
▓▓▓▓ ▓▓▓▓ ██ ██████▒▒ ▒▒██████ ██ ▓▓▓▓ ▓▓▓▓
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒██░░░░██ ░░▒▒▓▓▓▓▒▒░░ ██░░░░██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
██░░░░████░░░░██▒▒▒▒▒▒▒▒ ░░▒▒▓▓▓▓▒▒░░ ▒▒▒▒▒▒▒▒██░░░░████░░░░██
██ ████ ██ ▓▓▓▓ ████▒▒ ▒▒████ ▓▓▓▓ ██ ████ ██
████▒▒ ▒▒████ ▓▓▓▓ ████▒▒ ▒▒████ ▓▓▓▓ ████▒▒ ▒▒████
░░▒▒▓▓▓▓▒▒░░ ▒▒▒▒▒▒▒▒ ░░▒▒▓▓▓▓▒▒░░ ▒▒▒▒▒▒▒▒ ░░▒▒▓▓▓▓▒▒░░
░░▒▒▓▓▓▓▒▒░░ ██░░░░██ ░░▒▒▓▓▓▓▒▒░░ ██░░░░██ ░░▒▒▓▓▓▓▒▒░░
████▒▒ ▒▒██████ ██████▒▒ ▒▒██████ ██████▒▒ ▒▒████>>78
This one is pretty pleasing to the eyes.
This one is pretty pleasing to the eyes.
You can control the mapping of classes of rectangles to characters by editing #(4 4 1 3 0 2) and the characters themselves by editing "█▓▒░ ", to experiment with your own designs. The current classes of rectangles can be obtained by painting the rectangles with their class numbers:
44500544
13522531
13522531
44500544
4114
4334
5555
0220
0220
5555
4334
4114The class assigned to a rectangle within its grandparent is the index of the first predicate that holds in the preds list of predicates within the outer symbol lambda, with an implicit final predicate that always holds.
The Forced Indentation Of En Passant Captures
scheme@(guile-user)> (display ((lambda (rec xjoin grid place cellx celly chars pieces home) ((lambda (xjoin symbol) (xjoin (* 8 celly) (lambda (k) (string-append (xjoin (* 8 cellx) (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (k j) (or (place cellx celly pieces home k j) (grid cellx celly chars k j))))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (cellx celly chars k j) ((lambda (idx) (substring chars idx (+ idx 1))) (if (eq? (even? (quotient k celly)) (even? (quotient j cellx))) 1 0))) ((lambda (rowcol pawn rest) (lambda (cellx celly pieces home k j) ((lambda (rowcol) (if rowcol (apply (lambda (row col) (case row ((1) (pawn pieces #t)) ((6) (pawn pieces #f)) ((0) (rest pieces home col #t)) ((7) (rest pieces home col #f)) (else #f))) rowcol) #f)) (rowcol cellx celly k j)))) ((lambda (center) (lambda (cellx celly k j) (if (and (center celly k) (center cellx j)) `(,(- 7 (quotient k celly)) ,(quotient j cellx)) #f))) (lambda (cell kj) (= (modulo kj cell) (quotient cell 2)))) (lambda (pieces start) (substring (vector-ref pieces (if start 0 1)) 5 6)) (lambda (pieces home col start) ((lambda (idx) (substring (vector-ref pieces (if start 0 1)) idx (+ idx 1))) (vector-ref home col)))) 7 3 "▒ " #("♔♕♖♗♘♙" "♚♛♜♝♞♟") #(2 4 3 1 0 3 4 2)))separate output for 413
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
♜ ▒▒▒♞▒▒▒ ♝ ▒▒▒♛▒▒▒ ♚ ▒▒▒♝▒▒▒ ♞ ▒▒▒♜▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒♟▒▒▒ ♟ ▒▒▒♟▒▒▒ ♟ ▒▒▒♟▒▒▒ ♟ ▒▒▒♟▒▒▒ ♟
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
♙ ▒▒▒♙▒▒▒ ♙ ▒▒▒♙▒▒▒ ♙ ▒▒▒♙▒▒▒ ♙ ▒▒▒♙▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒
▒▒▒♖▒▒▒ ♘ ▒▒▒♗▒▒▒ ♕ ▒▒▒♔▒▒▒ ♗ ▒▒▒♘▒▒▒ ♖
▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒ >>82
I wanna play this chess.
>>83
You could check out a chess thread like https://wizchan.org/hob/res/48468.html if you can look past the nature of the site.
upgrade of >>14 with a coordinate painter
>> console.log (((self, xjoin, vec, fore, back, band, n, s, cells) => (expand => (cells => (symbol => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (2 * n - 1, "", j => symbol (k, j)))) ((k, j) => fore (n, band, s, k, j) ?? back (n, band, cells, k, j))) (expand (cells, s.length))) ((chars, n) => (a => self (vec) (a.length - 1, a, s => self (xjoin) (n, "", k => s))) ([...chars]))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (push => me => (n, vec, f) => n == 0 ? [f (vec [0])] : push (me (me) (n - 1, vec, f), f (vec [n]))) ((a, x) => (dis => a) (a.push (x))), (abs => (n, band, s, k, j) => ((k, j) => (k + j) % band == 0 ? s : null) (abs (n - 1 - k), abs (n - 1 - j))) (Math.abs), ((abs, path, div) => (n, band, cells, k, j) => ((k, j) => (ring => (path => cells [(div (cells.length * path, 4 * ring) + div (ring, band)) % cells.length]) (path (ring, k, j))) (abs (k) + abs (j))) (n - 1 - k, j - n + 1)) (Math.abs, (ring, k, j) => (k >= 0) && (j > 0) ? k : (k > 0) && (j <= 0) ? ring - j : (k <= 0) && (j < 0) ? 2 * ring - k : 3 * ring + j, (a, b) => (a - a % b) / b), 3, 10, "rho", "█▓▒░ "))
rho▓▓▓▓▓▓rho██████rho rho rho rho██████rho
▓▓▓▓▓▓rho██████rho rho░░░rho ░░░rho rho██████
▓▓▓rho██████rho rho░░░░░░░░░rho░░░░░░rho rho███
rho██████rho rho░░░░░░rho░░░▒▒▒rho░░░░░░rho rho
▓▓▓▓▓▓rho rho░░░░░░rho▒▒▒rho▒▒▒▒▒▒rho░░░░░░rho
▓▓▓rho██████rho░░░░░░rho▒▒▒▒▒▒▒▒▒rho▒▒▒▒▒▒rho░░░░░░rho
rho██████rho ░░░rho▒▒▒▒▒▒rho▓▓▓▓▓▓rho▒▒▒▒▒▒rho░░░░░░rho
██████rho rho░░░▒▒▒rho▓▓▓rho▓▓▓▓▓▓rho▒▒▒▒▒▒rho░░░░░░
███rho rho░░░░░░rho▓▓▓▓▓▓███rho▓▓▓▓▓▓rho▒▒▒▒▒▒rho░░░
rho rho░░░░░░rho▒▒▒▒▒▒rho██████rho▓▓▓▓▓▓rho▒▒▒▒▒▒rho
███rho rho░░░░░░rho░░░░░░ rho██████rho▓▓▓▓▓▓rho▒▒▒
██████rho rho rho░░░rho██████rho▓▓▓▓▓▓rho▒▒▒▒▒▒
rho██████rho ███rho rho██████rho▓▓▓▓▓▓rho▒▒▒▒▒▒rho
▓▓▓rho███▓▓▓rho██████rho ███rho▓▓▓▓▓▓rho▒▒▒▒▒▒rho░░░
▓▓▓▓▓▓rho▓▓▓▓▓▓rho██████rho rho▓▓▓▓▓▓rho▒▒▒▒▒▒rho░░░░░░
rho▒▒▒▒▒▒rho▓▓▓▓▓▓rho██████rho███▓▓▓rho▒▒▒▒▒▒rho░░░░░░rho
░░░rho▒▒▒▒▒▒rho▓▓▓▓▓▓rho█████████rho▒▒▒▒▒▒rho░░░░░░rho
░░░░░░rho▒▒▒▒▒▒rho▓▓▓▓▓▓rho███rho▒▒▒▒▒▒rho░░░░░░rho
rho░░░░░░rho▒▒▒▒▒▒rho▓▓▓▓▓▓rho▓▓▓▓▓▓rho░░░░░░rho rho
<- undefined
>> larger version with colors and wider bands: http://paste.textboard.org/9f796569/raw
What's the meaning of the rho?
What's the meaning of the rho?
The guiding shape that defines >>14 >>85 the rings is a rhombus.
https://en.wikipedia.org/wiki/Rhombus#Etymology
The word "rhombus" comes from Ancient Greek: ῥόμβος, romanized: rhombos, meaning something that spins,[4] which derives from the verb ῥέμβω, romanized: rhémbō, meaning "to turn round and round."[5] The word was used both by Euclid and Archimedes, who used the term "solid rhombus" for a bicone, two right circular cones sharing a common base.[6] The surface we refer to as rhombus today is a cross section of the bicone on a plane through the apexes of the two cones.
That's pretty interesting I had no idea that's where it comes from.
upgrade of >>11 with a coordinate painter
>> console.log (((self, xjoin, vec, fore, back, pad, n, s, cells) => (expand => (cells => (symbol => self (xjoin) (2 * n - 1, "\n", k => self (xjoin) (2 * n - 1, pad, j => symbol (k, j)))) ((k, j) => fore (n, s, k, j) ?? back (n, cells, k, j))) (expand (cells, [...s].length))) ((chars, n) => (a => self (vec) (a.length - 1, a, s => self (xjoin) (n, "", k => s))) ([...chars]))) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (push => me => (n, vec, f) => n == 0 ? [f (vec [0])] : push (me (me) (n - 1, vec, f), f (vec [n]))) ((a, x) => (dis => a) (a.push (x))), (abs => (n, s, k, j) => ((k, j) => ((kev, jev) => (kev ? jev || j < k : jev && j > k) ? s : null) (k % 2 == 0, j % 2 == 0)) (abs (n - 1 - k), abs (n - 1 - j))) (Math.abs), ((ring, path) => (n, cells, k, j) => ((k, j) => (ring => (path => cells [path % cells.length]) (path (ring, k, j))) (ring (k, j))) (n - 1 - k, j - n + 1)) (((abs, max) => (k, j) => max (abs (k), abs (j))) (Math.abs, Math.max), (ring, k, j) => k == ring ? ring + j : j == ring ? 3 * ring - k : k == -ring ? 5 * ring - j : 7 * ring + k), " ", 9, "mem", "█▓▒░ ░▒▓"))
mem mem mem mem mem mem mem mem mem mem mem mem mem mem mem mem mem
mem ███ ▓▓▓ ▒▒▒ ░░░ ░░░ ▒▒▒ ▓▓▓ ███ ▓▓▓ ▒▒▒ ░░░ ░░░ ▒▒▒ mem
mem ▓▓▓ mem mem mem mem mem mem mem mem mem mem mem mem mem ▓▓▓ mem
mem ▒▒▒ mem ███ ▓▓▓ ▒▒▒ ░░░ ░░░ ▒▒▒ ▓▓▓ ███ ▓▓▓ ▒▒▒ mem ███ mem
mem ░░░ mem ▓▓▓ mem mem mem mem mem mem mem mem mem ░░░ mem ▓▓▓ mem
mem mem ▒▒▒ mem ███ ▓▓▓ ▒▒▒ ░░░ ░░░ ▒▒▒ mem mem ▒▒▒ mem
mem ░░░ mem ░░░ mem ▓▓▓ mem mem mem mem mem ▓▓▓ mem ░░░ mem ░░░ mem
mem ▒▒▒ mem mem ▒▒▒ mem ███ ▓▓▓ ▒▒▒ mem ███ mem ▒▒▒ mem mem
mem ▓▓▓ mem ░░░ mem ░░░ mem ▓▓▓ mem ░░░ mem ▓▓▓ mem ▓▓▓ mem ░░░ mem
mem ███ mem ▒▒▒ mem mem ▒▒▒ ░░░ mem ▒▒▒ mem ███ mem ▒▒▒ mem
mem ▓▓▓ mem ▓▓▓ mem ░░░ mem mem mem mem mem ░░░ mem ▓▓▓ mem ▓▓▓ mem
mem ▒▒▒ mem ███ mem ▒▒▒ ▓▓▓ ███ ▓▓▓ ▒▒▒ ░░░ mem ▒▒▒ mem ███ mem
mem ░░░ mem ▓▓▓ mem mem mem mem mem mem mem mem mem ░░░ mem ▓▓▓ mem
mem mem ▒▒▒ ░░░ ░░░ ▒▒▒ ▓▓▓ ███ ▓▓▓ ▒▒▒ ░░░ mem ▒▒▒ mem
mem ░░░ mem mem mem mem mem mem mem mem mem mem mem mem mem ░░░ mem
mem ▒▒▒ ▓▓▓ ███ ▓▓▓ ▒▒▒ ░░░ ░░░ ▒▒▒ ▓▓▓ ███ ▓▓▓ ▒▒▒ ░░░ mem
mem mem mem mem mem mem mem mem mem mem mem mem mem mem mem mem mem
<- undefined
>> larger version with colors: http://paste.textboard.org/ff61b68f/raw
upgrade of >>10 with a coordinate painter
scheme@(guile-user)> (display ((lambda (rec xjoin fore back pad n s chars) ((lambda (xjoin cell cycle) ((lambda (expand) ((lambda (chars) ((lambda (symbol) (xjoin (- (* 2 n) 1) (lambda (k) (string-append (xjoin (- (* 2 n) 1) (lambda (j) (symbol k j)) pad) "\n")) "")) (lambda (k j) (or (fore n s k j) (back n chars cell cycle k j))))) (expand chars cell))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (x) ((lambda (idx) (substring chars idx (+ 1 idx))) (quotient x n))) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length s) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (n s k j) (if (< (abs (- n 1 j)) (- n 1 (abs (- n 1 k)))) #f s)) ((lambda (extract) (lambda (n chars cell cycle k j) (extract chars (* cell (modulo (min (abs (- n 1 k)) (abs (- n 1 j))) cycle)) cell))) (lambda (str pos len) (substring str pos (+ pos len)))) " " 11 "me" "█▓▒░ "))
me me me me me me me me me me me me me me me me me me me me me
me me me me me me me me me me ██ me me me me me me me me me me
me me me me me me me me me ▓▓ ██ ▓▓ me me me me me me me me me
me me me me me me me me ▒▒ ▓▓ ██ ▓▓ ▒▒ me me me me me me me me
me me me me me me me ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ me me me me me me me
me me me me me me ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ me me me me me me
me me me me me ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ me me me me me
me me me me ░░ ░░ ░░ ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ ░░ ░░ ░░ me me me me
me me me ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▓▓ ██ ▓▓ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ me me me
me me ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ██ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ me me
me ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ me
me me ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ██ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ me me
me me me ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▓▓ ██ ▓▓ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ me me me
me me me me ░░ ░░ ░░ ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ ░░ ░░ ░░ me me me me
me me me me me ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ me me me me me
me me me me me me ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ me me me me me me
me me me me me me me ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ me me me me me me me
me me me me me me me me ▒▒ ▓▓ ██ ▓▓ ▒▒ me me me me me me me me
me me me me me me me me me ▓▓ ██ ▓▓ me me me me me me me me me
me me me me me me me me me me ██ me me me me me me me me me me
me me me me me me me me me me me me me me me me me me me me me
scheme@(guile-user)> larger version with colors: http://paste.textboard.org/830c6de2/raw
>>90
Wow, that's something.
>>90
And it looks even nicer in black-and-white.
>>91 >>92
You can take advantage of quadrant symmetry using a coordinate transform. The incoming coordinates of the back lambda are zero-based row and column indices, so the first thing it does is switch from [k, j] to [(abs (- n 1 k)), (abs (- n 1 j))] in a square field of size (- (* 2 n) 1), after which it only has to consider one quadrant because the other three will be symmetrically filled in for free by the coordinate transform. The remaining task is to assign zero-based class numbers to the quarter-cross shapes that should be painted with the same character, then use the class number as a cycling index into the chosen string of characters. A moment of reflection will show that after the coordinate transform the class number of any point is simply the smaller of its two coordinates.
Looks like a bunch of memes.
upgrade of >>9 with a coordinate painter
>>> print ((lambda mY, xjoin, index, symbol, pad, n, cell, chars, E: (lambda cycle, xjoin: (lambda expand: (lambda z, chars: (lambda symbol: xjoin (n, lambda k: xjoin (2 * n - 1, lambda j: symbol (k, j), pad), '\n')) (lambda k, j: symbol (cell, chars, z, index (cycle, n, k, j)))) (expand (E, cell), expand (chars, cell))) (lambda chars, n: xjoin (n * len (chars), lambda x: chars [x // n], ''))) (len (chars), mY (xjoin))) (lambda f, *more: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args), *more)), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), lambda cycle, n, k, j: (lambda j: -1 if j > k else min (k - j, n - 1 - k) % cycle) (abs (n - 1 - j)), (lambda extract: lambda cell, chars, z, index: z if index < 0 else extract (chars, cell * index, cell)) (lambda s, pos, len: s [pos : pos + len]), " ", 14, 2, "█▓▒░ ░▒▓", " "))
██
██ ▓▓ ██
██ ▓▓ ▒▒ ▓▓ ██
██ ▓▓ ▒▒ ░░ ▒▒ ▓▓ ██
██ ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ ██
██ ▓▓ ▒▒ ░░ ░░ ░░ ▒▒ ▓▓ ██
██ ▓▓ ▒▒ ░░ ░░ ▒▒ ░░ ░░ ▒▒ ▓▓ ██
██ ▓▓ ▒▒ ░░ ░░ ▒▒ ▒▒ ▒▒ ░░ ░░ ▒▒ ▓▓ ██
██ ▓▓ ▒▒ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ▒▒ ▓▓ ██
██ ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ ██
██ ▓▓ ▒▒ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ▒▒ ▓▓ ██
██ ▓▓ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▓▓ ██
██ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ██
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
>>> larger version with colors: http://paste.textboard.org/8a443841/raw
>>95
:like: :like: :like:
>>96
You can experiment with your own designs by editing "█▓▒░ ░▒▓". The class numbers assigned to isosceles subshapes painted with the same character are produced by the index lambda. Since the shape is mirrored on its central vertical axis, a switch from [k, j] to [k, abs (n - 1 - j)] in a field of [n, 2 * n - 1] is applied first >>93. The legs of subshapes are numbered with the outermost starting at zero by k - j, while the bases of subshapes are numbered with the outermost starting at zero by n - 1 - k. Since it is the the outer segments that cut off the inner segments, the class number of any point within the shape is the smaller of its leg and base numbers.
>>97
No, this image is perfect, I barely can think of anything I would admire more.
Here is a variation of >>90 that replaces recursion using the meme combinator with looping via call-with-current-continuation. The latter is implemented by passing lambdas to each other and nesting them in various ways, without resorting to assignment. The state of the loop is passed through the continuation.
scheme@(guile-user)> (display ((lambda (rec xjoin fore back pad n s chars) ((lambda (xjoin cell cycle) ((lambda (expand) ((lambda (chars) ((lambda (symbol) (xjoin (- (* 2 n) 1) (lambda (k) (string-append (xjoin (- (* 2 n) 1) (lambda (j) (symbol k j)) pad) "\n")) "")) (lambda (k j) (or (fore n s k j) (back n chars cell cycle k j))))) (expand chars cell))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (x) ((lambda (idx) (substring chars idx (+ 1 idx))) (quotient x n))) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length s) (string-length chars))) (lambda (fun . args) ((lambda (cont+args) ((lambda (cont args) ((lambda (next) (apply fun next args)) (lambda args (cont (cons cont args))))) (car cont+args) (cdr cont+args))) (call-with-current-continuation (lambda (cont) (cons cont args))))) (lambda (next n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (next (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (n s k j) (if (< (abs (- n 1 j)) (- n 1 (abs (- n 1 k)))) #f s)) ((lambda (extract) (lambda (n chars cell cycle k j) (extract chars (* cell (modulo (min (abs (- n 1 k)) (abs (- n 1 j))) cycle)) cell))) (lambda (str pos len) (substring str pos (+ pos len)))) " " 11 "cc" " ░▒▓█"))
cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc
cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc
cc cc cc cc cc cc cc cc cc ░░ ░░ cc cc cc cc cc cc cc cc cc
cc cc cc cc cc cc cc cc ▒▒ ░░ ░░ ▒▒ cc cc cc cc cc cc cc cc
cc cc cc cc cc cc cc ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ cc cc cc cc cc cc cc
cc cc cc cc cc cc ██ ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ ██ cc cc cc cc cc cc
cc cc cc cc cc ██ ██ ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ ██ ██ cc cc cc cc cc
cc cc cc cc ▓▓ ▓▓ ▓▓ ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ ▓▓ ▓▓ ▓▓ cc cc cc cc
cc cc cc ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ░░ ░░ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ cc cc cc
cc cc ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ cc cc
cc cc
cc cc ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ ░░ cc cc
cc cc cc ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ░░ ░░ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ cc cc cc
cc cc cc cc ▓▓ ▓▓ ▓▓ ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ ▓▓ ▓▓ ▓▓ cc cc cc cc
cc cc cc cc cc ██ ██ ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ ██ ██ cc cc cc cc cc
cc cc cc cc cc cc ██ ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ ██ cc cc cc cc cc cc
cc cc cc cc cc cc cc ▓▓ ▒▒ ░░ ░░ ▒▒ ▓▓ cc cc cc cc cc cc cc
cc cc cc cc cc cc cc cc ▒▒ ░░ ░░ ▒▒ cc cc cc cc cc cc cc cc
cc cc cc cc cc cc cc cc cc ░░ ░░ cc cc cc cc cc cc cc cc cc
cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc
cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc
scheme@(guile-user)> The only change of substance, other than the rec implementation, is that xjoin no longer has to provide the invoked function as its own first argument when handing off to the next iteration.
A Sierpinski triangle >>21 painted over a Sierpinski carpet >>17.
>>> print ((lambda mY, xjoin, size, half, cell, boot, pred, n, E, L, R, C: (lambda xjoin, cell, pred, n: (lambda symbol: xjoin (n, lambda k: xjoin (2 * n, lambda j: symbol (k, j), ''), '\n')) (lambda k, j: (lambda c: L if c < 0 else R if c > 0 else C if pred (k, j // 2) else E) (boot (cell, n, k, j)))) (mY (xjoin), mY (cell, mY (half)), mY (pred), size (n))) (lambda f, *more: (lambda x: x (x)) (lambda y: f (lambda *args: y (y) (*args), *more)), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), lambda n: 3 ** n, lambda f: lambda n, p: p >> 1 if p > n else f (n, p << 1), lambda f, half: lambda lr, k, j: 0 if j > k else lr if k == 0 else (lambda h: f (-lr, k - h, h - 1 - j) if j < h else f (lr, k - h, j - h)) (half (k, 2)), lambda cell, n, k, j: cell (-1, k, n - 1 - j) if j < n else cell (1, k, j - n), lambda f: lambda k, j: ((k == 0) or (j == 0)) or (not ((k % 3 == 1) and (j % 3 == 1)) and f (k // 3, j // 3)), 3, " ", "◢", "◣", "░"))separate output for 413
░░░░░░░░░░░░░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░░░░░░░░░░░░░
░░ ░░░░ ░░░░ ░░░░ ░░░◢◣◢◣░░░ ░░░░ ░░░░ ░░░░ ░░
░░░░░░░░░░░░░░░░░░░░░░░░◢◣░░◢◣░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░ ░░░░░░░░░░░◢◣◢◣◢◣◢◣░░░░░░░░░░░ ░░░░░░
░░ ░░ ░░ ░░░░ ◢◣ ◢◣ ░░░░ ░░ ░░ ░░
░░░░░░ ░░░░░░░░░◢◣◢◣ ◢◣◢◣░░░░░░░░░ ░░░░░░
░░░░░░░░░░░░░░░░░░░░◢◣░░◢◣░░◢◣░░◢◣░░░░░░░░░░░░░░░░░░░░
░░ ░░░░ ░░░░ ░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░ ░░░░ ░░░░ ░░
░░░░░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░◢◣◢◣ ◢◣◢◣░░░░░░░░░░░░░░░░░
░░ ░░░░ ░░░░ ◢◣ ◢◣ ◢◣ ◢◣ ░░░░ ░░░░ ░░
░░░░░░░░░░░░░░░◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣░░░░░░░░░░░░░░░
░░░░░░ ░░◢◣░░ ◢◣ ◢◣ ░░◢◣░░ ░░░░░░
░░ ░░ ░◢◣◢◣░ ◢◣◢◣ ◢◣◢◣ ░◢◣◢◣░ ░░ ░░
░░░░░░ ◢◣░░◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣░░◢◣ ░░░░░░
░░░░░░░░░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░░░░░░░░░
░░ ░░░░ ◢◣░░ ░░ ░░ ░░◢◣ ░░░░ ░░
░░░░░░░░░◢◣◢◣░░░░░ ░░░░░◢◣◢◣░░░░░░░░░
░░░░░░░░◢◣░░◢◣░░░░░░░░░░░░░░░░░░░░░░░░░░◢◣░░◢◣░░░░░░░░
░░ ░░░◢◣◢◣◢◣◢◣ ░░░░ ░░░░ ░░░░ ░░░░ ◢◣◢◣◢◣◢◣░░░ ░░
░░░░░░◢◣░░░░░░◢◣░░░░░░░░░░░░░░░░░░░░░░◢◣░░░░░░◢◣░░░░░░
░░░░░◢◣◢◣ ░◢◣◢◣░░░░░░░ ░░░░░░░◢◣◢◣░ ◢◣◢◣░░░░░
░░ ◢◣ ◢◣ ◢◣ ◢◣░░ ░░ ░░ ░░◢◣ ◢◣ ◢◣ ◢◣ ░░
░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░░░ ░░░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░
░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░░░░░░░░░░░░░
░░ ░░░░ ░░░░ ░░░░ ░░░◢◣◢◣░░░ ░░░░ ░░░░ ░░░░ ░░
░░░░░░░░░░░░░░░░░░░░░░░░◢◣░░◢◣░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░ ░░░░░░░░░░░◢◣◢◣◢◣◢◣░░░░░░░░░░░ ░░░░░░
░░ ░░ ░░ ░░░░ ◢◣ ◢◣ ░░░░ ░░ ░░ ░░
░░░░░░ ░░░░░░░░░◢◣◢◣ ◢◣◢◣░░░░░░░░░ ░░░░░░
░░░░░░░░░░░░░░░░░░░░◢◣░░◢◣░░◢◣░░◢◣░░░░░░░░░░░░░░░░░░░░
░░ ░░░░ ░░░░ ░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░ ░░░░ ░░░░ ░░
░░░░░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░◢◣◢◣ ◢◣◢◣░░░░░░░░░░░░░░░░░
░░ ░░░░ ░░░░ ◢◣ ◢◣ ◢◣ ◢◣ ░░░░ ░░░░ ░░
░░░░░░░░░░░░░░░◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣░░░░░░░░░░░░░░░
░░░░░░ ░░◢◣░░ ◢◣ ◢◣ ░░◢◣░░ ░░░░░░
░░ ░░ ░◢◣◢◣░ ◢◣◢◣ ◢◣◢◣ ░◢◣◢◣░ ░░ ░░
░░░░░░ ◢◣░░◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣░░◢◣ ░░░░░░
░░░░░░░░░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░░░░░░░░░
░░ ░░░░ ◢◣░░ ░░ ░░ ░░◢◣ ░░░░ ░░
░░░░░░░░░◢◣◢◣░░░░░ ░░░░░◢◣◢◣░░░░░░░░░
░░░░░░░░◢◣░░◢◣░░░░░░░░░░░░░░░░░░░░░░░░░░◢◣░░◢◣░░░░░░░░
░░ ░░░◢◣◢◣◢◣◢◣ ░░░░ ░░░░ ░░░░ ░░░░ ◢◣◢◣◢◣◢◣░░░ ░░
░░░░░░◢◣░░░░░░◢◣░░░░░░░░░░░░░░░░░░░░░░◢◣░░░░░░◢◣░░░░░░
░░░░░◢◣◢◣ ░◢◣◢◣░░░░░░░ ░░░░░░░◢◣◢◣░ ◢◣◢◣░░░░░
░░ ◢◣ ◢◣ ◢◣ ◢◣░░ ░░ ░░ ░░◢◣ ◢◣ ◢◣ ◢◣ ░░
░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░░░ ░░░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░
░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░◢◣░░
>>101
No one-liner. Rejected.
Here is a variation of >>99 that uses two coroutines implemented via call-with-current-continuation. The coroutines bounce the task of displaying a line between each other, alternately displaying even and odd lines. The looping needed inside a coroutine is also implemented via call-with-current-continuation as in >>99. No assignments are used and all the state of the computation is passed through the various continuations. This discipline allows the various continuations to be interleaved and mixed without interfering with each other.
scheme@(guile-user)> ((lambda (rec xjoin fore back pad n s chars) ((lambda (coroutine xjoin cell cycle size) ((lambda (bounce expand) ((lambda (chars) ((lambda (symbol) ((lambda (oneline) (bounce oneline size)) (lambda (k) (display (string-append (xjoin size (lambda (j) (symbol k j)) pad) "\n"))))) (lambda (k j) (or (fore n s k j) (back n chars cell cycle k j))))) (expand chars cell))) (lambda (task n) ((coroutine task n) (cons (coroutine task n) 0))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (x) ((lambda (idx) (substring chars idx (+ 1 idx))) (quotient x n))) "")))) (lambda (task limit) (lambda (other+n) (rec (lambda (next passto k) (when (< k limit) (task k) ((lambda (next+x) (when (pair? next+x) (next (car next+x) (cdr next+x)))) (call-with-current-continuation (lambda (c) (passto (cons c (+ k 1)))))))) (car other+n) (cdr other+n)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length s) (string-length chars) (- (* 2 n) 1))) (lambda (fun . args) ((lambda (cont+args) ((lambda (cont args) ((lambda (next) (apply fun next args)) (lambda args (cont (cons cont args))))) (car cont+args) (cdr cont+args))) (call-with-current-continuation (lambda (cont) (cons cont args))))) (lambda (next n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (next (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (n s k j) (if (< (abs (- n 1 j)) (- n 1 (abs (- n 1 k)))) #f s)) ((lambda (extract) (lambda (n chars cell cycle k j) (extract chars (* cell (modulo (min (abs (- n 1 k)) (abs (- n 1 j))) cycle)) cell))) (lambda (str pos len) (substring str pos (+ pos len)))) " " 11 "co" "█▓▒░ ")separate output for 413
co co co co co co co co co co co co co co co co co co co co co
co co co co co co co co co co ██ co co co co co co co co co co
co co co co co co co co co ▓▓ ██ ▓▓ co co co co co co co co co
co co co co co co co co ▒▒ ▓▓ ██ ▓▓ ▒▒ co co co co co co co co
co co co co co co co ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ co co co co co co co
co co co co co co ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ co co co co co co
co co co co co ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ co co co co co
co co co co ░░ ░░ ░░ ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ ░░ ░░ ░░ co co co co
co co co ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▓▓ ██ ▓▓ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ co co co
co co ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ██ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ co co
co ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ co
co co ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ██ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓ co co
co co co ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▓▓ ██ ▓▓ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ co co co
co co co co ░░ ░░ ░░ ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ ░░ ░░ ░░ co co co co
co co co co co ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ co co co co co
co co co co co co ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ co co co co co co
co co co co co co co ░░ ▒▒ ▓▓ ██ ▓▓ ▒▒ ░░ co co co co co co co
co co co co co co co co ▒▒ ▓▓ ██ ▓▓ ▒▒ co co co co co co co co
co co co co co co co co co ▓▓ ██ ▓▓ co co co co co co co co co
co co co co co co co co co co ██ co co co co co co co co co co
co co co co co co co co co co co co co co co co co co co co co>>9
Star light.
The Forced Indentation Of ├┤ Tree Fractals
scheme@(guile-user)> (display ((lambda (rec xjoin extract index size start startlr n chars) ((lambda (xjoin index size) ((lambda (lincol) ((lambda (lines columns) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index lines columns k j startlr) 1)))) (car lincol) (cadr lincol))) (size (+ n 1) start))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (rows cols k j lr) (rec index rows cols k j lr)) (lambda (n rowcol) (rec size n rowcol)))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (self rows cols k j lr) ((lambda (r2 c2) (if (= k r2) (if (= j c2) (if lr 6 5) (if ((if lr < >) j c2) 0 1)) ((lambda (r4) ((lambda (r4+) (if (= j c2) (if (< k r4) 0 (if (= k r4) 3 (if (< k r4+) 2 (if (= k r4+) 4 0)))) (if (= (abs (- j c2)) 1) (if (or (= k r4) (= k r4+)) 1 0) (self self r2 (- c2 1) (if (< k r2) k (- k r2 1)) (if (< j c2) j (- j c2 2)) (< j c2))))) (+ 2 (* 3 r4)))) (quotient r2 2)))) (quotient rows 2) (quotient cols 2))) (lambda (self n rowcol) (if (= n 0) rowcol (self self (- n 1) (list (+ 1 (* 2 (car rowcol))) (+ 3 (* 2 (cadr rowcol))))))) '(1 0) #t 3 " ─│┬┴┤├"))separate output for 413
─┬─ ─┬─ ─┬─ ─┬─ ─┬─ ─┬─ ─┬─ ─┬─
├──┬──┤ ├──┬──┤ ├──┬──┤ ├──┬──┤
─┴─ │ ─┴─ ─┴─ │ ─┴─ ─┴─ │ ─┴─ ─┴─ │ ─┴─
├─────┬─────┤ ├─────┬─────┤
─┬─ │ ─┬─ │ ─┬─ │ ─┬─ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─
├──┴──┤ │ ├──┴──┤ ├──┴──┤ │ ├──┴──┤
─┴─ ─┴─ │ ─┴─ ─┴─ ─┴─ ─┴─ │ ─┴─ ─┴─
├───────────┬───────────┤
─┬─ ─┬─ │ ─┬─ ─┬─ │ ─┬─ ─┬─ │ ─┬─ ─┬─
├──┬──┤ │ ├──┬──┤ │ ├──┬──┤ │ ├──┬──┤
─┴─ │ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─
├─────┴─────┤ │ ├─────┴─────┤
─┬─ │ ─┬─ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─ ─┬─ │ ─┬─
├──┴──┤ ├──┴──┤ │ ├──┴──┤ ├──┴──┤
─┴─ ─┴─ ─┴─ ─┴─ │ ─┴─ ─┴─ ─┴─ ─┴─
├──────────────────────
─┬─ ─┬─ ─┬─ ─┬─ │ ─┬─ ─┬─ ─┬─ ─┬─
├──┬──┤ ├──┬──┤ │ ├──┬──┤ ├──┬──┤
─┴─ │ ─┴─ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─ ─┴─ │ ─┴─
├─────┬─────┤ │ ├─────┬─────┤
─┬─ │ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─
├──┴──┤ │ ├──┴──┤ │ ├──┴──┤ │ ├──┴──┤
─┴─ ─┴─ │ ─┴─ ─┴─ │ ─┴─ ─┴─ │ ─┴─ ─┴─
├───────────┴───────────┤
─┬─ ─┬─ │ ─┬─ ─┬─ ─┬─ ─┬─ │ ─┬─ ─┬─
├──┬──┤ │ ├──┬──┤ ├──┬──┤ │ ├──┬──┤
─┴─ │ ─┴─ │ ─┴─ │ ─┴─ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─
├─────┴─────┤ ├─────┴─────┤
─┬─ │ ─┬─ ─┬─ │ ─┬─ ─┬─ │ ─┬─ ─┬─ │ ─┬─
├──┴──┤ ├──┴──┤ ├──┴──┤ ├──┴──┤
─┴─ ─┴─ ─┴─ ─┴─ ─┴─ ─┴─ ─┴─ ─┴─Here is a variation of >>100 that replaces the plain meme combinator with the memestar combinator. The plain meme combinator is then expressed as a special case of the memestar combinator. The memestar combinator can be used to obtain letrec-like functionality for a group of mutually recursive functions, without resorting to hidden assignment. In this case two mutually recursive functions bounce the task of displaying the next line between each other, alternately displaying even and odd lines as in the >>104 coroutine demo.
>>> (lambda Ystar, maketask, xjoin, size, half, cell, boot, pred, n, E, L, R, C: (lambda Y, n: (lambda xjoin, half, cell, pred: (lambda symbol: (lambda oneline: (lambda even, odd: even (0)) (* Ystar (maketask (oneline, n, 0), maketask (oneline, n, 1)))) (lambda k: xjoin (2 * n, lambda j: symbol (k, j), ''))) (lambda k, j: (lambda c: L if c < 0 else R if c > 0 else C if pred (k, j // 2) else E) (boot (half, cell, n, k, j)))) (Y (xjoin), Y (half), Y (cell), Y (pred))) (lambda f: next (Ystar (f)), size (n))) (lambda *funs: (lambda x: x (x)) (lambda y: map (lambda onefun: lambda *args: onefun (* y (y)) (* args), funs)), lambda task, limit, id: lambda even, odd: lambda k: None if k >= limit else (lambda dis: (even, odd) [1 - id] (k + 1)) (print (task (k))), lambda f: lambda n, g, s: '' if n <= 0 else g (0) if n == 1 else f (n - 1, g, s) + s + g (n - 1), lambda n: 3 ** n, lambda f: lambda n, p: p >> 1 if p > n else f (n, p << 1), lambda f: lambda half, lr, k, j: 0 if j > k else lr if k == 0 else (lambda h: f (half, -lr, k - h, h - 1 - j) if j < h else f (half, lr, k - h, j - h)) (half (k, 2)), lambda half, cell, n, k, j: cell (half, -1, k, n - 1 - j) if j < n else cell (half, 1, k, j - n), lambda f: lambda k, j: ((k == 0) or (j == 0)) or (not ((k % 3 == 1) and (j % 3 == 1)) and f (k // 3, j // 3)), 3, " ", "◢", "◣", "░")separate output for 413
if your browser adds useless vertical scrollbars to code boxes after >>28 getting rid of vertical gaps:
dd pre {
line-height: 1em;
padding: 0.5em 0;
}░░░░░░░░░░░░░░░░░░░░░░░░◢◣░░◢◣░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░ ░░░░░░░░░░░◢◣◢◣◢◣◢◣░░░░░░░░░░░ ░░░░░░
░░ ░░ ░░ ░░░░ ◢◣ ◢◣ ░░░░ ░░ ░░ ░░
░░░░░░ ░░░░░░░░░◢◣◢◣ ◢◣◢◣░░░░░░░░░ ░░░░░░
░░░░░░░░░░░░░░░░░░░░◢◣░░◢◣░░◢◣░░◢◣░░░░░░░░░░░░░░░░░░░░
░░ ░░░░ ░░░░ ░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░ ░░░░ ░░░░ ░░
░░░░░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░◢◣◢◣ ◢◣◢◣░░░░░░░░░░░░░░░░░
░░ ░░░░ ░░░░ ◢◣ ◢◣ ◢◣ ◢◣ ░░░░ ░░░░ ░░
░░░░░░░░░░░░░░░◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣░░░░░░░░░░░░░░░
░░░░░░ ░░◢◣░░ ◢◣ ◢◣ ░░◢◣░░ ░░░░░░
░░ ░░ ░◢◣◢◣░ ◢◣◢◣ ◢◣◢◣ ░◢◣◢◣░ ░░ ░░
░░░░░░ ◢◣░░◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣░░◢◣ ░░░░░░
░░░░░░░░░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░░░░░░░░░
░░ ░░░░ ◢◣░░ ░░ ░░ ░░◢◣ ░░░░ ░░
░░░░░░░░░◢◣◢◣░░░░░ ░░░░░◢◣◢◣░░░░░░░░░
░░░░░░░░◢◣░░◢◣░░░░░░░░░░░░░░░░░░░░░░░░░░◢◣░░◢◣░░░░░░░░
░░ ░░░◢◣◢◣◢◣◢◣ ░░░░ ░░░░ ░░░░ ░░░░ ◢◣◢◣◢◣◢◣░░░ ░░
░░░░░░◢◣░░░░░░◢◣░░░░░░░░░░░░░░░░░░░░░░◢◣░░░░░░◢◣░░░░░░
░░░░░◢◣◢◣ ░◢◣◢◣░░░░░░░ ░░░░░░░◢◣◢◣░ ◢◣◢◣░░░░░
░░ ◢◣ ◢◣ ◢◣ ◢◣░░ ░░ ░░ ░░◢◣ ◢◣ ◢◣ ◢◣ ░░
░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░░░ ░░░░░◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣░░░
░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░◢◣░░░░░░░░░░░░░░◢◣░░
░◢◣◢◣░░░ ░░░░ ░◢◣◢◣ ░░░░ ░░░░ ◢◣◢◣░ ░░░░ ░░░◢◣◢◣░
◢◣░░◢◣░░░░░░░░░░◢◣░░◢◣░░░░░░░░░░◢◣░░◢◣░░░░░░░░░░◢◣░░◢◣The Forced Indentation Of Overlapping, Gapped Tile Heaps
scheme@(guile-user)> (display ((lambda (rec xjoin extract index spec chars n) ((lambda (xjoin index lines columns) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index (- k (* 2 n)) (- j (* 4 n) -1)) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (k j) (rec index spec k j)) (* 4 n) (- (* 8 n) 1))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (center? fromspec) (lambda (self spec k j) (if (center? k j) (fromspec spec k j) (if (= j 0) (self self spec (- (modulo (+ k 2) 4) 2) 0) (self self spec (+ k (if (< k 0) 2 -2)) (+ j (if (< j 0) 4 -4))))))) (lambda (k j) (and (<= -2 k 1) (<= -3 j 3))) (lambda (spec k j) (vector-ref spec (+ (* 7 (+ k 2)) j 3)))) #(3 1 8 1 8 1 4 9 0 0 0 0 0 10 9 0 0 0 0 0 10 5 1 7 1 7 1 6) " ─│┌┐└┘┬┴┤├" 6))
┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐
┤ ├─┤ ├─┤ ├─┤ ├─┤ ├─┤ ├
┤ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ├
└─┬─┤ ├─┤ ├─┤ ├─┤ ├─┤ ├─┬─┘
┌─┴─┤ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ├─┴─┐
┤ └─┬─┤ ├─┤ ├─┤ ├─┤ ├─┬─┘ ├
┤ ┌─┴─┤ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ├─┴─┐ ├
└─┬─┤ └─┬─┤ ├─┤ ├─┤ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ┌─┴─┴─┐ ┌─┴─┴─┐ ├─┴─┐ ├─┴─┐
┤ └─┬─┤ └─┬─┤ ├─┤ ├─┬─┘ ├─┬─┘ ├
┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┴─┐ ├─┴─┐ ├─┴─┐ ├
└─┬─┤ └─┬─┤ └─┬─┤ ├─┬─┘ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ├─┴─┐ ├─┴─┐ ├─┴─┐
┤ └─┬─┤ └─┬─┤ └─┬─┬─┘ ├─┬─┘ ├─┬─┘ ├
┤ ┌─┴─┤ ┌─┴─┤ ├─┤ ├─┴─┐ ├─┴─┐ ├
└─┬─┤ └─┬─┤ └─┬─┬─┘ └─┬─┬─┘ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ├─┤ ├─┤ ├─┴─┐ ├─┴─┐
┤ └─┬─┤ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ ├─┬─┘ ├
┤ ┌─┴─┤ ├─┤ ├─┤ ├─┤ ├─┴─┐ ├
└─┬─┤ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ ├─┬─┘
┌─┴─┤ ├─┤ ├─┤ ├─┤ ├─┤ ├─┴─┐
┤ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ ├
┤ ├─┤ ├─┤ ├─┤ ├─┤ ├─┤ ├
└─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘
scheme@(guile-user)> >>111
One-line 3D graphics
The Forced Resumption Of Tile Heap Fractals
scheme@(guile-user)> (display ((lambda (rec xjoin extract index size spec chars n) ((lambda (xjoin index size) ((lambda (lincol) ((lambda (lines columns) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index lines columns k j) 1)))) (car lincol) (cadr lincol))) (size n '(4 7)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (rows cols k j) (rec index spec rows cols k j #f)) (lambda (n rowcol) (rec size n rowcol)))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (base? fromspec) (lambda (self spec lines columns k j over) (if (base? lines columns) (fromspec spec k j over) ((lambda (l2 c2) (if (and (<= (- l2 2) k (+ l2 1)) (<= (- c2 3) j (+ c2 3))) (self self spec 4 7 (- k l2 -2) (- j c2 -3) #t) (if (= j c2) 0 (self self spec l2 c2 (if (< k l2) k (- k l2)) (if (< j c2) j (- j c2 1)) #f)))) (quotient lines 2) (quotient columns 2))))) (lambda (lin col) (and (= lin 4) (= col 7))) (lambda (spec k j over) ((lambda (cell) (if (pair? cell) (if over (car cell) (cadr cell)) cell)) (vector-ref spec (+ j (* 7 k)))))) (lambda (self n rowcol) (if (= n 0) rowcol (self self (- n 1) (list (* 2 (car rowcol)) (+ 1 (* 2 (cadr rowcol))))))) #(3 1 (8 1) 1 (8 1) 1 4 (9 2) 0 0 0 0 0 (10 2) (9 2) 0 0 0 0 0 (10 2) 5 1 (7 1) 1 (7 1) 1 6) " ─│┌┐└┘┬┴┤├" 2))
┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐
│ │ │ │ │ │ │ │
│ ┌─┴─┴─┐ │ │ ┌─┴─┴─┐ │
└───┤ ├───┘ └───┤ ├───┘
┌───┤ ├───┐ ┌───┤ ├───┐
│ └─┬─┬─┘ │ │ └─┬─┬─┘ │
│ │ │ ┌─┴─┴─┐ │ │ │
└─────┘ └───┤ ├───┘ └─────┘
┌─────┐ ┌───┤ ├───┐ ┌─────┐
│ │ │ └─┬─┬─┘ │ │ │
│ ┌─┴─┴─┐ │ │ ┌─┴─┴─┐ │
└───┤ ├───┘ └───┤ ├───┘
┌───┤ ├───┐ ┌───┤ ├───┐
│ └─┬─┬─┘ │ │ └─┬─┬─┘ │
│ │ │ │ │ │ │ │
└─────┘ └─────┘ └─────┘ └─────┘
scheme@(guile-user)> level 4: http://paste.textboard.org/65462c0b/raw
if your browser adds useless vertical scrollbars to code boxes after >>28 getting rid of vertical gaps:
dd pre {
line-height: 1em;
padding: 0.5em 0;
}updated counts >>76 from April
1 9 12 391 >>> 35 40
2 10 7 461 scheme@(guile-user)> 40 36
3 11 13 483 >> 31 34
4 13 15 627 >> 25 30
5 14 13 471 >> 32 35
6 17 14 524 >>> 29 32
7 21 18 789 >>> 22 26
8 24 15 851 scheme@(guile-user)> 26 25
9 25 13 692 scheme@(guile-user)> 33 28
10 28 25 1599 >>> 6 5
11 30 10 508 >> 36 33
12 34 13 560 >> 34 31
13 35 19 1375 scheme@(guile-user)> 19 10
14 37 15 642 >> 27 29
15 39 21 909 >> 12 22
16 42 10 452 >> 37 38
17 43 10 444 >> 38 39
18 46 18 707 >>> 23 27
19 49 23 1070 >>> 9 17
20 53 21 873 >>> 13 24
21 55 14 1066 scheme@(guile-user)> 30 19
22 59 21 1475 scheme@(guile-user)> 14 7
23 65 19 1110 scheme@(guile-user)> 20 16
24 67 25 1716 >>> 7 3
25 69 10 460 >> 39 37
26 70 20 1333 scheme@(guile-user)> 17 12
27 72 25 1717 scheme@(guile-user)> 8 2
28 77 33 2654 scheme@(guile-user)> 1 1
29 81 20 1459 scheme@(guile-user)> 18 8
30 85 30 1180 >> 4 14
31 89 32 1176 >> 2 15
32 90 18 1067 scheme@(guile-user)> 24 18
33 95 21 888 >>> 15 23
34 99 23 1262 scheme@(guile-user)> 10 13
35 100 22 993 >>> 11 21
36 104 30 1649 scheme@(guile-user)> 5 4
37 107 19 1391 scheme@(guile-user)> 21 9
38 109 31 1336 >>> 3 11
39 111 15 1062 scheme@(guile-user)> 28 20
40 113 21 1566 scheme@(guile-user)> 16 6The Forced Resurrection of Tile Heap Fractal Dust
scheme@(guile-user)> (display ((lambda (rec xjoin extract index size spec chars n) ((lambda (xjoin index size) ((lambda (lincol) ((lambda (lines columns) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index lines columns k j) 1)))) (car lincol) (cadr lincol))) (size n '(4 7)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (rows cols k j) (rec index spec rows cols k j 0)) (lambda (n rowcol) (rec size n rowcol)))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (base? fromspec cornerid) (lambda (self spec lines columns k j corners) (if (base? lines columns) (fromspec spec k j corners) ((lambda (l2 c2) (if (and (<= (- l2 2) k (- (* 2 l2) 3)) (<= (- c2 3) j (- (* 2 c2) 4))) (self self spec l2 c2 (- k l2 -2) (- j c2 -3) 5) ((lambda (up down left right) (if (and (or up down) (or left right)) ((lambda (corid) (self self spec l2 c2 (if up k (- k (* 2 l2) -4)) (if left j (- j (* 2 c2) -6)) (if (or (= corners 5) (= corners corid)) corid 0))) (cornerid up left)) 0)) (< k l2) (>= k (- (* 2 l2) 4)) (< j c2) (>= j (- (* 2 c2) 6))))) (quotient (+ lines 4) 3) (quotient (+ columns 6) 3))))) (lambda (lin col) (and (= lin 4) (= col 7))) (lambda (spec k j corners) ((lambda (cell) (if (pair? cell) (if (or (= corners 5) (= corners (car cell))) (cadr cell) (caddr cell)) cell)) (vector-ref spec (+ j (* 7 k))))) (lambda (up left) (if up (if left 1 2) (if left 3 4)))) (lambda (self n rowcol) (if (= n 0) rowcol (self self (- n 1) (list (- (* 3 (car rowcol)) 4) (- (* 3 (cadr rowcol)) 6))))) #(3 1 (1 8 1) 1 (2 8 1) 1 4 (1 9 2) 0 0 0 0 0 (2 10 2) (3 9 2) 0 0 0 0 0 (4 10 2) 5 1 (3 7 1) 1 (4 7 1) 1 6) " ─│┌┐└┘┬┴┤├" 2))
┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐
│ │ │ │ │ │ │ │
│ ┌─┴─┴─┐ │ │ ┌─┴─┴─┐ │
└───┤ ├───┘ └───┤ ├───┘
┌───┤ ├───┐ ┌───┤ ├───┐
│ └─┬─┬─┘ │ │ └─┬─┬─┘ │
│ │ │ ┌─┴───┐ ┌───┴─┐ │ │ │
└─────┘ └───┤ │ │ ├───┘ └─────┘
│ ┌─┴─┴─┐ │
└───┤ ├───┘
┌───┤ ├───┐
│ └─┬─┬─┘ │
┌─────┐ ┌───┤ │ │ ├───┐ ┌─────┐
│ │ │ └─┬───┘ └───┬─┘ │ │ │
│ ┌─┴─┴─┐ │ │ ┌─┴─┴─┐ │
└───┤ ├───┘ └───┤ ├───┘
┌───┤ ├───┐ ┌───┤ ├───┐
│ └─┬─┬─┘ │ │ └─┬─┬─┘ │
│ │ │ │ │ │ │ │
└─────┘ └─────┘ └─────┘ └─────┘
scheme@(guile-user)> The fractal dust of >>115 has a ratio of area covered by tiles to area of the enclosing rectangle that converges to 0. This is because at each new level the cover ratio is multiplied by a factor that converges to 5/9, so the overall product will drop below any strictly positive bound.
The tile heap of >>111 has a cover ratio that converges to a fixed value. With symmetry assumptions of square tiles and gaps and overlaps that are one third of a tile, the heap can be divided into quadrants, arbitrarily choosing to put the (0, 0) cell into the first quadrant, and the quadrants can be retiled with repeating 4x4 blocks:
2 2 2 2 | 1 1 1 1
0 2 2 2 | 0 1 1 1
2 2 2 2 | 1 1 1 1
2 2 0 2 | 1 1 0 1
--------+--------
3 3 3 3 | 4 4 4 4
0 3 3 3 | 0 4 4 4
3 3 3 3 | 4 4 4 4
3 3 0 3 | 4 4 0 4Since each 4x4 block has two empty cells, the cover ratio converges to 7/8.
The ratio for the non-dust fractal of >>113 is only slightly harder to obtain. Using the same symmetry assumptions, at each new level the overall size is doubled and incremented by one, while the occupied cell count is multiplied by 4 and incremented by 9 - 4 = 5. The overall size forms the stream 3, 7, 15, 31, 63... which is one less than the next power of 2. The occupied cell count is C(n+1) = 4 * C(n) + 5, with C(0) depending on our choice of starting pattern. We would obtain the same result by choosing either a single 3x3 tile or a 5-group of corners-and-center as our starting pattern, but I find the latter to be clearer because it already exhibits the replication rule. So here we will take C(0) = 4 * 9 + 9 - 4 = 41 and an overall size that starts with 7. We get the ratio:
C(n)
-----------------------
(2 ** (3 + n) - 1) ** 2Expanding C(n) recursively as 4 * C(n-1) + 5 with C(0) = 41 yields:
C(n) = 41 * 4n + 5 * 4(n-1) + 5 * 4**(n-2) + ... + 5 * 4 + 5
We split the 41 back into 36 + 5 and we take Q to be 4**n and we get:
C(n) = 36 * Q + 5 * Q * (1 + 1/4 + 1/42 + ... + 1/4n)
The parens contain the partial sum of the geometric series of ratio 1/4. In the limit the partial sum becomes the actual sum of the series.
Since the sum of the geometric series of ratio 1/N is N / (N - 1), our sum becomes 4/3. Substituting into the numerator and expanding the square in the denominator we get:
36 * Q + 5 * Q * 4/3
-------------------------
64 * Q - 16 * sqrt(Q) + 1The latter two terms in the denominator, a constant and a term proportional to 2n, become insignificant compared to the dominant term proportional to 2(2*n) as n grows, so in the limit they do not influence the ratio and can be ignored. Our ratio thus becomes (36 + 20/3) / 64 which is 2/3.
Empirically, without simplifying the denominator or anything else:
>>> C = lambda n: 41 if n < 1 else 4 * C (n - 1) + 5
>>> D = lambda n: (2 ** (3 + n) - 1) ** 2
>>> R = lambda n: (lambda a, b: (a / b, a, b)) (C (n), D (n))
>>> print ("\n".join (map (lambda kr: "{}. {} = {} / {}".format (kr [0], kr [1] [0], kr [1] [1], kr [1] [2]), map (lambda k: (k, R (k)), range (10)))))
0. 0.8367346938775511 = 41 / 49
1. 0.7511111111111111 = 169 / 225
2. 0.708636836628512 = 681 / 961
3. 0.6875787351977828 = 2729 / 3969
4. 0.6771033542067084 = 10921 / 16129
5. 0.6718800461361015 = 43689 / 65025
6. 0.6692720999077056 = 174761 / 261121
7. 0.6679690672690389 = 699049 / 1046529
8. 0.667317787728488 = 2796201 / 4190209
9. 0.6669922073585077 = 11184809 / 16769025
>>> print ("\n".join (map (lambda kr: "{}. {} = {} / {}".format (kr [0], kr [1] [0], kr [1] [1], kr [1] [2]), map (lambda k: (k, R (k)), range (10, 51, 5)))))
10. 0.666829432049174 = 44739241 / 67092481
15. 0.6666717529345381 = 45812984489 / 68718952449
20. 0.6666668256123908 = 46912496118441 / 70368727400449
25. 0.6666666716337204 = 48038396025285289 / 72057593501057025
30. 0.6666666668218871 = 49191317529892137641 / 73786976277658337281
35. 0.6666666666715173 = 50371909150609548946089 / 75557863725364567605249
40. 0.6666666666668183 = 51580834970224178120796841 / 77371252455318674995150849
45. 0.6666666666666714 = 52818775009509558395695966889 / 79228162514263774643590529025
50. 0.6666666666666669 = 54086425609737787797192670096041 / 81129638414606663681390495662081
>>> So, even though it may not be intuitively or visually obvious, as the recursion level increases the pattern of >>113 has two thirds of its enclosing area covered by tiles.
And of course I forgot that ** is the bold markup over here.
Fixes:
C(n) = 41 * 4^n + 5 * 4^(n-1) + 5 * 4^(n-2) + ... + 5 * 4 + 5
C(n) = 36 * Q + 5 * Q * (1 + 1/4 + 1/4^2 + ... + 1/4^n)
The latter two terms in the denominator, a constant and a term proportional to 2^n, become insignificant compared to the dominant term proportional to 2^(2*n) as n grows, so in the limit they do not influence the ratio and can be ignored.
The Forced Indentation Of Staring Into the Abyss
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars n) ((lambda (xjoin lines columns) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index lines columns k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (* 2 n) (- (* 6 n) 2))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (half) (lambda (lines columns k j) (apply (lambda (k up j left) ((lambda (jd jm) (if (<= jd (- k 2)) 1 (if (= jd (- k 1)) (if (= jm 1) (if up 3 4) 1) (if (= jd k) (if (= jm 0) 1 (if (= jm 1) (if left 6 5) 0)) (if (= jm 1) 2 0))))) (quotient j 3) (modulo j 3))) `(,@(half lines k) ,@(half columns j))))) (lambda (lines k) ((lambda (l2) (if (< k l2) `(,(- l2 k 1) #t) `(,(- k l2) #f))) (quotient lines 2)))) " ─│┬┴┤├" 9))
├──┬────────────────────────────────────────────┬──┤
│ ├──┬──────────────────────────────────────┬──┤ │
│ │ ├──┬────────────────────────────────┬──┤ │ │
│ │ │ ├──┬──────────────────────────┬──┤ │ │ │
│ │ │ │ ├──┬────────────────────┬──┤ │ │ │ │
│ │ │ │ │ ├──┬──────────────┬──┤ │ │ │ │ │
│ │ │ │ │ │ ├──┬────────┬──┤ │ │ │ │ │ │
│ │ │ │ │ │ │ ├──┬──┬──┤ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ ├──┤ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ ├──┤ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ ├──┴──┴──┤ │ │ │ │ │ │ │
│ │ │ │ │ │ ├──┴────────┴──┤ │ │ │ │ │ │
│ │ │ │ │ ├──┴──────────────┴──┤ │ │ │ │ │
│ │ │ │ ├──┴────────────────────┴──┤ │ │ │ │
│ │ │ ├──┴──────────────────────────┴──┤ │ │ │
│ │ ├──┴────────────────────────────────┴──┤ │ │
│ ├──┴──────────────────────────────────────┴──┤ │
├──┴────────────────────────────────────────────┴──┤
scheme@(guile-user)> if your browser adds useless vertical scrollbars to code boxes after >>28 getting rid of vertical gaps: >>109
The Forced Redemption of Circularly Overlapping Tile Meshes
>> console.log (((self, xjoin, symbol, tile, n) => ((xjoin, lines, columns) => xjoin (lines, "\n", k => xjoin (columns, "", j => symbol (tile, k, j)))) (self (xjoin), n * tile.length, n * tile [0].length)) (f => (...args) => f (f) (...args), me => (n, s, f) => n <= 0 ? "" : n == 1 ? f (0) : me (me) (n - 1, s, f) + s + f (n - 1), (mod => (tile, k, j) => tile [mod (k, tile.length)] [mod (j, tile [0].length)]) ((a, p) => ((a % p) + p) % p), [" ├─┴─┐ ", "┬─┘ ├─", "┤ ┌─┴─", "└─┬─┤ "], 6))
├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐
┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─
┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─
└─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤
├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐
┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─
┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─
└─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤
├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐
┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─
┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─
└─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤
├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐
┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─
┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─
└─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤
├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐
┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─
┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─
└─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤
├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐
┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─
┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─
└─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤
<- undefined
>> using the generic tile support from >>30
The Forced Indentation of Flower Gardens
scheme@(guile-user)> (display ((lambda (rec xjoin extract index patch chars band n) ((lambda (xjoin lines columns cycle) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle n k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ (* 2 n) 1) (+ (* 4 n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (div) (lambda (patch band cycle n k j) ((lambda (k j) (if (or (= (modulo (+ k j) band) 0) (= (modulo (- k j) band) 0)) 0 (+ (patch (- cycle 1) (div (+ k j) band) (div (- k j) band)) 1))) (- k n) (- j (* 2 n))))) (lambda (a b) (quotient (- a (modulo a b)) b))) (lambda (cycle x y) (modulo (* x y) cycle)) "🌵🌹💮🌼🌸🌻🌷🌺" 6 9))separate output for
413 Request Entity Too Large nginx/1.20.2
larger version: http://paste.textboard.org/e997be9b/raw
apply
* { line-height: 1em; }
to the larger version for more symmetry
if your browser adds useless vertical scrollbars to code boxes after >>28 getting rid of vertical gaps: >>109
🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵🌻🌻🌻🌻🌻🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼
🌼🌼🌵🌸🌵🌹🌹🌹🌵🌹🌵🌸🌸🌸🌵🌼🌵🌻🌻🌻🌵🌼🌵🌸🌸🌸🌵🌹🌵🌹🌹🌹🌵🌸🌵🌼🌼
🌼🌵🌸🌸🌸🌵🌹🌵🌹🌹🌹🌵🌸🌵🌼🌼🌼🌵🌻🌵🌼🌼🌼🌵🌸🌵🌹🌹🌹🌵🌹🌵🌸🌸🌸🌵🌼
🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵
🌺🌵🌸🌸🌸🌵🌻🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼🌵💮🌵🌼🌼🌼🌵🌹🌵🌹🌹🌹🌵🌻🌵🌸🌸🌸🌵🌺
🌺🌺🌵🌸🌵🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌼🌵💮💮💮🌵🌼🌵🌹🌹🌹🌵🌹🌵🌻🌻🌻🌵🌸🌵🌺🌺
🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵💮💮💮💮💮🌵🌹🌹🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺
🌺🌺🌵💮🌵🌻🌻🌻🌵🌷🌵🌹🌹🌹🌵🌹🌵💮💮💮🌵🌹🌵🌹🌹🌹🌵🌷🌵🌻🌻🌻🌵💮🌵🌺🌺
🌺🌵💮💮💮🌵🌻🌵🌷🌷🌷🌵🌹🌵🌹🌹🌹🌵💮🌵🌹🌹🌹🌵🌹🌵🌷🌷🌷🌵🌻🌵💮💮💮🌵🌺
🌵💮💮💮💮💮🌵🌷🌷🌷🌷🌷🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌷🌷🌷🌷🌷🌵💮💮💮💮💮🌵
🌷🌵💮💮💮🌵🌸🌵🌷🌷🌷🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌷🌷🌷🌵🌸🌵💮💮💮🌵🌷
🌷🌷🌵💮🌵🌸🌸🌸🌵🌷🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌷🌵🌸🌸🌸🌵💮🌵🌷🌷
🌷🌷🌷🌵🌸🌸🌸🌸🌸🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌸🌸🌸🌸🌸🌵🌷🌷🌷
🌷🌷🌵💮🌵🌸🌸🌸🌵🌷🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌷🌵🌸🌸🌸🌵💮🌵🌷🌷
🌷🌵💮💮💮🌵🌸🌵🌷🌷🌷🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌷🌷🌷🌵🌸🌵💮💮💮🌵🌷
🌵💮💮💮💮💮🌵🌷🌷🌷🌷🌷🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌷🌷🌷🌷🌷🌵💮💮💮💮💮🌵
🌺🌵💮💮💮🌵🌻🌵🌷🌷🌷🌵🌹🌵🌹🌹🌹🌵💮🌵🌹🌹🌹🌵🌹🌵🌷🌷🌷🌵🌻🌵💮💮💮🌵🌺
🌺🌺🌵💮🌵🌻🌻🌻🌵🌷🌵🌹🌹🌹🌵🌹🌵💮💮💮🌵🌹🌵🌹🌹🌹🌵🌷🌵🌻🌻🌻🌵💮🌵🌺🌺
🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵💮💮💮💮💮🌵🌹🌹🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺>>122
Awesome.
>>122
Pretty
But it serves a practical purpose as well. In >>101 >>110 the rendering was constrained by the available Unicode characters and the means of combining them. As a result the carpet does not show through in the half-empty cells of the Sierpinski triangle, which is inelegant. Rendering the Sierpinski triangle over the carpet over the flower garden will provide one solution to this issue, by allowing the carpet to show through in the half-empty cells.
The demos will be built up progressively to that point to make them easier to follow.
A gapless spiral centered on a 2x2 block, as opposed to a gapped spiral >>13 centered on a single cell.
scheme@(guile-user)> (display ((lambda (rec xjoin extract index pad chars n) ((lambda (xjoin lines columns cycle) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) pad) "\n")) "")) (lambda (k j) (extract chars (modulo (index n k j) cycle) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (* 2 n) (* 2 n) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (ring inside inring) (lambda (n k j) ((lambda (k j) ((lambda (ring) (+ (inside ring) (inring ring k j))) (ring k j))) (- n 1 k) (- j n)))) (lambda (k j) (quotient (+ (max (abs (+ (* 2 k) 1)) (abs (+ (* 2 j) 1))) 1) 2)) (lambda (ring) (if (< ring 2) 0 (* 4 (- ring 1) (- ring 1)))) (lambda (ring k j) (if (= k (- ring)) (+ (* 7 ring) -4 j) (if (= j (- ring)) (- (* 5 ring) 4 k) (if (= k (- ring 1)) (- (* 3 ring) 3 j) (+ ring -1 k)))))) " " "①②③④⑤⑥⑦⑧⑨" 5))
① ⑨ ⑧ ⑦ ⑥ ⑤ ④ ③ ② ①
② ⑤ ④ ③ ② ① ⑨ ⑧ ⑦ ⑨
③ ⑥ ⑧ ⑦ ⑥ ⑤ ④ ③ ⑥ ⑧
④ ⑦ ⑨ ① ⑨ ⑧ ⑦ ② ⑤ ⑦
⑤ ⑧ ① ② ② ① ⑥ ① ④ ⑥
⑥ ⑨ ② ③ ③ ④ ⑤ ⑨ ③ ⑤
⑦ ① ③ ④ ⑤ ⑥ ⑦ ⑧ ② ④
⑧ ② ④ ⑤ ⑥ ⑦ ⑧ ⑨ ① ③
⑨ ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ① ②
① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ①
scheme@(guile-user)> The flower garden >>122 is centered on a single cactus when the unit is a character, but when a flower patch is the unit it is centered on a 2x2 block.
Example of 8K post without 413 Request Entity Too Large:
https://textboard.org/prog/489#t489p47
🌼🌼🌼🌵💮💮💮💮💮🌵💮💮💮💮💮🌵🌼🌼🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹
🌼🌼🌵🌼🌵💮💮💮🌵🌼🌵💮💮💮🌵🌸🌵🌼🌼🌼🌵💮🌵🌹🌹🌹🌵🌸🌵🌻🌻🌻🌵🌷🌵🌹🌹
🌼🌵🌼🌼🌼🌵💮🌵🌼🌼🌼🌵💮🌵🌸🌸🌸🌵🌼🌵💮💮💮🌵🌹🌵🌸🌸🌸🌵🌻🌵🌷🌷🌷🌵🌹
🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌸🌸🌸🌸🌸🌵💮💮💮💮💮🌵🌸🌸🌸🌸🌸🌵🌷🌷🌷🌷🌷🌵
🌸🌵🌼🌼🌼🌵🌸🌵🌼🌼🌼🌵🌹🌵🌸🌸🌸🌵🌷🌵💮💮💮🌵🌻🌵🌸🌸🌸🌵🌼🌵🌷🌷🌷🌵🌺
🌸🌸🌵🌼🌵🌸🌸🌸🌵🌼🌵🌹🌹🌹🌵🌸🌵🌷🌷🌷🌵💮🌵🌻🌻🌻🌵🌸🌵🌼🌼🌼🌵🌷🌵🌺🌺
🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌷🌷🌷🌷🌷🌵🌻🌻🌻🌻🌻🌵🌼🌼🌼🌼🌼🌵🌺🌺🌺
🌸🌸🌵🌹🌵🌸🌸🌸🌵🌺🌵🌹🌹🌹🌵🌻🌵🌷🌷🌷🌵🌺🌵🌻🌻🌻🌵🌷🌵🌼🌼🌼🌵💮🌵🌺🌺
🌸🌵🌹🌹🌹🌵🌸🌵🌺🌺🌺🌵🌹🌵🌻🌻🌻🌵🌷🌵🌺🌺🌺🌵🌻🌵🌷🌷🌷🌵🌼🌵💮💮💮🌵🌺
🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺🌺🌺🌵🌷🌷🌷🌷🌷🌵💮💮💮💮💮🌵
🌺🌵🌹🌹🌹🌵🌷🌵🌺🌺🌺🌵💮🌵🌻🌻🌻🌵🌹🌵🌺🌺🌺🌵🌺🌵🌷🌷🌷🌵🌻🌵💮💮💮🌵🌸
🌺🌺🌵🌹🌵🌷🌷🌷🌵🌺🌵💮💮💮🌵🌻🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌷🌵🌻🌻🌻🌵💮🌵🌸🌸
🌺🌺🌺🌵🌷🌷🌷🌷🌷🌵💮💮💮💮💮🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵🌸🌸🌸
🌺🌺🌵🌷🌵🌷🌷🌷🌵🌻🌵💮💮💮🌵🌼🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌷🌵🌻🌻🌻🌵🌼🌵🌸🌸
🌺🌵🌷🌷🌷🌵🌷🌵🌻🌻🌻🌵💮🌵🌼🌼🌼🌵🌹🌵🌹🌹🌹🌵🌺🌵🌷🌷🌷🌵🌻🌵🌼🌼🌼🌵🌸
🌵🌷🌷🌷🌷🌷🌵🌻🌻🌻🌻🌻🌵🌼🌼🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌷🌷🌷🌷🌷🌵🌼🌼🌼🌼🌼🌵
🌻🌵🌷🌷🌷🌵🌻🌵🌻🌻🌻🌵💮🌵🌼🌼🌼🌵🌸🌵🌹🌹🌹🌵🌺🌵🌷🌷🌷🌵💮🌵🌼🌼🌼🌵🌺
🌻🌻🌵🌷🌵🌻🌻🌻🌵🌻🌵💮💮💮🌵🌼🌵🌸🌸🌸🌵🌹🌵🌺🌺🌺🌵🌷🌵💮💮💮🌵🌼🌵🌺🌺
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵💮💮💮💮💮🌵🌸🌸🌸🌸🌸🌵🌺🌺🌺🌺🌺🌵💮💮💮💮💮🌵🌺🌺🌺Spiral >>126 Flower Garden >>122
scheme@(guile-user)> (display ((lambda (rec xjoin extract index patch chars band n) ((lambda (xjoin lines columns cycle) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle n k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ (* 2 n) 1) (+ (* 4 n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (div) (lambda (patch band cycle n k j) ((lambda (k j) (if (or (= (modulo (+ k j) band) 0) (= (modulo (- k j) band) 0)) 0 (+ (patch (- cycle 1) (div (+ k j) band) (div (- k j) band)) 1))) (- k n) (- j (* 2 n))))) (lambda (a b) (quotient (- a (modulo a b)) b))) ((lambda (spiral) (lambda (cycle x y) (modulo (spiral x y) cycle))) ((lambda (ring inside inring) (lambda (k j) ((lambda (ring) (+ (inside ring) (inring ring k j))) (ring k j)))) (lambda (k j) (quotient (+ (max (abs (+ (* 2 k) 1)) (abs (+ (* 2 j) 1))) 1) 2)) (lambda (ring) (if (< ring 2) 0 (* 4 (- ring 1) (- ring 1)))) (lambda (ring k j) (if (= k (- ring)) (+ (* 7 ring) -4 j) (if (= j (- ring)) (- (* 5 ring) 4 k) (if (= k (- ring 1)) (- (* 3 ring) 3 j) (+ ring -1 k))))))) "🌵🌹🌺🌷🌻💮🌼🌸" 6 9))separate output >>128 for 413 >>127
larger version: http://paste.textboard.org/7f304d10/raw
apply
* { line-height: 1em; }
to the larger version for more symmetry
in the next episode: >>17
some shitty-looking waves in elixir, I honestly don't know if this complies with everything in >>33 because everyone else seems to be using combinators/lambda recursion of some sort
iex(1)> IO.puts(Enum.to_list 0..499 |> Enum.map(fn char -> (fn x, y -> if(x == 0, [do: "\n", else: if(trunc(-7*:math.pow(:math.cos(:math.sin(x/6)), 9)+10) == y, [do: "⚪", else: "🔵"])]) end).(rem(char, 50), trunc(char/50)) end))
🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵
🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵
🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵
⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵
🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵
🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵
🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵
🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵
🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵⚪🔵🔵🔵🔵🔵🔵🔵🔵
🔵🔵🔵🔵⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪🔵🔵🔵🔵🔵🔵🔵🔵⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪🔵🔵🔵🔵🔵🔵🔵🔵⚪⚪⚪⚪⚪⚪⚪⚪
:ok
iex(2)>the bit inside the trunc() can be changed to graph any f(x)-pattern function~
>>130
Thanks for contributing, and especially for picking a fresh language for the thread.
I honestly don't know if this complies with everything in >>33 because everyone else seems to be using combinators/lambda recursion of some sort
Compliance with all of >>33 is recommended but not strictly required.
Sierpinski carpet >>17 quadrant butterflies invading the spiral flower garden >>129
scheme@(guile-user)> (display ((lambda (rec xjoin extract index patch carpet chars band n) ((lambda (xjoin carpet lines columns cycle) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle n k j) 1)))) (lambda (cycle k j) (patch carpet cycle k j)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (k j) (rec carpet k j)) (+ (* 2 n) 1) (+ (* 2 n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (div) (lambda (patch band cycle n k j) ((lambda (k j) (if (or (= (modulo (+ k j) band) 0) (= (modulo (- k j) band) 0)) 0 (+ (patch (- cycle 1) (div (+ k j) band) (div (- k j) band)) 1))) (- k n) (- j n)))) (lambda (a b) (quotient (- a (modulo a b)) b))) ((lambda (spiral carpets) (lambda (carpet cycle x y) (if (carpets carpet x y) (+ (modulo (spiral x y) (- cycle 1)) 1) 0))) ((lambda (ring inside inring) (lambda (k j) ((lambda (ring) (+ (inside ring) (inring ring k j))) (ring k j)))) (lambda (k j) (quotient (+ (max (abs (+ (* 2 k) 1)) (abs (+ (* 2 j) 1))) 1) 2)) (lambda (ring) (if (< ring 2) 0 (* 4 (- ring 1) (- ring 1)))) (lambda (ring k j) (if (= k (- ring)) (+ (* 7 ring) -4 j) (if (= j (- ring)) (- (* 5 ring) 4 k) (if (= k (- ring 1)) (- (* 3 ring) 3 j) (+ ring -1 k)))))) (lambda (carpet k j) (if (>= k 0) (if (>= j 0) (carpet k j) (carpet k (- -1 j))) (if (>= j 0) (carpet (- -1 k) j) (carpet (- -1 k) (- -1 j)))))) (lambda (self k j) (if (or (= k 0) (= j 0)) #t (if (and (= (modulo k 3) 1) (= (modulo j 3) 1)) #f (self self (quotient k 3) (quotient j 3))))) "🌵🦋🌹🌺🌷🌻💮🌼🌸" 6 9))
🌵💮💮💮💮💮🌵🦋🦋🦋🦋🦋🌵🌹🌹🌹🌹🌹🌵
🌼🌵💮💮💮🌵🌸🌵🦋🦋🦋🌵💮🌵🌹🌹🌹🌵🌸
🌼🌼🌵💮🌵🌸🌸🌸🌵🦋🌵💮💮💮🌵🌹🌵🌸🌸
🌼🌼🌼🌵🌸🌸🌸🌸🌸🌵💮💮💮💮💮🌵🌸🌸🌸
🌼🌼🌵🌹🌵🌸🌸🌸🌵🌷🌵💮💮💮🌵🌻🌵🌸🌸
🌼🌵🌹🌹🌹🌵🌸🌵🌷🌷🌷🌵💮🌵🌻🌻🌻🌵🌸
🌵🌹🌹🌹🌹🌹🌵🌷🌷🌷🌷🌷🌵🌻🌻🌻🌻🌻🌵
🦋🌵🌹🌹🌹🌵🌻🌵🌷🌷🌷🌵🌺🌵🌻🌻🌻🌵🦋
🦋🦋🌵🌹🌵🌻🌻🌻🌵🌷🌵🌺🌺🌺🌵🌻🌵🦋🦋
🦋🦋🦋🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺🌺🌺🌵🦋🦋🦋
🦋🦋🌵💮🌵🌻🌻🌻🌵🌹🌵🌺🌺🌺🌵🌺🌵🦋🦋
🦋🌵💮💮💮🌵🌻🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🦋
🌵💮💮💮💮💮🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵
🌻🌵💮💮💮🌵🌼🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌷
🌻🌻🌵💮🌵🌼🌼🌼🌵🌹🌵🌹🌹🌹🌵🌺🌵🌷🌷
🌻🌻🌻🌵🌼🌼🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌷🌷🌷
🌻🌻🌵💮🌵🌼🌼🌼🌵🦋🌵🌹🌹🌹🌵🌺🌵🌷🌷
🌻🌵💮💮💮🌵🌼🌵🦋🦋🦋🌵🌹🌵🌺🌺🌺🌵🌷
🌵💮💮💮💮💮🌵🦋🦋🦋🦋🦋🌵🌺🌺🌺🌺🌺🌵
scheme@(guile-user)> larger version: http://paste.textboard.org/77f8309e/raw
apply
* { line-height: 1em; }
to the larger version for more symmetry
if your browser adds useless vertical scrollbars to code boxes after >>28 getting rid of vertical gaps: >>109
122
holy heckin germerald
What are the industry uses of these?
>>134
Forcibly indenting code
🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼
🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼
🌸🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌹🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼
🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵
🌸🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌹🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼
🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼
🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼
🌸🌸🌵🌹🌵🌸🌸🌸🌵🌹🌵🌸🌸🌸🌵🌹🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼🌵🌹🌵🌼🌼🌼🌵🌹🌵🌼🌼
🌸🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌼
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵
🌻🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺
🌻🌻🌵🌹🌵🌻🌻🌻🌵🌹🌵🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌹🌵🌺🌺
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺
🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺
🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌹🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌺
🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵
🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌹🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌺
🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺gapped quadrant flower garden
scheme@(guile-user)> (display ((lambda (rec xjoin extract index patch chars band n) ((lambda (xjoin lines columns cycle) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle n k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ (* 2 n) 1) (+ (* 4 n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (div) (lambda (patch band cycle n k j) ((lambda (k j) (if (or (= (modulo (+ k j) band) 0) (= (modulo (- k j) band) 0)) 0 (+ (patch (- cycle 1) (div (+ k j) band) (div (- k j) band)) 1))) (- k n) (- j (* 2 n))))) (lambda (a b) (quotient (- a (modulo a b)) b))) (lambda (cycle x y) (modulo (if (and (>= x 1) (<= (- x) y (- x 1))) 1 (if (and (<= y -2) (<= (+ y 1) x (- -2 y))) 2 (if (and (<= x -2) (<= (+ x 1) y (- -2 x))) 3 (if (and (>= y 1) (<= (- y) x (- y 1))) 4 0)))) cycle)) "🌵🌹🌺🌼🌸🌻🌷💮" 6 9))The flower garden has a natural partition into quadrants along the cactus diagonals that cross on the central cactus. Those are the quadrants used for the butterfly invasion >>132. The gapped quadrants radiate out from the sides of the central 2x2 block of flower patches. These were chosen so that they are prepared to host a shape that is two cells wide on its top row and that widens by two cells on subsequent rows.
separate output >>136 for 413 >>127
larger version: http://paste.textboard.org/e44ebf68/raw
apply
* { line-height: 1em; }
to the larger version for more symmetry
🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌹🌹🌹
🌹🌹🌵🌸🌵🌸🌸🌸🌵🌹🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼🌵🌼🌵🌹🌹
🌹🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌹🌵🌸🌸🌸🌵🌹🌵🌼🌼🌼🌵🌹🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌹
🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵🌼🌼🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵
🌸🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌸🌵🌸🌸🌸🌵🌹🌵🌼🌼🌼🌵🌼🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌼
🌸🌸🌵🌸🌵🌸🌸🌸🌵🌹🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌹🌵🌼🌼🌼🌵🌼🌵🌼🌼
🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼
🌸🌸🌵🌹🌵🌸🌸🌸🌵🌹🌵🌸🌸🌸🌵🌹🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼🌵🌹🌵🌼🌼🌼🌵🌹🌵🌼🌼
🌸🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌼
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵
🌻🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺
🌻🌻🌵🌹🌵🌻🌻🌻🌵🌹🌵🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌹🌵🌺🌺
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺
🌻🌻🌵🌻🌵🌻🌻🌻🌵🌹🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌺🌵🌺🌺
🌻🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌻🌵🌻🌻🌻🌵🌹🌵🌺🌺🌺🌵🌺🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺
🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵
🌹🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌹🌵🌻🌻🌻🌵🌹🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌹
🌹🌹🌵🌻🌵🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌺🌵🌹🌹
🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹Upgrade of >>137 with a function controlling the flower patches in the quadrants instead of having uniform quadrants.
scheme@(guile-user)> (display ((lambda (rec xjoin extract index patch chars band n) ((lambda (xjoin lines columns cycle) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle n k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ (* 2 n) 1) (+ (* 4 n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (div) (lambda (patch band cycle n k j) ((lambda (k j) (if (or (= (modulo (+ k j) band) 0) (= (modulo (- k j) band) 0)) 0 (+ (patch (- cycle 1) (div (+ k j) band) (div (- k j) band)) 1))) (- k n) (- j (* 2 n))))) (lambda (a b) (quotient (- a (modulo a b)) b))) ((lambda (quadrant) (lambda (cycle x y) (modulo (if (and (>= x 1) (<= (- x) y (- x 1))) (if (quadrant (if (>= y 0) (- -1 y) (- y)) (- x 1)) 1 0) (if (and (<= y -2) (<= (+ y 1) x (- -2 y))) (if (quadrant (if (>= x 0) (- -1 x) (- x)) (- -2 y)) 2 0) (if (and (<= x -2) (<= (+ x 1) y (- -2 x))) (if (quadrant (if (>= y 0) (+ y 1) y) (- -2 x)) 3 0) (if (and (>= y 1) (<= (- y) x (- y 1))) (if (quadrant (if (>= x 0) (+ x 1) x) (- y 1)) 4 0) 0)))) cycle))) (lambda (x y) (or (even? y) (= (abs x) (+ y 1))))) "🌵🌹🌺🌼🌸🌻🌷 💮" 6 9))separate output >>138 for 413 >>127
larger version: http://paste.textboard.org/11167db4/raw
apply
* { line-height: 1em; }
to the larger version for more symmetry
flower power
🌸🌸🌸🌸🌸🌹🌸🌹🌹🌹🌹🌹🌹🌸🌸🌸🌹🌹🌸🌹🌹🌹🌸🌹🌸🌸🌸🌸🌸🌹🌸🌸🌸🌸🌹
🌸🌹🌹🌹🌹🌹🌸🌹🌹🌹🌹🌹🌸🌹🌹🌹🌸🌹🌸🌹🌹🌹🌸🌹🌸🌹🌹🌹🌹🌹🌸🌹🌹🌹🌸
🌸🌸🌸🌸🌹🌹🌸🌹🌹🌹🌹🌹🌸🌹🌹🌹🌸🌹🌸🌹🌸🌹🌸🌹🌸🌸🌸🌸🌹🌹🌸🌸🌸🌸🌹
🌸🌹🌹🌹🌹🌹🌸🌹🌹🌹🌹🌹🌸🌹🌹🌹🌸🌹🌸🌹🌸🌹🌸🌹🌸🌹🌹🌹🌹🌹🌸🌹🌹🌹🌸
🌸🌹🌹🌹🌹🌹🌸🌸🌸🌸🌸🌹🌹🌸🌸🌸🌹🌹🌹🌸🌹🌸🌹🌹🌸🌸🌸🌸🌸🌹🌸🌹🌹🌹🌸
🌺🌺🌺🌺🌹🌹🌹🌺🌺🌺🌹🌹🌺🌹🌹🌹🌺🌹🌺🌺🌺🌺🌺🌹🌺🌺🌺🌺🌹
🌺🌹🌹🌹🌺🌹🌺🌹🌹🌹🌺🌹🌺🌹🌹🌹🌺🌹🌺🌹🌹🌹🌹🌹🌺🌹🌹🌹🌺
🌺🌺🌺🌺🌹🌹🌺🌹🌹🌹🌺🌹🌺🌹🌺🌹🌺🌹🌺🌺🌺🌺🌹🌹🌺🌺🌺🌺🌹
🌺🌹🌹🌹🌹🌹🌺🌹🌹🌹🌺🌹🌺🌹🌺🌹🌺🌹🌺🌹🌹🌹🌹🌹🌺🌹🌹🌹🌺
🌺🌹🌹🌹🌹🌹🌹🌺🌺🌺🌹🌹🌹🌺🌹🌺🌹🌹🌺🌺🌺🌺🌺🌹🌺🌹🌹🌹🌺141
Choose more contrasting colours
>>142
The contrast is more than enough: http://0x0.st/ojYt.png Get better fonts.
>>143
Now try with the default stylesheet.
Is that a movie? xD
It's manga.
Is that a movie? xD
"There's nothing dangerous about planting a garden." https://iteroni.com/watch?v=A_UbLs93P3Y >>132
🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼
🌹🌹🌵🌸🌵🌹🌹🌹🌵🌸🌵🌸🌸🌹🌵🌸🌵🌹🌹🌹🌵🌼🌵🌹🌼🌼🌵🌼🌵🌹🌹🌹🌵🌼🌵🌹🌹
🌹🌵🌸🌸🌸🌵🌹🌵🌸🌸🌸🌵🌸🌵🌸🌸🌹🌵🌹🌵🌹🌼🌼🌵🌼🌵🌼🌼🌼🌵🌹🌵🌼🌼🌼🌵🌹
🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌹🌹🌵🌹🌹🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵
🌸🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌸🌵🌸🌸🌹🌵🌹🌵🌹🌼🌼🌵🌼🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌼
🌸🌸🌵🌹🌵🌸🌸🌸🌵🌹🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌹🌵🌼🌼🌼🌵🌹🌵🌼🌼
🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺
🌻🌻🌵🌹🌵🌻🌻🌻🌵🌹🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌹🌵🌺🌺
🌻🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌻🌵🌻🌻🌹🌵🌹🌵🌹🌺🌺🌵🌺🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺
🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌹🌹🌵🌹🌹🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵
🌹🌵🌻🌻🌻🌵🌹🌵🌻🌻🌻🌵🌻🌵🌻🌻🌹🌵🌹🌵🌹🌺🌺🌵🌺🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌹
🌹🌹🌵🌻🌵🌹🌹🌹🌵🌻🌵🌻🌻🌹🌵🌻🌵🌹🌹🌹🌵🌺🌵🌹🌺🌺🌵🌺🌵🌹🌹🌹🌵🌺🌵🌹🌹
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺Upgrade of >>139 with intrapatch rendering, with half-triangles that align with their half of the quadrant as an example.
scheme@(guile-user)> (display ((lambda (rec xjoin extract index patch chars band n) ((lambda (xjoin lines columns cycle) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle n k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ (* 2 n) 1) (+ (* 4 n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (patch band cycle n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* 2 n)))) ((lambda (halfcell) ((lambda (quadrant) (lambda (cycle x y dx dy band) (modulo (if (and (>= x 1) (<= (- x) y (- x 1))) (if (quadrant (if (>= y 0) (- -1 y) (- y)) (- x 1) (- band dy) dx band) 1 0) (if (and (<= y -2) (<= (+ y 1) x (- -2 y))) (if (quadrant (if (>= x 0) (- -1 x) (- x)) (- -2 y) (- band dx) (- band dy) band) 2 0) (if (and (<= x -2) (<= (+ x 1) y (- -2 x))) (if (quadrant (if (>= y 0) (+ y 1) y) (- -2 x) dy (- band dx) band) 3 0) (if (and (>= y 1) (<= (- y) x (- y 1))) (if (quadrant (if (>= x 0) (+ x 1) x) (- y 1) dx dy band) 4 0) 0)))) cycle))) (lambda (x y dx dy band) (halfcell dx dy band (if (< x 0) -1 1))))) (lambda (dx dy band lr) (if (< lr 0) (<= (- band dx) dy) (if (> lr 0) (<= dx dy) #f)))) "🌵🌹🌺🌼🌸🌻🌷💮" 6 9))separate output >>148 for 413 >>127
larger version: http://0x0.st/ojhO.txt https://wirechan.org/b/res/2162.html#3732
in the next episode: >>21
Get a blog.
Have a sex.
🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼
🌹🌹🌵🌸🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌼🌵🌹🌹
🌹🌵🌸🌸🌹🌵🌹🌵🌸🌸🌹🌵🌹🌵🌸🌸🌹🌵🌹🌵🌹🌼🌼🌵🌹🌵🌹🌼🌼🌵🌹🌵🌹🌼🌼🌵🌹
🌵🌸🌸🌸🌹🌹🌵🌸🌸🌸🌹🌹🌵🌸🌸🌸🌹🌹🌵🌹🌹🌼🌼🌼🌵🌹🌹🌼🌼🌼🌵🌹🌹🌼🌼🌼🌵
🌸🌵🌸🌸🌹🌵🌸🌵🌸🌸🌹🌵🌸🌵🌸🌸🌹🌵🌹🌵🌹🌼🌼🌵🌼🌵🌹🌼🌼🌵🌼🌵🌹🌼🌼🌵🌼
🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼
🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺
🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺
🌻🌵🌻🌻🌹🌵🌻🌵🌻🌻🌹🌵🌻🌵🌻🌻🌹🌵🌹🌵🌹🌺🌺🌵🌺🌵🌹🌺🌺🌵🌺🌵🌹🌺🌺🌵🌺
🌵🌻🌻🌻🌹🌹🌵🌻🌻🌻🌹🌹🌵🌻🌻🌻🌹🌹🌵🌹🌹🌺🌺🌺🌵🌹🌹🌺🌺🌺🌵🌹🌹🌺🌺🌺🌵
🌹🌵🌻🌻🌹🌵🌹🌵🌻🌻🌹🌵🌹🌵🌻🌻🌹🌵🌹🌵🌹🌺🌺🌵🌹🌵🌹🌺🌺🌵🌹🌵🌹🌺🌺🌵🌹
🌹🌹🌵🌻🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺🌵🌹🌹
🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺Sierpinski triangles >>21 in the gapped quadrant flower garden >>149
scheme@(guile-user)> (display ((lambda (rec xjoin extract half cell index patch chars band n) ((lambda (xjoin half lines columns cycle) ((lambda (cell) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle n k j) 1)))) (patch cell))) (lambda (lr k j) (rec cell half lr k j)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (n) (rec half n 2)) (+ (* 2 n) 1) (+ (* 4 n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (self n p) (if (> p n) (quotient p 2) (self self n (* 2 p)))) (lambda (self half lr k j) (if (> j k) 0 (if (zero? k) lr ((lambda (h) (if (< j h) (self self half (- lr) (- k h) (- h 1 j)) (self self half lr (- k h) (- j h)))) (half k))))) (lambda (patch band cycle n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* 2 n)))) (lambda (cell) ((lambda (halfcell) ((lambda (quadrant) (lambda (cycle x y dx dy band) (modulo (if (and (>= x 1) (<= (- x) y (- x 1))) (if (quadrant (if (>= y 0) (- -1 y) (- y)) (- x 1) (- band dy) dx band) 1 0) (if (and (<= y -2) (<= (+ y 1) x (- -2 y))) (if (quadrant (if (>= x 0) (- -1 x) (- x)) (- -2 y) (- band dx) (- band dy) band) 2 0) (if (and (<= x -2) (<= (+ x 1) y (- -2 x))) (if (quadrant (if (>= y 0) (+ y 1) y) (- -2 x) dy (- band dx) band) 3 0) (if (and (>= y 1) (<= (- y) x (- y 1))) (if (quadrant (if (>= x 0) (+ x 1) x) (- y 1) dx dy band) 4 0) 0)))) cycle))) (lambda (x y dx dy band) (halfcell dx dy band (apply cell (if (< x 0) `(-1 ,y ,(- -1 x)) `(1 ,y ,(- x 1)))))))) (lambda (dx dy band lr) (if (< lr 0) (<= (- band dx) dy) (if (> lr 0) (<= dx dy) #f))))) "🌵 🌹🌺🌼🌸🌻🌷💮" 6 9))separate output >>152 for 413 >>127
larger version: http://0x0.st/oeLs.txt https://wirechan.org/b/res/2162.html#3752
in the next episode: >>125
Continue to get a blog.
>>154
This is a real programming thread filled with code that's ready to run for yourself. The essence of this thread easily justifies its existence in this forum.
🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵🦋🦋🦋🦋🦋🌵🌼🌼🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼
🦋🦋🌵🌸🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌸🌵🦋🦋🦋🌵🌼🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌼🌵🦋🦋
🦋🌵🌸🌸🌹🌵🌹🌵🌸🌸🌹🌵🌹🌵🌸🌸🌹🌵🦋🌵🌹🌼🌼🌵🌹🌵🌹🌼🌼🌵🌹🌵🌹🌼🌼🌵🦋
🌵🌸🌸🌸🌹🌹🌵🌸🌸🌸🌹🌹🌵🌸🌸🌸🌹🌹🌵🌹🌹🌼🌼🌼🌵🌹🌹🌼🌼🌼🌵🌹🌹🌼🌼🌼🌵
🌸🌵🌸🌸🌹🌵🌸🌵🌸🌸🌹🌵🌸🌵🌸🌸🌹🌵🌹🌵🌹🌼🌼🌵🌼🌵🌹🌼🌼🌵🌼🌵🌹🌼🌼🌵🌼
🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼
🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼
🌹🌹🌵🌹🌵🌹🌹🌹🌵🦋🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🦋🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌹🌵🌹🌵🦋🦋🦋🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🦋🦋🦋🌵🌹🌵🌹🌹🌹🌵🌹
🌵🌹🌹🌹🌹🌹🌵🦋🦋🦋🦋🦋🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🦋🦋🦋🦋🦋🌵🌹🌹🌹🌹🌹🌵
🌹🌵🌹🌹🌹🌵🌹🌵🦋🦋🦋🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🦋🦋🦋🌵🌹🌵🌹🌹🌹🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌹🌵🦋🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🦋🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺
🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺
🌻🌵🌻🌻🌹🌵🌻🌵🌻🌻🌹🌵🌻🌵🌻🌻🌹🌵🌹🌵🌹🌺🌺🌵🌺🌵🌹🌺🌺🌵🌺🌵🌹🌺🌺🌵🌺
🌵🌻🌻🌻🌹🌹🌵🌻🌻🌻🌹🌹🌵🌻🌻🌻🌹🌹🌵🌹🌹🌺🌺🌺🌵🌹🌹🌺🌺🌺🌵🌹🌹🌺🌺🌺🌵
🦋🌵🌻🌻🌹🌵🌹🌵🌻🌻🌹🌵🌹🌵🌻🌻🌹🌵🦋🌵🌹🌺🌺🌵🌹🌵🌹🌺🌺🌵🌹🌵🌹🌺🌺🌵🦋
🦋🦋🌵🌻🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌻🌵🦋🦋🦋🌵🌺🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺🌵🦋🦋
🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🦋🦋🦋🦋🦋🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺Sierpinski triangle over Sierpinski carpet >>100 >>109 on the flower garden >>153
scheme@(guile-user)> (display ((lambda (rec xjoin extract twolevels half cell carpet index patch1 patch2 chars band columnfactor n) ((lambda (xjoin half carpet lines columns cycle) ((lambda (cell) ((lambda (patch1 patch2) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (twolevels patch1 patch2))) (patch1 cell) (patch2 carpet))) (lambda (lr k j) (rec cell half lr k j)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (n) (rec half n 2)) (lambda (x y dx dy band) (rec carpet x y)) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (first second) (lambda (cycle x y dx dy band) ((lambda (f) (if (zero? f) (second cycle x y dx dy band) (+ f 1))) (first cycle x y dx dy band)))) (lambda (self n p) (if (> p n) (quotient p 2) (self self n (* 2 p)))) (lambda (self half lr k j) (if (> j k) 0 (if (zero? k) lr ((lambda (h) (if (< j h) (self self half (- lr) (- k h) (- h 1 j)) (self self half lr (- k h) (- j h)))) (half k))))) (lambda (self k j) (if (or (= k 0) (= j 0)) #t (if (and (= (modulo k 3) 1) (= (modulo j 3) 1)) #f (self self (quotient k 3) (quotient j 3))))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (cell) ((lambda (halfcell) ((lambda (quadrant) (lambda (cycle x y dx dy band) (if (and (>= x 1) (<= (- x) y (- x 1))) (if (quadrant (if (>= y 0) (- -1 y) (- y)) (- x 1) (- band dy) dx band) 1 0) (if (and (<= y -2) (<= (+ y 1) x (- -2 y))) (if (quadrant (if (>= x 0) (- -1 x) (- x)) (- -2 y) (- band dx) (- band dy) band) 2 0) (if (and (<= x -2) (<= (+ x 1) y (- -2 x))) (if (quadrant (if (>= y 0) (+ y 1) y) (- -2 x) dy (- band dx) band) 3 0) (if (and (>= y 1) (<= (- y) x (- y 1))) (if (quadrant (if (>= x 0) (+ x 1) x) (- y 1) dx dy band) 4 0) 0)))))) (lambda (x y dx dy band) (halfcell dx dy band (apply cell (if (< x 0) `(-1 ,y ,(- -1 x)) `(1 ,y ,(- x 1)))))))) (lambda (dx dy band lr) (if (< lr 0) (<= (- band dx) dy) (if (> lr 0) (<= dx dy) #f))))) (lambda (quad) ((lambda (reflect) (lambda (cycle x y dx dy band) (if (reflect quad x y dx dy band) 0 1))) (lambda (quad x y dx dy band) (if (>= x 0) (if (>= y 0) (quad x y dx dy band) (quad x (- -1 y) dx (- band dy) band)) (if (>= y 0) (quad (- -1 x) y (- band dx) dy band) (quad (- -1 x) (- -1 y) (- band dx) (- band dy) band)))))) "🌵🌹🦋🌺🌼🌸🌻🌷💮" 6 2 9))separate output >>156 for 413 >>127
As promised in >>125 the half-empty cells of the triangle show either roses or butterflies as appropriate for the carpet at that location.
larger version: https://endchan.net/art/res/2.html#71 http://0x0.st/oenp.txt http://0x0.st/oenV.png
>>157
I really like these flower gardens most of all.
But does the code have to be obfuscated? I get it, it's a one-liner, one hell of a one-liner. I tried to make sense of it, but it's too much for me. Do you have a more concise, maybe a general expression of how you do these?
larger versions on the paster:
>>149 http://paste.textboard.org/76fb47c2/raw intrapatch rendering
>>153 http://paste.textboard.org/ab1e1c1b/raw Sierpinski triangles
>>157 http://paste.textboard.org/661ab540/raw triangles over carpets
apply
* { line-height: 1em; }
to the larger versions for more symmetry
But does the code have to be obfuscated?
This has been covered in >>75.
I tried to make sense of it, but it's too much for me.
The complexity has been slowly built up over 40+ >>114 demos. It is unreasonable to expect to be able to jump straight into the latest demo from scratch and find it a piece of cake. If instead you follow the demos one by one from the beginning, even skipping some occasionally, you will find the increase in complexity you have to digest between adjacent demos to be minor.
Do you have a more concise, maybe a general expression of how you do these?
This is the concise form, an easily readable version would be considerably longer and would not fit into a single post >>127 in this thread. Here's the overall structure of >>157.
Rec is the recursive bootstrapper that you are familiar with from SICP exercise 4.21 https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-26.html#%_thm_4.21 Its only job is to make a function available to itself as an argument to enable recursive calls. Xjoin maps a string-producing function over a iota and joins the results on a separator. For larger demos this needs to be >>24 tail recursive. Symbol produces the string for a pair of coordinates in the overall matrix. Two nested xjoins map symbol over all lines and columns and pass the assembled result to display. These form the outermost layer of the structure and can generate any pattern by customizing symbol. Everything below this layer exists to produce the custom symbol function.
Symbol deals with separating logical matrix element generation from character selection. Index generates the logical matrix element and extract knows how to extract substrings from strings. Symbol simply passes te output of index to extract. For example, if you switch out all the flowers in the chars constant for fruits, you can draw orchards instead of flower gardens.
Index applies the coordinate transformation from the lines-and-columns matrix of the terminal to the diagonal grid of the garden. It produces the cactus diagonals and delegates the content of the flower patches to patch. This can produce any garden by customizing patch. Everything below this layer exists to produce the custom patch function.
Patch is produced by twolevels which takes two levels of garden content as arguments. It tries the first level, in this case the triangles, and if that returns empty it tries the second level, in this case the carpets. This paints the triangles over the carpets. Up to this point the code path is linear, but from here it splits into patch1 for the triangles and patch2 for the carpets.
Patch1, which produces the layer of the triangles, uses three components. Cell produces one logical Sierpinski triangle by returning -1/0/1 for left/empty/right, and is passed in from the outside to patch1. Halfcell knows how to produce left or right half-triangles in a flower patch by filling below the first or the second diagonal of the current flower patch. Quadrant knows how to draw one quadrant by calling cell with its calling convention and passing the result to halfcell. Patch1 itself applies the coordinate transformation from the diagonal grid of the garden to each of the >>137 gapped quadrants, and calls quadrant to deal with a quadrant. Either reflection or rotation could be used for the four quadrants, and patch1 happens to use rotation.
Cell, which produces one logical Sierpinski triangle for patch1, consists of the same half and cell functions as in >>21, and there is nothing new to understand here compared to that post.
Patch2, which produces the layer of the carpets, uses two components. Quad produces one logical Sierpinski carpet, and is passed in from the outside to patch2. Reflect knows how to apply the coordinate transformation from the diagonal grid of the garden to each of the >>132 proper, ungapped quadrants delimited by the cactus diagonals that cross on the central cactus, and calls quad to deal with each quadrant. Reflect uses reflection symmetry on its quadrants. Patch2 simply passes quad to reflect.
The quad that produces one logical Sierpinski carpet for patch2 is the carpet lambda, which is simply the pred lambda from >>17, and there is nothing new to understand here compared to that post.
And that's all there is to >>157.
It seems you still haven't gotten a blog... Need any help with that?
Since m4 was linked in https://textboard.org/prog/538#t538p18 here is the Sierpinski carpet >>17 in m4:
$ cat carpet.m4
divert(-1)
define(`carpet_level',3)
define(`carpet_empty',` ')
define(`carpet_full',`m4')
define(`carpet_size',eval(3**carpet_level))
define(`carpet_pred',`ifelse(eval(($1==0)||($2==0)),1,1,`ifelse(eval((($1%3)==1)&&(($2%3)==1)),1,0,`carpet_pred(eval($1/3),eval($2/3))')')')
define(`carpet_symbol',`ifelse(carpet_pred($1,$2),1,carpet_full,carpet_empty)')
define(`carpet_xjoin',`ifelse($1,1,`$2(0)`$4'',`carpet_xjoin(decr($1),`$2',`$3',`$3'$2(decr($1))`$4')')')
define(`carpet_linesymbol',`carpet_symbol(carpet_currentline,$1)')
define(`carpet_line',`pushdef(`carpet_currentline',$1)carpet_xjoin(carpet_size,`carpet_linesymbol',,)popdef(`carpet_currentline')')
define(`carpet_carpet',`carpet_xjoin(carpet_size,`carpet_line',`
',)')
divert(0)carpet_carpet
$ m4 carpet.m4
m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4
m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4
m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4
m4m4m4 m4m4m4m4m4m4 m4m4m4m4m4m4 m4m4m4
m4 m4 m4 m4m4 m4 m4 m4m4 m4 m4 m4
m4m4m4 m4m4m4m4m4m4 m4m4m4m4m4m4 m4m4m4
m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4
m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4
m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4
m4m4m4m4m4m4m4m4m4 m4m4m4m4m4m4m4m4m4
m4 m4m4 m4m4 m4 m4 m4m4 m4m4 m4
m4m4m4m4m4m4m4m4m4 m4m4m4m4m4m4m4m4m4
m4m4m4 m4m4m4 m4m4m4 m4m4m4
m4 m4 m4 m4 m4 m4 m4 m4
m4m4m4 m4m4m4 m4m4m4 m4m4m4
m4m4m4m4m4m4m4m4m4 m4m4m4m4m4m4m4m4m4
m4 m4m4 m4m4 m4 m4 m4m4 m4m4 m4
m4m4m4m4m4m4m4m4m4 m4m4m4m4m4m4m4m4m4
m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4
m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4
m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4
m4m4m4 m4m4m4m4m4m4 m4m4m4m4m4m4 m4m4m4
m4 m4 m4 m4m4 m4 m4 m4m4 m4 m4 m4
m4m4m4 m4m4m4m4m4m4 m4m4m4m4m4m4 m4m4m4
m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4
m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4m4 m4
m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4m4If you need someone to talk to, I'm here...
updated counts >>114 since June
1 9 12 391 >>> 46 52
2 10 7 461 scheme@(guile-user)> 52 48
3 11 13 483 >> 42 46
4 13 15 627 >> 34 41
5 14 13 471 >> 43 47
6 17 14 524 >>> 40 43
7 21 18 789 >>> 27 37
8 24 15 851 scheme@(guile-user)> 35 36
9 25 13 692 scheme@(guile-user)> 44 39
10 28 25 1599 >>> 9 10
11 30 10 508 >> 48 44
12 34 13 560 >> 45 42
13 35 19 1375 scheme@(guile-user)> 24 17
14 37 15 642 >> 36 40
15 39 21 909 >> 17 33
16 42 10 452 >> 49 50
17 43 10 444 >> 50 51
18 46 18 707 >>> 28 38
19 49 23 1070 >>> 13 26
20 53 21 873 >>> 18 35
21 55 14 1066 scheme@(guile-user)> 41 28
22 59 21 1475 scheme@(guile-user)> 19 12
23 65 19 1110 scheme@(guile-user)> 25 24
24 67 25 1716 >>> 10 7
25 69 10 460 >> 51 49
26 70 20 1333 scheme@(guile-user)> 22 19
27 72 25 1717 scheme@(guile-user)> 11 6
28 77 33 2654 scheme@(guile-user)> 2 2
29 81 20 1459 scheme@(guile-user)> 23 13
30 85 30 1180 >> 5 21
31 89 32 1176 >> 3 22
32 90 18 1067 scheme@(guile-user)> 29 27
33 95 21 888 >>> 20 34
34 99 23 1262 scheme@(guile-user)> 14 20
35 100 22 993 >>> 15 31
36 104 30 1649 scheme@(guile-user)> 6 9
37 107 19 1391 scheme@(guile-user)> 26 16
38 109 31 1336 >>> 4 18
39 111 15 1062 scheme@(guile-user)> 37 29
40 113 21 1566 scheme@(guile-user)> 21 11
41 115 24 1935 scheme@(guile-user)> 12 4
42 119 16 1031 scheme@(guile-user)> 33 30
43 120 11 495 >> 47 45
44 121 15 990 scheme@(guile-user)> 38 32
45 126 17 1097 scheme@(guile-user)> 31 25
46 129 22 1423 scheme@(guile-user)> 16 15
47 132 27 1872 scheme@(guile-user)> 7 5
48 137 15 1164 scheme@(guile-user)> 39 23
49 139 17 1449 scheme@(guile-user)> 32 14
50 149 18 1660 scheme@(guile-user)> 30 8
51 153 26 2101 scheme@(guile-user)> 8 3
52 157 36 2926 scheme@(guile-user)> 1 1>>159
Did they delete SICP?
>>164
It seems to be the case:
https://mitpress.mit.edu/sites/default/files/sicp/index.html
404 - Page not found!
I hope this is only temporary.
>>164,165
They're uploading the new and improved Python version.
What do you think of this FIOC Lisp?
https://www.draketo.de/software/wisp
Did they delete SICP?
SICP is considered obsolete. They are tying to erase it from the world because it is a backward product from the primitive era of computing that would be dangerous in the wrong hands. It's time for humanity to look forward to a bright future with JSICP, which holds the key to everlasting universal peace and enlightenment.
>>167
This is bullshit garbage like everything written in Lisp, including this amateur BBS.
>>164
As >>165 said it's currently down. It was up at the time of >>159.
https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book.html
However a bit of digging still shows it here:
https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/full-text/book/book.html
The pdf from MIT:
https://web.mit.edu/6.001/6.037/sicp.pdf
A backup of the MIT pdf:
https://endchan.net/tech/res/15059.html#15104
Sierpinski triangle >>21 >>153 >>157 in m4 >>161:
$ cat triangle.m4
divert(-1)
define(`triangle_level',5)
define(`triangle_empty',` ')
define(`triangle_left',`◢')
define(`triangle_right',`◣')
define(`triangle_size',eval(2**triangle_level))
define(`triangle_cell',`ifelse(eval($2>$1),1,0,`ifelse($1,0,$3,`ifelse(eval($1<$4),1,`triangle_cell($1,$2,$3,eval($4/2))',`ifelse(eval($2<$4),1,`triangle_cell(eval($1-$4),eval($4-1-$2),eval(-($3)),eval($4/2))',`triangle_cell(eval($1-$4),eval($2-$4),$3,eval($4/2))')')')')')
define(`triangle_char',`ifelse($1,-1,triangle_left,$1,1,triangle_right,triangle_empty)')
define(`triangle_symbol',`ifelse(eval($2<triangle_size),1,`triangle_char(triangle_cell($1,eval(triangle_size-1-$2),-1,eval(triangle_size/2)))',`triangle_char(triangle_cell($1,eval($2-triangle_size),1,eval(triangle_size/2)))')')
define(`triangle_xjoin',`ifelse($1,1,`$2(0)`$4'',`triangle_xjoin(decr($1),`$2',`$3',`$3'$2(decr($1))`$4')')')
define(`triangle_linesymbol',`triangle_symbol(triangle_currentline,$1)')
define(`triangle_line',`pushdef(`triangle_currentline',$1)triangle_xjoin(eval(2*triangle_size),`triangle_linesymbol',,)popdef(`triangle_currentline')')
define(`triangle_triangle',`triangle_xjoin(triangle_size,`triangle_line',`
',)')
divert(0)triangle_triangle
$ m4 triangle.m4
◢◣
◢◣◢◣
◢◣ ◢◣
◢◣◢◣◢◣◢◣
◢◣ ◢◣
◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣
◢◣ ◢◣
◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣
◢◣ ◢◣
◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣ ◢◣◢◣◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣ ◢◣◢◣
◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣ ◢◣
◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣Interlude: Church predecessor function with roses [1/2]
Recall that Church numerals are iterative appliers that take two arguments, a state transformer and an initial state. They work by repeatedly applying the state transformer to the current state, starting with the initial state. The number of applications performed by the Church numeral n is equal to the natural number n. One consequence is that the Church numeral zero returns the initial state unmodified. Another consequence is that given the Church numeral n, we can obtain the behavior of n+1 by letting n run the state transformer n times and then applying it one more time.
(define (zero state-transformer initial-state) initial-state)
(define empty "")
(define (addrose string) (string-append string "🌹"))
(zero addrose empty)
=> ""
(define (succ n) (lambda (state-transformer initial-state) (state-transformer (n state-transformer initial-state))))
((succ zero) addrose empty)
=> "🌹"
((succ (succ zero)) addrose empty)
=> "🌹🌹"
((succ (succ (succ zero))) addrose empty)
=> "🌹🌹🌹"
((succ (succ (succ (succ zero)))) addrose empty)
=> "🌹🌹🌹🌹"
((succ (succ (succ (succ (succ zero))))) addrose empty)
=> "🌹🌹🌹🌹🌹"Recall from SICP exercise 2.4 https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/full-text/book/book-Z-H-14.html#%_thm_2.4 that pairs can be represented as invokers that take one argument, a receiver function. A pair works by invoking the receiver function with the two components of the pair as arguments. To extract the first component of the pair pass in the first projection as the receiver function, and to extract the second component pass in the second projection.
(define (make-pair a b) (lambda (receiver) (receiver a b)))
(define (first-projection a b) a)
(define (second-projection a b) b)
(define (first pair) (pair first-projection))
(define (second pair) (pair second-projection))
(first (make-pair "🌹" "🦋"))
=> "🌹"
(second (make-pair "🌹" "🦋"))
=> "🦋"In the same spirit we can define a box that holds a single element. The box works by invoking the receiver function with the content of the box as argument. To extract the content of the box pass in the identity function as the receiver.
(define (make-box a) (lambda (receiver) (receiver a)))
(define (identity a) a)
(define (extract box) (box identity))
(extract (make-box "🌹"))
=> "🌹"We can simulate the behavior of the Church numeral n using states in a box rather than naked states. We start by putting the initial state into a box, then at each step we extract the state from the current box, apply the state transformer and repack the result into a new box. At the end we have the result in a box, so we use a final extraction.
(define (make-repacker state-transformer) (lambda (box) (make-box (state-transformer (extract box)))))
(define (same-but-with-boxes n) (lambda (state-transformer initial-state) (extract (n (make-repacker state-transformer) (make-box initial-state)))))
((same-but-with-boxes (succ (succ (succ zero)))) addrose empty)
=> "🌹🌹🌹"This is not particularly useful yet because we are simulating n by using the n we already have in hand, but with two modifications this will change. First we look at the three steps of the repacker, extracting the state from the current box, applying the state transformer and repacking the result into a new box. The first two steps can be merged by passing the state transformer to the box. The box works by invoking the receiver function, in this case the state transformer, on the content of the box. This may look like a cosmetic change but the substance of it is that we are giving the box control over the application of the state transformer.
(define (make-merged-repacker state-transformer) (lambda (box) (make-box (box state-transformer))))
(define (same-again-but-with-boxes n) (lambda (state-transformer initial-state) (extract (n (make-merged-repacker state-transformer) (make-box initial-state)))))
((same-again-but-with-boxes (succ (succ (succ zero)))) addrose empty)
=> "🌹🌹🌹"[2/2] Next, we note that in the repacking chain we have n applications of the state transformer, which provide the behavior of the Church numeral n, so if we manage to elide one of the applications but keep the rest, we will obtain the behavior of the Church numeral n-1. We also have the repacker produce every box after the initial one, but the initial box is special in that it is created outside of the repacker's control. The natural idea is to try to exploit the common all-but-one nature of these two situations. To this end we create a fake box that works by ignoring the receiver function and directly returning the content of the box.
(define (make-fake-box a) (lambda (receiver) a))
(extract (make-fake-box "🌹"))
=> "🌹"Note that the fake box works correctly with the extractor, because the only thing the fake box is capable of returning, the content of the box, is the correct return for the extractor. If we use the fake box as the initial box, the first attempt to apply the state transformer will be ignored by the fake box, because the fake box ignores the receiver function, but every subsequent box will be a regular box created by the repacker, so all remaining attempts to apply the state transformer will be carried out. This results in n-1 applications of the state transformer, which is the behavior of the Church numeral n-1. This is why we changed the repacker to give the box control over the application of the state transformer, because if we had kept the explicit application of the state transformer in the repacker then using a fake box would have made no difference to the number of applications of the state transformer.
(define (pred n) (lambda (state-transformer initial-state) (extract (n (make-merged-repacker state-transformer) (make-fake-box initial-state)))))
((pred zero) addrose empty)
= ""
((pred (succ zero)) addrose empty)
= ""
((pred (succ (succ zero))) addrose empty)
= "🌹"
((pred (succ (succ (succ zero)))) addrose empty)
= "🌹🌹"
((pred (succ (succ (succ (succ zero))))) addrose empty)
= "🌹🌹🌹"
((pred (succ (succ (succ (succ (succ zero)))))) addrose empty)
= "🌹🌹🌹🌹"
((pred (pred (succ (succ (succ (succ (succ zero))))))) addrose empty)
= "🌹🌹🌹"
((pred (pred (pred (succ (succ (succ (succ (succ zero)))))))) addrose empty)
= "🌹🌹"Recall that in the context of Church numerals the predecessor of zero is zero itself. The merged repacker and the fake box suffice for this derivation of the Church predecessor function.
As a bonus we can take our definition of pred, inline its entire dependency tree, obfuscate all the parameter names and arrive at the first PRED formula currently on the https://en.wikipedia.org/wiki/Lambda_calculus page.
PRED := λn.λf.λx.n (λg.λh.h (g f)) (λu.x) (λu.u)The final (λu.u) is the identity function that the extractor passes to the final box to extract its content. The preceding (λu.x), which uses a different u__, is the inlined fake box which ignores the receiver function, __u, and returns the content of the box, which is x__, the initial state. The box parameter from the repacker's definition is renamed to __g, while the receiver function from make-box is renamed to h__. The initial state is __x and the state transformer is f. Translation:
PRED := λn.λf .λx .n (λg .λh .h (g f )) (λu .x ) (λu.u)
PRED := λn.λstate .λinitial.n (λcurrent .λmake .make (current state )) (λmake .initial) identity
transformer state box of box box box of transformer fake box state function
repacker receiver receiver repacker receiver of extractHowever, because the current version of that page was written by dodo birds, they'd rather offer induction than explain a derivation of the formula, such as the one with the repacker chain and the fake box.
The solution for single-character markup is in https://textboard.org/prog/140#t140p29 2020-08-02.
How can a man be so willfully boring and ignorant about it at the same time?
A generic tile mesh engine that delegates the existence and overlap of tiles to two separate functions, with the mesh of opposite winding to >>120 as an example.
scheme@(guile-user)> (display ((lambda (rec xjoin extract exists overlaps spec chars n) ((lambda (xjoin lines columns grid) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (grid k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (* 4 n) (* 8 n) ((lambda (cell split) ((lambda (corner) (lambda (k j) (apply (lambda (kd km jd jm) (if (= jm 3) (if (or (= km 1) (= km 2)) 0 (if (exists (+ (* 2 kd) 1) jd) 1 0)) (if (= jm 7) (if (= km 1) (if (exists (* 2 kd) (+ jd 1)) 1 0) (if (= km 2) (if (exists (+ (* 2 kd) 2) (+ jd 1)) 1 0) 0)) (apply (lambda (up k left j) (corner (if (eq? up left) 2 3) (+ (* 2 kd) (if up 0 1)) (+ jd (if (and up (not left)) 1 0)) (+ (* 2 kd) (if up 1 2)) (+ jd (if (not (or up left)) 1 0)) (not (eq? up left)) k j)) `(,@(split km 2) ,@(split jm 4)))))) `(,(quotient k 4) ,(modulo k 4) ,(quotient j 8) ,(modulo j 8))))) (lambda (id firstk firstj secondk secondj left k j) (if (exists firstk firstj) (if (exists secondk secondj) (cell (if (overlaps firstk firstj left) id (- 3 id)) 1 k j) (cell id 0 k j)) (if (exists secondk secondj) (cell (- 3 id) 0 k j) 0))))) (lambda (corner double k j) (vector-ref (vector-ref (vector-ref spec corner) double) (+ (* 3 k) j))) (lambda (k limit) (if (< k limit) `(#t ,k) `(#f ,(- k limit))))))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (k j) #t) (lambda (k j left) (eq? (even? k) left)) #(#(#(1 1 4 0 0 2) #(8 1 4 0 0 10)) #(#(3 1 1 2 0 0) #(3 1 8 9 0 0)) #(#(0 0 2 1 1 6) #(0 0 10 7 1 6)) #(#(2 0 0 5 1 1) #(9 0 0 5 1 7))) " ─│┌┐└┘┬┴┤├" 6))
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─
┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─
┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─
┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─
┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─
┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─
┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘
scheme@(guile-user)> It is hard to describe how pointless all of this is. It is practically spam. The anon wasting their time here has no presentation skills at all. Newlines exist, comments are useful... At the very least --for your own sake -- VIP your own posts if you have no interest in people reading them! That way you won't come of at as "deranged".
It is hard to describe how pointless all of this is.
I think this is one of best threads on /prog/. It is eye candy. It is computational art.
People don't always demand source code for the results of computational art.
>>177
hello mr. stop-doing-cool-things-cause-i-am-not-cool
take a s(w)eat
>>177
It's /prog/ and it stays on 1 thread.
>>177
You can use the pretty printer if you're really struggling. That's what I do in my self modifying programs.
Custom tile existence function >>176 to remove the center tile of every 3x3 block.
scheme@(guile-user)> (display ((lambda (rec xjoin extract exists overlaps spec chars n) ((lambda (xjoin lines columns grid) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (grid k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (* 4 n) (* 8 n) ((lambda (cell split) ((lambda (corner) (lambda (k j) (apply (lambda (kd km jd jm) (if (= jm 3) (if (or (= km 1) (= km 2)) 0 (if (exists (+ (* 2 kd) 1) jd) 1 0)) (if (= jm 7) (if (= km 1) (if (exists (* 2 kd) (+ jd 1)) 1 0) (if (= km 2) (if (exists (+ (* 2 kd) 2) (+ jd 1)) 1 0) 0)) (apply (lambda (up k left j) (corner (if (eq? up left) 2 3) (+ (* 2 kd) (if up 0 1)) (+ jd (if (and up (not left)) 1 0)) (+ (* 2 kd) (if up 1 2)) (+ jd (if (not (or up left)) 1 0)) (not (eq? up left)) k j)) `(,@(split km 2) ,@(split jm 4)))))) `(,(quotient k 4) ,(modulo k 4) ,(quotient j 8) ,(modulo j 8))))) (lambda (id firstk firstj secondk secondj left k j) (if (exists firstk firstj) (if (exists secondk secondj) (cell (if (overlaps firstk firstj left) id (- 3 id)) 1 k j) (cell id 0 k j)) (if (exists secondk secondj) (cell (- 3 id) 0 k j) 0))))) (lambda (corner double k j) (vector-ref (vector-ref (vector-ref spec corner) double) (+ (* 3 k) j))) (lambda (k limit) (if (< k limit) `(#t ,k) `(#f ,(- k limit))))))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (k j) (not (or (and (= (modulo k 6) 2) (= (modulo j 3) 1)) (and (= (modulo k 6) 5) (= (modulo j 3) 2))))) (lambda (k j left) (eq? (even? k) left)) #(#(#(1 1 4 0 0 2) #(8 1 4 0 0 10)) #(#(3 1 1 2 0 0) #(3 1 8 9 0 0)) #(#(0 0 2 1 1 6) #(0 0 10 7 1 6)) #(#(2 0 0 5 1 1) #(9 0 0 5 1 7))) " ─│┌┐└┘┬┴┤├" 5))
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─
┴─┐ │ │ ├─┴─┐ ├─┴─┐ │ │ ├─
├───┘ └───┬─┘ ├─┬─┘ ├───┘ └───┬─┘
┌─┴───┐ ┌───┤ ┌─┴─┤ ┌─┴───┐ ┌───┤
┤ │ │ └─┬─┤ └─┬─┤ │ │ └─┬─
┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ │ │ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬───┘ └───┤ └─┬─┤ └─┬─
┴─┐ ├─┴─┐ ├───┐ ┌───┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ │ │ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─
┴─┐ │ │ ├─┴─┐ ├─┴─┐ │ │ ├─
├───┘ └───┬─┘ ├─┬─┘ ├───┘ └───┬─┘
┌─┴───┐ ┌───┤ ┌─┴─┤ ┌─┴───┐ ┌───┤
┤ │ │ └─┬─┤ └─┬─┤ │ │ └─┬─
┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘
scheme@(guile-user)> larger version: http://paste.textboard.org/8e1bf5dc/raw
in the next episode: >>17
I think this is one of best threads on /prog/. It is eye candy.
Thanks! There will be a few more flower garden posts at some point.
Ok, if this is so great, then could you at least summarize what is happening.
Sierpinski carpet >>17 on the tile mesh >>182
scheme@(guile-user)> (display ((lambda (rec xjoin extract carpet toquadrants exists overlaps spec chars n) ((lambda (xjoin lines columns carpet) ((lambda (quadcarpet) ((lambda (exists) ((lambda (grid) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (grid k j) 1)))) ((lambda (cell split) ((lambda (corner) (lambda (k j) (apply (lambda (kd km jd jm) (if (= jm 3) (if (or (= km 1) (= km 2)) 0 (if (exists (+ (* 2 kd) 1) jd) 1 0)) (if (= jm 7) (if (= km 1) (if (exists (* 2 kd) (+ jd 1)) 1 0) (if (= km 2) (if (exists (+ (* 2 kd) 2) (+ jd 1)) 1 0) 0)) (apply (lambda (up k left j) (corner (if (eq? up left) 2 3) (+ (* 2 kd) (if up 0 1)) (+ jd (if (and up (not left)) 1 0)) (+ (* 2 kd) (if up 1 2)) (+ jd (if (not (or up left)) 1 0)) (not (eq? up left)) k j)) `(,@(split km 2) ,@(split jm 4)))))) `(,(quotient k 4) ,(modulo k 4) ,(quotient j 8) ,(modulo j 8))))) (lambda (id firstk firstj secondk secondj left k j) (if (exists firstk firstj) (if (exists secondk secondj) (cell (if (overlaps firstk firstj left) id (- 3 id)) 1 k j) (cell id 0 k j)) (if (exists secondk secondj) (cell (- 3 id) 0 k j) 0))))) (lambda (corner double k j) (vector-ref (vector-ref (vector-ref spec corner) double) (+ (* 3 k) j))) (lambda (k limit) (if (< k limit) `(#t ,k) `(#f ,(- k limit))))))) (lambda (k j) (exists quadcarpet k j)))) (toquadrants carpet))) (lambda (n fun sep) (rec xjoin n fun sep "")) (* 4 n) (* 8 n) (lambda (k j) (rec carpet k j)))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (self k j) (if (or (= k 0) (= j 0)) #t (if (and (= (modulo k 3) 1) (= (modulo j 3) 1)) #f (self self (quotient k 3) (quotient j 3))))) (lambda (basequad) (lambda (k j) (if (>= k 0) (if (>= j 0) (basequad k j) (basequad k (- -1 j))) (if (>= j 0) (basequad (- -1 k) j) (basequad (- -1 k) (- -1 j)))))) ((lambda (div) (lambda (oncoords k j) ((lambda (x) (oncoords x (+ k x))) (- j (div k 2))))) (lambda (a b) (quotient (- a (modulo a b)) b))) (lambda (k j left) (eq? (even? k) left)) #(#(#(1 1 4 0 0 2) #(8 1 4 0 0 10)) #(#(3 1 1 2 0 0) #(3 1 8 9 0 0)) #(#(0 0 2 1 1 6) #(0 0 10 7 1 6)) #(#(2 0 0 5 1 1) #(9 0 0 5 1 7))) " ─│┌┐└┘┬┴┤├" 5))
┌─┴───┐ ┌───┤ ┌─┴───┐
┤ │ │ └─┬─┤ │
┴─┐ ├─┴─┐ ├─┴─┐ ├───┐ ┌───
├─┬─┘ ├─┬─┘ ├─┬─┘ │ │
┌─┴─┤ ┌─┴─┤ │ │ ┌─┴───┐ ┌───┤
┤ └─┬─┤ └─┬───┘ └───┤ │ │ └─┬─
┴─┐ ├─┴─┐ ├───┐ ┌───┴─┐ ├─┴─┐ ├─
├─┬─┘ ├─┬─┘ │ │ ├─┬─┘ ├─┬─┘
┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤ ┌─┴─┤
┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─┤ └─┬─
┴─┐ │ │ ├─┴─┐ ├─┴─┐ │ │ ├─
├───┘ └───┬─┘ ├─┬─┘ ├───┘ └───┬─┘
┌─┴───┐ ┌───┤ ┌─┴─┤ ┌─┴───┐ ┌───┤
┤ │ │ └─┬─┤ └─┬─┤ │ │ └─┬─
│ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─┴─┐ ├─
└───┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘ ├─┬─┘
│ ┌─┴─┤ │ │ ┌─┴─┤ ┌─┴─┤
└───┤ └─┬───┘ └───┤ └─┬─┤ └─┬─
┌───┴─┐ ├───┐ ┌───┴─┐ ├─┴─┐ ├─
│ ├─┬─┘ │ │ ├─┬─┘ ├─┬─┘
scheme@(guile-user)> larger version to see the pattern: http://0x0.st/opn7.txt https://wirechan.org/b/res/2162.html#3865 http://0x0.st/opnh.png
Second Interlude: Church predecessor function with tulips [1/2]
We can make an adder function that adds some fixed value to its argument.
(define (add-two augend) (+ augend 2))
(add-two 3)
=> 5If we have an adder function but don't know what fixed value it uses as its increment, we can obtain it by passing in 0.
(add-two 0)
=> 2We can create a factory that makes adder functions for a given increment.
(define (make-adder addend) (lambda (augend) (+ augend addend)))
((make-adder 2) 3)
=> 5If we have an adder function in hand, one way to create the adder function that uses an increment that is 1 higher is to add 1 to its output.
(define (next-adder adder) (lambda (augend) (+ (adder augend) 1)))
((next-adder (make-adder 2)) 4)
=> 7We can play the same adder game with Church numerals. We start with the basic zero and succ from >>172.
(define (zero state-transformer initial-state) initial-state)
(define empty "")
(define (addtulip string) (string-append string "🌷"))
(define (succ n) (lambda (state-transformer initial-state) (state-transformer (n state-transformer initial-state))))
(zero addtulip empty)
=> ""
((succ zero) addtulip empty)
=> "🌷"
((succ (succ zero)) addtulip empty)
=> "🌷🌷"
((succ (succ (succ zero))) addtulip empty)
=> "🌷🌷🌷"The adder with a 0 increment returns its argument unmodified, so it is simply the identity function. The adder with an increment of 1 is the successor function. To make an adder that uses an increment that is 1 higher we wrap the output of the current adder in succ.
(define (identity x) x)
(define add-zero identity)
(define add-one succ)
(define (next-adder adder) (lambda (augend) (succ (adder augend))))
(((next-adder (next-adder (next-adder add-zero))) zero) addtulip empty)
=> "🌷🌷🌷"We can simulate the behavior of the Church numeral n by using adders as the state of the computation. We start with the zero adder as the initial state, and on each application of the state transformer we create an adder 1 higher than the current one. After n rounds we obtain an adder with an increment of n, but this is still an adder rather than a numeral. To extract its increment we simply pass in 0.
(define (same-but-with-adders n) ((n next-adder add-zero) zero))
((same-but-with-adders (succ (succ (succ zero)))) addtulip empty)
=> "🌷🌷🌷"[2/2] This is not particularly useful yet because we are simulating n by using the n we already have in hand, but we'll tweak this a bit. If we somehow manage to elide one of the applications of next-adder but keep the rest, we will obtain an adder with an increment of n-1, from which it is easy to extract the numeral by passing in 0. The route we will take here is to use conditionals. One representation of booleans in lambda calculus is to use the first projection as true and the second projection as false. To make a conditional we pass the consequent and the alternate to the boolean test result, and the boolean will choose which branch to return.
(define (true a b) a)
(define (false a b) b)
(true "yes" "no")
=> "yes"
(false "yes" "no")
=> "no"Scheme is an applicative-order language https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/full-text/book/book-Z-H-10.html#%_sec_Temp_22 so this representation of conditionals is not appropriate for the general case because both the consequent and the alternate are always evaluated, but in our case both branches will construct lambdas so these conditionals will suffice. If we have a Church numeral we can determine whether it is zero by using true as the initial state and using a state transformer that switches the state to false. If the numeral is zero the state transformer is never applied and the state remains true. If the state transformer is applied even once because the numeral is non-zero, the state becomes false.
(define (iszero n) (n (lambda (ignored) false) true))
((iszero zero) "yes" "no")
=> "yes"
((iszero (succ zero)) "yes" "no")
=> "no"To tweak same-but-with-adders and elide one of the applications of next-adder but keep the rest, we will use the following strategy. We replace the initial add-zero with a fake adder with two properties: it should function correctly in case it is also the final adder because the state transformer is never applied, and it should be easy to check for in the state transformer. The state transformer is switched from next-adder to a wrapped version of next-adder that first checks whether it is dealing with the fake adder. If so it discards the fake adder and returns add-zero, otherwise it delegates to next-adder. The net result is that the first round of the state transformer is used up for changing the state of the computation from the fake adder to add-zero, while from the second round the next-adder chain proceeds as normal as it did from the first round in same-but-with-adders, but now we only have n-1 rounds left. The final adder will therefore use an increment of n-1. A simple fake adder with the desired properties is one that ignores its argument and always returns 0. To detect it in the state transformer we check whether it returns 0 when invoked on 1. This works because no normal adder returns a result that is less than the argument it is given.
(define (fake-adder ignored) zero)
(define one (succ zero))
(define (next-state adder) ((iszero (adder one)) add-zero (next-adder adder)))
(define (pred n) ((n next-state fake-adder) zero))To see it in action:
((pred zero) addtulip empty)
=> ""
((pred (succ zero)) addtulip empty)
=> ""
((pred (succ (succ zero))) addtulip empty)
=> "🌷"
((pred (succ (succ (succ zero)))) addtulip empty)
=> "🌷🌷"
((pred (succ (succ (succ (succ zero))))) addtulip empty)
=> "🌷🌷🌷"
((pred (succ (succ (succ (succ (succ zero)))))) addtulip empty)
=> "🌷🌷🌷🌷"
((pred (pred (succ (succ (succ (succ (succ zero))))))) addtulip empty)
=> "🌷🌷🌷"
((pred (pred (pred (succ (succ (succ (succ (succ zero)))))))) addtulip empty)
=> "🌷🌷"The conditional adder increment chain and the fake adder suffice for this derivation of the Church predecessor function.
As a bonus we can take our definition of pred, inline its entire dependency tree except iszero, obfuscate all the parameter names and almost arrive at the second PRED formula currently on the https://en.wikipedia.org/wiki/Lambda_calculus page.
PRED := λn.n (λg.λk.ISZERO (g 1) k (PLUS (g k) 1)) (λv.0) 0There are two differences. One is the gratuitous use of (PLUS arg 1) instead of (SUCC arg). There is no need to make PLUS a dependency of PRED when all you're going to add is 1, that's what the successor function is for. The other is more curious. The test of ISZERO does not depend on k, yet it is placed inside λk. The result is that the same test, which k has no influence on, is wastefully recomputed each time λk is invoked. Instead, the test can be evaluated as soon as all the information necessary to perform the test is available, inside λg. This way instead of one lambda with a test that does not use the lambda argument, and two branches as the body, we can have one test with two unconditional lambdas as branches:
PRED := λn.n (λg.ISZERO (g 1) (λk.k) (λk.PLUS (g k) 1)) (λv.0) 0The final 0 is the extraction of the increment from the final adder. The preceding (λv.0) is our fake adder which ignores its argument. The g parameter is the current adder of next-state. The (λk.k) branch is add-zero. The PLUS branch is the body of next-adder. Translation:
PRED := λn.n (λg .ISZERO (g 1) (λk.k) (λk.PLUS (g k) 1)) (λv.0) 0
PRED := λn.n (λcurrent .ISZERO (current 1) add-zero (succ (g k)) fake extract
adder of adder of body of next-adder adder final
next-state next-state incrementHowever, because the current version of that page was written by dodo birds, they'd rather offer induction than explain a derivation of the formula, such as the one with the conditional adder increment chain and the fake adder.
PSA: This is not a blog.
>>187
Yes your right. this is a /prog/ textboard.
not a imageboard.
Connector >>119 version of the tower of memel >>46 >>49
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars n) ((lambda (xjoin lines columns) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index lines columns k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ 2 (* 2 n)) (+ 3 (* 4 n)))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (split corner) (lambda (lines columns k j) (apply (lambda (k up j left) (if (= j 0) (if (= k 1) 0 1) ((lambda (jd jm) (if (<= jd (- k 3)) 1 (if (or (= jd (- k 2)) (= jd k)) (if (= jm 1) 0 (corner 6 up -2 left -1)) (if (= jd (- k 1)) (if (= jm 1) 1 (corner 3 up 2 left 1)) (if (= jm 1) 0 2))))) (quotient (- j 1) 2) (modulo (- j 1) 2)))) `(,@(split lines k 1) ,@(split columns j 0))))) (lambda (lines k adjust) ((lambda (l2) (if (< k l2) `(,(- l2 k) #t) `(,(+ (- k l2) adjust) #f))) (quotient lines 2))) (lambda (from up upstep left leftstep) (+ from (if up upstep 0) (if left leftstep 0)))) " ─│┌┐└┘" 10))
┘ ┌─────────────────────────────────────┐ └
┌─┘ ┌─────────────────────────────────┐ └─┐
│ ┌─┘ ┌─────────────────────────────┐ └─┐ │
│ │ ┌─┘ ┌─────────────────────────┐ └─┐ │ │
│ │ │ ┌─┘ ┌─────────────────────┐ └─┐ │ │ │
│ │ │ │ ┌─┘ ┌─────────────────┐ └─┐ │ │ │ │
│ │ │ │ │ ┌─┘ ┌─────────────┐ └─┐ │ │ │ │ │
│ │ │ │ │ │ ┌─┘ ┌─────────┐ └─┐ │ │ │ │ │ │
│ │ │ │ │ │ │ ┌─┘ ┌─────┐ └─┐ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ ┌─┘ ┌─┐ └─┐ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ ┌─┘ └─┐ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ └─┐ ┌─┘ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ └─┐ └─┘ ┌─┘ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ └─┐ └─────┘ ┌─┘ │ │ │ │ │ │ │
│ │ │ │ │ │ └─┐ └─────────┘ ┌─┘ │ │ │ │ │ │
│ │ │ │ │ └─┐ └─────────────┘ ┌─┘ │ │ │ │ │
│ │ │ │ └─┐ └─────────────────┘ ┌─┘ │ │ │ │
│ │ │ └─┐ └─────────────────────┘ ┌─┘ │ │ │
│ │ └─┐ └─────────────────────────┘ ┌─┘ │ │
│ └─┐ └─────────────────────────────┘ ┌─┘ │
└─┐ └─────────────────────────────────┘ ┌─┘
┐ └─────────────────────────────────────┘ ┌
scheme@(guile-user)> Connector >>189 version of >>11
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars n) ((lambda (xjoin lines columns) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index lines columns k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ 1 (* 2 n)) (+ 2 (* 4 n)))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (base patch) (lambda (lines columns k j) ((lambda (k j) ((lambda (jev) (or (patch k j jev) (base k j jev))) (even? j))) (- k (quotient lines 2)) ((lambda (c2) (if (< j c2) (- j c2) (- j c2 -1))) (quotient columns 2))))) (lambda (k j jev) (if (= k 0) (if (<= -1 j 1) 1 (if jev 0 2)) ((lambda (corner jabs) (if (< jabs corner) 1 (if (= jabs corner) (+ 3 (if (< k 0) 0 2) (if (< j 0) 0 1)) (if jev 0 2)))) (+ (* 2 (abs k)) 1) (abs j)))) (lambda (k j jev) #f)) " ─│┌┐└┘" 10))
┌────────────────────────────────────────┐
│ ┌────────────────────────────────────┐ │
│ │ ┌────────────────────────────────┐ │ │
│ │ │ ┌────────────────────────────┐ │ │ │
│ │ │ │ ┌────────────────────────┐ │ │ │ │
│ │ │ │ │ ┌────────────────────┐ │ │ │ │ │
│ │ │ │ │ │ ┌────────────────┐ │ │ │ │ │ │
│ │ │ │ │ │ │ ┌────────────┐ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ ┌────────┐ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ ┌────┐ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ ── │ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ └────┘ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ └────────┘ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ └────────────┘ │ │ │ │ │ │ │
│ │ │ │ │ │ └────────────────┘ │ │ │ │ │ │
│ │ │ │ │ └────────────────────┘ │ │ │ │ │
│ │ │ │ └────────────────────────┘ │ │ │ │
│ │ │ └────────────────────────────┘ │ │ │
│ │ └────────────────────────────────┘ │ │
│ └────────────────────────────────────┘ │
└────────────────────────────────────────┘
scheme@(guile-user)> in the next episode: >>13
Connector >>190 version of >>13
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars n) ((lambda (xjoin lines columns) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index lines columns k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ 1 (* 2 n)) (+ 2 (* 4 n)))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (base patch) (lambda (lines columns k j) ((lambda (k j) ((lambda (jev) (or (patch k j jev) (base k j jev))) (even? j))) (- k (quotient lines 2)) ((lambda (c2) (if (< j c2) (- j c2) (- j c2 -1))) (quotient columns 2))))) (lambda (k j jev) (if (= k 0) (if (<= -1 j 1) 1 (if jev 0 2)) ((lambda (corner jabs) (if (< jabs corner) 1 (if (= jabs corner) (+ 3 (if (< k 0) 0 2) (if (< j 0) 0 1)) (if jev 0 2)))) (+ (* 2 (abs k)) 1) (abs j)))) (lambda (k j jev) (if (or (< k 0) (< j 0)) #f ((lambda (corner) (if (= j corner) 6 (if (or (= j (- corner 1)) (= j (- corner 2))) 1 #f))) (+ (* 2 k) 3))))) " ─│┌┐└┘" 10))
┌────────────────────────────────────────┐
│ ┌────────────────────────────────────┐ │
│ │ ┌────────────────────────────────┐ │ │
│ │ │ ┌────────────────────────────┐ │ │ │
│ │ │ │ ┌────────────────────────┐ │ │ │ │
│ │ │ │ │ ┌────────────────────┐ │ │ │ │ │
│ │ │ │ │ │ ┌────────────────┐ │ │ │ │ │ │
│ │ │ │ │ │ │ ┌────────────┐ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ ┌────────┐ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ ┌────┐ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │ ───┘ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ └──────┘ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ └──────────┘ │ │ │ │ │ │ │
│ │ │ │ │ │ │ └──────────────┘ │ │ │ │ │ │
│ │ │ │ │ │ └──────────────────┘ │ │ │ │ │
│ │ │ │ │ └──────────────────────┘ │ │ │ │
│ │ │ │ └──────────────────────────┘ │ │ │
│ │ │ └──────────────────────────────┘ │ │
│ │ └──────────────────────────────────┘ │
│ └──────────────────────────────────────┘
└─────────────────────────────────────────
scheme@(guile-user)> in the next episode: >>37
Connector >>191 version of >>37
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars n) ((lambda (xjoin lines columns) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index lines columns k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (+ 1 (* 2 n)) (+ 2 (* 4 n)))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (base patch) (lambda (lines columns k j) ((lambda (k j) ((lambda (jev) (or (patch k j jev) (base k j jev))) (even? j))) (- k (quotient lines 2)) ((lambda (c2) (if (< j c2) (- j c2) (- j c2 -1))) (quotient columns 2))))) (lambda (k j jev) (if (= k 0) (if (<= -1 j 1) 1 (if jev 0 2)) ((lambda (corner jabs) (if (< jabs corner) 1 (if (= jabs corner) (+ 3 (if (< k 0) 0 2) (if (< j 0) 0 1)) (if jev 0 2)))) (+ (* 2 (abs k)) 1) (abs j)))) (lambda (k j jev) (if (and (>= k 0) (> j 0)) ((lambda (corner) (if (= j corner) 6 (if (or (= j (- corner 1)) (= j (- corner 2))) 1 #f))) (+ (* 2 k) 3)) (if (and (<= k 0) (< j 0)) ((lambda (corner) (if (= j corner) 3 (if (or (= j (+ corner 1)) (= j (+ corner 2))) 1 #f))) (- (* 2 k) 3)) #f)))) " ─│┌┐└┘" 10))
─────────────────────────────────────────┐
┌──────────────────────────────────────┐ │
│ ┌──────────────────────────────────┐ │ │
│ │ ┌──────────────────────────────┐ │ │ │
│ │ │ ┌──────────────────────────┐ │ │ │ │
│ │ │ │ ┌──────────────────────┐ │ │ │ │ │
│ │ │ │ │ ┌──────────────────┐ │ │ │ │ │ │
│ │ │ │ │ │ ┌──────────────┐ │ │ │ │ │ │ │
│ │ │ │ │ │ │ ┌──────────┐ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ ┌──────┐ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ ┌────┘ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ └──────┘ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ └──────────┘ │ │ │ │ │ │ │
│ │ │ │ │ │ │ └──────────────┘ │ │ │ │ │ │
│ │ │ │ │ │ └──────────────────┘ │ │ │ │ │
│ │ │ │ │ └──────────────────────┘ │ │ │ │
│ │ │ │ └──────────────────────────┘ │ │ │
│ │ │ └──────────────────────────────┘ │ │
│ │ └──────────────────────────────────┘ │
│ └──────────────────────────────────────┘
└─────────────────────────────────────────
scheme@(guile-user)> Third Interlude: Church predecessor function with cherry blossoms
Recall from SICP 1.2.2 Tree Recursion https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/full-text/book/book-Z-H-11.html#%_sec_1.2.2 that to go from a tree-recursive procedure for computing Fibonacci numbers to an iterative procedure, we used the technique of keeping two consecutive values from the Fibonacci sequence and moving them at each step to the next position in the sequence. Here is a version without the superfluous round performed in SICP:
(define (fib-iter a b n) (if (= n 1) b (fib-iter b (+ a b) (- n 1))))
(define (fib n) (if (<= n 0) 0 (fib-iter 0 1 n)))
(fib 10)
=> 55We can use the same technique of keeping two consecutive values from a sequence on Church numerals. We start with the basic zero and succ from >>172 >>185.
(define (zero state-transformer initial-state) initial-state)
(define empty "")
(define (addcherry string) (string-append string "🌸"))
(define (succ n) (lambda (state-transformer initial-state) (state-transformer (n state-transformer initial-state))))
((succ (succ (succ zero))) addcherry empty)
=> "🌸🌸🌸"We also use the pairs from >>172 SICP exercise 2.4 https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/full-text/book/book-Z-H-14.html#%_thm_2.4 to package the two consecutive values.
(define (make-pair a b) (lambda (receiver) (receiver a b)))
(define (first-projection a b) a)
(define (second-projection a b) b)
(define (first pair) (pair first-projection))
(define (second pair) (pair second-projection))
(first (make-pair "🌸" "🦋"))
=> "🌸"
(second (make-pair "🌸" "🦋"))
=> "🦋"We can rebuild the Church numeral n by starting with 0 and applying the successor function n times, but in the spirit of the iterative Fibonacci technique we also keep around the previous value in our sequence, the one to which we apply the successor function. Our state transformation is [a, b] --> [b, b+1]. Starting with [0, 0] this yields the chain [0, 0] --> [0, 1] --> [1, 2] --> [2, 3] and so on. After n rounds the second component of our pair is n.
(define (keep-one-behind pair) (make-pair (second pair) (succ (second pair))))
(define (same-but-with-one-behind n) (second (n keep-one-behind (make-pair zero zero))))
((same-but-with-one-behind (succ (succ (succ zero)))) addcherry empty)
=> "🌸🌸🌸"This is not particularly useful yet because we are simulating n by using the n we already have in hand, but we can easily change this into a predecessor function by extracting the first component of the final pair instead of the second component. At this point it becomes important that the first component of our initial pair is 0. In same-but-with-one-behind the first component of our initial pair could be any value because that value will never be used. But here it must be 0 so that we get the correct predecessor even when the state transformer is not applied at all because n happens to be 0.
(define (pred n) (first (n keep-one-behind (make-pair zero zero))))
((pred zero) addcherry empty)
=> ""
((pred (succ zero)) addcherry empty)
=> ""
((pred (succ (succ zero))) addcherry empty)
=> "🌸"
((pred (succ (succ (succ zero)))) addcherry empty)
=> "🌸🌸"
((pred (succ (succ (succ (succ zero))))) addcherry empty)
=> "🌸🌸🌸"
((pred (succ (succ (succ (succ (succ zero)))))) addcherry empty)
=> "🌸🌸🌸🌸"
((pred (pred (succ (succ (succ (succ (succ zero))))))) addcherry empty)
=> "🌸🌸🌸"
((pred (pred (pred (succ (succ (succ (succ (succ zero)))))))) addcherry empty)
=> "🌸🌸"The successor sequence that keeps around two consecutive values suffices for this derivation of the Church predecessor function.
In this case the third PRED formula from the https://en.wikipedia.org/wiki/Lambda_calculus page is effectively in the clear, with Φ being our keep-one-behind function.
Φ := λx.PAIR (SECOND x) (SUCC (SECOND x))
PRED := λn.FIRST (n Φ (PAIR 0 0))updated counts >>163 since August
1 9 12 391 >>> 53 59
2 10 7 461 scheme@(guile-user)> 59 55
3 11 13 483 >> 49 53
4 13 15 627 >> 41 48
5 14 13 471 >> 50 54
6 17 14 524 >>> 47 50
7 21 18 789 >>> 32 44
8 24 15 851 scheme@(guile-user)> 42 43
9 25 13 692 scheme@(guile-user)> 51 46
10 28 25 1599 >>> 10 13
11 30 10 508 >> 55 51
12 34 13 560 >> 52 49
13 35 19 1375 scheme@(guile-user)> 28 20
14 37 15 642 >> 43 47
15 39 21 909 >> 18 40
16 42 10 452 >> 56 57
17 43 10 444 >> 57 58
18 46 18 707 >>> 33 45
19 49 23 1070 >>> 14 33
20 53 21 873 >>> 19 42
21 55 14 1066 scheme@(guile-user)> 48 35
22 59 21 1475 scheme@(guile-user)> 20 15
23 65 19 1110 scheme@(guile-user)> 29 30
24 67 25 1716 >>> 11 10
25 69 10 460 >> 58 56
26 70 20 1333 scheme@(guile-user)> 23 23
27 72 25 1717 scheme@(guile-user)> 12 9
28 77 33 2654 scheme@(guile-user)> 2 2
29 81 20 1459 scheme@(guile-user)> 24 16
30 85 30 1180 >> 6 27
31 89 32 1176 >> 3 28
32 90 18 1067 scheme@(guile-user)> 34 34
33 95 21 888 >>> 21 41
34 99 23 1262 scheme@(guile-user)> 15 24
35 100 22 993 >>> 16 38
36 104 30 1649 scheme@(guile-user)> 7 12
37 107 19 1391 scheme@(guile-user)> 30 19
38 109 31 1336 >>> 4 22
39 111 15 1062 scheme@(guile-user)> 44 36
40 113 21 1566 scheme@(guile-user)> 22 14
41 115 24 1935 scheme@(guile-user)> 13 5
42 119 16 1031 scheme@(guile-user)> 40 37
43 120 11 495 >> 54 52
44 121 15 990 scheme@(guile-user)> 45 39
45 126 17 1097 scheme@(guile-user)> 37 31
46 129 22 1423 scheme@(guile-user)> 17 18
47 132 27 1872 scheme@(guile-user)> 8 7
48 137 15 1164 scheme@(guile-user)> 46 29
49 139 17 1449 scheme@(guile-user)> 38 17
50 149 18 1660 scheme@(guile-user)> 35 11
51 153 26 2101 scheme@(guile-user)> 9 4
52 157 36 2926 scheme@(guile-user)> 1 1
53 176 20 1817 scheme@(guile-user)> 25 8
54 182 20 1913 scheme@(guile-user)> 26 6
55 184 31 2422 scheme@(guile-user)> 5 3
56 189 17 1223 scheme@(guile-user)> 39 25
57 190 18 1089 scheme@(guile-user)> 36 32
58 191 19 1222 scheme@(guile-user)> 31 26
59 192 20 1359 scheme@(guile-user)> 27 21>>194
Could you explain what those "counts" are?
All I see is a long list of numbers.
>>195
Columns:
* autoincrement counter from 1
* post number
* lambda count
* character count
* language prompt
* ranking by lambda count, current leader is >>157 with 36
* ranking by character count, current leader is the same >>157 just shy of 3K
The code is in >>76.
🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌹🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌸🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌸🌸🌸🌵🌸🌵🌹🌹🌹🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌸🌵🌸🌸🌸🌵🌹🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼
🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼
🌹🌹🌵🌻🌵🌹🌹🌹🌵🌻🌵🌹🌹🌹🌵🌻🌵🌸🌸🌸🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼
🌹🌵🌻🌻🌻🌵🌹🌵🌻🌻🌻🌵🌹🌵🌻🌻🌻🌵🌸🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼🌵🌼🌼🌼🌵🌼
🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵
🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌺🌵🌼🌼🌼🌵🌹🌵🌼🌼🌼🌵🌹🌵🌼🌼🌼🌵🌹
🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌺🌺🌺🌵🌼🌵🌹🌹🌹🌵🌼🌵🌹🌹🌹🌵🌼🌵🌹🌹
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹
🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌹🌵🌺🌺🌺🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹
🌵🌻🌻🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵
🌻🌵🌻🌻🌻🌵🌻🌵🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹
🌻🌻🌵🌻🌵🌻🌻🌻🌵🌻🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌻🌻🌻🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹Quadrant windmill >>25 >>65 flower garden:
scheme@(guile-user)> (display ((lambda (rec xjoin extract index quadrotate windmill windout chars band columnfactor n) ((lambda (xjoin patch lines columns cycle) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (quadrotate windmill windout) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (quad output) (lambda (cycle x y dx dy band) (if (>= x 0) (if (>= y 0) (output cycle 0 (quad x y dx dy band)) (output cycle 1 (quad (- -1 y) x (- band dy) dx band))) (if (>= y 0) (output cycle 3 (quad y (- -1 x) dy (- band dx) band)) (output cycle 2 (quad (- -1 x) (- -1 y) (- band dx) (- band dy) band)))))) (lambda (x y dx dy band) (>= x y)) (lambda (cycle quadindex fromquad) (if fromquad (+ quadindex 1) 0)) "🌵🌹🌺🌼🌸🌻🌷💮🦋" 6 2 9))separate output >>197 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4099 http://paste.textboard.org/7c3d3d3f/raw
apply
* { line-height: 1em; }
to the larger version for more symmetry
>>198
Fold [clap emoji] your [clap emoji] code [clap emoji] over [clap emoji] multiple [clap emoji] lines.
🌻🌻🌻🌵🌺🌺🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌻🌻🌻
🌻🌻🌵🌻🌵🌺🌺🌺🌵🌺🌵🌻🌻🌻🌵🌺🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌻🌵🌻🌻
🌻🌵🌻🌻🌻🌵🌺🌵🌺🌺🌺🌵🌻🌵🌺🌺🌺🌵🌺🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺🌵🌻🌻🌻🌵🌻
🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵
🌺🌵🌻🌻🌻🌵🌺🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌺🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌻🌵🌻🌻🌻🌵🌺
🌺🌺🌵🌻🌵🌺🌺🌺🌵🌺🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌺🌵🌻🌻🌻🌵🌻🌵🌺🌺
🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺
🌺🌺🌵🌺🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌺🌵🌻🌻🌻🌵🌻🌵🌺🌺
🌺🌵🌺🌺🌺🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌻🌵🌻🌻🌻🌵🌺
🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵
🌺🌵🌺🌺🌺🌵🌺🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺🌵🌻🌻🌻🌵🌺
🌺🌺🌵🌺🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌻🌵🌺🌺
🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺
🌺🌺🌵🌻🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌺🌵🌺🌺
🌺🌵🌻🌻🌻🌵🌺🌵🌺🌺🌺🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺
🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵
🌺🌵🌻🌻🌻🌵🌻🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌺🌺🌺🌵🌺
🌺🌺🌵🌻🌵🌻🌻🌻🌵🌺🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌺🌵🌺🌺
🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺https://en.wikipedia.org/wiki/Sauwastika The compact swastika can be seen as a chiral irregular icosagon (20-sided polygon) with fourfold (90°) rotational symmetry. Such a swastika proportioned on a 5 × 5 square grid and with the broken portions of its legs shortened by one unit can tile the plane by translation alone.
Flower garden port of the left-winding tiles. >>35 >>36
scheme@(guile-user)> (display ((lambda (rec xjoin extract index reduce home moves chars band columnfactor n) ((lambda (xjoin reduce lines columns cycle) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (modulo (reduce y x) cycle)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (k j) (rec reduce home moves k j 0)) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) ((lambda (done last move) (lambda (self home moves k j acc) (if (done k j) (+ acc (last home k j)) (apply (lambda (dk dj) (self self home moves (+ k dk) (+ j dj) (+ acc 1))) (vector-ref moves (move k j)))))) (lambda (k j) (and (<= -2 k) (<= k 2) (<= -2 j) (<= j 2))) (lambda (home k j) (if (logbit? (- 2 j) (vector-ref home (+ k 2))) 1 0)) (lambda (k j) (if (zero? k) (if (positive? j) 1 2) (if (zero? j) (if (positive? k) 0 3) (+ (if (positive? k) 0 1) (if (positive? j) 0 2)))))) #(19 26 0 11 25) #((-3 -2) (2 -3) (-2 3) (3 2)) "🌵🌹🌺🌻🌼" 6 2 9))separate output >>200 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4141 http://paste.textboard.org/56d168d3/raw
apply
* { line-height: 1em; }
to the larger version for more symmetry
You don't read threads from the start, do you?
Quadrant flower garden port of >>10.
scheme@(guile-user)> (display ((lambda (rec xjoin extract index quadreflect reduce rhombfun rhombout chars start band columnfactor n) ((lambda (xjoin reduce lines columns cycle) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (quadreflect (rhombfun reduce) rhombout))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (x y) (rec reduce start x y)) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (quad output) (lambda (cycle x y dx dy band) (if (>= x 0) (if (>= y 0) (output cycle 0 (quad x y dx dy band)) (output cycle 1 (quad x (- -1 y) dx (- band dy) band))) (if (>= y 0) (output cycle 3 (quad (- -1 x) y (- band dx) dy band)) (output cycle 2 (quad (- -1 x) (- -1 y) (- band dx) (- band dy) band)))))) (lambda (self n x y) (if (<= (max x y) n) (>= (+ x y) n) (self self (+ (* 2 n) 2) x y))) (lambda (reduce) (lambda (x y dx dy band) (reduce x y))) (lambda (cycle quadindex fromquad) (if fromquad (+ quadindex 1) 0)) "🌵🌹🌺🌼🌸🌻🌷💮🦋" 2 6 1 10))
🌵🌹🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌸🌵🌸🌸🌸🌵🌹🌵
🌹🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌸🌸🌸🌸🌸🌵🌹
🌵🌻🌵🌸🌸🌸🌵🌹🌵🌸🌸🌸🌵🌹🌵🌸🌸🌸🌵🌼🌵
🌻🌻🌻🌵🌸🌵🌹🌹🌹🌵🌸🌵🌹🌹🌹🌵🌸🌵🌼🌼🌼
🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼
🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼
🌵🌻🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌼🌵
🌻🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌼
🌵🌻🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌼🌵
🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼
🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼
🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼
🌵🌻🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌼🌵
🌻🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌼
🌵🌻🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌼🌵
🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼
🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼
🌻🌻🌻🌵🌺🌵🌹🌹🌹🌵🌺🌵🌹🌹🌹🌵🌺🌵🌼🌼🌼
🌵🌻🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌹🌵🌺🌺🌺🌵🌼🌵
🌹🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌺🌺🌺🌺🌺🌵🌹
🌵🌹🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌺🌵🌺🌺🌺🌵🌹🌵
scheme@(guile-user)> larger version: https://wirechan.org/b/res/2162.html#4154 http://paste.textboard.org/bedf4f11/raw
apply
* { line-height: 1em; }
to the larger version for more symmetry
Fourth Interlude: Church predecessor function with sunflowers
To have at least one predecessor function not on the https://en.wikipedia.org/wiki/Lambda_calculus page, here's a derivation using a chain of function and argument pairs. We start with the basic zero and succ from >>172 >>185 >>193.
(define (zero state-transformer initial-state) initial-state)
(define empty "")
(define (addsunflower string) (string-append string "🌻"))
(define (succ n) (lambda (state-transformer initial-state) (state-transformer (n state-transformer initial-state))))
((succ (succ (succ zero))) addsunflower empty)
=> "🌻🌻🌻"We also use the pairs from >>172 >>193 SICP exercise 2.4 https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/full-text/book/book-Z-H-14.html#%_thm_2.4 to package a function and its argument.
(define (make-pair a b) (lambda (receiver) (receiver a b)))
(define (first-projection a b) a)
(define (second-projection a b) b)
(define (first pair) (pair first-projection))
(define (second pair) (pair second-projection))
(first (make-pair "🌻" "🦋"))
=> "🌻"
(second (make-pair "🌻" "🦋"))
=> "🦋"We can rebuild the Church numeral n by starting with 0 and applying the successor function n times, but we keep the successor function in the first component of a pair and its current argument in the second component. We are using [fun, arg] --> [fun, fun(arg)] as the state tranformer and starting off the chain with [succ, 0]. After n rounds the initial 0 is wrapped in n applications of succ.
(define (apply-fun-value pair) (make-pair (first pair) ((first pair) (second pair))))
(define (same-but-with-fun-value n) (second (n apply-fun-value (make-pair succ zero))))
((same-but-with-fun-value (succ (succ (succ zero)))) addsunflower empty)
=> "🌻🌻🌻"This is not particularly useful yet because we are simulating n by using the n we already have in hand, but if we manage to elide one round of succ application while keeping the rest, we will be left with n-1 applications of succ on our initial 0, which is what we want from our predecessor function. To elide one round we resort to the usual device of a special initial state and a state tranformer that can handle it. In the new state tranformer, instead of always applying and propagating the function we find in the first component of the current pair, we apply the function we find but then overwrite it with succ. We use [fun, arg] --> [succ, fun(arg)]. This allows us to start off the chain with [identity, 0] as the new initial state. On the first round identity is applied to 0 and is then replaced with succ: [identity, 0] --> [succ, 0]. The remaining n-1 rounds wrap 0 in n-1 applications of the successor function.
(define (apply-and-switch-to-succ pair) (make-pair succ ((first pair) (second pair))))
(define (identity a) a)
(define (pred n) (second (n apply-and-switch-to-succ (make-pair identity zero))))
((pred zero) addsunflower empty)
=> ""
((pred (succ zero)) addsunflower empty)
=> ""
((pred (succ (succ zero))) addsunflower empty)
=> "🌻"
((pred (succ (succ (succ zero)))) addsunflower empty)
=> "🌻🌻"
((pred (succ (succ (succ (succ zero))))) addsunflower empty)
=> "🌻🌻🌻"
((pred (succ (succ (succ (succ (succ zero)))))) addsunflower empty)
=> "🌻🌻🌻🌻"
((pred (pred (succ (succ (succ (succ (succ zero))))))) addsunflower empty)
=> "🌻🌻🌻"
((pred (pred (pred (succ (succ (succ (succ (succ zero)))))))) addsunflower empty)
=> "🌻🌻"The chain of function and argument pairs with the succ overwrite and identity bootstrap suffices for this derivation of the Church predecessor function.
This technique of rebuilding n and then arranging for one of the rounds to be elided can be used as a general method for obtaining various forms of the predecessor function.
church numeral and successor/predecessor functions
That's dope. I figured out (on paper) several extensions to PA to increasingly construct the rationals, and then the algebraic and complex numbers. It started with dropping the least-element axiom and adding a predecessor function to build the negative numbers. If this is translated to church numerals, we can have the whole of arithmetic built up from pure λ-terms.
The system developed into a rotation group where the "imaginary" unit together with multiplication were the fundamental entities. It can be extended with addition to represent an arbitrary complex number. The system can be generalized to a sort of Clifford algebra.
I wonder if such an algebra can be implemented with pure λ-terms, in such a way that multiplication is encoded by λ-application. So if ι and κ are both objects of the system, another element of the system can be yielded by the expression (ι κ). Furthermore,if the group is cyclic, could there be a term Κ such that ιΚ = ι? For example, could there be a λ-term that applied to itself 3 times yields itself? This in analogy to how powers of the "imaginary" unit i yield: i, -1, -i, 1, i ...
Can this be extended to clifford (aka geometric) algebras? Where we have(say) a set of primitives e1, e2, e3, where you can construct a 'blade' e1*e2, e1*e2*e3, but certain combinations such as e1*e1=0 and e1*e2*e3*e1=0 and so on.
I got stuck with this question, maybe you have an idea as to how this could be done?
🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹
🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹
🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹Upgrade of the flower garden with the ability to render connectors in flower patches. The port of the ├┤ tree fractal >>107 >>108 as an example.
scheme@(guile-user)> (display ((lambda (rec xjoin extract windowtopleft index hindex size connector connectors start startlr levels chars band columnfactor n) ((lambda (xjoin hindex size connector lines columns cycle) ((lambda (hlincol) ((lambda (hlines hcolumns) ((lambda (hindex) ((lambda (window) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (window x y) dx dy) 1 0)))) (windowtopleft hcolumns hlines hindex))) (lambda (k j) (hindex hlines hcolumns k j startlr)))) (car hlincol) (cadr hlincol))) (size (+ levels 1) start))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (rows cols k j lr) (rec hindex rows cols k j lr)) (lambda (n rowcol) (rec size n rowcol)) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (width height fun) ((lambda (w2 h2) ((lambda (x1 x2 y1 y2) (lambda (x y) (if (and (<= x1 x x2) (<= y1 y y2)) (fun (- y y1) (- x x1)) 0))) (- w2) (- width w2 1) (- h2) (- height h2 1))) (quotient width 2) (quotient height 2))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (self rows cols k j lr) ((lambda (r2 c2) (if (= k r2) (if (= j c2) (if lr 6 5) (if ((if lr < >) j c2) 0 1)) ((lambda (r4) ((lambda (r4+) (if (= j c2) (if (< k r4) 0 (if (= k r4) 3 (if (< k r4+) 2 (if (= k r4+) 4 0)))) (if (= (abs (- j c2)) 1) (if (or (= k r4) (= k r4+)) 1 0) (self self r2 (- c2 1) (if (< k r2) k (- k r2 1)) (if (< j c2) j (- j c2 2)) (< j c2))))) (+ 2 (* 3 r4)))) (quotient r2 2)))) (quotient rows 2) (quotient cols 2))) (lambda (self n rowcol) (if (= n 0) rowcol (self self (- n 1) (list (+ 1 (* 2 (car rowcol))) (+ 3 (* 2 (cadr rowcol))))))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 33 17 10 12) '(1 0) #t 1 "🌵🌹🌺🌼🌸🌻🌷💮🦋" 6 2 9))separate output >>207 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4205 http://paste.textboard.org/64be4e7d/raw
>>206
Thanks for the laughs. I appreciate the effort you put into the technical jargon to make your post entertaining. I wish I could provide an answer matching the style of your post, but I lack your comedic talent. For a real answer, however, you will no doubt recall that lambda terms are countable, so you are invited to defend your statement that you've already managed to "represent an arbitrary complex number" and have it "built up from pure λ-terms", since that would imply representing the real subset, and in turn the transcendent subset which is uncountable. The invitation is of course rhetorical.
so you are invited to defend your statement that you've already managed to "represent an arbitrary complex number" and have it "built up from pure λ-terms"
My bad, I meant an *algebraic* complex number.
>>208
And I was being serious, but I', glad you found it funny.
🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹
🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵
🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹Port of the tile maze >>30 >>34 to the connector flower garden >>208.
scheme@(guile-user)> (display ((lambda (rec xjoin extract tilegrid index connector connectors tilespec chars band columnfactor n) ((lambda (xjoin tilegrid connector lines columns cycle) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (tilegrid x y) dx dy) 1 0)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (tilegrid tilespec) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (spec) ((lambda (rows cols) (lambda (x y) (vector-ref (vector-ref spec (modulo y rows)) (modulo x cols)))) (vector-length spec) (vector-length (vector-ref spec 0)))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 36 34 20 18 33 17 10 12) #(#(1 1 1 9 0 10 1 1) #(0 0 0 2 0 2 0 0) #(0 2 0 2 0 2 0 2) #(0 2 0 0 0 0 0 2) #(0 10 1 1 1 1 1 9) #(0 2 0 0 0 0 0 2) #(0 2 0 2 0 2 0 2) #(0 0 0 2 0 2 0 0)) "🌵🌹🌺🌼🌸🌻🌷💮🦋" 6 2 9))separate output >>211 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4224 http://paste.textboard.org/8906113f/raw
>>209 >>210
OK, we can play goalpost moving for a few more rounds as long as you're entertaining. Since you now claim to have already managed to represent an arbitrary algebraic complex number, built up from pure λ-terms, and "to increasingly construct the rationals, and then the algebraic and complex numbers", there are two problems. First, the set of algebraics that can be constructed from the rationals with the usual operations is a strict subset of all algebraics. You cannot construct all algebraics that way, regardless of your particular representation, for example due to Galois and the quintic. The second problem is more fundamental. Since you cannot have R due to the uncountability issue >>208, you do not yet have a larger field containing Q. You can take polynomials over Q, but their roots are either in Q, in which case they are not useful to you because they add nothing to Q, or they are not in Q, in which case they do not exist at all because you do not have a larger containing field to take them from. Unrestricted comprehension is an invalid operation. A predicate P, such as "is a root of such and such polynomial", must be used to filter an existing set, not the "universe of everything". Otherwise you find yourself in the set-of-all-sets situation, and Bertrand Russell will pop up to interject for a moment that what you are referring to as the set of all sets is in fact a violation of the consistency of your construction. So without a support to scan over with P, you don't get to apply P. Naturally I don't expect you, the anon, to have an actual response to either of these problems, but I'm mildly curious to see what answers your assumed persona will give to defend the construction which is stated to already exist.
🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌺🌹🌹🌵🌹🌵🌹🌹🌺🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹
🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹🌹🌺🌹🌹🌹🌵🌹🌹🌹🌺🌹🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹
🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌺🌹🌹🌹🌵🌹🌵🌹🌹🌹🌺🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹
🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵
🌹🌺🌹🌹🌹🌵🌹🌵🌹🌹🌹🌺🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌺🌹🌹🌹🌵🌹🌵🌹🌹🌹🌺🌹
🌹🌹🌺🌺🌺🌺🌵🌺🌺🌺🌺🌹🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹🌹🌺🌺🌺🌺🌵🌺🌺🌺🌺🌹🌹
🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹
🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵
🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹
🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹
🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹
🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵
🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹
🌹🌹🌺🌺🌺🌺🌵🌺🌺🌺🌺🌹🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹🌹🌺🌺🌺🌺🌵🌺🌺🌺🌺🌹🌹
🌹🌺🌹🌹🌹🌵🌹🌵🌹🌹🌹🌺🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌺🌹🌹🌹🌵🌹🌵🌹🌹🌹🌺🌹
🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵🌹🌹🌹🌵
🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌺🌹🌹🌹🌵🌹🌵🌹🌹🌹🌺🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹
🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹🌹🌺🌹🌹🌹🌵🌹🌹🌹🌺🌹🌹🌹🌵🌹🌹🌹🌹🌹🌹🌹🌵🌹🌹
🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹🌹🌺🌹🌹🌵🌹🌵🌹🌹🌺🌹🌹🌵🌹🌵🌹🌹🌹🌹🌹🌵🌹🌵🌹Sierpinski space-filling curve on the connector flower garden >>208. The 3π/4 connectors that would enable it to be drawn symmetrically in plain text mode seem to be missing from Unicode.
scheme@(guile-user)> (display ((lambda (rec xjoin extract windowtopleft derive expandsize cell index connector connectors cellspec cellrows cellcols expansions expandx expandy levels chars band columnfactor n) ((lambda (xjoin derive cell connector lines columns cycle size) ((lambda (sizex sizey) ((lambda (derive) ((lambda (derivecell) ((lambda (window) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (window x y) dx dy) 1 0)))) (windowtopleft sizex sizey derivecell))) (lambda (y x) ((lambda (qx mx qy my) (cell (derive qx qy) mx my)) (quotient x cellcols) (modulo x cellcols) (quotient y cellrows) (modulo y cellrows))))) ((lambda (sizex sizey) (lambda (x y) (rec derive 0 x y sizex sizey))) (quotient sizex cellcols) (quotient sizey cellrows)))) (car size) (cadr size))) (lambda (n fun sep) (rec xjoin n fun sep "")) (derive expansions expandx expandy) (cell cellspec cellcols) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars) (expandsize cellcols cellrows expandx expandy levels))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (width height fun) ((lambda (w2 h2) ((lambda (x1 x2 y1 y2) (lambda (x y) (if (and (<= x1 x x2) (<= y1 y y2)) (fun (- y y1) (- x x1)) 0))) (- w2) (- width w2 1) (- h2) (- height h2 1))) (quotient width 2) (quotient height 2))) (lambda (spec expandx expandy) (lambda (self var x y sizex sizey) (if (= sizex 1) var ((lambda (subx suby) ((lambda (qx mx qy my) (self self (vector-ref (vector-ref spec var) (+ (* qy expandx) qx)) mx my subx suby)) (quotient x subx) (modulo x subx) (quotient y suby) (modulo y suby))) (quotient sizex expandx) (quotient sizey expandy))))) ((lambda (size) (lambda (cellx celly expandx expandy levels) (list (size cellx expandx levels) (size celly expandy levels)))) (lambda (start expand levels) (* start (expt expand levels)))) (lambda (spec columns) (lambda (index dx dy) (vector-ref (vector-ref spec index) (+ (* dy columns) dx)))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))) (and (= dx dy) (or (on 6 bits) (and (< dx b2) (on 7 bits)) (and (> dx b2) (on 8 bits)))) (and (= (+ dx dy) band) (or (on 9 bits) (and (< dx b2) (on 10 bits)) (and (> dx b2) (on 11 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 36 34 20 18 33 17 10 12 64 512 132 1028 2050 258 160 2080 1040 272 2304 1152 1280 2176) #(#(0 23 0 21 0 22 0 24 0) #(0 23 0 15 0 22 0 18 0) #(0 23 0 21 0 13 0 17 0) #(0 19 0 21 0 14 0 24 0) #(0 20 0 16 0 22 0 24 0) #(0 19 0 15 0 14 0 18 0) #(0 20 0 16 0 13 0 17 0)) 3 3 #(#(2 1 3 4) #(2 1 5 4) #(2 1 3 6) #(2 5 3 4) #(6 1 3 4) #(2 5 5 4) #(6 1 3 6)) 2 2 2 "🌵🌹🌺🌼🌸🌻🌷💮🦋" 8 2 9))separate output >>213 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4271 http://paste.textboard.org/e398a285/raw
That's funny... You still didn't get a blog?
Fifth Interlude: Church predecessor function with hibiscus flowers
The technique of rebuilding n and then arranging for one of the rounds to be elided >>205 is not the only way to build predecessor functions. For example the chain of function and argument pairs from the previous interlude >>205 can be built directly on the state transformer and initial state which are the arguments of a Church numeral >>172, instead of being built on succ and zero, thus unwrapping one level of abstraction. We start with the by now usual zero, succ and make-pair, but the first two will only be used to test the predecessor function, not to build it.
(define (zero state-transformer initial-state) initial-state)
(define empty "")
(define (addhibiscus string) (string-append string "🌺"))
(define (succ n) (lambda (state-transformer initial-state) (state-transformer (n state-transformer initial-state))))
((succ (succ (succ zero))) addhibiscus empty)
=> "🌺🌺🌺"
(define (make-pair a b) (lambda (receiver) (receiver a b)))
(define (first-projection a b) a)
(define (second-projection a b) b)
(define (first pair) (pair first-projection))
(define (second pair) (pair second-projection))
(first (make-pair "🌺" "🦋"))
=> "🌺"
(second (make-pair "🌺" "🦋"))
=> "🦋"To obtain the behavior of the Church numeral n-1 we need n-1 applications of the state transformer wrapping the initial state. With n in hand we have n rounds available, so just as in the previous interlude >>205 we use the first round to apply the identity function to the initial state, and then switch to the real state transformer for the remaining rounds.
(define (apply-and-switch-to switch-to-this) (lambda (pair) (make-pair switch-to-this ((first pair) (second pair)))))
(define (identity a) a)
(define (pred n) (lambda (state-transformer initial-state) (second (n (apply-and-switch-to state-transformer) (make-pair identity initial-state)))))To see pred in action:
((pred zero) addhibiscus empty)
=> ""
((pred (succ zero)) addhibiscus empty)
=> ""
((pred (succ (succ zero))) addhibiscus empty)
=> "🌺"
((pred (succ (succ (succ zero)))) addhibiscus empty)
=> "🌺🌺"
((pred (succ (succ (succ (succ zero))))) addhibiscus empty)
=> "🌺🌺🌺"
((pred (succ (succ (succ (succ (succ zero)))))) addhibiscus empty)
=> "🌺🌺🌺🌺"
((pred (pred (succ (succ (succ (succ (succ zero))))))) addhibiscus empty)
=> "🌺🌺🌺"
((pred (pred (pred (succ (succ (succ (succ (succ zero)))))))) addhibiscus empty)
=> "🌺🌺"By storing both a function and its argument the pairs are able to simulate both the fake box and the real box from the first interlude >>173, and by being more flexible they don't need two separate definitions to do this.
🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺Port of >>119 to the connector flower garden >>208.
scheme@(guile-user)> (display ((lambda (rec xjoin extract cell index connector connectors chars band columnfactor n) ((lambda (xjoin cell connector lines columns cycle) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (cell x y) dx dy) 1 0)))) (lambda (n fun sep) (rec xjoin n fun sep "")) ((lambda (shift) (lambda (x y) (shift (cell x y)))) (lambda (x) (if (< x 3) x (+ x 4)))) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (half) (lambda (j k) (apply (lambda (k up j left) ((lambda (jd jm) (if (<= jd (- k 2)) 1 (if (= jd (- k 1)) (if (= jm 1) (if up 3 4) 1) (if (= jd k) (if (= jm 0) 1 (if (= jm 1) (if left 6 5) 0)) (if (= jm 1) 2 0))))) (quotient j 3) (modulo j 3))) `(,@(half k) ,@(half j))))) (lambda (k) (if (< k 0) `(,(- -1 k) #t) `(,k #f)))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 36 34 20 18 33 17 10 12) "🌵🌹🌺🌼🌸🌻🌷💮🦋" 6 2 9))separate output >>217 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4366 http://paste.textboard.org/ea001243/raw
The thing is, why this thread? What are you getting at. These are all just meaningless variations, developed to no end. If you want to do something interesting, try to generalise this and create a program that spews out your unreadable line of code given a specification of some sort.
>>219
You have been forcibly indented, we all have
Oh no, you have committed the greatest sin, enjoying something that >>219-san does not.
🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺Port of >>189 to the connector flower garden >>208.
scheme@(guile-user)> (display ((lambda (rec xjoin extract cell index connector connectors chars band columnfactor n) ((lambda (xjoin connector lines columns cycle) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (cell x y) dx dy) 1 0)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (split corner) (lambda (j k) (apply (lambda (k up j left) (if (= j 0) (if (= k 1) 0 1) ((lambda (jd jm) (if (<= jd (- k 3)) 1 (if (or (= jd (- k 2)) (= jd k)) (if (= jm 1) 0 (corner 6 up -2 left -1)) (if (= jd (- k 1)) (if (= jm 1) 1 (corner 3 up 2 left 1)) (if (= jm 1) 0 2))))) (quotient (- j 1) 2) (modulo (- j 1) 2)))) `(,@(split k 1) ,@(split j 0))))) (lambda (k adjust) (if (< k 0) `(,(- k) #t) `(,(+ k adjust) #f))) (lambda (from up upstep left leftstep) (+ from (if up upstep 0) (if left leftstep 0)))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 36 34 20 18 33 17 10 12) "🌵🌹🌺🌼🌸🌻🌷💮🦋" 6 2 9))separate output >>223 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4389 http://paste.textboard.org/d5e8e090/raw
>>219-222-chin
stop having orgies in this hellenistic brogramming gym retards and get off muh dik
im trying to get them brogramming gainz and i need my test
test
>>223
It’s beautiful 😍 but it’s a big ppppp
🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺Port of >>190 to the connector flower garden >>208.
scheme@(guile-user)> (display ((lambda (rec xjoin extract cell index connector connectors chars band columnfactor n) ((lambda (xjoin connector lines columns cycle) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (cell x y) dx dy) 1 0)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (base patch) (lambda (j k) ((lambda (j) ((lambda (jev) (or (patch k j jev) (base k j jev))) (even? j))) (if (< j 0) j (+ j 1))))) (lambda (k j jev) (if (= k 0) (if (<= -1 j 1) 1 (if jev 0 2)) ((lambda (corner jabs) (if (< jabs corner) 1 (if (= jabs corner) (+ 3 (if (< k 0) 0 2) (if (< j 0) 0 1)) (if jev 0 2)))) (+ (* 2 (abs k)) 1) (abs j)))) (lambda (k j jev) #f)) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 36 34 20 18 33 17 10 12) "🌵🌹🌺🌼🌸🌻🌷💮🦋" 6 2 9))separate output >>228 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4408 http://paste.textboard.org/7eec6890/raw
🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺Port of >>191 to the connector flower garden >>208.
scheme@(guile-user)> (display ((lambda (rec xjoin extract cell index connector connectors chars band columnfactor n) ((lambda (xjoin connector lines columns cycle) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (cell x y) dx dy) 1 0)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (base patch) (lambda (j k) ((lambda (j) ((lambda (jev) (or (patch k j jev) (base k j jev))) (even? j))) (if (< j 0) j (+ j 1))))) (lambda (k j jev) (if (= k 0) (if (<= -1 j 1) 1 (if jev 0 2)) ((lambda (corner jabs) (if (< jabs corner) 1 (if (= jabs corner) (+ 3 (if (< k 0) 0 2) (if (< j 0) 0 1)) (if jev 0 2)))) (+ (* 2 (abs k)) 1) (abs j)))) (lambda (k j jev) (if (or (< k 0) (< j 0)) #f ((lambda (corner) (if (= j corner) 6 (if (or (= j (- corner 1)) (= j (- corner 2))) 1 #f))) (+ (* 2 k) 3))))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 36 34 20 18 33 17 10 12) "🌵🌹🌺🌼🌸🌻🌷💮🦋" 6 2 9))separate output >>230 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4447 http://paste.textboard.org/c5107752/raw
🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺
🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹
🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹
🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵
🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹
🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹
🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺Port of >>192 to the connector flower garden >>208.
scheme@(guile-user)> (display ((lambda (rec xjoin extract cell index connector connectors chars band columnfactor n) ((lambda (xjoin connector lines columns cycle) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (cell x y) dx dy) 1 0)))) (lambda (n fun sep) (rec xjoin n fun sep "")) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (base patch) (lambda (j k) ((lambda (j) ((lambda (jev) (or (patch k j jev) (base k j jev))) (even? j))) (if (< j 0) j (+ j 1))))) (lambda (k j jev) (if (= k 0) (if (<= -1 j 1) 1 (if jev 0 2)) ((lambda (corner jabs) (if (< jabs corner) 1 (if (= jabs corner) (+ 3 (if (< k 0) 0 2) (if (< j 0) 0 1)) (if jev 0 2)))) (+ (* 2 (abs k)) 1) (abs j)))) (lambda (k j jev) (if (and (>= k 0) (> j 0)) ((lambda (corner) (if (= j corner) 6 (if (or (= j (- corner 1)) (= j (- corner 2))) 1 #f))) (+ (* 2 k) 3)) (if (and (<= k 0) (< j 0)) ((lambda (corner) (if (= j corner) 3 (if (or (= j (+ corner 1)) (= j (+ corner 2))) 1 #f))) (- (* 2 k) 3)) #f)))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 36 34 20 18 33 17 10 12) "🌵🌹 🌺🌼🌸🌻🌷💮🦋" 6 2 9))separate output >>232 for renewed 413 >>127
larger version: https://wirechan.org/b/res/2162.html#4485 http://paste.textboard.org/404f3db5/raw
██████████████████████████████████████████████████████████████████
██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██
██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██
██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██
██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██
██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██
██████████████████████████████████████████████████████████████████
██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██
██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██
██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██
██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██
██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██
██████████████████████████████████████████████████████████████████
░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░
▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒
▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓
▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒
░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░
░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░
▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒
▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓ ▓▓▒▒░░██░░▒▒▓▓
▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒ ▒▒██▒▒
░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░
Black-and-white cell renderer in five shades with an inversion switch, generalizing >>53.
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars m n cell invert) ((lambda (xjoin cycle) ((lambda (expand) ((lambda (chars) ((lambda (symbol) (xjoin m (lambda (k) (string-append (xjoin n (lambda (j) (symbol k j)) "") "\n")) "")) ((lambda (ifinvert) (lambda (k j) (extract chars (* cell (ifinvert (index m n k j cycle))) cell))) (if invert (lambda (x) (- cycle 1 x)) (lambda (x) x))))) (expand chars cell))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (k) (extract chars (quotient k n) 1)) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (m n k j cycle) (abs (- (modulo (* k j) (* 2 (- cycle 1))) cycle -1))) " ░▒▓█" 17 33 2 #f))A modulo multiplication table >>234 and its inverse >>235 as demos.
kawaii
kowai
updated counts >>196 since October >>194
1 9 12 391 >>> 65 71
2 10 7 461 scheme@(guile-user)> 71 67
3 11 13 483 >> 61 65
4 13 15 627 >> 53 60
5 14 13 471 >> 62 66
6 17 14 524 >>> 59 62
7 21 18 789 >>> 42 56
8 24 15 851 scheme@(guile-user)> 54 55
9 25 13 692 scheme@(guile-user)> 63 58
10 28 25 1599 >>> 16 23
11 30 10 508 >> 67 63
12 34 13 560 >> 64 61
13 35 19 1375 scheme@(guile-user)> 38 31
14 37 15 642 >> 55 59
15 39 21 909 >> 27 52
16 42 10 452 >> 68 69
17 43 10 444 >> 69 70
18 46 18 707 >>> 43 57
19 49 23 1070 >>> 21 44
20 53 21 873 >>> 28 54
21 55 14 1066 scheme@(guile-user)> 60 46
22 59 21 1475 scheme@(guile-user)> 29 26
23 65 19 1110 scheme@(guile-user)> 39 41
24 67 25 1716 >>> 17 18
25 69 10 460 >> 70 68
26 70 20 1333 scheme@(guile-user)> 33 34
27 72 25 1717 scheme@(guile-user)> 18 17
28 77 33 2654 scheme@(guile-user)> 4 4
29 81 20 1459 scheme@(guile-user)> 34 27
30 85 30 1180 >> 8 38
31 89 32 1176 >> 5 39
32 90 18 1067 scheme@(guile-user)> 44 45
33 95 21 888 >>> 30 53
34 99 23 1262 scheme@(guile-user)> 22 35
35 100 22 993 >>> 23 49
36 104 30 1649 scheme@(guile-user)> 9 22
37 107 19 1391 scheme@(guile-user)> 40 30
38 109 31 1336 >>> 6 33
39 111 15 1062 scheme@(guile-user)> 56 47
40 113 21 1566 scheme@(guile-user)> 31 24
41 115 24 1935 scheme@(guile-user)> 20 11
42 119 16 1031 scheme@(guile-user)> 52 48
43 120 11 495 >> 66 64
44 121 15 990 scheme@(guile-user)> 57 50
45 126 17 1097 scheme@(guile-user)> 48 42
46 129 22 1423 scheme@(guile-user)> 24 29
47 132 27 1872 scheme@(guile-user)> 11 15
48 137 15 1164 scheme@(guile-user)> 58 40
49 139 17 1449 scheme@(guile-user)> 49 28
50 149 18 1660 scheme@(guile-user)> 45 21
51 153 26 2101 scheme@(guile-user)> 14 7
52 157 36 2926 scheme@(guile-user)> 2 2
53 176 20 1817 scheme@(guile-user)> 35 16
54 182 20 1913 scheme@(guile-user)> 36 12
55 184 31 2422 scheme@(guile-user)> 7 5
56 189 17 1223 scheme@(guile-user)> 50 36
57 190 18 1089 scheme@(guile-user)> 46 43
58 191 19 1222 scheme@(guile-user)> 41 37
59 192 20 1359 scheme@(guile-user)> 37 32
60 198 17 1487 scheme@(guile-user)> 51 25
61 201 22 1674 scheme@(guile-user)> 25 20
62 203 21 1685 scheme@(guile-user)> 32 19
63 208 35 2731 scheme@(guile-user)> 3 3
64 212 22 1913 scheme@(guile-user)> 26 13
65 214 40 3578 scheme@(guile-user)> 1 1
66 218 27 1966 scheme@(guile-user)> 12 10
67 224 25 2056 scheme@(guile-user)> 19 8
68 229 26 1912 scheme@(guile-user)> 15 14
69 231 27 2045 scheme@(guile-user)> 13 9
70 233 28 2183 scheme@(guile-user)> 10 6
71 236 18 956 scheme@(guile-user)> 47 51████████████████████████████████████████████████████████
████████████████████████████████████████████████████████
██████████████████████▓▓▓▓▓▓▓▓▓▓▓▓██████████████████████
████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████████████
████████████▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓████████████
██████████▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓██████████
████████▓▓▓▓▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░▒▒▒▒▒▒▓▓▓▓▓▓████████
██████▓▓▓▓▓▓▒▒▒▒▒▒░░░░░░░░ ░░░░░░░░▒▒▒▒▒▒▓▓▓▓▓▓██████
██████▓▓▓▓▓▓▒▒▒▒▒▒░░░░ ░░░░▒▒▒▒▒▒▓▓▓▓▓▓██████
██████▓▓▓▓▓▓▒▒▒▒▒▒░░░░ ░░░░▒▒▒▒▒▒▓▓▓▓▓▓██████
██████▓▓▓▓▓▓▒▒▒▒▒▒░░░░░░░░ ░░░░░░░░▒▒▒▒▒▒▓▓▓▓▓▓██████
████████▓▓▓▓▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░▒▒▒▒▒▒▓▓▓▓▓▓████████
██████████▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓██████████
████████████▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓████████████
████████████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████████████
██████████████████████▓▓▓▓▓▓▓▓▓▓▓▓██████████████████████
████████████████████████████████████████████████████████
████████████████████████████████████████████████████████Scaling ellipse rings on the five-shade renderer >>236.
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars m n cell invert) ((lambda (xjoin cycle) ((lambda (expand) ((lambda (chars) ((lambda (symbol) (xjoin m (lambda (k) (string-append (xjoin n (lambda (j) (symbol k j)) "") "\n")) "")) ((lambda (ifinvert) (lambda (k j) (extract chars (* cell (ifinvert (index m n k j cycle))) cell))) (if invert (lambda (x) (- cycle 1 x)) (lambda (x) x))))) (expand chars cell))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (k) (extract chars (quotient k n) 1)) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (int sqr) ((lambda (radius) (lambda (m n k j cycle) (min (int (* cycle (radius j k (/ (- n 1) 2) (/ (- m 1) 2)))) (- cycle 1)))) (lambda (px py cx cy) (sqrt (+ (sqr (/ (- px cx) cx)) (sqr (/ (- py cy) cy))))))) (lambda (x) (inexact->exact (truncate x))) (lambda (x) (* x x))) " ░▒▓█" 23 40 2 #f))▓▓██▓▓▒▒▒▒░░ ░░▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒░░ ░░▒▒▒▒▓▓██▓▓
██▓▓▓▓▒▒░░ ░░▒▒▒▒▓▓▓▓████████████▓▓▓▓▒▒▒▒░░ ░░▒▒▓▓▓▓██
██▓▓▒▒░░ ░░▒▒▓▓▓▓████▓▓▓▓▓▓▓▓▓▓▓▓████▓▓▓▓▒▒░░ ░░▒▒▓▓██
▓▓▒▒▒▒░░ ░░▒▒▓▓▓▓██▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓██▓▓▓▓▒▒░░ ░░▒▒▒▒▓▓
▓▓▒▒░░ ░░▒▒▒▒▓▓██▓▓▓▓▒▒▒▒░░░░░░░░▒▒▒▒▓▓▓▓██▓▓▒▒▒▒░░ ░░▒▒▓▓
▓▓▒▒░░ ░░▒▒▓▓██▓▓▓▓▒▒░░░░ ░░░░▒▒▓▓▓▓██▓▓▒▒░░ ░░▒▒▓▓
▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░░░░░░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒
▒▒░░ ░░▒▒▓▓██▓▓▒▒▒▒░░ ░░▒▒▒▒▒▒▒▒░░ ░░▒▒▒▒▓▓██▓▓▒▒░░ ░░▒▒
▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▒▒▓▓▓▓▒▒▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒
▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓████▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒
▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▓▓████▓▓▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒
▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒▒▒▓▓▓▓▒▒▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒
▒▒░░ ░░▒▒▓▓██▓▓▒▒▒▒░░ ░░▒▒▒▒▒▒▒▒░░ ░░▒▒▒▒▓▓██▓▓▒▒░░ ░░▒▒
▒▒░░ ░░▒▒▓▓██▓▓▒▒░░ ░░░░░░░░ ░░▒▒▓▓██▓▓▒▒░░ ░░▒▒
▓▓▒▒░░ ░░▒▒▓▓██▓▓▓▓▒▒░░░░ ░░░░▒▒▓▓▓▓██▓▓▒▒░░ ░░▒▒▓▓
▓▓▒▒░░ ░░▒▒▒▒▓▓██▓▓▓▓▒▒▒▒░░░░░░░░▒▒▒▒▓▓▓▓██▓▓▒▒▒▒░░ ░░▒▒▓▓
▓▓▒▒▒▒░░ ░░▒▒▓▓▓▓██▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓██▓▓▓▓▒▒░░ ░░▒▒▒▒▓▓
██▓▓▒▒░░ ░░▒▒▓▓▓▓████▓▓▓▓▓▓▓▓▓▓▓▓████▓▓▓▓▒▒░░ ░░▒▒▓▓██
██▓▓▓▓▒▒░░ ░░▒▒▒▒▓▓▓▓████████████▓▓▓▓▒▒▒▒░░ ░░▒▒▓▓▓▓██
▓▓██▓▓▒▒▒▒░░ ░░▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒░░ ░░▒▒▒▒▓▓██▓▓Concentric waves on the five-shade renderer >>236.
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars m n cell invert) ((lambda (xjoin cycle) ((lambda (expand) ((lambda (chars) ((lambda (symbol) (xjoin m (lambda (k) (string-append (xjoin n (lambda (j) (symbol k j)) "") "\n")) "")) ((lambda (ifinvert) (lambda (k j) (extract chars (* cell (ifinvert (index m n k j cycle))) cell))) (if invert (lambda (x) (- cycle 1 x)) (lambda (x) x))))) (expand chars cell))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (k) (extract chars (quotient k n) 1)) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (int sqr wave) ((lambda (radius) (lambda (m n k j cycle) (wave (int (radius j k (/ (- n 1) 2) (/ (- m 1) 2))) cycle))) (lambda (px py cx cy) (sqrt (+ (sqr (- px cx)) (sqr (- py cy))))))) (lambda (x) (inexact->exact (truncate x))) (lambda (x) (* x x)) (lambda (x cycle) (abs (- (modulo x (* 2 (- cycle 1))) cycle -1)))) " ░▒▓█" 23 40 2 #f))▓▓▒▒░░▒▒▓▓▓▓▓▓▒▒░░ ░░░░▒▒▓▓████▓▓▒▒░░░░ ░░▒▒▓▓▓▓▓▓▒▒░░▒▒▓▓
▓▓▓▓▒▒▓▓▓▓▓▓▓▓▓▓░░ ░░▒▒▓▓████▓▓▒▒░░ ░░▓▓▓▓▓▓▓▓▓▓▒▒▓▓▓▓
▒▒░░▒▒▓▓██████▓▓▒▒░░ ░░░░▓▓████▓▓░░░░ ░░▒▒▓▓██████▓▓▒▒░░▒▒
░░░░░░▒▒▓▓████▓▓░░░░░░░░░░▓▓████▓▓░░░░░░░░░░▓▓████▓▓▒▒░░░░░░
░░ ░░░░▓▓██▓▓▓▓▒▒░░░░░░▒▒▓▓▓▓▓▓▓▓▒▒░░░░░░▒▒▓▓▓▓██▓▓░░░░ ░░
░░▒▒▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓▒▒░░
░░ ░░░░▒▒▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓▒▒░░░░ ░░
░░░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░░░
▒▒░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▒▒
▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓
▒▒░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▒▒
░░░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░░░
░░ ░░░░▒▒▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓▒▒░░░░ ░░
░░▒▒▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓░░░░░░░░▓▓▓▓▓▓▓▓▒▒░░
░░ ░░░░▓▓██▓▓▓▓▒▒░░░░░░▒▒▓▓▓▓▓▓▓▓▒▒░░░░░░▒▒▓▓▓▓██▓▓░░░░ ░░
░░░░░░▒▒▓▓████▓▓░░░░░░░░░░▓▓████▓▓░░░░░░░░░░▓▓████▓▓▒▒░░░░░░
▒▒░░▒▒▓▓██████▓▓▒▒░░ ░░░░▓▓████▓▓░░░░ ░░▒▒▓▓██████▓▓▒▒░░▒▒
▓▓▓▓▒▒▓▓▓▓▓▓▓▓▓▓░░ ░░▒▒▓▓████▓▓▒▒░░ ░░▓▓▓▓▓▓▓▓▓▓▒▒▓▓▓▓
▓▓▒▒░░▒▒▓▓▓▓▓▓▒▒░░ ░░░░▒▒▓▓████▓▓▒▒░░░░ ░░▒▒▓▓▓▓▓▓▒▒░░▒▒▓▓Simplistic wave interference on the five-shade renderer >>236.
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars m n cell invert) ((lambda (xjoin cycle) ((lambda (expand) ((lambda (chars) ((lambda (symbol) (xjoin m (lambda (k) (string-append (xjoin n (lambda (j) (symbol k j)) "") "\n")) "")) ((lambda (ifinvert) (lambda (k j) (extract chars (* cell (ifinvert (index m n k j cycle))) cell))) (if invert (lambda (x) (- cycle 1 x)) (lambda (x) x))))) (expand chars cell))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (k) (extract chars (quotient k n) 1)) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (int sqr wave combineodd) ((lambda (radius) (lambda (m n k j cycle) ((lambda (wave) (combineodd (wave 0 (/ (- m 1) 2)) (wave (- n 1) (/ (- m 1) 2)) cycle)) (lambda (cx cy) (wave (int (radius j k cx cy)) cycle))))) (lambda (px py cx cy) (sqrt (+ (sqr (- px cx)) (sqr (- py cy))))))) (lambda (x) (inexact->exact (truncate x))) (lambda (x) (* x x)) (lambda (x cycle) (abs (- (modulo x (* 2 (- cycle 1))) cycle -1))) ((lambda (center) (lambda (w1 w2 cycle) (center (+ w1 w2) cycle))) (lambda (x cycle) (quotient (+ x (if (>= x cycle) 1 0)) 2)))) " ░▒▓█" 23 40 2 #f))separate output >>244 for even lower 413 >>127
larger version to see any detail: http://paste.textboard.org/fcec6460/raw
▒▒░░ ░░░░░░▓▓▒▒▒▒░░░░░░▒▒▓▓▓▓▓▓▒▒░░░░░░▒▒▒▒▓▓░░░░░░ ░░▒▒
▒▒░░ ░░▒▒▓▓▓▓▒▒▒▒░░▒▒▓▓▓▓▓▓▓▓▓▓▒▒░░▒▒▒▒▓▓▓▓▒▒░░ ░░▒▒
░░ ░░▒▒▓▓██▓▓▓▓▓▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▓▓▓▓▓▓██▓▓▒▒░░ ░░
░░░░ ░░▒▒▓▓████▓▓▒▒▒▒░░▒▒▒▒▒▒▒▒▒▒░░▒▒▒▒▓▓████▓▓▒▒░░ ░░░░
░░░░░░▒▒▓▓██████▓▓▒▒░░░░░░░░░░░░░░░░░░▒▒▓▓██████▓▓▒▒░░░░░░
░░░░▒▒░░▓▓▓▓▓▓▓▓▓▓▒▒░░░░░░░░░░░░░░░░░░▒▒▓▓▓▓▓▓▓▓▓▓░░▒▒░░░░
▓▓▓▓▓▓▒▒▒▒▓▓▒▒▒▒▓▓▒▒░░░░░░░░░░░░░░░░░░▒▒▓▓▒▒▒▒▓▓▒▒▒▒▓▓▓▓▓▓
▓▓▓▓▓▓▒▒░░░░░░▒▒░░▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒░░▒▒░░░░░░▒▒▓▓▓▓▓▓
████▓▓░░░░ ░░░░▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░░░ ░░░░▓▓████
██▓▓▓▓▒▒░░ ░░▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒░░ ░░▒▒▓▓▓▓██
████▓▓░░░░ ░░░░▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░░░ ░░░░▓▓████
▓▓▓▓▓▓▒▒░░░░░░▒▒░░▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒░░▒▒░░░░░░▒▒▓▓▓▓▓▓
▓▓▓▓▓▓▒▒▒▒▓▓▒▒▒▒▓▓▒▒░░░░░░░░░░░░░░░░░░▒▒▓▓▒▒▒▒▓▓▒▒▒▒▓▓▓▓▓▓
░░░░▒▒░░▓▓▓▓▓▓▓▓▓▓▒▒░░░░░░░░░░░░░░░░░░▒▒▓▓▓▓▓▓▓▓▓▓░░▒▒░░░░
░░░░░░▒▒▓▓██████▓▓▒▒░░░░░░░░░░░░░░░░░░▒▒▓▓██████▓▓▒▒░░░░░░
░░░░ ░░▒▒▓▓████▓▓▒▒▒▒░░▒▒▒▒▒▒▒▒▒▒░░▒▒▒▒▓▓████▓▓▒▒░░ ░░░░
░░ ░░▒▒▓▓██▓▓▓▓▓▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▓▓▓▓▓▓██▓▓▒▒░░ ░░
▒▒░░ ░░▒▒▓▓▓▓▒▒▒▒░░▒▒▓▓▓▓▓▓▓▓▓▓▒▒░░▒▒▒▒▓▓▓▓▒▒░░ ░░▒▒
▒▒░░ ░░░░░░▓▓▒▒▒▒░░░░░░▒▒▓▓▓▓▓▓▒▒░░░░░░▒▒▒▒▓▓░░░░░░ ░░▒▒Vertical interference >>245.
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars m n cell invert) ((lambda (xjoin cycle) ((lambda (expand) ((lambda (chars) ((lambda (symbol) (xjoin m (lambda (k) (string-append (xjoin n (lambda (j) (symbol k j)) "") "\n")) "")) ((lambda (ifinvert) (lambda (k j) (extract chars (* cell (ifinvert (index m n k j cycle))) cell))) (if invert (lambda (x) (- cycle 1 x)) (lambda (x) x))))) (expand chars cell))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (k) (extract chars (quotient k n) 1)) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (int sqr wave combineodd) ((lambda (radius) (lambda (m n k j cycle) ((lambda (wave) (combineodd (wave (/ (- n 1) 2) 0) (wave (/ (- n 1) 2) (- m 1)) cycle)) (lambda (cx cy) (wave (int (radius j k cx cy)) cycle))))) (lambda (px py cx cy) (sqrt (+ (sqr (- px cx)) (sqr (- py cy))))))) (lambda (x) (inexact->exact (truncate x))) (lambda (x) (* x x)) (lambda (x cycle) (abs (- (modulo x (* 2 (- cycle 1))) cycle -1))) ((lambda (center) (lambda (w1 w2 cycle) (center (+ w1 w2) cycle))) (lambda (x cycle) (quotient (+ x (if (>= x cycle) 1 0)) 2)))) " ░▒▓█" 23 40 2 #f))separate output >>246 for even lower 413 >>127
larger version to see any detail: http://paste.textboard.org/7a84c2a0/raw
succ succ succ
▓▓░░░░░░░░▒▒▓▓▓▓▓▓▒▒░░ ░░▓▓▓▓██▓▓▓▓░░ ░░░░░░▓▓▓▓▒▒▒▒░░▒▒▓▓████▓▓▓▓▒▒░░▒▒▓▓▓▓
░░▒▒░░░░░░▓▓▓▓▓▓▓▓▒▒░░░░░░░░▓▓████▓▓▒▒░░ ░░▒▒▓▓▓▓▓▓▒▒▒▒▓▓▓▓▓▓██▓▓▒▒░░░░░░▒▒▓▓
░░░░▒▒▒▒▒▒▒▒▓▓▓▓▓▓░░░░░░░░▒▒▓▓▓▓██▓▓░░░░ ░░░░▓▓██▓▓▓▓▓▓░░▒▒▒▒▓▓▓▓▒▒░░░░ ░░░░▒▒
░░░░░░░░▓▓▒▒▒▒▒▒▒▒░░░░░░░░▓▓▓▓▓▓▓▓▒▒░░ ░░▒▒▓▓████▓▓▒▒░░░░░░▒▒▓▓░░░░ ░░░░
░░░░▓▓▒▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒░░▓▓▓▓▓▓▓▓▒▒░░░░░░░░▓▓████▓▓▓▓░░ ░░░░░░▒▒▒▒░░░░ ░░░░▒▒
░░░░▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒░░░░▓▓▒▒▒▒▓▓▓▓░░░░░░░░▒▒▓▓████▓▓▒▒░░ ░░▒▒▓▓▓▓▒▒░░░░░░▒▒▓▓
▒▒▓▓▓▓▓▓▓▓▓▓▓▓░░░░▒▒▒▒▒▒▒▒▓▓▓▓▓▓░░░░░░░░░░▓▓▓▓▓▓▓▓▓▓░░ ░░░░▓▓▓▓▓▓▓▓▒▒░░▒▒▓▓▓▓
▓▓▓▓██▓▓▓▓▓▓░░▒▒▒▒░░░░▓▓▒▒▒▒▒▒▒▒░░░░░░░░▓▓▓▓▓▓▓▓▒▒▒▒░░ ░░▒▒▓▓██▓▓▓▓▓▓▒▒▓▓▓▓██
████████▓▓▒▒░░░░░░░░▒▒▒▒▒▒▓▓▓▓░░▒▒▒▒▒▒░░▓▓▓▓▓▓▓▓▒▒░░░░ ░░▒▒▓▓██████▓▓▒▒░░▒▒▓▓▓▓
▓▓██▓▓▓▓▒▒░░░░░░░░░░▓▓▓▓▓▓▒▒▒▒▒▒▒▒░░░░▓▓▒▒▒▒▓▓▓▓░░░░░░░░▒▒▓▓████▓▓▓▓░░░░░░▒▒▓▓▓▓
▓▓▓▓▓▓▒▒░░ ░░░░░░▓▓▓▓▒▒▒▒▓▓░░░░▒▒▒▒▒▒▒▒▓▓▓▓▓▓░░░░░░░░░░▒▒▓▓▓▓██▓▓▒▒░░ ░░░░▒▒▓▓
▓▓▒▒░░░░░░ ░░▒▒▓▓▓▓▓▓▓▓░░▒▒▒▒▒▒░░▓▓▒▒▒▒▒▒▒▒░░░░░░░░▓▓▓▓▓▓▓▓▓▓▒▒░░░░ ░░░░▒▒▒▒░░░░ ░░░░▒▒▓▓▓▓▓▓▓▓▓▓░░░░░░░░▒▒▒▒▒▒▒▒▓▓░░▒▒▒▒▒▒░░▓▓▓▓▓▓▓▓▒▒░░ ░░░░░░▒▒▓▓
▓▓▒▒░░░░ ░░▒▒▓▓██▓▓▓▓▒▒░░░░░░░░░░▓▓▓▓▓▓▒▒▒▒▒▒▒▒░░░░▓▓▒▒▒▒▓▓▓▓░░░░░░ ░░▒▒▓▓▓▓▓▓
▓▓▓▓▒▒░░░░░░▓▓▓▓████▓▓▒▒░░░░░░░░▓▓▓▓▒▒▒▒▓▓░░░░▒▒▒▒▒▒▒▒▓▓▓▓▓▓░░░░░░░░░░▒▒▓▓▓▓██▓▓
▓▓▓▓▒▒░░▒▒▓▓██████▓▓▒▒░░ ░░░░▒▒▓▓▓▓▓▓▓▓░░▒▒▒▒▒▒░░▓▓▓▓▒▒▒▒▒▒░░░░░░░░▒▒▓▓████████
██▓▓▓▓▒▒▓▓▓▓▓▓██▓▓▒▒░░ ░░▒▒▒▒▓▓▓▓▓▓▓▓░░░░░░░░▒▒▒▒▒▒▒▒▓▓░░░░▒▒▒▒░░▓▓▓▓▓▓██▓▓▓▓
▓▓▓▓▒▒░░▒▒▓▓▓▓▓▓▓▓░░░░ ░░▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░▓▓▓▓▓▓▒▒▒▒▒▒▒▒░░░░▓▓▓▓▓▓▓▓▓▓▓▓▒▒
▓▓▒▒░░░░░░▒▒▓▓▓▓▒▒░░ ░░▒▒▓▓████▓▓▒▒░░░░░░░░▓▓▓▓▒▒▒▒▓▓░░░░▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒▒░░░░
▒▒░░░░ ░░░░▒▒▒▒░░░░░░ ░░▓▓▓▓████▓▓░░░░░░░░▒▒▓▓▓▓▓▓▓▓░░▒▒▒▒▒▒▒▒▓▓▓▓▒▒▒▒▓▓░░░░
░░░░ ░░░░▓▓▒▒░░░░░░▒▒▓▓████▓▓▒▒░░ ░░▒▒▓▓▓▓▓▓▓▓░░░░░░░░▒▒▒▒▒▒▒▒▓▓░░░░░░░░
▒▒░░░░ ░░░░▒▒▓▓▓▓▒▒▒▒░░▓▓▓▓▓▓██▓▓░░░░ ░░░░▓▓██▓▓▓▓▒▒░░░░░░░░▓▓▓▓▓▓▒▒▒▒▒▒▒▒░░░░
▓▓▒▒░░░░░░▒▒▓▓██▓▓▓▓▓▓▒▒▒▒▓▓▓▓▓▓▒▒░░ ░░▒▒▓▓████▓▓░░░░░░░░▒▒▓▓▓▓▓▓▓▓░░░░░░▒▒░░
▓▓▓▓▒▒░░▒▒▓▓▓▓████▓▓▒▒░░▒▒▒▒▓▓▓▓░░░░░░ ░░▓▓▓▓██▓▓▓▓░░ ░░▒▒▓▓▓▓▓▓▒▒░░░░░░░░▓▓diagonal interference >>247
scheme@(guile-user)> (display ((lambda (rec xjoin extract index chars m n cell invert) ((lambda (xjoin cycle) ((lambda (expand) ((lambda (chars) ((lambda (symbol) (xjoin m (lambda (k) (string-append (xjoin n (lambda (j) (symbol k j)) "") "\n")) "")) ((lambda (ifinvert) (lambda (k j) (extract chars (* cell (ifinvert (index m n k j cycle))) cell))) (if invert (lambda (x) (- cycle 1 x)) (lambda (x) x))))) (expand chars cell))) (lambda (chars n) (xjoin (* n (string-length chars)) (lambda (k) (extract chars (quotient k n) 1)) "")))) (lambda (n fun sep) (rec xjoin n fun sep "")) (string-length chars))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) ((lambda (int sqr wave combineodd) ((lambda (radius) (lambda (m n k j cycle) ((lambda (wave) (combineodd (wave 0 0) (wave (- n 1) (- m 1)) cycle)) (lambda (cx cy) (wave (int (radius j k cx cy)) cycle))))) (lambda (px py cx cy) (sqrt (+ (sqr (- px cx)) (sqr (- py cy))))))) (lambda (x) (inexact->exact (truncate x))) (lambda (x) (* x x)) (lambda (x cycle) (abs (- (modulo x (* 2 (- cycle 1))) cycle -1))) ((lambda (center) (lambda (w1 w2 cycle) (center (+ w1 w2) cycle))) (lambda (x cycle) (quotient (+ x (if (>= x cycle) 1 0)) 2)))) " ░▒▓█" 23 40 2 #f))terminal-sized output: >>249,250
To reassemble the split output posts:
(/*join*/(thread, pids, separ, remove) => ((getcode) => (codes => (count => {codes [count - 1].innerText = codes.map (e => e.innerText).join (separ); if (remove) {codes. slice (0, -1).forEach (e => e.remove ())}}) (codes.length)) (pids.split (" ").map (s => getcode (thread, parseInt (s, 10))))) ((thread, id) => document.getElementById ("t" + thread + "p" + id).parentNode.nextElementSibling.querySelector ("code"))) (22, "249 250", "\n", true)larger output: http://paste.textboard.org/8c14441e/raw
What I want to know is if you intentionally make your code unreadable before posting it here, for no reason at all, or if you actually program in a single line.
VTE plasma
Nice.
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹
🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹
🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹
🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹
🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹
🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵
🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹
🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹
🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺
🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵
🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹
🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹
🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺
🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵
🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹
🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹
🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹
🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵
🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹
🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹
🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵scheme@(guile-user)> (display ((lambda (rec xjoin extract windowtopleft expandspec derive expandsize cell index connector connectors cellspec cellrows cellcols expansions expandx expandy levels start chars band columnfactor n) ((lambda (xjoin expandspec connector lines columns cycle size) ((lambda (cellspec expansions sizex sizey) ((lambda (derive cell) ((lambda (derive) ((lambda (derivecell) ((lambda (window) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (window x y) dx dy) 1 0)))) (windowtopleft sizex sizey derivecell))) (lambda (y x) ((lambda (qx mx qy my) (cell (derive qx qy) mx my)) (quotient x cellcols) (modulo x cellcols) (quotient y cellrows) (modulo y cellrows))))) ((lambda (sizex sizey) (lambda (x y) (rec derive start x y sizex sizey))) (quotient sizex cellcols) (quotient sizey cellrows)))) (derive expansions expandx expandy) (cell cellspec cellcols))) (expandspec cellspec) (expandspec expansions) (car size) (cadr size))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (spec) (rec expandspec spec '())) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars) (expandsize cellcols cellrows expandx expandy levels))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (width height fun) ((lambda (w2 h2) ((lambda (x1 x2 y1 y2) (lambda (x y) (if (and (<= x1 x x2) (<= y1 y y2)) (fun (- y y1) (- x x1)) 0))) (- w2) (- width w2 1) (- h2) (- height h2 1))) (quotient width 2) (quotient height 2))) ((lambda (onecorner) ((lambda (onecell) (lambda (self spec acc) (if (null? spec) (apply vector acc) (self self (cdr spec) (onecell onecell (car spec) acc 3))))) (lambda (self cell acc round) (if (< round 0) acc (self self cell (cons (onecorner onecorner cell '() round #t) acc) (- round 1)))))) (lambda (self corners acc bits fresh) (if (null? corners) (apply vector acc) (if (caar corners) (self self (cdr corners) (cons ((if (logbit? (if fresh 0 1) bits) caddar cadar) corners) acc) bits #f) (self self (cdr corners) (cons (cadar corners) acc) bits fresh)))))(lambda (spec expandx expandy) (lambda (self var x y sizex sizey) (if (= sizex 1) var ((lambda (subx suby) ((lambda (qx mx qy my) (self self (vector-ref (vector-ref spec var) (+ (* qy expandx) qx)) mx my subx suby)) (quotient x subx) (modulo x subx) (quotient y suby) (modulo y suby))) (quotient sizex expandx) (quotient sizey expandy))))) ((lambda (size) (lambda (cellx celly expandx expandy levels) (list (size cellx expandx levels) (size celly expandy levels)))) (lambda (start expand levels) (* start (expt expand levels)))) (lambda (spec columns) (lambda (index dx dy) (vector-ref (vector-ref spec index) (+ (* dy columns) dx)))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))) (and (= dx dy) (or (on 6 bits) (and (< dx b2) (on 7 bits)) (and (> dx b2) (on 8 bits)))) (and (= (+ dx dy) band) (or (on 9 bits) (and (< dx b2) (on 10 bits)) (and (> dx b2) (on 11 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 36 34 20 18 33 17 10 12 64 512 132 1028 2050 258 160 2080 1040 272 2304 1152 1280 2176) '(((#f 6) (#f 1) (#t 1 3) (#f 4) (#f 1) (#f 5) (#t 1 6) (#f 1) (#f 3)) ((#t 1 4) (#f 1) (#f 5) (#f 6) (#f 1) (#f 3) (#f 4) (#f 1) (#t 1 5))) 3 3 '(((#f 6) (#f 0) (#t 4 5) (#f 1) (#f 4) (#f 2) (#t 4 6) (#f 0) (#f 5)) ((#t 0 1) (#f 4) (#f 2) (#f 6) (#f 0) (#f 5) (#f 1) (#f 4) (#t 0 2))) 3 3 1 0 "🌵🌹🌺🌼🌸🌻🌷💮🦋" 6 1 19))Peano space-filling curve on the connector flower garden >>214. Up to the level of rendering connectors in flower patches this is the same as the >>214 Sierpinski space-filling curve. The change is that the Peano grammar is slightly compressed by factoring out the invariant portion of the RHS of productions. The grammar expander is the expandspec lambda. After that the same derivation tree walker is used as in >>214, in the derive lambda.
terminal-sized output: >>254,255
code: >>256,257
larger output: http://paste.textboard.org/684b55d2/raw https://endchan.net/art/res/2.html#72
Upgrade of the post joiner >>251 with batch mode, to reassemble all the split posts up to this point >>249,250 >>254,255 >>256,257:
((getcode, thread, joinspecs) => joinspecs.forEach (([pids, separ, remove]) => (codes => (count => {codes [count - 1].innerText = codes.map (e => e.innerText).join (separ); if (remove) {codes. slice (0, -1).forEach (e => e.remove ())}}) (codes.length)) (pids.split (" ").map (s => getcode (thread, parseInt (s, 10)))))) ((thread, id) => document.getElementById ("t" + thread + "p" + id).parentNode.nextElementSibling.querySelector ("code"), 22, [["249 250", "\n", true], ["254 255", "\n", true], ["256 257", " ", true]])🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹
🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹
🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹
🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹
🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹
🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵
🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹
🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹
🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺
🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵
🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺
🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹
🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹
🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵
🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹
🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹
🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹
🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹
🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌺🌵🌹🌵🌺🌹🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌺🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵
🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌺🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌹
🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌹🌵scheme@(guile-user)> (display ((lambda (rec xjoin extract windowtopleft expandspec derive expandsize cell index connector connectors cellspec cellrows cellcols expansions expandx expandy levels start chars band columnfactor n) ((lambda (xjoin expandspec connector lines columns cycle size) ((lambda (cellspec expansions sizex sizey) ((lambda (derive cell) ((lambda (derive) ((lambda (derivecell) ((lambda (window) ((lambda (patch) ((lambda (symbol) (xjoin lines (lambda (k) (string-append (xjoin columns (lambda (j) (symbol k j)) "") "\n")) "")) (lambda (k j) (extract chars (index patch band cycle columnfactor n k j) 1)))) (lambda (cycle x y dx dy band) (if (connector (window x y) dx dy) 1 0)))) (windowtopleft sizex sizey derivecell))) (lambda (y x) ((lambda (qx mx qy my) (cell (derive qx qy) mx my)) (quotient x cellcols) (modulo x cellcols) (quotient y cellrows) (modulo y cellrows))))) ((lambda (sizex sizey) (lambda (x y) (rec derive start x y sizex sizey))) (quotient sizex cellcols) (quotient sizey cellrows)))) (derive expansions expandx expandy) (cell cellspec cellcols))) (expandspec cellspec) (expandspec expansions) (car size) (cadr size))) (lambda (n fun sep) (rec xjoin n fun sep "")) (lambda (spec) (rec expandspec spec '())) (connector connectors band) (+ (* 2 n) 1) (+ (* 2 columnfactor n) 1) (string-length chars) (expandsize cellcols cellrows expandx expandy levels))) (lambda (f . args) (apply f (cons f args))) (lambda (self n fun sep acc) (if (<= n 0) "" (if (= n 1) (string-append (fun 0) acc) (self self (- n 1) fun sep (string-append sep (fun (- n 1)) acc))))) (lambda (str pos len) (substring str pos (+ pos len))) (lambda (width height fun) ((lambda (w2 h2) ((lambda (x1 x2 y1 y2) (lambda (x y) (if (and (<= x1 x x2) (<= y1 y y2)) (fun (- y y1) (- x x1)) 0))) (- w2) (- width w2 1) (- h2) (- height h2 1))) (quotient width 2) (quotient height 2))) ((lambda (onecorner) ((lambda (onecell) (lambda (self spec acc) (if (null? spec) (apply vector acc) (self self (cdr spec) (onecell onecell (car spec) acc 3))))) (lambda (self cell acc round) (if (< round 0) acc (self self cell (cons (onecorner onecorner cell '() round #t) acc) (- round 1)))))) (lambda (self corners acc bits fresh) (if (null? corners) (apply vector acc) (if (caar corners) (self self (cdr corners) (cons ((if (logbit? (if fresh 0 1) bits) caddar cadar) corners) acc) bits #f) (self self (cdr corners) (cons (cadar corners) acc) bits fresh)))))(lambda (spec expandx expandy) (lambda (self var x y sizex sizey) (if (= sizex 1) var ((lambda (subx suby) ((lambda (qx mx qy my) (self self (vector-ref (vector-ref spec var) (+ (* qy expandx) qx)) mx my subx suby)) (quotient x subx) (modulo x subx) (quotient y suby) (modulo y suby))) (quotient sizex expandx) (quotient sizey expandy))))) ((lambda (size) (lambda (cellx celly expandx expandy levels) (list (size cellx expandx levels) (size celly expandy levels)))) (lambda (start expand levels) (* start (expt expand levels)))) (lambda (spec columns) (lambda (index dx dy) (vector-ref (vector-ref spec index) (+ (* dy columns) dx)))) (lambda (patch band cycle columnfactor n k j) ((lambda (k j) ((lambda (dx dy) (if (or (= dx 0) (= dy 0)) 0 (+ (patch (- cycle 1) (quotient (- (+ k j) dx) band) (quotient (- (- k j) dy) band) dx dy band) 1))) (modulo (+ k j) band) (modulo (- k j) band))) (- k n) (- j (* columnfactor n)))) (lambda (spec band) ((lambda (b2 on) (lambda (index dx dy) (if (zero? index) #f ((lambda (bits) (or (and (= dy b2) (or (= dx b2) (on 0 bits) (and (< dx b2) (on 1 bits)) (and (> dx b2) (on 2 bits)))) (and (= dx b2) (or (on 3 bits) (and (< dy b2) (on 4 bits)) (and (> dy b2) (on 5 bits)))) (and (= dx dy) (or (on 6 bits) (and (< dx b2) (on 7 bits)) (and (> dx b2) (on 8 bits)))) (and (= (+ dx dy) band) (or (on 9 bits) (and (< dx b2) (on 10 bits)) (and (> dx b2) (on 11 bits)))))) (vector-ref spec index))))) (quotient band 2) logbit?)) #(#f 1 8 36 34 20 18 33 17 10 12 64 512 132 1028 2050 258 160 2080 1040 272 2304 1152 1280 2176) '(((#t 1 4) (#f 5) (#t 1 6) (#f 3)) ((#t 5 2) (#t 6 2) (#f 4) (#f 3)) ((#f 6) (#t 1 3) (#f 4) (#t 1 5)) ((#f 6) (#f 5) (#t 3 2) (#t 4 2))) 2 2 '(((#t 8 9) (#f 14) (#t 0 1) (#f 13)) ((#t 14 15) (#t 6 7) (#f 9) (#f 10)) ((#f 6) (#t 8 10) (#f 5) (#t 0 2)) ((#f 1) (#f 2) (#t 13 15) (#t 5 7))) 2 2 1 8 "🌵🌹🌺🌼🌸🌻🌷💮🦋" 6 1 10))Hilbert space-filling curve on the connector flower garden >>258. The supporting infrastructure is the same as for Peano >>258, with the grammar switched to Hilbert and the expansion factors to 2.
terminal-sized output: >>259,260
code: >>261,262
larger output: http://paste.textboard.org/85314814/raw https://endchan.net/art/res/2.html#72
Post joiner to reassemble all the split posts up to this point >>249,250 >>254,255 >>256,257 >>259,260 >>261,262:
((getcode, thread, joinspecs) => joinspecs.forEach (([pids, separ, remove]) => (codes => (count => {codes [count - 1].innerText = codes.map (e => e.innerText).join (separ); if (remove) {codes. slice (0, -1).forEach (e => e.remove ())}}) (codes.length)) (pids.split (" ").map (s => getcode (thread, parseInt (s, 10)))))) ((thread, id) => document.getElementById ("t" + thread + "p" + id).parentNode.nextElementSibling.querySelector ("code"), 22, [["249 250", "\n", true], ["254 255", "\n", true], ["256 257", " ", true], ["259 260", "\n", true], ["261 262", " ", true]])Updated lambda and character count table generator code >>76 with split post support
console.log (((repeat, thread, magic) => ((id2code, extractors, formatters, pads, stringify, layout, synthesize, synthspec) => ((table, aligns, strs) => ((table, aligns, strs) => layout (stringify (table, strs, formatters), aligns, pads)) (...synthesize (synthspec, table, aligns, strs))) (magic.split (" ").map (id => [id, id2code (thread, id)]).filter (p => p [1].every (c => c !== null)).map (([id, code], index) => (text => [index + 1, id].concat (extractors.map (ex => ex ["fun"] (text)))) (code.map (c => c.innerText).join (" "))), repeat (2, "right").concat (extractors.map (ex => ex ["align"])), ["tostring", "id"].concat (extractors.map (ex => ex ["str"])))) ((thread, id) => id.split ('+').map (id => document.getElementById ("t" + thread + "p" + id).parentNode.nextElementSibling.querySelector ("code")), [{"fun": s => [...s.matchAll (/\blambda | => /g)].length, "align": "right", "str": "tostring"}, {"fun": (max => s => s.split ("\n").reduce ((acc, item) => max (acc, item.length), 0)) (Math.max), "align": "right", "str": "tostring"}, {"fun": s => (m => m ? m [1] : "?") (s.match (/^(>>>|>>|scheme@\(guile-user\)>) /m)), "align": "left", "str": "id"}], {"id": x => x, "tostring": x => x.toString ()}, {"left": (s, n, pad) => s.padEnd (n, pad), "right": (s, n, pad) => s.padStart (n, pad)}, (rows, how, formatters) => rows.map (r => r.map ((c, index) => formatters [how [index]] (c))), (lengths => (rows, how, pads) => (lengths => rows.map (r => r.map ((c, index) => pads [how [index]] (c, lengths [index], " ")).join (" ")).join ("\n")) (lengths (rows))) ((max => rows => rows.reduce ((acc, r) => acc.map ((a, index) => max (a, r [index].length)), rows [0].map (x => 0))) (Math.max)), ((extend, addcolumns, orderof) => (spec, table, aligns, strs) => [addcolumns (table, spec.map (s => orderof (table, s.column, s.up))), extend (aligns, spec.length, "right"), extend (strs, spec.length, "tostring")]) ((arr, n, item) => arr.concat (repeat (n, item)), (table, columns) => table.map ((r, index) => r.concat (columns.map (c => c [index]))), (table, col, up) => table.map ((r, index) => [r [col], index]).sort (up ? ((a, b) => a [0] - b [0]) : ((a, b) => b [0] - a [0])).map (([val, pos], index) => [pos, index]).sort ((a, b) => a [0] - b [0]).map (a => 1 + a [1])), [{"column": 2, "up": false}, {"column": 3, "up": false}])) ((n, item) => Array.from ({length: n}, (dis, k) => item), 22, "9 10 11 13 14 17 21 24 25 28 30 34 35 37 39 42 43 46 49 53 55 59 65 67 69 70 72 77 81 85 89 90 95 99 100 104 107 109 111 113 115 119 120 121 126 129 132 137 139 149 153 157 176 182 184 189 190 191 192 198 201 203 208 212 214 218 224 229 231 233 236 241 243 245 247 251 256+257 261+262"))updated counts >>196 since December >>239
1 9 12 391 >>> 72 78
2 10 7 461 scheme@(guile-user)> 78 74
3 11 13 483 >> 68 72
4 13 15 627 >> 60 67
5 14 13 471 >> 69 73
6 17 14 524 >>> 66 69
7 21 18 789 >>> 49 63
8 24 15 851 scheme@(guile-user)> 61 62
9 25 13 692 scheme@(guile-user)> 70 65
10 28 25 1599 >>> 21 25
11 30 10 508 >> 74 70
12 34 13 560 >> 71 68
13 35 19 1375 scheme@(guile-user)> 45 36
14 37 15 642 >> 62 66
15 39 21 909 >> 34 59
16 42 10 452 >> 75 76
17 43 10 444 >> 76 77
18 46 18 707 >>> 50 64
19 49 23 1070 >>> 27 51
20 53 21 873 >>> 35 61
21 55 14 1066 scheme@(guile-user)> 67 53
22 59 21 1475 scheme@(guile-user)> 36 28
23 65 19 1110 scheme@(guile-user)> 46 48
24 67 25 1716 >>> 22 20
25 69 10 460 >> 77 75
26 70 20 1333 scheme@(guile-user)> 40 39
27 72 25 1717 scheme@(guile-user)> 23 19
28 77 33 2654 scheme@(guile-user)> 6 6
29 81 20 1459 scheme@(guile-user)> 41 29
30 85 30 1180 >> 10 44
31 89 32 1176 >> 7 45
32 90 18 1067 scheme@(guile-user)> 51 52
33 95 21 888 >>> 37 60
34 99 23 1262 scheme@(guile-user)> 28 40
35 100 22 993 >>> 30 56
36 104 30 1649 scheme@(guile-user)> 11 24
37 107 19 1391 scheme@(guile-user)> 47 35
38 109 31 1336 >>> 8 38
39 111 15 1062 scheme@(guile-user)> 63 54
40 113 21 1566 scheme@(guile-user)> 38 26
41 115 24 1935 scheme@(guile-user)> 25 13
42 119 16 1031 scheme@(guile-user)> 59 55
43 120 11 495 >> 73 71
44 121 15 990 scheme@(guile-user)> 64 57
45 126 17 1097 scheme@(guile-user)> 55 49
46 129 22 1423 scheme@(guile-user)> 31 33
47 132 27 1872 scheme@(guile-user)> 16 17
48 137 15 1164 scheme@(guile-user)> 65 46
49 139 17 1449 scheme@(guile-user)> 56 30
50 149 18 1660 scheme@(guile-user)> 52 23
51 153 26 2101 scheme@(guile-user)> 19 9
52 157 36 2926 scheme@(guile-user)> 4 4
53 176 20 1817 scheme@(guile-user)> 42 18
54 182 20 1913 scheme@(guile-user)> 43 14
55 184 31 2422 scheme@(guile-user)> 9 7
56 189 17 1223 scheme@(guile-user)> 57 41
57 190 18 1089 scheme@(guile-user)> 53 50
58 191 19 1222 scheme@(guile-user)> 48 42
59 192 20 1359 scheme@(guile-user)> 44 37
60 198 17 1487 scheme@(guile-user)> 58 27
61 201 22 1674 scheme@(guile-user)> 32 22
62 203 21 1685 scheme@(guile-user)> 39 21
63 208 35 2731 scheme@(guile-user)> 5 5
64 212 22 1913 scheme@(guile-user)> 33 15
65 214 40 3578 scheme@(guile-user)> 3 3
66 218 27 1966 scheme@(guile-user)> 17 12
67 224 25 2056 scheme@(guile-user)> 24 10
68 229 26 1912 scheme@(guile-user)> 20 16
69 231 27 2045 scheme@(guile-user)> 18 11
70 233 28 2183 scheme@(guile-user)> 15 8
71 236 18 956 scheme@(guile-user)> 54 58
72 241 23 1162 scheme@(guile-user)> 29 47
73 243 24 1205 scheme@(guile-user)> 26 43
74 245 29 1428 scheme@(guile-user)> 12 31
75 247 29 1428 scheme@(guile-user)> 13 32
76 251 29 1410 scheme@(guile-user)> 14 34
77 256+257 47 4320 scheme@(guile-user)> 1 2
78 261+262 47 4324 scheme@(guile-user)> 2 1Current leaders are: >>261,262 Hilbert space-filling curve on the connector flower garden, >>256,257 Peano space-filling curve on the connector flower garden, >>214 Sierpinski space-filling curve on the connector flower garden, >>208 ├┤ tree fractal flower garden with the ability to render connectors in flower patches, >>157 Sierpinski triangle over Sierpinski carpet on the flower garden.
52 157 36 2926 scheme@(guile-user)> 4 4
63 208 35 2731 scheme@(guile-user)> 5 5
65 214 40 3578 scheme@(guile-user)> 3 3
77 256+257 47 4320 scheme@(guile-user)> 1 2
78 261+262 47 4324 scheme@(guile-user)> 2 1