Unicode Art, Math Theme

122

🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵🌻🌻🌻🌻🌻🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼
🌼🌼🌵🌸🌵🌹🌹🌹🌵🌹🌵🌸🌸🌸🌵🌼🌵🌻🌻🌻🌵🌼🌵🌸🌸🌸🌵🌹🌵🌹🌹🌹🌵🌸🌵🌼🌼
🌼🌵🌸🌸🌸🌵🌹🌵🌹🌹🌹🌵🌸🌵🌼🌼🌼🌵🌻🌵🌼🌼🌼🌵🌸🌵🌹🌹🌹🌵🌹🌵🌸🌸🌸🌵🌼
🌵🌸🌸🌸🌸🌸🌵🌹🌹🌹🌹🌹🌵🌼🌼🌼🌼🌼🌵🌼🌼🌼🌼🌼🌵🌹🌹🌹🌹🌹🌵🌸🌸🌸🌸🌸🌵
🌺🌵🌸🌸🌸🌵🌻🌵🌹🌹🌹🌵🌹🌵🌼🌼🌼🌵💮🌵🌼🌼🌼🌵🌹🌵🌹🌹🌹🌵🌻🌵🌸🌸🌸🌵🌺
🌺🌺🌵🌸🌵🌻🌻🌻🌵🌹🌵🌹🌹🌹🌵🌼🌵💮💮💮🌵🌼🌵🌹🌹🌹🌵🌹🌵🌻🌻🌻🌵🌸🌵🌺🌺
🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵💮💮💮💮💮🌵🌹🌹🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺
🌺🌺🌵💮🌵🌻🌻🌻🌵🌷🌵🌹🌹🌹🌵🌹🌵💮💮💮🌵🌹🌵🌹🌹🌹🌵🌷🌵🌻🌻🌻🌵💮🌵🌺🌺
🌺🌵💮💮💮🌵🌻🌵🌷🌷🌷🌵🌹🌵🌹🌹🌹🌵💮🌵🌹🌹🌹🌵🌹🌵🌷🌷🌷🌵🌻🌵💮💮💮🌵🌺
🌵💮💮💮💮💮🌵🌷🌷🌷🌷🌷🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌷🌷🌷🌷🌷🌵💮💮💮💮💮🌵
🌷🌵💮💮💮🌵🌸🌵🌷🌷🌷🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌷🌷🌷🌵🌸🌵💮💮💮🌵🌷
🌷🌷🌵💮🌵🌸🌸🌸🌵🌷🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌷🌵🌸🌸🌸🌵💮🌵🌷🌷
🌷🌷🌷🌵🌸🌸🌸🌸🌸🌵🌺🌺🌺🌺🌺🌵🌹🌹🌹🌹🌹🌵🌺🌺🌺🌺🌺🌵🌸🌸🌸🌸🌸🌵🌷🌷🌷
🌷🌷🌵💮🌵🌸🌸🌸🌵🌷🌵🌺🌺🌺🌵🌹🌵🌹🌹🌹🌵🌹🌵🌺🌺🌺🌵🌷🌵🌸🌸🌸🌵💮🌵🌷🌷
🌷🌵💮💮💮🌵🌸🌵🌷🌷🌷🌵🌺🌵🌹🌹🌹🌵🌹🌵🌹🌹🌹🌵🌺🌵🌷🌷🌷🌵🌸🌵💮💮💮🌵🌷
🌵💮💮💮💮💮🌵🌷🌷🌷🌷🌷🌵🌹🌹🌹🌹🌹🌵🌹🌹🌹🌹🌹🌵🌷🌷🌷🌷🌷🌵💮💮💮💮💮🌵
🌺🌵💮💮💮🌵🌻🌵🌷🌷🌷🌵🌹🌵🌹🌹🌹🌵💮🌵🌹🌹🌹🌵🌹🌵🌷🌷🌷🌵🌻🌵💮💮💮🌵🌺
🌺🌺🌵💮🌵🌻🌻🌻🌵🌷🌵🌹🌹🌹🌵🌹🌵💮💮💮🌵🌹🌵🌹🌹🌹🌵🌷🌵🌻🌻🌻🌵💮🌵🌺🌺
🌺🌺🌺🌵🌻🌻🌻🌻🌻🌵🌹🌹🌹🌹🌹🌵💮💮💮💮💮🌵🌹🌹🌹🌹🌹🌵🌻🌻🌻🌻🌻🌵🌺🌺🌺

28 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))

108

─┬─   ─┬─   ─┬─   ─┬─   ─┬─   ─┬─   ─┬─   ─┬─
 ├──┬──┤     ├──┬──┤     ├──┬──┤     ├──┬──┤
─┴─ │ ─┴─   ─┴─ │ ─┴─   ─┴─ │ ─┴─   ─┴─ │ ─┴─
    ├─────┬─────┤           ├─────┬─────┤
─┬─ │ ─┬─ │ ─┬─ │ ─┬─   ─┬─ │ ─┬─ │ ─┬─ │ ─┬─
 ├──┴──┤  │  ├──┴──┤     ├──┴──┤  │  ├──┴──┤
─┴─   ─┴─ │ ─┴─   ─┴─   ─┴─   ─┴─ │ ─┴─   ─┴─
          ├───────────┬───────────┤
─┬─   ─┬─ │ ─┬─   ─┬─ │ ─┬─   ─┬─ │ ─┬─   ─┬─
 ├──┬──┤  │  ├──┬──┤  │  ├──┬──┤  │  ├──┬──┤
─┴─ │ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─ │ ─┴─
    ├─────┴─────┤     │     ├─────┴─────┤
─┬─ │ ─┬─   ─┬─ │ ─┬─ │ ─┬─ │ ─┬─   ─┬─ │ ─┬─
 ├──┴──┤     ├──┴──┤  │  ├──┴──┤     ├──┴──┤
─┴─   ─┴─   ─┴─   ─┴─ │ ─┴─   ─┴─   ─┴─   ─┴─
                      ├──────────────────────
─┬─   ─┬─   ─┬─   ─┬─ │ ─┬─   ─┬─   ─┬─   ─┬─
 ├──┬──┤     ├──┬──┤  │  ├──┬──┤     ├──┬──┤
─┴─ │ ─┴─   ─┴─ │ ─┴─ │ ─┴─ │ ─┴─   ─┴─ │ ─┴─
    ├─────┬─────┤     │     ├─────┬─────┤
─┬─ │ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─ │ ─┬─
 ├──┴──┤  │  ├──┴──┤  │  ├──┴──┤  │  ├──┴──┤
─┴─   ─┴─ │ ─┴─   ─┴─ │ ─┴─   ─┴─ │ ─┴─   ─┴─
          ├───────────┴───────────┤
─┬─   ─┬─ │ ─┬─   ─┬─   ─┬─   ─┬─ │ ─┬─   ─┬─
 ├──┬──┤  │  ├──┬──┤     ├──┬──┤  │  ├──┬──┤
─┴─ │ ─┴─ │ ─┴─ │ ─┴─   ─┴─ │ ─┴─ │ ─┴─ │ ─┴─
    ├─────┴─────┤           ├─────┴─────┤
─┬─ │ ─┬─   ─┬─ │ ─┬─   ─┬─ │ ─┬─   ─┬─ │ ─┬─
 ├──┴──┤     ├──┴──┤     ├──┴──┤     ├──┴──┤
─┴─   ─┴─   ─┴─   ─┴─   ─┴─   ─┴─   ─┴─   ─┴─

111, The Forced Indentation Of Overlapping, Gapped Tile Heaps

┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐
┤     ├─┤     ├─┤     ├─┤     ├─┤     ├─┤     ├
┤   ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐   ├
└─┬─┤     ├─┤     ├─┤     ├─┤     ├─┤     ├─┬─┘
┌─┴─┤   ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐   ├─┴─┐
┤   └─┬─┤     ├─┤     ├─┤     ├─┤     ├─┬─┘   ├
┤   ┌─┴─┤   ┌─┴─┴─┐ ┌─┴─┴─┐ ┌─┴─┴─┐   ├─┴─┐   ├
└─┬─┤   └─┬─┤     ├─┤     ├─┤     ├─┬─┘   ├─┬─┘
┌─┴─┤   ┌─┴─┤   ┌─┴─┴─┐ ┌─┴─┴─┐   ├─┴─┐   ├─┴─┐
┤   └─┬─┤   └─┬─┤     ├─┤     ├─┬─┘   ├─┬─┘   ├
┤   ┌─┴─┤   ┌─┴─┤   ┌─┴─┴─┐   ├─┴─┐   ├─┴─┐   ├
└─┬─┤   └─┬─┤   └─┬─┤     ├─┬─┘   ├─┬─┘   ├─┬─┘
┌─┴─┤   ┌─┴─┤   ┌─┴─┤     ├─┴─┐   ├─┴─┐   ├─┴─┐
┤   └─┬─┤   └─┬─┤   └─┬─┬─┘   ├─┬─┘   ├─┬─┘   ├
┤   ┌─┴─┤   ┌─┴─┤     ├─┤     ├─┴─┐   ├─┴─┐   ├
└─┬─┤   └─┬─┤   └─┬─┬─┘ └─┬─┬─┘   ├─┬─┘   ├─┬─┘
┌─┴─┤   ┌─┴─┤     ├─┤     ├─┤     ├─┴─┐   ├─┴─┐
┤   └─┬─┤   └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘   ├─┬─┘   ├
┤   ┌─┴─┤     ├─┤     ├─┤     ├─┤     ├─┴─┐   ├
└─┬─┤   └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘   ├─┬─┘
┌─┴─┤     ├─┤     ├─┤     ├─┤     ├─┤     ├─┴─┐
┤   └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘   ├
┤     ├─┤     ├─┤     ├─┤     ├─┤     ├─┤     ├
└─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘ └─┬─┬─┘

(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))

113 The Forced Resumption Of Tile Heap Fractals

┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐
│     │ │     │ │     │ │     │
│   ┌─┴─┴─┐   │ │   ┌─┴─┴─┐   │
└───┤     ├───┘ └───┤     ├───┘
┌───┤     ├───┐ ┌───┤     ├───┐
│   └─┬─┬─┘   │ │   └─┬─┬─┘   │
│     │ │   ┌─┴─┴─┐   │ │     │
└─────┘ └───┤     ├───┘ └─────┘
┌─────┐ ┌───┤     ├───┐ ┌─────┐
│     │ │   └─┬─┬─┘   │ │     │
│   ┌─┴─┴─┐   │ │   ┌─┴─┴─┐   │
└───┤     ├───┘ └───┤     ├───┘
┌───┤     ├───┐ ┌───┤     ├───┐
│   └─┬─┬─┘   │ │   └─┬─┬─┘   │
│     │ │     │ │     │ │     │
└─────┘ └─────┘ └─────┘ └─────┘

(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))

189 Connector #119 version of the tower of memel #46 #49

┘ ┌─────────────────────────────────────┐ └
┌─┘ ┌─────────────────────────────────┐ └─┐
│ ┌─┘ ┌─────────────────────────────┐ └─┐ │
│ │ ┌─┘ ┌─────────────────────────┐ └─┐ │ │
│ │ │ ┌─┘ ┌─────────────────────┐ └─┐ │ │ │
│ │ │ │ ┌─┘ ┌─────────────────┐ └─┐ │ │ │ │
│ │ │ │ │ ┌─┘ ┌─────────────┐ └─┐ │ │ │ │ │
│ │ │ │ │ │ ┌─┘ ┌─────────┐ └─┐ │ │ │ │ │ │
│ │ │ │ │ │ │ ┌─┘ ┌─────┐ └─┐ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ ┌─┘ ┌─┐ └─┐ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ ┌─┘ └─┐ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ └─┐ ┌─┘ │ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ └─┐ └─┘ ┌─┘ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ └─┐ └─────┘ ┌─┘ │ │ │ │ │ │ │
│ │ │ │ │ │ └─┐ └─────────┘ ┌─┘ │ │ │ │ │ │
│ │ │ │ │ └─┐ └─────────────┘ ┌─┘ │ │ │ │ │
│ │ │ │ └─┐ └─────────────────┘ ┌─┘ │ │ │ │
│ │ │ └─┐ └─────────────────────┘ ┌─┘ │ │ │
│ │ └─┐ └─────────────────────────┘ ┌─┘ │ │
│ └─┐ └─────────────────────────────┘ ┌─┘ │
└─┐ └─────────────────────────────────┘ ┌─┘
┐ └─────────────────────────────────────┘ ┌

(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))

190 Connector #189 version of #11

    ┌────────────────────────────────────────┐
    │ ┌────────────────────────────────────┐ │
    │ │ ┌────────────────────────────────┐ │ │
    │ │ │ ┌────────────────────────────┐ │ │ │
    │ │ │ │ ┌────────────────────────┐ │ │ │ │
    │ │ │ │ │ ┌────────────────────┐ │ │ │ │ │
    │ │ │ │ │ │ ┌────────────────┐ │ │ │ │ │ │
    │ │ │ │ │ │ │ ┌────────────┐ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ ┌────────┐ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ ┌────┐ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ ── │ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ └────┘ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ └────────┘ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ └────────────┘ │ │ │ │ │ │ │
    │ │ │ │ │ │ └────────────────┘ │ │ │ │ │ │
    │ │ │ │ │ └────────────────────┘ │ │ │ │ │
    │ │ │ │ └────────────────────────┘ │ │ │ │
    │ │ │ └────────────────────────────┘ │ │ │
    │ │ └────────────────────────────────┘ │ │
    │ └────────────────────────────────────┘ │
    └────────────────────────────────────────┘

(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))

191 Connector #190 version of #13

    ┌────────────────────────────────────────┐
    │ ┌────────────────────────────────────┐ │
    │ │ ┌────────────────────────────────┐ │ │
    │ │ │ ┌────────────────────────────┐ │ │ │
    │ │ │ │ ┌────────────────────────┐ │ │ │ │
    │ │ │ │ │ ┌────────────────────┐ │ │ │ │ │
    │ │ │ │ │ │ ┌────────────────┐ │ │ │ │ │ │
    │ │ │ │ │ │ │ ┌────────────┐ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ ┌────────┐ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ ┌────┐ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ │ ───┘ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ └──────┘ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ └──────────┘ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ └──────────────┘ │ │ │ │ │ │
    │ │ │ │ │ │ └──────────────────┘ │ │ │ │ │
    │ │ │ │ │ └──────────────────────┘ │ │ │ │
    │ │ │ │ └──────────────────────────┘ │ │ │
    │ │ │ └──────────────────────────────┘ │ │
    │ │ └──────────────────────────────────┘ │
    │ └──────────────────────────────────────┘
    └─────────────────────────────────────────

(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))

192 Connector #191 version of #37

    ─────────────────────────────────────────┐
    ┌──────────────────────────────────────┐ │
    │ ┌──────────────────────────────────┐ │ │
    │ │ ┌──────────────────────────────┐ │ │ │
    │ │ │ ┌──────────────────────────┐ │ │ │ │
    │ │ │ │ ┌──────────────────────┐ │ │ │ │ │
    │ │ │ │ │ ┌──────────────────┐ │ │ │ │ │ │
    │ │ │ │ │ │ ┌──────────────┐ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ ┌──────────┐ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ ┌──────┐ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ ┌────┘ │ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ │ └──────┘ │ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ │ └──────────┘ │ │ │ │ │ │ │
    │ │ │ │ │ │ │ └──────────────┘ │ │ │ │ │ │
    │ │ │ │ │ │ └──────────────────┘ │ │ │ │ │
    │ │ │ │ │ └──────────────────────┘ │ │ │ │
    │ │ │ │ └──────────────────────────┘ │ │ │
    │ │ │ └──────────────────────────────┘ │ │
    │ │ └──────────────────────────────────┘ │
    │ └──────────────────────────────────────┘
    └─────────────────────────────────────────

(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))