text:
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 code-golf 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!

AKA: "Find the Best Compression Algorithm"

I am really quite tired of [tag:ascii-art] + [tag:kolmogorov-complexity], it has been done a thousand times and they are quite practically all the same challenge.

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

Your snake seems to have gotten mirrored.

@xnor fixed it, base conversion is dangerous ;).

Yeah, base notation really should start with the least significant digit :) It looks like your i*=94;i+=c-32 can be i=i*94+c-32.

@xnor thanks a lot

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

It looks like the challenge allows getting rid of the empty columns of spaces on the left and right. Might that save you some bytes?

@xnor It doesn't look like it, he could probably vary the number of padding spaces by about 10 or so without affecting the length of his code.

@Neil it seems like centering method has less number of runs than mirroring 1/3.

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

171 bytes by using the base and the number from my program (because this uses the exact same algorithm): Try it online!

170 bytes by changing the ...,36,... to ...,1,0,35,... in the compressed integer-list, so the 1-byte builtin ₆ (36) can be used instead of 37.

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

looks like we arrive at the same approach :)

@SurculoseSputum certainly does!

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!

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!

Save a byte by using base 35 (changing the one 36 to 2,0,34). Save another two by using modulo indexing (⁶”L2ƭx$€F -> Jx$ị⁾ L). TIO

Nice. I tried to get modular indexing to work, but it was too long. How does the Jx$ part work, though?

$ treats the two links (in this case atoms) to the left as if it were a monadic chain, so it's a function which accepts the list of integers (call this a), gets the 1-indexed indices (J) and then performs repetition (x) vectorised across a. (e.g. if the big list of digts were a = [4,1,2] then this would do x(J([4,1,2]),[4,1,2]) = x([1,2,3],[4,1,2]) = [1,1,1,1,2,3,3])

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

305

this is close but sadly doesn't work

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.

Wow. This is magic.

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 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 line simply inserts the encoded data.
\d+
*L

Run-length decode the integers to Ls.
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.

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!

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)

lmao runtime encoding

note that this is a ~1:4 compression, which... isn't great considering this is binary data and you'd probably do better just packing the characters as binary into raw bytes

you are right - i just hacked it together because no C answer was here =)

445 bytes

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

it should be possible to encode as the ascii codepoints directly but that's harder to edit and looks very messy

also, should be possible to essentially hardcode the central bar and flip (cf arnauld's answer) but not sure if the tradeoff will be worth it

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.

probably very suboptimal. this is just to see how long it would be without real compression

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 Ls.
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.


text:
The first digit of a to the power of b (approximately)
Inspired by This answer to a Puzzling question
Background - exponentiation by squaring
If you don't want to read the background, or don't understand it, there's a worked example in Java, linked at the bottom of the post.
\$a^{2^{x+1}} = a^{2^{x}} * a^{2^{x}}\$
Therefore to find \$a^b\$ (where \$a\$ and \$b\$ are base-10 numbers), you can use the following steps:
(using the example: \$a^b = 3^{2020} = 6.0944502154628860109199404161593e+963\$)

Convert \$b\$ to binary (\$2020\$ -> \$11111100100\$)
For each \$1\$ in the binary (\$n\$), calculate \$a^n\$, by starting at \$a^1\$ and repeatedly squaring to get \$a^2\$, \$a^4\$, etc... and keeping only those numbers we need (\$3^1 = 3\$, \$3^2 = 9\$, squared gives \$3^4 = 81\$, squared gives \$3^8 = 6561\$, squared gives \$3^{16} = 43046721\$, squared gives \$3^{32} = 1853020188851841\$, etc. We just keep those numbers where the binary mask is a 1.)
Multiply all the kept answers from step 2 where the binary mask is a \$1\$ (\$81*1853020188851841*...\$).
The first non-zero digit is therefore \$6\$.

The problem with this method though, even though it is easier for humans than calculating such a large exponent straight-off, is that you still have to square some pretty large numbers.
In Theory, though, we can approximate!
According to the link at the start of the question, you can approximate by just considering the first \$n\$ digits (rounded) at each stage in step 2 above - with larger \$n\$ giving a lower margin of error.
For example, if \$n=4\$, then you get* \$3^2=9,^2=81,^2=6561,^2\approx4305,^2\approx1853,^2\approx3434,^2\approx1179,^2\approx1390,^2\approx1932,^2\approx3733\$.
note that the numbers here have been rounded*, rather than just truncated - e.g. 6561 * 6561 = 43046721 - which has been rounded to 4305 rather than 4304.
Keeping \$3733,1932,1390,1179,3434,1853,81\$ from the bitmask we can then do \$3733*1932*1390*1179*3434*1853*81= 6091923575465178358320\$, so the first digit is \$6\$, as we would expect.
This is not only easier in our heads, but it gives us the same first digit! Much simpler!
However, if we only consider the first \$3\$ digits when we double, instead of the first \$4\$, we get \$353*188*137*117*342*185*81 = 5451573062187720\$, which gives us a first digit of \$5\$ instead of \$6\$ - that's why it's only approximately accurate!

The Challenge is to find the first digit of \$a^b\$, where only the first \$n\$ digits, rounded, are considered each time we square. You don't have to use exponentiation by squaring in your program, if you can get the correct answers by another method.
Inputs
Three positive Integers (greater than \$0\$), up to an arbitrary maximum (your program should work in theory for all possible Integers) - the base \$a\$, the exponent \$b\$ and the approximation length \$n\$
Output
a single digit or character in the range [1..9]
Some Worked Examples
3,2020,3 -> 5 (see worked example in background above)
3,2020,4 -> 6 (see worked example in background above)
2,20,1 -> \$20_{10} = 10100_2. 2^1=2,^2=4,^2=16\approx2,^2=4,^2=16\approx2\$ which gives \$2^{16}*2^4\approx2*2\$ = 4
2,20,2 -> \$2^1=2,^2=4,^2=16,^2=256\approx26,^2=676\approx68\$ which gives \$68*16 = 1088\$, first digit 1
2,20,3 -> \$2^1=2,^2=4,^2=16,^2=256,^2=65536\approx655\$ which gives \$655*16 = 10480\$, first digit 1
2,20,4 -> \$6554*16 = 104864\$, first digit 1
2,20,5 or above -> \$65536*16 = 1048576\$, first digit  1
15,127,5 -> 15,225,50625,25629...,65685...,43145...,18615... -> 231009687490539279462890625 -> 2
The same Examples formatted for easy copying, plus some additional ones
a,b,n,outputs result
3,2020,3 outputs 5
3,2020,4 outputs 6
3,2020,5 outputs 6
2,20,1 outputs 4
2,20,2 outputs 1
2,20,3 outputs 1
2,20,4 outputs 1
2,20,5 outputs 1
2,20,6 outputs 1
2,11111,4 outputs 5
4,1234,3 outputs 8
5,54,2 outputs 6
6,464,3 outputs 1
7,2202,4 outputs 8
8,1666,5 outputs 3
9,46389,6 outputs 2
10,1234,7 outputs 1
11,5555,8 outputs 8
12,142,14 outputs 1

Sample implementation on TIO
This is code-golf, usual rules and restrictions apply, lowest bytes wins.

EDIT
*to clarify what I mean by rounding, any number less than \$x.5\$ should round down to \$x\$. Any number greater than \$x.5\$ should round up to \$x+1\$. The boundary (\$x.5\$) can go either way, depending on your language.

About the sample implementation: a random quote from the getFirstCharacterApproximately function: BigInteger.valueOf(Long.parseLong(fullCurrentPowerString.substring(0, Math.min(fullCurrentPowerString.length(), n+1)))); :)

@mypronounismonicareinstate It wasn't supposed to be a golfed sample implementation :P

"Multiply and round" is not an associative operation.  How should the various a^2^x be multiplied together?

@Nitrodon you round each of the $a^{2^x}$ individually as you calculate them, and use the rounded version to calculate the next one. Then, once you calculated all your powers, you'll have a list of rounded numbers, and the multiplication happens to each of the rounded elements at the end. Does that make sense? See also reference implementation, and the puzzling question, both of which hopefully clarify the steps to take

That is a pretty convoluted way to get a wrong digit :D

@Kaddath the original context was that it was "good enough", if you had to do it by hand without a calcuator. Hopefully it makes for a fun challenge here though

Yep, fun it is ;) love this kind of maths

Python 2, 88 bytes
a,b,n=input()
s=1
while b:a=int(`a`[:n])+(`a`[n:]>"5");s*=a**(b%2);a*=a;b/=2
print`s`[0]

Try it online! or Check all test cases!
Reads 3 integers from STDIN, and print out the first digit approximation.
Rounding: x.5 is always rounded down. This causes the test case (5, 54, 2) to gives the wrong result.
Explanation:
This part is the regular exponentiation by squaring:
while b:s*=a**(b%2);a*=a;b/=2

This is the rounding part:
a=int(`a`[:n])+(`a`[n:]>"5")

which takes the first n digits of a, and adds an extra 1 if the remaining part is more than 5.

Way shorter than what I wrote :)

JavaScript (Node.js), 100 bytes
Takes input as (b)(n)(a), where \$a\$ and \$b\$ are BigInts.
b=>n=>g=(a,k=p=1n)=>k>b?(p+g)[0]:g((BigInt((a*a+'0'.repeat(n)).slice(0,n+1))+5n)/10n,k+k,b&k?p*=a:0)

Try it online!

JavaScript (ES6),  92  87 bytes
Improved the upper bound of \$n\$ thanks to @Neil
Without BigInts. Works for \$n\le 10\$.
b=>n=>g=(a,k=p=1)=>k>b?(p+g)[0]:g((+(a*a).toPrecision(n)+'').slice(0,n),k+k,b&k?p*=a:0)

Try it online!
How?
At each iteration:

We compute \$a^2\$ with \$n\$ significant digits thanks to the .toPrecision() method. This gives a string, which may be in scientific notation.
Example for \$a=1023\$:
  (1046529).toPrecision(4) ~> "1.047e+6"

we coerce this result to a number and immediately back to a string:
  +(1046529).toPrecision(4)+'' ~> "1047000"

we keep the \$n\$ first characters to get the new value of \$a\$:
  (+(1046529).toPrecision(4)+'').slice(0,4) ~> "1047"

The highest value of \$n\$ that can be supported is \$10\$ because:
$$(10^{10}-1)^2=99999999980000000000$$
which is already greater than Number.MAX_SAFE_INTEGER, but sill coerced to its standard decimal representation "99999999980000000000".
For \$n>10\$, the result is always stringified in scientific notation (e.g. 9.9999999998e+21) and the algorithm doesn't work anymore.

How high could n go if you used toPrecision instead of manual rounding?

@Neil I think that would work up  to n=10 -- and the same byte count, I think. Is that what you had in mind?

To be honest I hadn't looked at the byte count, I was just curious as to whether it worked for higher n.

Charcoal, 45 bytes
ＮθＮηＮζＦ⮌↨η²«Ｆι⊞υθ≧×θθ¿›ＬＩθζ≔÷⁺⁵Ｉ…Ｉθ⊕ζχθ»§ＩΠυ⁰

Try it online! Link is to verbose version of code. Explanation:
ＮθＮηＮζ

Input a, b and n.
Ｆ⮌↨η²«

Loop over the bits of b from LSB to MSB.
Ｆι⊞υθ

If the current bit of b is set then push a to the empty list.
≧×θθ

Square a.
¿›ＬＩθζ

If a has more than n digits...
≔÷⁺⁵Ｉ…Ｉθ⊕ζχθ

... then take the first n+1 digits, add 5, and drop the last digit, thus rounding the power of a to n digits.
»§ＩΠυ⁰

Print the first digit of the product of the desired powers of a.

Python 3.8 (pre-release), 131 bytes
lambda a,b,n:(m:=a)and str(math.prod((m:=round(m/10**(len(str(m))-n)))**int((m:=m**2)and c)for c in f"{b:b}"[::-1]))[0]
import math

Try it online! How it works:
lambda a,B,n:                      # function taking the three arguments as input
             (m:=a)and             # initialize the base for repeated squaring and
                       str(...)[0] # return the first digit of the string representing the final number

# Inside str():
math.prod(                           ) # the product of (new in 3.8)
          ... for c in f"{B:b}"[::-1]  # something we compute for each character in the reversed binary representation of the input B

# Use repeated := to modify the base we keep squaring
# Inside math.prod(... for c in f"{B:b}"[::-1])
(m:=                            )                      # modify m
    round(m/10**(len(str(m))-n))                       # by rounding it to the first n digits
                                       (m:=m**2)and    # finally we square m again (without effecting anything else)
                                 **int(             c) # and only include this number in the product if the binary digit is 1

My (5, 54, 2) test case gives a different result; I suspect it is because of how Python rounds 62.5 vs how the reference implementation rounds 62.5. Python rounds it down to 62, but if I force Python to round up I get the reference solution of 6.

In Python 3, round tie-breaks to nearest even instead of away from 0. So you probably need to use the longer solution :(

I think the standard Python rounding is fine, actually. It's not key to the problem which what happens at the .5 boundary, just that the numbers are rounded. Other numbers should still round up/down accordingly though (so you can't just round everything decimal down, for example). I'll update the spec to clarify

@simonalexander2005 I'm not saying python's rounding is wrong or whatever. I just explained why my solution gave a different result from your solution. With your updated spec, my "error" is no longer an error and all is fine :)

Save a byte by using m*m in place of m**2.

114 bytes by not using m, and shorten the rounding part. Can be way shorter with recursion though.

05AB1E (legacy), 20 bytes
b©vDnDg°I°÷/ò})®RÏPн

Uses the legacy version of 05AB1E, because division-by-zero errors will result in the initial integer, whereas the new 05AB1E version would make it 0 instead.
Input-order as \$b,a,n\$.
Just like both Python answers, the test case 54,5,2 will result in 4 instead of 6, because of different rounding than the Java reference implementation.
Try it online or verify all test cases.
Explanation:
b              # Convert the (implicit) input-integer `b` to a binary string
 ©             # Store it in variable `®` (without popping)
  v            # Pop and loop its length amount of times:
   D           #  Duplicate the top value
               #  (which is the implicit input-integer `a` in the first iteration)
    n          #  Square it
     Dg        #  Take its length without popping (by duplicating first)
       °       #  Take 10 to the power that length
        I°     #  Take 10 to the power input-integer `n` as well
          ÷    #  Integer-divide 10^length by 10^n
           /   #  Divide the current square by this
               #  (the value remains the same for division-by-zero errors in the legacy
               #   version, which will happen if the amount of digits in the squared
               #   value is smaller than `n`)
            ò  #  And bankers-round that decimal to the nearest integer
  })           # After the loop: wrap all values on the stack into a list
    ®R         # Push the binary-string from `®` and reverse it
      Ï        # Only leave the values in the list at the 1-bits
       P       # Take the product of those remaining values
        н      # And pop and push its first digit
               # (after which it is output implicitly as result)

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Calculate The Digit Sum
Your task is to get two numbers, and output the digit sum of them. We'll define digit sum as the following:

take the decimal (base 10) digits of each of them, and pad with 0s the shortest number (e.g. [1,9], [0, 7])
sum the digits as vectors (e.g. [1, 16])
convert the number back from base 19, and output it (e.g. 1*19+16=35)

Input
You can take the input as two numbers, as a list containing both of them or in any other reasonable format (like an array of digits). You can assume the shortest number is padded with zeros so it fits the length of the longer one
Output
You can output the digit sum in any reasonable format.
Test cases
1, 2 -> 3
5, 10 -> 24
42, 32 -> 137
15717, 51358 -> 826819
1000, 1 -> 6860

explanation of 5, 10: the digits of these are [0, 5] and [1, 0]. Their sum is [1, 5], which when converted from base 19 results in 24.
Scoring
This is code golf, so the shortest answer wins, good luck!

Post in sandbox

Can we take the input digit lists in reverse?

i have a question, why base 19? is it a random specific or it has a mathematical meaning who i don't get?

@D'ArcyNader I'm not OP, but in a comment on the sandbox post (s)he mentions: "It's the smallest base for which the sum of any two digits in base 10 fit in".

J, 6 bytes
19#.+/

Try it online!

19#. convert the following to base 19...
+/ elementwise sum of the input digit lists.

You can take a digit list as an input.

Thanks, not much content at this point though.

Jelly, 4 bytes
ḅ19S

A monadic Link accepting a list of lists of digits which yields an integer.
Try it online!

Python, 30 bytes
lambda a,b:int(a,19)+int(b,19)

An unnamed function accepting two strings of (base ten) digit characters which returns an integer.
Try it online!

05AB1E, 4 bytes
-1 thanks to Command Master.
+19β

Try it online!

4 bytes

+ vectorizes!? I was an idiot.

Japt -mx, 6 3 bytes
Takes input as an array of digit arrays.
ì19

Try it

Python 2, 46 bytes
f=lambda a,b:a+b and a%10+b%10+19*f(a/10,b/10)

Try it online!
Recursive function that sums each digit pair and convert them to base 19.

Wolfram Language (Mathematica), 24 bytes
Tr[#~FromDigits~19&/@#]&

Unnamed function taking as input a list that contains two lists of digits. The main point here is that converting to base 19 first and then adding means that padding on the left is unnecessary.
Try it online!

Wolfram Language (Mathematica), 30 bytes
Total@PadLeft@#~FromDigits~19&

Try it online!
Takes input as list of digits as @my pronoun is monicareinstate suggested and saved 13 bytes (IntegerDigits)
-1 byte @LegionMammal978

I think you can take two lists of digits as input.

-1 byte: Total@PadLeft@IntegerDigits@#~FromDigits~19&

C (gcc), 67 65 bytes
Saved 2 bytes thanks to Mitchell Spector!!!
s;m;f(a,b){for(s=m=1;a+b;a/=10,b/=10,m*=19)s+=(a%10+b%10)*m;s--;}

Try it online!

65 bytes

@MitchellSpector Nice, homogeneous init with a tweak at the end to make it the return value - thanks! :-)

Bash, 54 53 19 bytes
echo $[19#$1+19#$2]

Try the test cases online!

The input numbers are passed as two arguments.
Output is on stdout.

K (oK), 5 bytes
Solution:
19/+/

Try it online!
Explanation:
Takes input as two lists of digits. Assumes the shorter number is padded with 0s.
19/+/ / the solution
   +/ / sum
19/   / decode from base 19

Charcoal, 8 bytes
ＩΣＥ²⍘Ｓ¹⁹

Try it online! Link is to verbose version of code. Takes input as two strings. Explanation:
    ⍘Ｓ¹⁹    Convert the input from base 19
  Ｅ²        Repeated twice
ＩΣ          Summed and output in decimal

Pyth, 7 6 5 bytes
Takes input as two lists of digits. Assumes the shorter number is padded with 0's.
siR19

Try it online!
siR19
  R       (Right-) Map each digit array of the input to:
 i 19     The digit array converted from base 19
s         Take the sum

dc, 47 bytes
?[0q]sZ[sydsxly+0=ZlxA~rlyA~4R+_3Rlfx19*+]dsfxp

Try it online!
Or verify all the test cases online.
Input is on stdin (the two numbers on one line, separated by a space).
Output is on stdout.

This program makes use of a nice facility in dc, where the single-character command ~ will compute both the quotient and the remainder in a division operation.

JavaScript (Babel Node), 43 bytes
f=(a,b)=>a+b&&a%10+b%10+19*f(a/10|0,b/10|0)

Try it online!

But (a,b)=>(p=parseInt)(a,19)+p(b,19) is only 33 bytes...

Java (JDK), 40 bytes
a->b->a.valueOf(""+a,19)+a.valueOf(b,19)

Try it online!
Takes input as a:Integer and b:String.

PHP, 75 bytes
for($n=strlen($a=$argv[1]);$n--;)$r+=($a[$i]+$argv[2][$i++])*19**$n;echo$r;

Try it online!
As often, getting arguments and dollars makes PHP the longest answer so far :D still i'm content with this
Takes input as strings already padded with zeroes

Ruby, 24 bytes
->a{a.sum{|x|x.to_i 19}}

Accepts an array of two strings.
Try it online!

Brachylog, 6 bytes
~ḃ₁₉ᵐ+

Try it online!
Takes input as a digit list, but the testing header converts from single integers for convenience.

Thunno, \$ 6 \log_{256}(96) \approx \$ 4.94 bytes
z+19Ad

Attempt This Online!
Takes in the numbers as digit arrays.
Thunno, \$ 7 \log_{256}(96) \approx \$ 5.76 bytes
e19AdES

Attempt This Online!
Takes in the numbers as digit arrays.
Explanations
z+19Ad  # Implicit input
z+      # Add the digits in the same positions together
    Ad  # Convert from
  19    # base-19

e19AdES  # Implicit input
e    E   # Map over the input:
   Ad    #  Convert from
 19      #  base-19
      S  # Sum the list
         # Implicit output

Nibbles, 4.5 bytes
`@19!$_+

Attempt This Online!
`@ Convert from base
19  19
!   zip
$    first input
_    second input
+    addition

Python 3, 77 72 bytes
lambda x,y:sum(n*19**x for x,n in enumerate([*map(sum,zip(x,y))][::-1]))

Try it online!
Not one of the shortest approaches, but it works.
-5 bytes thanks to @ovs

You can use map for 72 bytes: enumerate([*map(sum,zip(x,y))][::-1]).

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
How to find the original value based on modulus/reminder and some other information
This might be a very basic question in terms of math,
x % constant = x_modulus

(x + some_number) % constant = y_modulus

Given the value of x_modulus, y_modulus, (x + some_number) and constant(common in both), output the value of x itself based on these values.

Are you asking this question because you don't know, or because you want us to write programs that will input these numbers and output x?

I am asking becase I really don't know in terms of math, how to correlate all these values together. I don't want the complete program, just rough steps would be enough.

Then maybe you should post this on the math stackexchange, where you will be very likely to get an answer. On code golf, you would get answers of short programs that could solve your problem but not always direct answers. See why this question was closed.

Just as a side note, the value of some_number is the absolute difference between x_modulus and y_modulus, which is in turn x's distance with the closest multiple of constant larger than x. Therefore it's impossible to find what exactly is the value of x. That greatly simplifies the question.

05AB1E, 1 byte
Finds the smallest possible value of all values of x, takes input as some_number, constant, x_modulus, y_modulus
α

Try it online!
Explanation
Here are my observations:

The value of some_number is the absolute difference between x_modulus and y_modulus
The above value is in turn x's distance with the closest multiple of constant larger than x.

Therefore it's impossible to find what exactly is the value of x. That greatly trivializes the question into a simple absolute difference between some_number and constant.
The code itself is just absolute difference, I don't feel like explaining it. :D

What does this do? :)

@mypronounismonicareinstate This solves the question. :)


text:
Russian Roulette, varying chances
Russian roulette
It's Russian roulette! The rules are simple. Shoot a revolver with n slots for bullets and one round inside at your head and you might not die!
This Question is different from other Russian roulette questions because it takes input to change the chance of exiting with an error.
Task:
Make a program that takes integer n (you can assume that 10<=n<=128) as input and outputs nothing.

but how do I tell if I'm dead?

The program generates a random number x in the range 0 - n inclusive. If x=0 the revolver fires and the program exits with an error (you die). Otherwise the program exits normally.
If your language needs it, the range can be 1-n inclusive.
Standard loopholes forbidden, etc. Upvote answers in fun languages! What I'd really like to see is an answer in a language that doesn't have normal randomness (eg. in Befunge where ? sends you in a random direction instead of giving a random number).

sandboxed

If our language natively generates random number in the range of 1 - n inclusive, instead, is that alright?

I was trying to solve that problem in the sandbox. I'll make it clearerer now

@Wezl Thanks for your edit. Perfect now. You might also want allow a seed for languages without own randomness source.

Related: Make your code error, but only sometimes!

Possible duplicate of Russian Roulette

@pppery But this question takes input and does not print " I survived".

I don't view either of those distinctions as material enough to make it no longer possible to directly copy answers from the other question, make minor tweaks to them, and submit them.

@pppery the question is simple enough that that could be more work than creating an original response.

no one's going to beat the 3-byte APL answer but there is still room for "fun" languages.

Are we allowed to output something or not? It looks like many existing answers output a number for the cases when the program doesn't error

@mathjunkie You are not supposed to. I will look over the answers.

@Wezl I would suggest also updating the question to state that more explicitly

Re-reading the question, I've realised that several of the current answers (mine included) don't meet the spec. My revolver fires when the random number $x=0$, not when $x=n$. The probability of firing is the same either way, but can you clarify whether firing when $x=0$ (or any value other than $n$) is acceptable?

To be clear, I'm specifically referring to cases in which the stated exception for erroring when $x=0$—'your language needs it'—doesn't apply.

@Dingus I initially thought that it was too easy to test if x=0 but most answers are using division by zero so to change it now would be impossible.

Charcoal, 5 bytes
≔‽‽Ｎθ

Try it online! Link is to verbose version of code. Explanation: The Ｎ function reads the input number. The ‽ generates a random number between 0 and its argument. However, this errors if the argument is zero. This happens if the inner ‽ randomised a 0, i.e. 1 in n times. The ≔θ simply serves to make the program do nothing if it was successful.

APL (Dyalog Unicode), 3 bytes
Full program. Exits with code 11 or 0. Requires ⎕IO←0.
÷?⎕

Try it online!
⎕ prompt for n
? generate random integer in range 0…n-1
÷ reciprocal (errors if argument is 0)

Darn! Nice one... I've been waiting for a while to post this, but was waiting for OP to relax the requirements. Otherwise, ÷(⊢-?)⎕ is a little closer to the original, though without ⎕IO←0!

@AviF.S. Sorry for that. Originally your answer would be eligible but some objected in the sandbox so I changed it... and now I changed it back.

@Wezl Haha, no worries! Thanks for a challenge simple enough to be accessible to the wildest of esolangs, yet still interesting! Working on an implementation in what you're calling a more 'fun' language!

JavaScript (V8), 18 bytes
Community consensus is that time can count as a source of randomness. This function will simply take the time in milliseconds modulo the inputted value. If 0, the function tries to return a, which does not exist.
n=>Date.now()%n||a

Try it online!

Pyth, 3 bytes
JlO

Try it online!
O - generate a random integer in the range 0 - n-1
l - log base 2 of that integer. Throws a math domain error if 0 was generated
J - assign the value to a variable so that we suppress all output

  (space) is the more standard way to suppress printing, but this works too.

Rust + time crate, 38 bytes
|n:u8|1/(time::Time::now().second()%n)

Defines a closure that takes an unsigned 8-bit integer as input and returns an integer or panics with "attempt to divide by zero".
try it online.
Our rules about using the time as randomness state the following (emphasis mine):

[...] if you have to select one random value per script execution, current seconds/milliseconds should be sufficient.

Python, 57 43 bytes
Saved 14 bytes synchronously with thanks to Surculose Sputum!!!
lambda n:1/randint(0,n)
from random import*

Try it online!

I don't think you need to output anything, so just lambda n:1/randint(0,n) should work.

@SurculoseSputum Was just looking into that - thanks! :-)

Python 2, 26 bytes
id(0)%129%-~n gives a random number from 0 to n inclusive. It returns an error if it equals 0, because of ZeroDivisionError.
lambda n:1/(id(0)%129%-~n)

Try it online!

Python 2, 23 bytes
1/(id(0)%129%-~input())

which is a merging of dingledooper's answer with my original one (below). Try it online!
Python 2, 40 bytes
from random import*
1/randint(0,input())

Try it online! Full program.

Ruby, 14 bytes
->n{1./rand~n}

Try it online!
Exits with ZeroDivisionError when rand~n returns 0. It's helpful that rand takes the absolute value of its argument.

W j, 2 bytes
g(

Explanation
    Implicit input
g   Randrange 1 to input
 (  Decrement the number by 1

Flag:j (Evaluates the J command at the end of the program)

The J command, given a number operand, reciprocals the number.

It throws a 0-division error when the operand is 0.

If g uses a range from 1 to input, I don't see how can this crash.

@mypronounismonicareinstate The range is probably fixed now.

MATLAB, 32 bytes
@(n)eval('if(randi(n)==n)a;end')

randi(n) outputs random integer from [1,2,3...n] list
a is undefined, so when it is called, program errors out

Python3, 66 bytes
0/0 if __import__("random").randint(0,int(input()))==1 else exit()

Welcome to codegolf, and nice first answer! It seems that the double underscore in your code is interpreted as bold mark-up. I suggest you use this online intepreter to format your answer faster - simply click on the "generate perma-link" button (third button at the top), then copy the "Codegolf submission" entry and paste it in your answer here.

Ah ok, thanks for the tip!

05AB1E, 5 bytes
Ý<Ω¬F

Try it online!

T-SQL, 24 bytes
DECLARE @ INT=10

SET @/=floor(rand()*-~@)

Try it online

Java (JDK), 22 bytes
n->n/=n*=Math.random()

Try it online!