title: Rod of Asclepius

text:
# Question
Title: Rod of Asclepius
With this challenge we pay homage to everyone around the whole world fighting against the coronavirus crisis; particularly represented are the people tied to medicine, as the *Rod of Asclepius* is a symbol associated with medicine and health care.

For that matter, we resort to some ASCII art found at asciiart.eu (wrongfully) listed under the ASCII art associated with the Rod of Caduceus.

# Task

Your task is to print or return the following modified art of an original by Juergen Jakubowski:

```
                          LLLLLLLLLLLLLLLLLLL
                          LLLLLLLLLLLLLLLLLLL
                          LLLLLLLLLLLLLLLLLLL
                          LLLLLLLLLLLLLLLLLLL
                          LLLLLLLLLLLLLLLLLLL
          LLL             LLLLLLLLLLLLLLLLLLL             LLL
         LLLLLLL          LLLLLLLLLLLLLLLLLLL          LLLLLLL
         LLLLLLLLLL       LLLLLLLLL  LLLLLLLL       LLLLLLLLLL
        LLLLLLLLLLLLL     LLLLLLLLL      LLLL     LLLLLLLLLLLLL
       LLLLLLLLLLLLLLLLL  LLLLL L  LL    LLLL  LLLLLLLLLLLLLLLLL
      LLLLLLLLLLLLLLLLLLLLLLL   LLL  LL    LLLLLLLLLLLLLLLLLLLLLL
     LLLLLLLLLLLLLLLLLLLLLLL      LLLLLL  LLLLLLLLLLLLLLLLLLLLLLLL
    LLLLLLLLLLLLLLLLLLLLLLL    LLLLLLLLL  LLLLLLLLLLLLLLLLLLLLLLLLL
   LLLLLLLLLLLLLLLLLLLLLLLL     LLLL     LLLLLLLLLLLLLLLLLLLLLLLLLLL
 LLLLLLLLLLLLLLLLLLLLLLLLLLL        LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
 LLLLLLLLLLLLLLLLLLLLLLLLLLLLL          LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
    LLLLLLLLLLLLLLLLLLLLLLLLLLLLL         LLLLLLLLLLLLLLLLLLLLLLLLL
       LLLLLLLLLLLLLLLLLLLLLLLLLLLLL       LLLLLLLLLLLLLLLLLLLLL
          LLLLLLLLLLLLLLLLLLLLLLLLLLLLL      LLLLLLLLLLLLLLLL
             LLLLLLLLLLLLLLLLLLLLLL  LLL     LLLLLLLLLLLLL
              LLLLLLLLLLLLLLLLLLLL    L     LLLLLLLLLLLLL
                LLLLLLLLLLLLLLLL  LL   L   LLLLLLLLLLLL
            LLLLLLLLLLLLLLLLLLL   LL  L LLLLLLLLLLLLLLLLLLL
          LLLLLLLLLLLLLLLLLLLLL      LLLLLLLLLLLLLLLLLLLLLLLL
       LLLLLLLLLLLLLLLLLLLLLLLLL       LLLLLLLLLLLLLLLLLLLLLLLLL
    LLLLLLLLLLLLLLLLLLLLLLLLLLLLL        LLLLLLLLLLLLLLLLLLLLLLLLLL
 LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL       LLLLLLLLLLLLLLLLLLLLLLLLLLLL
  LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL    LLLLLLLLLLLLLLLLLLLLLLLLLLL
   LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL LLL   LLLLLLLLLLLLLLLLLLLLLLLLLL
    LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL   L  LLLLLLLLLLLLLLLLLLLLLLLLLL
     LLLLLLLLLLLLLLLLLLLLLLLLLLL      LLLLLLLLLLLLLLLLLLLLLLLLLLLL
       LLLLLLLLLLLLLLLLLL LLLLLL   L  LLLLLLL LLLLLLLLLLLLLLLLLL
       LLLLLLLLLLLLLLL    LLLLLL    LLLLLLLLL    LLLLLLLLLLLLLLL
        LLLLLLLLLLLL      LLLLLLL     LLLLLLL      LLLLLLLLLLLL
         LLLLLLLL         LLLLLLLLL     LLLLL         LLLLLLLL
         LLLLL            LLLLLLLLLLL  LLLLLL            LLLLL
          LL              LLLLLLLLLLLLLLLLLLL              LL
                          LLLLLLLLLL LLLLLLLL
                          LLLLLLLLLL LLLLLLLL
                          LLLLLLLLLLLLLLLLLLL
                          LLLLLLLLLLLLLLLLLLL
                          LLLLLLLLLLLLLLLLLLL

```

This art has been made more symmetrical, non-L characters have been replaced by Ls and the author name and e-mail have been removed from the art.

You may add/remove leading/trailing whitespace as long as the layout of the Ls and the whitespace within them doesn't change.

---

This is so shortest submission in bytes, wins! If you liked this challenge, consider upvoting it! If you dislike this challenge, please give me your feedback. Happy golfing!

# Answer
> 6 votes
# Python 3.8 (pre-release), ~~304~~ ~~291~~ ~~288~~ 284 bytes

-2 bytes thanks to xnor.

```
i=k=0
for c in b"b!FjnuaV5k6[ZvtUk]-M81/DoW(3D|I]wB$j;D0mR' |tBjimp?$NAWR5N^21ZLk#sqG:GRQcBXMAgSYaZL\:%El2:=T{Kw%o,pd3Tav[pM$-&pN|jVdYlavl^;8E?zI\"PQ5:%A>yHa:7^) ,LX~3RH^bG;dGg.2{xsqLW5o":i=i*100+c-27
s=''
while~i+k:c=i%37;i//=37;s+=' L'[k]*c;k^=1;c or print(f'{s:^71}'+(s:=''))

```

Try it online!

Since the string contains some unprintables, here is a hexdump:

```
00000000: 6221 466a 6e75 6156 351d 6b36 5b5a 1b76  b!FjnuaV5.k6[Z.v
00000010: 7455 6b5d 2d4d 3831 2f44 6f57 2833 447c  tUk]-M81/DoW(3D|
00000020: 495d 7742 246a 3b44 306d 5227 207c 7442  I]wB$j;D0mR' |tB
00000030: 6a69 6d70 3f24 4e41 5752 354e 5e32 311f  jimp?$NAWR5N^21.
00000040: 5a4c 6b23 7371 473a 4752 5163 421e 584d  ZLk#sqG:GRQcB.XM
00000050: 4167 5359 615a 4c5c 3a25 456c 323a 3d54  AgSYaZL\:%El2:=T
00000060: 7b4b 7725 6f2c 7064 3354 6176 5b70 4d24  {Kw%o,pd3Tav[pM$
00000070: 1e2d 2670 4e7c 6a56 6459 6c61 766c 5e3b  .-&pN|jVdYlavl^;
00000080: 3845 3f7a 4922 5051 353a 2541 3e79 4861  8E?zI"PQ5:%A>yHa
00000090: 3a37 5e29 1f20 2c4c 587e 3352 485e 6247  :7^). ,LX~3RH^bG
000000a0: 3b64 4767 2e32 7b78 7371 4c57 356f       ;dGg.2{xsqLW5o

```

# Answer
> 5 votes
# Python 3, ~~325 ... 276 273~~ 260 bytes

```
s="";i=0
for n in b"_____)393O-090S0-/(.-V3+/,*+Y7(+''((**(]=))((*b=,,(d=*/(e>+*+gA.nC0jC/eC-aC,\<()+Y:*'+Y6(()')X9)((''_;,d?-eC.fH-hJ*gF'))fE)'(fA,h8',)'(-'^5*,*/*[2,-+-,X.//++/T+21(,2Q(494N0'T0'T___":
 s+=n%38*"L "[i];i^=1
 if n>75:print(f"{s:^71}");s="";i=0

```

Try it online!

**How**:

The big idea is to encode each line as a list of integer, each denotes the number of consecutive `"L"` or `" "` characters. For example, `[1, 2, 3]` denotes `L LLL` (1 `L`, 2 spaces, 3 `L`).

Each list of integer can be further encoded as a byte-string (Python3 byte string acts similarly to a list of code points). The run lengths are between `1` and `36`, most of which are unprintable ASCII code points. Thus, I map each integer `i` to `i+38` instead. The above example would maps to:

```
"L  LLL" -> [1,2,3] -> [39,40,41] -> "'()"

```

(38 is chosen instead of 37 because it prevents a backslash character `\` that needs to be escaped).

The new line character can be sneaked into a sequence by adding an extra `38` to the end of each line.

```
"L  LLL\n" -> [39,40,41] -> [39,40,79] -> "'(O"

```

In summary: for each code point `n` in the byte string, `n%38` gives the length of the current run, and `n>=76` if the current run is the end of a line.

~~I use Neil's idea of only compressing the left two thirds of each line, then mirror the rest to save more characters.~~

I additionally exploit the symmetry of the shape by ignoring the spaces on both side of each line. When decoding, I center align each line in a block of width 71. (This idea is the same as ovs's approach, though I came up with it independently).

# Answer
> 5 votes
# 05AB1E, 170 bytes

-9 bytes thanks to @mypronounismonicareinstate.

-1 byte thanks to @KevinCruijssen.

```
•2yÂ6:å₂øǝ₄²¤ΩàΘ₄IüÊX¹åêøë®Ñ¼(á×¿ìŒΓÉnγΘi‰—θвƶ\`α\ǝ)t~óÌ
dHD{iÍ;½vŽć·µ°Ãô-©ã„jΛ":иdC{!hâ'gÊć'Ž?«*9¢h¬βÉšGƶ¿Ć9₄>G>„FèQäªj'₂¿TNt …ΣSjδ!¯„мŸ>₅&¯!E-&&Wž™è°‹aтćËà•₆в„ LÞ×J69ô»

```

Try it online!

## Explanation

```
•...•              Gigantic packed integer-list of run-lengths
     37в           Convert it from base 37
        „ L        Length-2 string " L"
           Þ       Extend to the length of the other operand
            ×      Multiply them
             J     Join the output string
              69ô  Split into chunks of length 69
                 » Join by newlines

```

# Answer
> 3 votes
# Python 3, 341 bytes

```
for c in b'[S [S [S [S [S KCMSMC JGJSJG JJGIBHGJ IMEIFDEM HQBEAABBDDBQ GWCCBBDV FWFFBX EWDIBY DXEDE[ B[Hb B]J^ E]IY H]GU K]FP NVBCEM OTDAEM QPBBCACL MSCBBAAS KUFX HYGY E]HZ BbG\\ CdD[ D`ACCZ E_CABZ F[F\\ HRAFCABGAR HODFDIDO ILFGEGFL JHIIEEIH JELKBFLE KBNSNB [JAH [JAH [S [S [S'.split():print(''.join(' L'[i%2]*(j-64)for i,j in enumerate(c)))

```

Try it online!

Basic run-length encoding

# Answer
> 3 votes
# Bubblegum, 202 bytes

Uses the file with all unnecessary leading and trailing whitespace removed. Since the code is a raw DEFLATE stream, here's a hex dump (not that it helps significantly):

```
00000000: d596 410a 4331 0805 f739 8507 eafd cf53  ..A.C1...9.....S
00000010: 0882 30e2 2059 b559 257d ce53 acc2 8fe9  ..0. Y.Y%}.S....
00000020: 7cfa 39ff 195c a207 77fd 2076 0933 758b  |.9..\..w. v.3u.
00000030: a977 7405 74cf 0137 fe9e 3868 648c 7b29  .wt.t..7..8hd.{)
00000040: bcf7 0d38 cb48 6a0e 3aca 9788 2038 0c12  ...8.Hj.:... 8..
00000050: 9b28 1693 24bd 8387 6832 0e7b 171b 2c6f  .(..$...h2.{..,o
00000060: 8918 a9c5 d2c5 f89d 85ae ee04 da3c 0365  .............<.e
00000070: 4607 4b44 be24 89f9 b25f 141a d07d 6708  F.KD.$..._...}g.
00000080: efff 9ad7 09d9 8faa 5521 2e54 7d91 657f  ........U!.T}.e.
00000090: fde4 b8bc ef4c f26e e11e 8b6e 4c21 810a  .....L.n...nL!..
000000a0: eec3 78e6 c50d 0ff0 3156 8dfb b40d c5d2  ..x.....1V......
000000b0: b05e d440 0fcb 980f c858 27ae 320f 0276  .^.@.....X'.2..v
000000c0: df0a acd3 837f edfb e60b                 ..........

```

Try it online!

# Answer
> 3 votes
# Jelly, ~~186~~ ~~175~~ 174 bytes

```
“ç⁺lñỊɓ¡ḌỌKḃßƇ[Æ÷ịœi#⁵Q#^Fo$Q$'ẠKẏȤ⁴ịɲɦʋỌ⁷ḄLqẏ⁺nÄẉ⁾ṀⱮsọḢɲlọȮḄṡ-$ɓv?KggjḞƭCid/ Ȥx?ßɓṇȯ¢ḋ®ṖIQṁ"œıṚ/£;ẉ*ȧ%¹ȯḷŻṖ4eS⁸w÷ƭʋịṢḤUKGɦðþḥ³-_?ß§lÇĠⱮkĠƝẎ3UỌYBTẋŒØL®œƇỊ⁼Ẓd’b37⁶”L2ƭx$€Fs69Y

```

The part at the end can almost certainly be golfed, as I'm relatively bad at Jelly. Certain very long run lengths are replaced by shorter ones and a zero in the integer (e.g. `[..., 63, ...]` is changed to `[..., 32, 0, 31, ...]`).

### Explanation:

```
“...Ẓd’                  very large integer
       b37               decode into base 37 digits
          ⁶”L2ƭ          magically alternate between spaces and Ls
               x$€       those characters repeated each element times
                  Fs69Y  flatten, split into 69-long slices and join by newline

```

Try it online!

# Answer
> 2 votes
# JavaScript (ES6),  ~~315 308~~  305 bytes

*Saved 3 bytes thanks to @ASCII-only*

The data string is only 163 bytes long, which is pretty good. But the decompression code is too verbose.

```
_=>`jJJJJ
3dj
7ajA7928D5964H25112244N332242N6623N4923O5454R89Ta5T93T72T6M235K4151G223132J322115L68P76T84Y73Z0143W1333V3124R67I163127F4649C6757
89955
5cb26
2ejA18A18JJJ`[R='replace'](/[A-Z]/g,`
$&`)[R](/.+/g,s=>(s=s[R](k=/./g,x=>' L'[k^=1].repeat(parseInt(x,36))).padStart(45))+(g=k=>k--?s[k]+g(k):'')(26))

```

Try it online!

### Decompression

We first insert a line-feed before each letter in upper case. For instance, `7ajA7928D5964H25112244` is turned into:

```
7aj
A7928
D5964
H25112244

```

For a given line, we convert each character from base 36 to decimal:

```
"D5964" ~> [ 13, 5, 9, 6, 4 ]

```

For each value \\$n\\$ in this list, we generate a string of \\$n\\$ characters, alternating between `"L"` and `" "`:

```
[ 13, 5, 9, 6, 4 ] ~> "LLLLLLLLLLLLL     LLLLLLLLL      LLLL"

```

We insert as many leading spaces as necessary to reach 45 characters and append the first 26 characters at the end in reverse order:

```
 <-------------------- 45 ------------------->
"        LLLLLLLLLLLLL     LLLLLLLLL      LLLL"
"        LLLLLLLLLLLLL     LLLLLLLLL      LLLL     LLLLLLLLLLLLL        "
 <---------- 26 ---------->                   <---------- 26 ---------->

```

# Answer
> 2 votes
# Charcoal, 167 bytes

```
”}∨｜Sλχ6?↗⊕H4R¬.Y3nLïB⁷ζ↧*⟧﹪∨?Ｆ⬤SYηT⌊…δⅈJＫ´u＆⸿ＺÀec⎚υιw↙ＳkêX⁼E³ＺＧςδ=⪫s{εηB(⊘{⁷,W∧⸿ηＳＢiYγ\>tI;~↓ＥjＺ0⪫|∨_Ｄ?YＴ⟧？↘JＩψ∨；2≔↑⁵C⊕Ｗ⦄Ｍ↓|⮌κ¬Qb›b{″FJHo？?◨χcμχ‴Ｚ⁷ⅈ5Ｏν⭆.¶◨D3e]”‖ＯＯ←¹⁹

```

Try it online! Link is to verbose version of code. Explanation: The compressed string literal encodes the right two thirds of the output and then the right third is reflected to complete the image.

If the image was more vertically symmetric then it might have been possible to save a few more bytes.

# Answer
> 2 votes
# Retina, ~~290~~ 285 bytes

```

19¶19¶19¶19¶19¶3je19¶7jb19¶10h9c8¶13f9g4¶17c5b1c2e4¶23d3c2e2¶23g6c3¶23e9c3¶24f4f4¶27i9¶29jb5¶29j3¶29h2¶29g¶22c3f¶20e1f1¶16c2d1d2¶19d2c1b5¶21g8¶25h6¶29i4¶34h3¶36e3¶32b3d3¶31d1c4¶27g7¶18b6d1c7¶15e6e9¶12g7f7¶8j9f5¶5jd11c6¶2jf19¶10b8¶10b8¶19¶19¶19
\d+
*L
T`l`d
\d
*
P^`.+
%`.{19}$
$&$^$`

```

Try it online! Edit: Saved 4 bytes by encoding the left two thirds instead of the right two thirds. Explanation: Uses run-length encoding. The integers encode runs of up to 34 `L`s while the letters `b-j` encode runs of 1-9 spaces with `jb-jf` encoding runs of 10-14 spaces as this saves a byte in the decoder. The first line simply inserts the encoded data.

```
\d+
*L

```

Run-length decode the integers to `L`s.

```
T`l`d

```

Transpose the lower case letters to digits in preparation for run-length decoding.

```
\d
*

```

Run-length decode the digits to spaces (each digit decoded separately).

```
P^`.+

```

Left-pad all of the lines to the same length. Annoyingly the `P` command (unlike, say, the `O` command) does not have a useful default, which might save 2 bytes here.

```
%`.{19}$

```

Match the last 19 characters on each line.

```
$&$^$`

```

Append their reversed prefixes, thus mirroring the output.

# Answer
> 2 votes
# Deadfish~, 5802 bytes

```
{i}{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}{c}cccccc{d}{d}ddc{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}{c}cccccc{d}{d}ddc{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}{c}cccccc{d}{d}ddc{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}{c}cccccc{d}{d}ddc{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}{c}cccccc{d}{d}ddc{i}{i}ii{c}{{i}dddddd}iiiiccc{{d}iiiiii}dddd{c}ccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}ccc{{i}dddddd}iiiiccc{{d}iiiiii}dddd{c}{d}{d}ddc{i}{i}iiccccccccc{{i}dddddd}iiiiccccccc{{d}iiiiii}dddd{c}{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}{{i}dddddd}iiiiccccccc{{d}iiiiii}ddddccccccccc{d}{d}ddc{i}{i}iiccccccccc{{i}dddddd}iiii{c}{{d}iiiiii}ddddccccccc{{i}dddddd}iiiiccccccccc{{d}iiiiii}ddddcc{{i}dddddd}iiiicccccccc{{d}iiiiii}ddddccccccc{{i}dddddd}iiii{c}{{d}iiiiii}ddddccccccccc{d}{d}ddc{i}{i}iicccccccc{{i}dddddd}iiii{c}ccc{{d}iiiiii}ddddccccc{{i}dddddd}iiiiccccccccc{{d}iiiiii}ddddcccccc{{i}dddddd}iiiicccc{{d}iiiiii}ddddccccc{{i}dddddd}iiii{c}ccc{{d}iiiiii}ddddcccccccc{d}{d}ddc{i}{i}iiccccccc{{i}dddddd}iiii{c}ccccccc{{d}iiiiii}ddddcc{{i}dddddd}iiiiccccc{{d}iiiiii}ddddc{{i}dddddd}iiiic{{d}iiiiii}ddddcc{{i}dddddd}iiiicc{{d}iiiiii}ddddcccc{{i}dddddd}iiiicccc{{d}iiiiii}ddddcc{{i}dddddd}iiii{c}ccccccc{{d}iiiiii}ddddccccccc{d}{d}ddc{i}{i}iicccccc{{i}dddddd}iiii{c}{c}ccc{{d}iiiiii}ddddccc{{i}dddddd}iiiiccc{{d}iiiiii}ddddcc{{i}dddddd}iiiicc{{d}iiiiii}ddddcccc{{i}dddddd}iiii{c}{c}cc{{d}iiiiii}ddddcccccc{d}{d}ddc{i}{i}iiccccc{{i}dddddd}iiii{c}{c}ccc{{d}iiiiii}ddddcccccc{{i}dddddd}iiiicccccc{{d}iiiiii}ddddcc{{i}dddddd}iiii{c}{c}cccc{{d}iiiiii}ddddccccc{d}{d}ddc{i}{i}iicccc{{i}dddddd}iiii{c}{c}ccc{{d}iiiiii}ddddcccc{{i}dddddd}iiiiccccccccc{{d}iiiiii}ddddcc{{i}dddddd}iiii{c}{c}ccccc{{d}iiiiii}ddddcccc{d}{d}ddc{i}{i}iiccc{{i}dddddd}iiii{c}{c}cccc{{d}iiiiii}ddddccccc{{i}dddddd}iiiicccc{{d}iiiiii}ddddccccc{{i}dddddd}iiii{c}{c}ccccccc{{d}iiiiii}ddddccc{d}{d}ddc{i}{i}iic{{i}dddddd}iiii{c}{c}ccccccc{{d}iiiiii}ddddcccccccc{{i}dddddd}iiii{c}{c}{c}cccc{{d}iiiiii}ddddc{d}{d}ddc{i}{i}iic{{i}dddddd}iiii{c}{c}ccccccccc{{d}iiiiii}dddd{c}{{i}dddddd}iiii{c}{c}{c}{{d}iiiiii}ddddc{d}{d}ddc{i}{i}iicccc{{i}dddddd}iiii{c}{c}ccccccccc{{d}iiiiii}ddddccccccccc{{i}dddddd}iiii{c}{c}ccccc{{d}iiiiii}ddddcccc{d}{d}ddc{i}{i}iiccccccc{{i}dddddd}iiii{c}{c}ccccccccc{{d}iiiiii}ddddccccccc{{i}dddddd}iiii{c}{c}c{{d}iiiiii}ddddccccccc{d}{d}ddc{i}{i}ii{c}{{i}dddddd}iiii{c}{c}ccccccccc{{d}iiiiii}ddddcccccc{{i}dddddd}iiii{c}cccccc{{d}iiiiii}dddd{c}{d}{d}ddc{i}{i}ii{c}ccc{{i}dddddd}iiii{c}{c}cc{{d}iiiiii}ddddcc{{i}dddddd}iiiiccc{{d}iiiiii}ddddccccc{{i}dddddd}iiii{c}ccc{{d}iiiiii}dddd{c}ccc{d}{d}ddc{i}{i}ii{c}cccc{{i}dddddd}iiii{c}{c}{{d}iiiiii}ddddcccc{{i}dddddd}iiiic{{d}iiiiii}ddddccccc{{i}dddddd}iiii{c}ccc{{d}iiiiii}dddd{c}cccc{d}{d}ddc{i}{i}ii{c}cccccc{{i}dddddd}iiii{c}cccccc{{d}iiiiii}ddddcc{{i}dddddd}iiiicc{{d}iiiiii}ddddccc{{i}dddddd}iiiic{{d}iiiiii}ddddccc{{i}dddddd}iiii{c}cc{{d}iiiiii}dddd{c}cccccc{d}{d}ddc{i}{i}ii{c}cc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}ddddccc{{i}dddddd}iiiicc{{d}iiiiii}ddddcc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}cc{d}{d}ddc{i}{i}ii{c}{{i}dddddd}iiii{c}{c}c{{d}iiiiii}ddddcccccc{{i}dddddd}iiii{c}{c}cccc{{d}iiiiii}dddd{c}{d}{d}ddc{i}{i}iiccccccc{{i}dddddd}iiii{c}{c}ccccc{{d}iiiiii}ddddccccccc{{i}dddddd}iiii{c}{c}ccccc{{d}iiiiii}ddddccccccc{d}{d}ddc{i}{i}iicccc{{i}dddddd}iiii{c}{c}ccccccccc{{d}iiiiii}ddddcccccccc{{i}dddddd}iiii{c}{c}cccccc{{d}iiiiii}ddddcccc{d}{d}ddc{i}{i}iic{{i}dddddd}iiii{c}{c}{c}cccc{{d}iiiiii}ddddccccccc{{i}dddddd}iiii{c}{c}cccccccc{{d}iiiiii}ddddc{d}{d}ddc{i}{i}iicc{{i}dddddd}iiii{c}{c}{c}cccccc{{d}iiiiii}ddddcccc{{i}dddddd}iiii{c}{c}ccccccc{{d}iiiiii}ddddcc{d}{d}ddc{i}{i}iiccc{{i}dddddd}iiii{c}{c}{c}cc{{d}iiiiii}ddddc{{i}dddddd}iiiiccc{{d}iiiiii}ddddccc{{i}dddddd}iiii{c}{c}cccccc{{d}iiiiii}ddddccc{d}{d}ddc{i}{i}iicccc{{i}dddddd}iiii{c}{c}{c}c{{d}iiiiii}ddddccc{{i}dddddd}iiiic{{d}iiiiii}ddddcc{{i}dddddd}iiii{c}{c}cccccc{{d}iiiiii}ddddcccc{d}{d}ddc{i}{i}iiccccc{{i}dddddd}iiii{c}{c}ccccccc{{d}iiiiii}ddddcccccc{{i}dddddd}iiii{c}{c}cccccccc{{d}iiiiii}ddddccccc{d}{d}ddc{i}{i}iiccccccc{{i}dddddd}iiii{c}cccccccc{{d}iiiiii}ddddc{{i}dddddd}iiiicccccc{{d}iiiiii}ddddccc{{i}dddddd}iiiic{{d}iiiiii}ddddcc{{i}dddddd}iiiiccccccc{{d}iiiiii}ddddc{{i}dddddd}iiii{c}cccccccc{{d}iiiiii}ddddccccccc{d}{d}ddc{i}{i}iiccccccc{{i}dddddd}iiii{c}ccccc{{d}iiiiii}ddddcccc{{i}dddddd}iiiicccccc{{d}iiiiii}ddddcccc{{i}dddddd}iiiiccccccccc{{d}iiiiii}ddddcccc{{i}dddddd}iiii{c}ccccc{{d}iiiiii}ddddccccccc{d}{d}ddc{i}{i}iicccccccc{{i}dddddd}iiii{c}cc{{d}iiiiii}ddddcccccc{{i}dddddd}iiiiccccccc{{d}iiiiii}ddddccccc{{i}dddddd}iiiiccccccc{{d}iiiiii}ddddcccccc{{i}dddddd}iiii{c}cc{{d}iiiiii}ddddcccccccc{d}{d}ddc{i}{i}iiccccccccc{{i}dddddd}iiiicccccccc{{d}iiiiii}ddddccccccccc{{i}dddddd}iiiiccccccccc{{d}iiiiii}ddddccccc{{i}dddddd}iiiiccccc{{d}iiiiii}ddddccccccccc{{i}dddddd}iiiicccccccc{{d}iiiiii}ddddccccccccc{d}{d}ddc{i}{i}iiccccccccc{{i}dddddd}iiiiccccc{{d}iiiiii}dddd{c}cc{{i}dddddd}iiii{c}c{{d}iiiiii}ddddcc{{i}dddddd}iiiicccccc{{d}iiiiii}dddd{c}cc{{i}dddddd}iiiiccccc{{d}iiiiii}ddddccccccccc{d}{d}ddc{i}{i}ii{c}{{i}dddddd}iiiicc{{d}iiiiii}dddd{c}cccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}cccc{{i}dddddd}iiiicc{{d}iiiiii}dddd{c}{d}{d}ddc{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}{{d}iiiiii}ddddc{{i}dddddd}iiiicccccccc{{d}iiiiii}dddd{c}{c}cccccc{d}{d}ddc{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}{{d}iiiiii}ddddc{{i}dddddd}iiiicccccccc{{d}iiiiii}dddd{c}{c}cccccc{d}{d}ddc{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}{c}cccccc{d}{d}ddc{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}{c}cccccc{d}{d}ddc{i}{i}ii{c}{c}cccccc{{i}dddddd}iiii{c}ccccccccc{{d}iiiiii}dddd{c}{c}cccccc

```

Thought all the Ls would make this shorter - nope!

# Answer
> 1 votes
# C (gcc), 726 bytes

```
z;int x[]={25,211,25,211,25,211,25,211,25,211,9,67,13,83,13,195,8,71,10,83,10,199,8,74,7,73,2,72,7,202,7,77,5,73,6,68,5,205,6,81,2,69,1,65,2,66,4,68,2,209,5,87,3,67,2,66,4,214,4,87,6,70,2,216,3,87,4,73,2,217,2,88,5,68,5,219,91,8,226,93,10,222,3,93,9,217,6,93,7,213,9,93,6,208,12,86,2,67,5,205,13,84,4,65,5,205,15,80,2,66,3,65,3,204,11,83,3,66,2,65,1,211,9,85,6,216,6,89,7,217,3,93,8,218,98,7,220,1,100,4,219,2,96,1,67,3,218,3,95,3,65,2,218,4,91,6,220,6,82,1,70,3,65,2,71,1,210,6,79,4,70,4,73,4,207,7,76,6,71,5,71,6,204,8,72,9,73,5,69,9,200,8,69,12,75,2,70,12,197,9,66,14,83,14,194,25,74,1,200,25,74,1,200,25,211,25,211,25,83,0},*y=x;f(){while(*y){for(z=*y&0x3f;z;--z)printf("%c",(*y&0x40)?'L':' ');if(*y++&0x80)printf("\n");}}

```

Try it online!

The compression is a run time encoding. Every byte consists of a number(the bottom 6 bits), a flag if the character is a 'L' or a ' ' (the 6th bit) and a flag for a newline (the 7th bit)

# Answer
> 1 votes
# C (gcc), ~~310~~ 300 bytes

```
y,c,l;main(z){for(;z="ICbCbCbCbCR3=C=3A7:C:7@:79287:?=59645==A251122442A;G33224F9G662H7G492I5H545K2K8o:N3M9I9M7E?M6@EF235=ID415=L@22313<JC32211CDE6H?I7I9M8J3R7L1T4K3P133J5O312J7K6L:B1631271B<?46494?=<67576<?8995598@5<;26<5A2>C>2R:18b:18bCbCbC"[y++];l=!l)for(;z-->48;++c%69||puts(""))printf(L" L"+l);}

```

Try it online!

a simple RLE. newlines inserted every 69 characters. left and right columns removed to combine some `L` runs. add `I` to the end of the data string for nice padding

thanks ceilingcat for -10 bytes

# Answer
> 1 votes
# C (gcc), 473 bytes

```
*y=L"øûøûøûøûøûøûúøû„;úøãô;ûøø{„ûûxšûûÄûûcüûûäûûøøûûôûûƒûøûûüûûúûûúûûôûûû;úûû;ûûû;ôûûûøûû„ûûûüûûøûû{äûäûûãäûÄûûGôûûûˆü{ôû{Hûûøû{äûû„ûûû„ûûûôûûûúûûúûûûøûû;øûûû;øûûüûûûsøûûôûûûCúûûäûûûÄûûû„ûûùÌÛûû„û;øôúûûøÅü{úøÄ;:ø›:øûøëøëøûøûøû";main(i,j,z){for(;*y;puts(""))for(i=9;i--;)for(z=4^*y++,j=8;j--;z/=2)putchar(z&1?76:32);}

```

Try it online!

binary encoding just as a reference,  -\> `0`, `L` -\> `1`. xor'd with 4 so there are no `\0` bytes.

# Answer
> 0 votes
# Retina 0.8.2, ~~313~~ 307 bytes

```

19¶19¶19¶19¶19¶3je19¶7jb19¶10h9c8¶13f9g4¶17c5b1c2e4¶23d3c2e2¶23g6c3¶23e9c3¶24f4f4¶27i9¶29jb5¶29j3¶29h2¶29g¶22c3f¶20e1f1¶16c2d1d2¶19d2c1b5¶21g8¶25h6¶29i4¶34h3¶36e3¶32b3d3¶31d1c4¶27g7¶18b6d1c7¶15e6e9¶12g7f7¶8j9f5¶5jd11c6¶2jf19¶10b8¶10b8¶19¶19¶19
\d+
$*L
T`l`d
\d
$*
%+`^.{1,43}$
 $&
+`(.){34}.(?<-1>.)*
$&$1

```

Try it online! Edit: Saved 4 bytes by encoding the left two thirds instead of the right two thirds. Explanation: Uses run-length encoding. The integers encode runs of up to 34 Ls while the letters `b-j` encode runs of 1-9 spaces with `jb-jf` encoding runs of 10-14 spaces as this saves a byte in the decoder. The first stage simply inserts the encoded data.

```
\d+
$*L

```

Run-length decode the integers to `L`s.

```
T`l`d

```

Transpose the lower case letters to digits in preparation for run-length decoding.

```
\d
$*

```

Run-length decode the digits to spaces (each digit decoded separately).

```
%+`^.{1,43}$
 $&

```

Pad all the lines to 44 characters.

```
+`(.){34}.(?<-1>.)*
$&$1

```

Note down the first 34 characters of each line, then skip a character, then start forgetting the noted characters. Append the first remaining character. Repeat until all lines are 69 characters long. This mirrors the left-hand third of the output to the right.

---
Tags: code-golf, ascii-art, kolmogorov-complexity
---


title: Help, I've mixed my week up!

text:
# Question
Title: Help, I've mixed my week up!
My dog ate my calendar, and now my days are all mixed up. I tried putting it back together, but I keep mixing up the days of the week! I need some help putting my calendar back together, with the days in the correct order.

And since I need my calendar put together as fast as possible, don't waste my time by sending me superfluous bytes. The fewer bytes I have to read, the better!

## Input

The days of the week, in any order. Input can be taken as a list of strings, or a space separated string, or any reasonable way of representing 7 strings (one for each day of the week).

The strings themselves are all capitalized, as weekdays should be, so the exact strings are:

```
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

```

## Output

The days of the week, in sorted order (Monday - Sunday, because of course we adhere to ISO 8601). Output can be as a list of strings, or printed with some delimiter.

## Disclaimer

Note that this is a challenge, with the added benefit of being able to use the input to shorten your code. You are not required to use the input if you don't want to. You are also free to use any approach, from a builtin datetime library to hard-coding the output.

## Examples

To see example input and output, you can consult this python script.

# Answer
# Pyth, 7 bytes

```
o%CN258

```

Try it online!

Convert each string to a number via treating its ASCII codes as a base 256 number, then take that mod 258, and sort. This gives the mapping

```
['Monday', 49]
['Tuesday', 75]
['Wednesday', 89]
['Thursday', 99]
['Friday', 103]
['Saturday', 125]
['Sunday', 211]

```

Same length but less fun is

```
.P1314S

```

The 1314th permutation of the sorted input in lexicographic order.
> 20 votes

# Answer
# JavaScript (Node.js),  ~~37 36~~  35 bytes

*This should also work in Chrome and Edge (Chromium)*

Returns a list of strings.

```
a=>a.sort().sort(_=>-(a=a*595|5)%7)

```

Try it online!

### How?

We first sort the input array in lexicographical order. Whatever the input is, we get:

```
Friday, Monday, Saturday, Sunday, Thursday, Tuesday, Wednesday

```

We then invoke `sort()` a second time with a callback function that, while ignoring its input, generates a sequence of positive and negative values in such a way that the underlying sorting algorithm (insertion sort) is tricked into putting the array in the desired order.

Below is a summary of all steps. Note that because of the bitwise OR, the value stored in \\$a\\$ is always coerced to a signed 32-bit integer (and so are the 3rd and 4th columns in this table).

```
  A  |  B  | previous a  | -(a*595|5)  | mod 7 | new order
-----+-----+-------------+-------------+-------+-----------------------------------
 Fri | Mon |  NaN        | -5          |  -5   | **Mon Fri** Sat Sun Thu Tue Wed
 Mon | Sat |  5          | -2975       |   0   | unchanged
 Fri | Sat |  2975       | -1770125    |   0   | unchanged
 Fri | Sun |  1770125    | -1053224375 |   0   | unchanged
 Sat | Sun |  1053224375 |  396722091  |   3   | unchanged
 Sat | Thu | -396722091  | -173557135  |  -3   | Mon Fri **Thu Sat** Sun Tue Wed
 Fri | Thu |  173557135  | -187280221  |  -2   | Mon **Thu Fri** Sat Sun Tue Wed
 Mon | Thu |  187280221  |  237418201  |   6   | unchanged
 Fri | Tue | -237418201  | -470091173  |  -6   | Mon Thu **Tue Fri** Sat Sun Wed
 Thu | Tue |  470091173  | -531373695  |  -6   | Mon **Tue Thu** Fri Sat Sun Wed
 Mon | Tue |  531373695  |  1660231379 |   2   | unchanged
 Fri | Wed | -1660231379 | -4807575    |  -3   | Mon Tue Thu **Wed Fri** Sat Sun
 Tue | Wed |  4807575    |  1434460171 |   4   | unchanged
 Thu | Wed | -1434460171 | -1194690159 |  -5   | Mon Tue **Wed Thu** Fri Sat Sun

```
> 10 votes

# Answer
# Pyke, 2 bytes

Pyke has some weird constant built-ins (a link to the Stack Exchange API, the lengths of months as numbers, the names of the days of the week and so on).

```
~C

```

Doesn't take input. Try it online!
> 9 votes

# Answer
# APL (Dyalog Unicode) 18.0 beta, 19 bytes

Full program, taking no input.

```
'Dddd'(1200⌶)⍳7

```

Returns a list of strings:

```
┌──────┬───────┬─────────┬────────┬──────┬────────┬──────┐
│Monday│Tuesday│Wednesday│Thursday│Friday│Saturday│Sunday│
└──────┴───────┴─────────┴────────┴──────┴────────┴──────┘

```

`⍳7` Integers 1…7, representing the dates Jan 1–7, 1900

`(1200⌶)`Format Date-time ("12:00") as follows:

`'Dddd'` long **D**ay name
> 7 votes

# Answer
## JavaScript, 37 characters

```
e=>[...'1564023'].map(a=>e.sort()[a])

```

## JavaScript, 38 characters

```
e=>[1,5,6,4,0,2,3].map(a=>e.sort()[a])

```

## Javascript, 39 characters

```
e=>e.map((a,i)=>e.sort()['1564023'[i]])

```

## Javascript, 45 characters

```
e=>e.map((a,i)=>e.sort()[[1,5,6,4,0,2,3][i]])

```

## Javascript, 51 characters

```
e=>(v=e.sort(),v.map((a,i)=>v[[1,5,6,4,0,2,3][i]]))

```

## Javascript, 52 characters

```
e=>(v=e.sort(),[v[1],v[5],v[6],v[4],v[0],v[2],v[3]])

```

## Javascript, 61 characters

I tried a couple of things, but they were fractionally longer than:

```
z=>'Monday Tuesday Wednesday Thursday Friday Saturday Sunday'

```
> 7 votes

# Answer
# Python 3, ~~40~~ 38 bytes

*-2 bytes thanks to xnor*

```
from calendar import*;print(*day_name)

```

Try it online!

---

# Python 2, ~~44~~ 43 bytes

```
lambda d:sorted(d,key=lambda x:~hash(x)%72)

```

Try it online!
> 7 votes

# Answer
# APL (Dyalog Unicode), 21 bytes

Anonymous prefix lambda. Port of isaacg's Pyth solution — go upvote that!

```
{⍵[⍋258|256⊥¨⎕UCS¨⍵]}

```

Try it online!

`{``}` "dfn"; argument is :

`⍵[``]` reorder the argument into the following order:

`⎕UCS¨⍵` Universal Character Set code points of each string

`256⊥¨` evaluate each in base-256

`258|` the division remainder when divided by 258

grade (permutation that would sort it)
> 6 votes

# Answer
# Java (JDK), 27 bytes

```
java.time.DayOfWeek::values

```

Try it online!

Doing this because the challenge input is very structured, but the output is not structured at all.

# No built-ins, 49 bytes

```
l->l.sort((a,b)->~a[0]*a[4]%-473-~b[0]*b[4]%-473)

```

Try it online!
> 6 votes

# Answer
# Wolfram Language (Mathematica), 27 bytes

```
DayName@{#}&/@198~Range~204

```

Try it online!
> 5 votes

# Answer
# 05AB1E, 6 bytes

Port of isaacg's base conversion answer.

```
Σ₁ö29%

```

Try it online!

## Explanation

```
Σ      Filter the input by this function:
 ₁ö    Base-convert it from 256
   ₁   Constant 256
    Ì  Add 2 (= 258)
     % Modulo by this number

```

# 05AB1E, 6 bytes

-1 byte thanks to Expired Data

```
{œŽ5dè

```

Try it online!

# 05AB1E, 21 bytes

```
Σ"TuWeThFrSaSu"2ôåāsÏ

```

Try it online!

## Explanation

```
Σ                     Sort by the output of this function.
 "TuWeThFrSaSu"2ô     Split every item of that by length of 2.
                 å    Contains?
                  āsÏ Find all truthy indices of that.

```
> 5 votes

# Answer
# APL (Dyalog Unicode), 35 bytes

Anonymous prefix lambda. This one actually sorts its argument and doesn't use any "cheating" built-ins.

```
{⍵[⍋((∊∘⎕A⊂⊢)'MoTuWeThFrSa')⍳2↑¨⍵]}

```

Try it online!

`{``}` "dfn"; argument is :

`⍵[``]` reorder the argument into the following order:

`2↑¨` take the first two letters from each input day name

`(``)⍳` find the index in the following list (missing items become 1 beyond last index)

`(``)'MoTuWeThFrSa'` apply the following tacit function to this string:

the argument

split on

`∊∘⎕A` membership of the uppercase **A**lphabet

grade (permutation that would sort it)
> 5 votes

# Answer
# C (gcc) `-m32`, 50 bytes

```
main(i){for(;puts(nl_langinfo(131079+i%7))-i++;);}

```

Try it online!

## Explanation

Simply put, `nl_langinfo()` is a useful function which returns a particular string given an argument. It just turns out that the argument to pass for obtaining weekday names is `131079 ... 131086`. One other thing is that we must add the flag `-m32`, which is explained nicely in this answer.
> 5 votes

# Answer
# Python 2, ~~45~~ 43 bytes

*-2 bytes thanks to @xnor!*

```
lambda l:map(sorted(l).pop,[1,4,4,3,0,0,0])

```

Try it online!

Sort by normal string comparison first, then look up the correct permutation.

---

# Python 3, 58 bytes

```
lambda l:sorted(l,key=lambda s:"TuWeThFrSaSu".find(s[:2]))

```

Try it online!

Use the first 2 letters of each day to look up the order.
> 4 votes

# Answer
# Factor, 20 bytes

```
day-names 1 rotate .

```

Try it online!

Factor has a built-in sequence for the days of the week, but is starts with Sunday - that's why I need to rotate the items to the right.
> 4 votes

# Answer
# , 30 bytes

Assuming an English locale

```
weekdays(as.Date("1/1/1")+0:6)

```

Try it online!

January 1st of the year 1 is a Monday (according to R).
> 4 votes

# Answer
# T-SQL, 49 bytes

```
SELECT DATENAME(w,RANK()OVER(ORDER BY d)-1)FROM t

```

Input is taken as a pre-existing table *t* with varchar column *d*, per our IO standards.

My code doesn't actually *use* the values in the input table in any way, so the input order doesn't matter (nor do the actual strings, they just have to be distinct). Instead, it uses the fact that it has 7 rows, along with the `RANK()` function, to generate the numbers 1 through 7.

After subtracting 1, these numbers are implicitly cast as dates (0=Mon Jan 1, 0001, 6=Sun Jan 7, 0001), and the `DATENAME` function returns the corresponding day of the week.
> 4 votes

# Answer
# MathGolf, 8 bytes

```
á{$ûÞ♠$%

```

Try it online!

## Explanation

```
á{         sort by the output given from a code block
  $        convert to ordinal (base 256)
   ûÞ♠     push "Þ♠"
      $    convert to ordinal (gives 1791)
       %   modulo

```

I had the exact same idea as isaacg's Pyth answer, but in MathGolf I had to use another modulo. I tried every number up to 1000000, and noticed that the ordinal strings for each weekday ended up in the correct order for sorting when taking them modulo 1791.
> 3 votes

# Answer
# Kotlin , 58 bytes

```
DayOfWeek.values().map{it.name.toLowerCase().capitalize()}

```
> 3 votes

# Answer
# C (gcc), ~~72~~ 70 bytes

Saved 2 bytes thanks to gastropner!!!

```
f(){puts("Monday Tuesday Wednesday Thursday Friday Saturday Sunday");}

```

Try it online!

Just prints the days of the week.
Unfortunately this is shorter than sorting the input! T\_T

# C (gcc) Little Endian Byte Order, ~~123~~ \\$\cdots\\$ ~~99~~ 85 bytes

```
h,s;c(int**a,int**b){h=(h=**a%274%79)>(s=**b%274%79)-(h<s);}f(int*s){qsort(s,7,8,c);}

```

Try it online!

Function `f` takes a list of strings as input and sorts it.

**How**

Reads the first four characters as a 32-bit `int`, \\$i\\$, and then calculates \\$((i\mod{274})\mod{79})\\$:

```
Monday -> 5
Tuesday -> 7
Wednesday -> 11
Thursday -> 23
Friday -> 47
Saturday -> 59
Sunday -> 61

```

Then uses `qsort` to sort the array.
> 3 votes

# Answer
# Perl 5, ~~33~~ 29 bytes

```
print+(sort<>)[1,5,6,4,0,2,3]

```

Try it online! Just another sort/permute answer. Edit: Saved 4 bytes thanks to @Xcali.
> 3 votes

# Answer
# PHP, 39 bytes

```
for(;$i<7;)echo" ".jddayofweek($i++,1);

```

Try it online!

Works in Windows but not in TIO, gotta find how to activate the extension.. takes no input.

We could save 4 bytes with an empty delimiter (which is "some delimiter" the question doesn't say a **non-empty** delimiter) but I'm not that nasty..

EDIT: version that works universally for 1 byte more

# PHP, 40 bytes

```
for(;$i<7;)echo date("l ",1e6+$i++*8e4);

```

Try it online!
> 3 votes

# Answer
## Powershell, 23 bytes

```
1..6+0|%{[DayOfWeek]$_}

```

Convert integers to weekday, but bump array by one because .net prefers Sundays.

## 37 bytes sorting

```
($args|%{[DayOfWeek]$_}|sort)[1..6+0]

```

input is string list to args.
> 3 votes

# Answer
# Keg, 15 bytes

```
“jnsDt[rƳm⑺dQ7⅍

```

Try it online!

You'd think this was some sort of fancy sorting algorithm, but no. It's simply a compressed string.
> 2 votes

# Answer
# Bash \+ Unix utilities, 29 bytes

```
jot "-wdate +%%A -d7-1-" 7|sh

```

Try it online!
> 2 votes

# Answer
# Red, 24 bytes

```
print system/locale/days

```

Try it online!
> 2 votes

# Answer
# , 10 bytes

```
1314 A./:~

```

Try it online!

Port of isaacg's alternative Pyth solution — please upvote him!
> 2 votes

# Answer
# Retina, 40 bytes

```
^
MTuWThFSaSu
,6L$s`(.+)(?=.*(\1\w+))
$2

```

Try it online! Link shuffles input in header. Explanation:

```
^
MTuWThFSaSu

```

Insert unique day name abbreviations.

```
,6L$s`(.+)(?=.*(\1\w+))
$2

```

Find the first seven duplicate substrings, and output the word containing the duplicate, thus unabbreviating the names.
> 2 votes

# Answer
# Charcoal, ~~29~~ 25 bytes

```
≔Ｅ⁷ＳθＷ⁻θυ⊞υ⌊ιＥ1564023§υＩι

```

Try it online! Link is to verbose version of code. Explanation:

```
≔Ｅ⁷Ｓθ

```

Input the seven days.

```
Ｗ⁻θυ⊞υ⌊ι

```

Sort the days lexicographically.

```
Ｅ1564023§υＩι

```

Apply the permutation to the array.
> 2 votes

# Answer
# MATL, 4 bytes

```
23Y2

```

Built-in ¯\\\_(ツ)\_/¯. Takes no input.

Try it online!
> 2 votes

# Answer
# Retina 0.8.2, ~~32~~ ~~29~~ ~~27~~ 26 bytes

```
Tu
13
T`MWT`E
O`
T`d`MTWuT

```

Try it online!

**Approach**: ~~Replace the first letter of the days with `A`, `B`, `C`, etc. so we can sort them lexicographically.~~ Replace the `M` in Monday with a `0`, the `T` in Tuesday with a `1`, the `W` in Wednesday with a `2`, and the `T` in Thursday with `4`. To help golf off a byte, also replace the `u` in Tuesday with `3`

```
Tu
13
T`MWT`E

```

Perform the replacements described above (The `E` inserts even numbers `02468`)

```
O`

```

Sort lexicographically. At this point, our list of words looks like this:

```
0onday
13esday
2ednesday
4hursday
Friday
Saturday
Sunday

```

Notice that Friday, Saturday, and Sunday are already conveniently in alphabetical order.

```
T`d`MTWuT

```

Undo the transformations we performed above (The `d` inserts the range `0-9`)
> 2 votes

# Answer
# Japt, 8 bytes

```
n á g#4

```

Try it here
> 2 votes

# Answer
# Python 3, ~~64~~ ~~62~~ 59 chars

Takes input as a list of strings, sorts it inplace:

```
lambda l:l.sort(key=lambda x:'uehrau'.find(x[1],x[0]=='S'))

```

Try it: https://ideone.com/rYxtff
> 2 votes

# Answer
# R (English locale), 36 bytes

```
weekdays(.leap.seconds[c(8:12,6:7)])

```

Not quite as short as the other answer, but I posted it because it makes use of one of the strangest objects kicking around in base R — a list of all the leap seconds. It so happens that leap seconds frequently occur in increasing sequences of days so we only have to take two "chunks" from the list.

Luckily, the leap seconds object has the oldest leap second first, so I don't have to qualify this program with "will only work for the next 2–3 years"!

TIO link here.
> 2 votes

# Answer
**Python**

Input: Space separated strings

Once the input is sorted then the output should be ordered using indices \[1, 5, 6, 4, 0, 2, 3\] of the sorted array

```
inp=sorted(input().split())
for i in [1, 5, 6, 4, 0, 2, 3]:
  print(inp[i])

```

Try it here
> 1 votes

# Answer
# Deadfish~, 464 bytes

```
{{i}dd}dddc{i}{i}{i}iiiicdc{d}cdddc{i}{i}iiiic{{d}}{d}dc{{i}ddd}iiiic{i}{i}{i}iiic{d}ddddddc{i}iiiic{d}dddddcdddc{i}{i}iiiic{{d}}{d}dc{{i}dd}dddc{i}iiiicdc{i}c{d}ic{i}iiiic{d}dddddcdddc{i}{i}iiiic{{d}}{d}dc{{i}ddd}iiiic{i}{i}c{i}iiicdddcic{d}dddddcdddc{i}{i}iiiic{{d}}{d}dc{{i}dddd}c{{i}dddddd}iiiic{d}icdddddcdddc{i}{i}iiiic{{d}}{d}dc{{i}ddd}iiic{i}iiiic{i}{i}dcicdddc{d}ddddcdddc{i}{i}iiiic{{d}}{d}dc{{i}ddd}iiic{i}{i}{i}iiiic{d}iiic{d}cdddc{i}{i}iiiic{{d}}{d}dc

```

Try it online!

Deadfish - the worst compression algorithm.
> 1 votes

---
Tags: code-golf, string, kolmogorov-complexity, date, sorting
---


title: Print this maximally long URL

text:
# Question
Title: Print this maximally long URL
## Task

This one is simple. We want to compress a URL, but don't trust URL shorteners.

Write a program that prints to stdout (or a 0-argument function that returns) the following, working URL:

http://a.b.c.d.e.f.g.h.i.j.k.l.m.n.oo.pp.qqq.rrrr.ssssss.tttttttt.uuuuuuuuuuu.vvvvvvvvvvvvvvv.wwwwwwwwwwwwwwwwwwwwww.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy.zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.me

Code golf, standard rules.

You may output uppercase or lowercase.

Leading or trailing whitespace is ok.

## Context

Explanation taken from the website:

> The domain is created to reach the maximum number of allowed characters (255 (really 253)) with an exponential curve in the length of the letters as you proceed through the alphabet. The formula used is "1 + 62 * (10/7)^(x-26)". To help illustrate this curve, reference the distribution on this spreadsheet. It's colorful because I like colors and wanted to do a progressive "rainbow" animation in CSS3.

# Answer
# 05AB1E, ~~25~~ ~~24~~ ~~23~~ 21 bytes

```
žXAS.7Ƶ-t∞-m>×….me¬ýJ

```

-1 byte thanks to *@Neil*'s analysis that `*(10/7)**` is the same as `/.7**`.
-3 bytes thanks to *@Grimmy* using a different formula and ingenious use of `ý`!

Try it online.

**Explanation:**

The formula used to get the correct amount of characters of the alphabet, where \\$n\\$ is the 1-based index of the alphabetic letter:
\\$a(n) = \left\lfloor0.7^{(\sqrt{208}-n)}+1\right\rfloor\\$

```
žX                     # Push builtin "http://"
      Ƶ-               # Push compressed 208
        t              # Take the square-root of that: 14.422...
         ∞             # Push an infinite list of positive integers: [1,2,3,...]
          -            # Subtract each from the 14.422...: [13.442...,12.442...,...]
    .7     m           # Take 0.7 to the power of each of these: [0.008...,0.011...,...]
            >          # Increase each by 1: [1.008...,1.011...,...]
  AS                   # Push the lowercase alphabet as list of characters,
             ×         # and repeat each the calculated values amount of times as string
                       # (which implicitly truncates the floats to integers, and ignores
                       #  the floats beyond the length of the alphabet)
              ….me     # Push ".me"
                  ¬    # Push its head (the "."), without popping the ".me" itself
                   ý   # Join with delimiter. Normally it will use the top value as
                       # delimiter and joins the top-1'th list. In this case however, the
                       # top-1'th item is a string, so instead it will join the entire stack
                       # together. BUT, because the stack contains a list, it will instead
                       # only join all lists on the stacks by the "." delimiter
                    J  # And finally join the three strings on the stack together
                       # (after which this result is output implicitly)

```

See this 05AB1E tip of mine (section *How to compress large integers?*) to understand why `Ƶ-` is `208`.
> 6 votes

# Answer
# Python 3, <sup>~~86~~ \\$\cdots\\$ ~~81~~</sup> 77 bytes

Saved 3 bytes thanks to mypetlion!!!
Saved 4 bytes thanks to Shieru Asakoto!!!

```
print(f"http://{'.'.join(chr(i+97)*int(1+.7**-i/120)for i in range(26))}.me")

```

Try it online!

Uses Shieru Asakoto's 0-based formula.
> 6 votes

# Answer
# APL (Dyalog), ~~41~~ 38 bytes

*-3 bytes thanks to Bubbler*

```
2⌽'mehttp://',∊'.',¨⍨⎕A⍴¨⍨⌊1+62×.7*⍒⎕A

```

Try it online!

Outputs the URL with the letters capitalised. Uses the 0 indexed formula \\$ \lfloor 1 + 62 \times 0.7^{25-x} \rfloor \\$, since \\$ (\frac{10}{7})^{x-25} = ((\frac{7}{10})^{-1})^{x-25} = (\frac{7}{10})^{25-x}\\$

### Explanation:

```
2⌽                         ⍝ Rotate by two places (moving the 'me' to the end)
  'mehttp://'              ⍝ The start string
             ,             ⍝ Followed by
              ∊               ⍝ The flattened string of
               '.'            ⍝ A period
                  ,⍨¨         ⍝ Appended to the end of each of
                     ⎕A            ⍝ The uppercase alphabet
                       ⍴¨⍨         ⍝ Where each letter is repeated by
                          ⌊               ⍝ The floor of
                           1+             ⍝ 1 plus
                             62×          ⍝ 62 times
                                .7*       ⍝ 0.7 to the power of
                                   ⍒⎕A  ⍝ The range 26 to 1

```
> 6 votes

# Answer
# Perl 5, ~~61~~ ~~57~~ 55 bytes

*-4 bytes thanks to @Neil*

```
say"http://",(map{$_ x(1+62/.7**(++$p-26))."."}a..z),me

```

Try it online!
> 4 votes

# Answer
# JavaScript (Node.js), 77 bytes

Based on @ShieruAsakoto's formula. Builds the URL recursively.

```
f=n=>n>25?".me":(n?".".padEnd(2+.7**-n/120,Buffer([97+n])):"http://a")+f(-~n)

```

Try it online!
> 4 votes

# Answer
# Java (JDK), 108 bytes

```
v->{var s="HTTP://";for(char c=64,t;++c<91;s+=(""+c).repeat(t/=Math.pow(.7,c-90))+c+".")t=62;return s+"ME";}

```

Try it online!

## Credits

* -4 bytes thanks to Kevin Cruijssen
> 4 votes

# Answer
# Charcoal, 27 bytes

```
http://⭆β⁺×ι⊕×⁶²Ｘ·⁷⁻²⁵κ.¦me

```

Try it online! Link is to verbose version of code. Explanation:

```
http://                     Implicitly print literal string `http://`
        β                   Lowercase alphabet
       ⭆                    Map over letters and join
                      κ     Current index
                   ⁻²⁵      Subtract from 25
                Ｘ·⁷         Raise 0.7 to that power
             ×⁶²            Multiply by 62
            ⊕               Increment
          ×ι                Repeat letter that many times
         ⁺             .    Concatenate literal string `.`
                        ¦   Implicitly print
                         me Implicitly print literal string `me`

```
> 3 votes

# Answer
# Jelly, ~~49~~ ~~48~~ ~~46~~ 31 bytes (send help)

A niladic link printing the URL

```
26RU.7*×89ĊØa×⁾meṭj”.“http://”;

```

-2 bytes thanks to Kevin

-15 bytes thanks to Nick!

I never wrote anything this complex in Jelly and the *tacicity* isn't obvious to me yet... So this is very golfable (see 49 byte link). I would appreciate feedback and golfing tips in small chunks so that I can digest it!

You can try this online.
> 3 votes

# Answer
# Wolfram Language (Mathematica), 71 bytes

```
"http://"<>Array[Table[Alphabet[][[#]],1+1.43^(#-26)62]<>"."&,26]<>"me"

```

Try it online!
> 2 votes

# Answer
# C (gcc), 99 bytes

```
n;f(i){for(i=printf("http://");i<33;)for(n=62/pow(.7,i++-32)+2;n--;)putchar(n?89+i:46);puts("me");}

```

*-3 or so bytes thanks to Noodle9!*

*-8 bytes thanks to gastropner!*

Try it online!
> 2 votes

# Answer
# JavaScript (Node.js), 93 bytes

```
_=>`http://${[...Array(26)].map((x,i)=>Buffer(Array(1+.7**-i/120|0).fill(97+i))).join`.`}.me`

```

Try it online!

When turning the formula into 0-indexed, the formula becomes \\$1+62\times(\frac{10}{7})^{x-25}=1+0.0083146\times0.7^{-x}\\$, and then 0.0083146 is approximated by 1/120.
> 2 votes

# Answer
# Japt, 29 bytes

```
;`http://{C®p.7**T´/#xÄ +'.}´

```

Saved 2 bytes thanks to @Shaggy

Test it
> 2 votes

# Answer
# , ~~124~~ ~~115~~ 63 bytes

This is way better than my original approach. Thanks to @Giuseppe and @Grimmy

```
cat("http://");cat(strrep(letters,1+62*.7^(25:0)),"me",sep=".")

```

Try it online!
> 2 votes

# Answer
# Haskell, 86 bytes

```
g(c,x)=replicate(floor$1+62*1.43**x)c++"."
f="http://"++(zip['a'..][-25..0]>>=g)++"me"

```

Try it online!
> 2 votes

# Answer
# C++ (gcc), ~~126~~ 123 bytes

-3 bytes thanks to S.S. Anne

Some acrobatics needed to avoid having to include `cmath`.

```
#import<map>
using s=std::string;s f(){s r="http://";for(float i=26,p=7456;i--;p*=.7)r+=s(1+62/p,122-i)+'.';return r+"me";}

```

Try it online!
> 1 votes

# Answer
# Keg, ~~46~~ 40 bytes

```
`3);://`0&(‡26   |⑻a+ⁿ⅍7
/⑻±Ëx/ℤ1+⑹*\.)`me

```

Try it online!

A port of the Python 3 answer by Noodle9.

*-6 bytes due to using string compression and some other things*
> 1 votes

# Answer
# PHP, 94 bytes

```
for($c='a',$s='http://',$i=-26;$i++;$c++,$s.='.')for($l=62/.7**$i;$l-->=0;$s.=$c);echo$s.'me';

```

Try it online!

Probably still golfable, uses the formula from the question and PHP's char incrementing

EDIT: saved 3 bytes with code reorganization

EDIT2: another byte less starting from `-26` and removing `($i-26)`
> 1 votes

# Answer
# Ruby, 64 bytes

Conveniently, when multiplying a string with a non-whole positive number, Ruby truncates the number to determine how many times to repeat the string.

```
puts"http://#{(?a..?z).map{|c|c*(1+62/0.7**(c.ord-122))}*?.}.me"

```

Try it online!
> 1 votes

# Answer
# MATLAB 92 bytes

```
b="";for i=1:26;b=b+repelem(char(96+i),floor(1+62*(10/7).^(i-26)))+".";end;"http://"+b+"me"

```
> 1 votes

# Answer
# Deadfish~, 809 bytes

```
{i}cc{{i}d}iiiic{i}iiccddddc{{d}iiiii}ddddc{d}dcc{{i}ddddd}c{{d}iiiii}dc{{i}ddddd}iic{{d}iiiii}ddc{{i}ddddd}iiic{{d}iiiii}dddc{{i}ddddd}iiiic{{d}iiiii}ddddc{{i}ddddd}iiiiic{{d}iiiii}dddddc{{i}ddddd}iiiiiic{{d}iiiii}ddddddc{{i}dddd}dddc{{d}iiii}iiic{{i}dddd}ddc{{d}iiii}iic{{i}dddd}dc{{d}iiii}ic{{i}dddd}c{{d}iiii}c{{i}dddd}ic{{d}iiii}dc{{i}dddd}iic{{d}iiii}ddc{{i}dddd}iiic{{d}iiii}dddc{{i}dddd}iiiic{{d}iiii}ddddc{{i}dddd}iiiiicc{{d}iiii}dddddc{{i}dddd}iiiiiicc{{d}iiii}ddddddc{{i}ddd}dddccc{{d}iii}iiic{{i}ddd}ddcccc{{d}iii}iic{{i}ddd}dcccccc{{d}iii}ic{{i}ddd}cccccccc{{d}iii}c{{i}ddd}i{c}c{{d}iii}dc{{i}ddd}ii{c}ccccc{{d}iii}ddc{{i}ddd}iii{c}{c}cc{{d}iii}dddc{{i}ddd}iiii{c}{c}{c}c{{d}iii}ddddc{{i}ddd}iiiii{c}{c}{c}{c}cccc{{d}iii}dddddc{{i}ddd}iiiiii{c}{c}{c}{c}{c}{c}ccc{{d}iii}ddddddc{{i}dddd}iiic{d}iic

```

Try it online!

E.
> 0 votes

---
Tags: code-golf, string, kolmogorov-complexity
---


# Question
Title: Find the number of ways to choose `n` objects from `r` objects with repetition so that every object has a matching neighbour
For example, if `n` is 5 and `r` is 2, it would mean the number of lists below:

```
[1,1,1,1,1]
[1,1,1,2,2]
[1,1,2,2,2]
[2,2,1,1,1]
[2,2,2,1,1]
[2,2,2,2,2]

```

which is **6**.

If `n` is 4 and `r` is 3:

```
[1,1,1,1]
[1,1,2,2]
[1,1,3,3]
[2,2,1,1]
...
[3,3,3,3]

```

which is **9**.

where each item has a neighbour whose value is the same.

For example, `[1,2,1,1,2]` is not counted, because both `2` are alone.

# Goal

Your task is to write a program/function which takes two inputs in any order, and which produces the required output.

# Detail

You can assume that `r≥2`.

# Scoring

This is . Shortest solution in bytes wins.

# Bonus

Multiply your score by **0.3** if the complexity of your program is below O(e^n).

For example, 10 bytes becomes 3 bytes.

# Testcases

Can be generated from this Pyth test suite.

Usage: two lines per testcase, `n` on top, `r` below.

```
n r output
2 5 5
4 4 16
6 3 33
8 2 26

```

# Additional information

When `r=2`: OEIS A006355.

# Answer
# Pyth, 14 bytes * 0.3 = 4.2 bytes

```
*Quh*~+ZGtQtE0

```

Try it online: Demonstration. Input `r` on the first line and `n` on the second line.

Complexity is `O(n)`.

### Explanation:

Let `f(n, r)` be the number of ways to create such a list with the last number being `0`. Obviously it doesn't matter if we take `0` or any other number.

It's easy to see, that the following recursion holds:

```
f(n, r) = 0                                  ... if n < 2
f(n, r) = sum(f(i, r), i <= n-2) * (r-1) + 1 ... otherwise

```

If `n == 0`, than the list cannot end with the number `0`. If `n == 1`, than the only number in the list has no neighbor. Therefore both cases have the value zero.

If `n >= 2`, than it could end in 2, 3, ... n zeros. The digit before the last zero can be any of the number 1, 2, ..., r-1. These are `r-1` possibilities. Therefore I'll add up all `f(i,n)` and multiply by `r-1`. At the end I'll have to add 1 (for the case that all digits are zeros).

The result to the question than is: `r * f(n, r)`, since the list can end in any of the `r` numbers.

In my code I make use of the predefined variable `Z = 0`. It will contain the last computed sum so far.

```
*Quh*~+ZGtQtE0   implicit: Q = first input number (r)
  u        tE0   start with G=0, do the following input-1 (n-1) times:
     ~+ZG           add G to Z
   h*~ Z tQ         and update G to the value Z*(Q-1) + 1
                    (using the old value of Z)
*Q               multiply the result with Q

```
> 3 votes

# Answer
## JavaScript (ES6), 64 (70 * 0.3 = 21) bytes

```
(n,r)=>[...Array(n)].map((m,i,a)=>a[i+2]=(s=s+m|0)*~-r+r).slice(-2)[0]

```

Now runs in linear time!
> 1 votes

# Answer
# Haskell, 16.5 (55 bytes)

```
r#n=l!!(n-1)where l=0:r:r:w l;w(x:y:s)=r*(x+y)-x:w(y:s)

```

It uses this recursive definition:

```
f(n,r) = r*f(n-2,r) + (r-1)*f(n-3,r)

```

and uses `O(n)` time. Usage: evaluate `r#n`
> 1 votes

# Answer
# Jelly, 8 bytes

```
ṗŒɠ€’Ạ€S

```

Try it online!

## How it works

```
ṗŒɠ€’Ạ€S - Main link. Takes r on the left and n on the right
ṗ        - n'th Cartesian power of [1,2,3,...,n]
   €     - Over each:
 Œɠ      -   Lengths of adjacent elements
    ’    - Decrement, mapping 1 to 0 and everything else to a positive integer
      €  - Over each:
     Ạ   -   All non-zero?
       S - Sum, counting the 1s

```
> 0 votes

# Answer
# Husk, 6 bytes

```
#oΛtgπ

```

Try it online!

## Explanation

```
#oΛtgπ
     π cartesian power n of range 1..r
#o     number of lists which satisfy
    g   adjacent elements grouped
  Λ     all the groups
   t    are non empty when popped from

```
> 0 votes

---
Tags: code-golf, combinatorics
---


title: Bake me a slice of cake

text:
# Question
Title: Bake me a slice of cake
My birthday is in a month, and this is a slice of tasty cake.

```
    .-""-.
 .-"      "-.
|""--..      "-.
|      ""--..   "-.
|""--..      ""--..\
|      ""--..      |
|            ""--..|
 ""--..            |
       ""--..      |
             ""--..|

```

In the fewest number of bytes, construct this slice of cake for me. You can print it to STDOUT or return it as a function result.

Any amount of extraneous whitespace is acceptable, so long as the characters line up appropriately.

### Rules and I/O

# Answer
# Eggsembly - 203 bytes

```
push '    .-""-.\n .-"      "-.\n|""--..      "-.\n|      ""--..   "-.\n|""--..      ""--..|\n|      ""--..      |\n|            ""--..|\n ""--..            |\n       ""--..      |\n             ""--..|'

```

Here is a less golfed version.

```
push '    .-""-.\n'
push ' .-"      "-.\n'
add
push '|""--..      "-.\n'
add
push '|      ""--..   "-.\n'
add
push '|""--..      ""--..\\n'
add
push '|      ""--..      |\n'
add
push '|            ""--..|\n'
add
push ' ""--..            |\n'
add
push '       ""--..      |\n'
add
push '             ""--..|\n'
add

```

---

This one works a bit differently, but it's significantly shorter in Chicken at 57,878 bytes.

```
push " "
push 4
rooster
push '.-""-.\n'
add
push ' .-"'
push " "
push 6
rooster
add
push '"-.\n'
add
push '|""--..'
push " "
push 6
rooster
add
push '"-.\n|'
add
push " "
push 6
rooster
add
push '""--..   "-.\n'
add
push '|""--..'
push " "
push 6
rooster
add
push '""--..\\n'
add
push '|'
push " "
push 6
rooster
add
push '""--..      |\n'
add
push '|'
push " "
push 12
rooster
add
push '""--..|\n'
add
push ' ""--..'
push " "
push 12
rooster
add
push '|\n'
add
push " "
push 7
rooster
add
push '""--..'
push " "
push 6
rooster
add
push '|\n'
add
push " "
push 13
rooster
add
push '""--..|\n'
add
add
add
add
add
add
add
add

```

---

# Chicken - ~~57,878~~ 28,135 bytes

```
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken

chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken
chicken chicken

```

So what was changed here is a little more understandable, here's the Eggsembly version.

```
push " "
push 4
rooster
push 4
peck
pick 4
axe
push '.-""-.\n'
add
push ' .-"'
pick 4
axe
push " "
push 2
rooster
add
push 6
peck
pick 6
axe
add
push '"-.\n'
add
push '|'
push '""--..'
push 2
peck
pick 2
axe
add
add
pick 6
axe
add
push '"-.\n'
add
push '|'
add
pick 6
axe
add
pick 2
axe
add
push " "
push 3
rooster
add
push '"-.\n'
add
push '|'
add
pick 2
axe
add
pick 6
axe
add
pick 2
axe
add
push '\\n'
add
push '|'
add
pick 6
axe
add
pick 2
axe
add
pick 6
axe
add
push '|\n'
add
push '|'
add
pick 6
axe
pick 6
axe
add
push 3
peck
pick 3
axe
add
pick 2
axe
add
push '|\n'
add
push " "
add
pick 2
axe
add
pick 3
axe
add
push '|\n'
add
pick 6
axe
push " "
add
add
pick 2
axe
add
pick 6
axe
add
push '|\n'
add
pick 3
axe
add
push " "
add
pick 2
axe
add
push '|\n'
add
add

```
> 13 votes

# Answer
# JavaScript (ES8), ~~115~~ 112 bytes

*Saved 3 bytes thanks to @ovs*

```
_=>`4.-""-.
1.-"6"-.
|06"-.
|603"-.
|060\\
|606|
|660|
1066|
706|
670|`.replace(/\d/g,n=>''.padEnd(n)||'""--..')

```

Try it online!
> 7 votes

# Answer
# Canvas, ~~77~~ ~~65~~ ~~58~~ ~~54~~ ~~44~~ ~~43~~ ~~42~~ ~~40~~ 39 bytes

```
"-.＊＼＼＼
２⁸±４⁸＋３⁸２１＊⌐∔１３╋５|＊×ω\；∔Ａ«３╋０３╋

```

Try it here!

Explanation:

```
"-.*\\\  Helper function F taking an argument n
"-.*     an array of n strings `"-.`
    \\\  pad each line with 1 more space than the previous, 3 times
Main program:
2⁸                          execute F with 2
  ±                         reverse that
   4⁸+                      and append F(4) - the top of the cake

3⁸                          F(3)
  21*                       extend horizontally 2x and vertically 1x - create one stripe
     ⌐                      create extra 2 copies of that on the stack
      ∔                     append 2 of those together
       13╋                  and insert it at (1; 3) in the last line
          5|*               array of 5 "|"
             ×              prepend that to the left of the stripes
              ω             retrieve back the array of "|"
               \；∔         prepend "\" to that
                   A«3╋     and insert that at ((10<<1); 3) in the object
                       03╋  and join the two parts together

```
> 6 votes

# Answer
# Charcoal, 40 bytes

```
Ｆ³«↑Ｆι⸿↑Ｆ³¶""--..»↑⁵←\Ｆ⁴←¶.-"Ｆ²«←"-.↓»↓⁵

```

Try it online! Link is to verbose version of code. Explanation:

```
Ｆ³«

```

Loop over the three horizontal lines.

```
↑Ｆι⸿↑

```

The lines overlap by an amount depending on which line we're on. This calculates the correct amount of overlap but also moves the cursor to the left of the canvas again.

```
Ｆ³¶""--..»

```

Repeat three times, move the cursor down one line and then print a third of the horizontal line.

```
↑⁵←\

```

Print the vertical line on the right and the backslash on the corner.

```
Ｆ⁴←¶.-"

```

Repeat four times, move the cursor up one line and then print a quarter of the diagonal.

```
Ｆ²«←"-.↓»

```

Print the other diagonal. (I couldn't find a way of combining the printing with the movement but this is still 2 bytes shorter than the next best way I could find.)

```
↓⁵

```

Print the vertical line on the left.
> 5 votes

# Answer
# T-SQL, ~~125~~ 121 bytes

```
PRINT REPLACE(REPLACE('    .-""-.
 .-"1"-.
|21"-.
|12   "-.
|212\
|121|
|112|
 211|
 121|
 112|',2,'""--..'),1,'      ')

```

Due to the overhead of the `REPLACE()` keyword, just two replacements gave me the best score. SQL allows line breaks inside of strings, so I don't have to replace those with `CHAR(13)` or whatever.

Hard to tell in the code above, but I had to add an extra space after the `\`, because normally that would be an escape character that would cause it to ignore the subsequent line break.

**EDIT**: Saved 4 bytes by changing my replacement characters to numerals instead of letters. This lets me eliminate the single quotes since `REPLACE` casts them to strings implicitly.

This generates:

```
    .-""-.
 .-"      "-.
|""--..      "-.
|      ""--..   "-.
|""--..      ""--..\
|      ""--..      |
|            ""--..|
 ""--..            |
       ""--..      |
             ""--..|

```

Happy birthday (next month)!
> 4 votes

# Answer
# Python 2, 99 bytes

```
00000000: 2363 6f64 696e 673a 4c31 0a70 7269 6e74  #coding:L1.print
00000010: 2278 da53 5050 50d0 d355 52d2 d5e3 02d1  "x.SPPP..UR.....
00000020: 5c6e 605c 30e2 d55c 30c5 74f5 f490 04a0  \n`\0..\0.t.....
00000030: 4c98 30a6 5c22 303b 0643 2110 d4c0 0491  L.0.\"0;.C!.....
00000040: a56a b850 d4c0 542a 60d3 ae80 453b 5c30  .j.P..T*`...E;\0
00000050: a94e 1d27 222e 6465 636f 6465 2827 7a69  .N.'".decode('zi
00000060: 7027 29                                  p')

```

Try it online!
> 3 votes

# Answer
# , 47+61=108 bytes

Once again stolen from @DigEmAll's nice answer previously, just compress to gzip and decompress in a 2 part answer.

```
cat(memDecompress(readBin('a','raw',61),'g',T))

```

Try it online!
> 2 votes

# Answer
# 05AB1E, 58 bytes

```
”. -"|\
”S”""--..”ð6×)˜•I8Γ·³§€ΓÎíÈÜ7γ¿·U₃´îØ©G¹râî.
d•SèJ

```

Try it online!
> 2 votes

# Answer
# Twig, 126 bytes

This is just a simple search/replace. Nothing fancy

```
{{'012
 10  2430  240  3   2430  3\\40  30  |40003|
 3000|
0   30  |
000 3|'|replace(['    ','.-"','"-.','""--..','
|'])|raw}}

```

Try this on https://twigfiddle.com/8zxyxa

Under "Result", click in "Show raw result", or else you will see this:

```
        .-""-.
    .-"      "-.
|""--..      "-.
|      ""--..   "-.
|""--..      ""--..\
|      ""--..      |
|            ""--..|
    ""--..            |
            ""--..      |
                ""--..|

```

Which looks closer to melting cheese than a cake slice...

---

Sadly, your cake has to be `|raw`, or you would get this:

```
        .-""-.
    .-"      "-.
|""--..      "-.
|      ""--..   "-.
|""--..      ""--..\
|      ""--..      |
|            ""--..|
    ""--..            |
            ""--..      |
                ""--..|

```

Which looks like .... I don't know :x
> 2 votes

# Answer
# Python 3, 116 bytes

```
print('''    .-" .-"||   |\\
||
||
 |
 |
 |'''.translate({1:'""--..',2:' '*6,3:'"-.\n'}))

```

Try it online!
> 2 votes

# Answer
# Python 2, ~~158~~ 125 bytes

```
print"""    .-""-.
 .-"s"-.
|es"-.
|se   "-.
|ese\\
|ses|
|sse|
 ess|
 ses|
 sse|""".replace('e','""--..').replace('s',' '*6)

```

Try it online!

---

Basically a translation of the JS and T-SQL answers
> 1 votes

# Answer
# 05AB1E, ~~84~~ ~~82~~ 81 bytes

```
“
 "-.\|“•6ÅΩæÍ[ÕŽÇ4Δ¼µðв‹ìbÿ¹0mĆÛh6Ë\HvçÏ—ÜâE«εx±5Â\₅δćzÁ₅3¨Éj€¾ï737Æüí·?т¹•7вèJ

```

-3 bytes thanks to *@Emigna*.

Try it online.

**Explanation:**

```
“\n "-.\|“       "#  Push string '\n "-.\|'
•6ÅΩæÍ[ÕŽÇ4Δ¼µðв‹ìbÿ¹0mĆÛh6Ë\HvçÏ—ÜâE«εx±5Â\₅δćzÁ₅3¨Éj€¾ï737Æüí·?т¹•
                  # Compressed integer 18017524448214263331172789946872235969387180564028761120954323919616255702509406136041325094115009009004153150633415914465807454405990069100373808902652333314
 7в               # Converted to Base 7 as list:
                  # [1,1,1,1,4,3,2,2,3,4,0,1,4,3,2,1,1,1,1,1,1,2,3,4,0,6,2,2,3,3,4,4,1,1,1,1,1,1,2,3,4,0,6,1,1,1,1,1,1,2,2,3,3,4,4,1,1,1,2,3,4,0,6,2,2,3,3,4,4,1,1,1,1,1,1,2,2,3,3,4,4,5,0,6,1,1,1,1,1,1,2,2,3,3,4,4,1,1,1,1,1,1,6,0,6,1,1,1,1,1,1,1,1,1,1,1,1,2,2,3,3,4,4,6,0,1,2,2,3,3,4,4,1,1,1,1,1,1,1,1,1,1,1,1,6,0,1,1,1,1,1,1,1,2,2,3,3,4,4,1,1,1,1,1,1,6,0,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,3,3,4,4,6]
è                 # Index each item in this list in the string
 J                # Join the indexed characters together (and output implicitly)

```

See this 05AB1E tip of mine (section *How to compress large integers?*) to understand why `•6ÅΩæÍ[ÕŽÇ4Δ¼µðв‹ìbÿ¹0mĆÛh6Ë\HvçÏ—ÜâE«εx±5Â\₅δćzÁ₅3¨Éj€¾ï737Æüí·?т¹•` is `18017524448214263331172789946872235969387180564028761120954323919616255702509406136041325094115009009004153150633415914465807454405990069100373808902652333314`.

Huge thanks to *@MagicOctopusUrn*'s ASCII art compress generator, after which ~~`žLR` has been golfed to `žh`, and the string has been fixed with the  and `«` because it contained a `"`~~ the transliterate has been golfed by reversing the string and number on the stack, using `в` instead of `B` to make it a list of characters instead, and index into it (thanks *@Emigna*).
> 1 votes

# Answer
# ///, 91 bytes

```
/d/"-.//D/""--..//s/   //S/ss/s .-"d
 .-"Sd
|DSd
|SDsd
|DSD\\
|SDS|
|SSD|
 DSS|
S DS|
SS D|

```

Try it online!
> 1 votes

# Answer
# Java (JDK), 139 bytes

```
v->"    .-\"\"-.\n .-\"6\"-.\n|06\"-.\n|60   \"-.\n|060\\\n|606|\n|660|\n 066|\n 606|\n66 0|".replace("6","      ").replace("0","\"\"--..")

```

Try it online!
> 0 votes

# Answer
# C# (.NET Core), 169 154 152 bytes

```
Console.Write("    .-\"\"-.\n .-\"2\"-.\n|12\"-.\n|21   \"-.\n|121\\\n|212|\n|221|\n 122|\n 212|\n 221|".Replace("1","\"\"--..").Replace("2","      "));

```

Try it online!

*-15 bytes: Realized I could made use of C#'s Replace function and removed a variable.*
*-2 bytes: Left two unnecessary spaces in the Replace functions.*

---

Alternate way to do this using an anonymous function instead of writing directly to the console.

# C# (.NET Core), 154 152 bytes

```
()=>{return("    .-\"\"-.\n .-\"2\"-.\n|12\"-.\n|21   \"-.\n|121\\\n|212|\n|221|\n 122|\n 212|\n 221|".Replace("1","\"\"--..").Replace("2","      "));};

```

Try it online!

*-2 bytes: Left two unnecessary spaces in the Replace functions.*
> 0 votes

# Answer
# ///, 88 bytes

```
/%/   //$/"-.
//#/""--..//!/%%/% .-"$ .-"!$|#!$|!#%$|#!#\\
|!#!|
|!!#|
 #!!|
! #!|
!! #|

```

Try it online!
> 0 votes

# Answer
# 05AB1E, 79 bytes

```
•6ÂËhHyã¡0÷íÓ].‚ηƶãqÛ-#Œ‘-)ìMι"ΩÒý³!7₄βýiÑ¡1:l*;∊ëžZ~ÙÂ¯Î©ïŒ×.gιü#‡•“. -"|
\“Åв

```

Try it online!

```
•...•“...“Åв  # trimmed program
          Åв  # characters in...
     “...“    # literal...
          Åв  # with indices in digits of...
•...•         # 17991054328044272488457460457310784314009191188977967735225363312688493035783656557746796791541044041617963464968803855853508169575617675885728820813516051270...
          Åв  # in base length of...
     “...“    # literal
              # implicit output

```
> 0 votes

---
Tags: code-golf, ascii-art, kolmogorov-complexity
---