text:
Output a Super Mario Image
This is a problem on Luogu OJ. I decided to post it here because on Luogu OJ, many people, including me and my friend, are interested about how to solve this problem within the fewest characters.
Your task is to output the following ASCII-art:
               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############

This is code-golf, so shortest program wins.

Is additional whitespace (for example to make a rectangle of characters) on the right hand side allowed? what about a trailing newline?

@LevelRiverSt Sorry for late reply. Yes, the OJ automatically strips all trailing whitespace/tab/newline and all whitespace/tab on the right hand side.

Brainfuck, 1347 bytes
Why do i do this to myself
+++++[>+++++++++>+++++++>++++++>++++++++>+++++++++>++<<<<<<-]>+>>++>++<<>...............>............>>.<<<...............<....<....>.<.>>>>>.<<<.............<.<..>...<.....>..<....>>>>>.<<<.............<...<.......>......>..<<<++[->>>............<...<<]>>>>>>.<<<................<<...........>>.....<<<++[->>>..........<.<...>.<<]>>>>>>.<<<...............<..>>.<<.......>.......<<<++[->>>..........<.<.>.<.>.<<]>>>>>>.<<<............<....>>.......<<......>...<<<++[->>>..........<.<.>.<.>.<<]>>>>>>.<<<...........<<...>><.>>...<<<.>>>....<<<.>>>.<<...<....>>..........<.<.>.<.>.>..........<.<.>.<.>.>>>>.<<<...........<<....>>>..........<<..<.....>>...........<...>............<...>>>>.<<<...........<<....>>>....<....>.....<<<....>>>>>.<<<.....<<<++[->>>........<....<<]>>>>>>.<<<...<<<++[->>>........<......<<]>>>>>>.<<<<<<+++++++[->>........<<]>>......>>>>.<<<<<<+++[->>.<...>.<......>.<.>.<<]>>.>>>..................<<<.>>>>.<<<<<<+++++++[->>......<<]>>.>>>..................<<<.>>>>.<<<<<<+++[->>.<..>.<....>.<....>.<<]<+++++[->>>....<<<]>>>>>>>.<<<<<<+++++++[->>......<<]>>>....<.>>>..........<<<.>>>>.<<<<<<+++[->>.<.....>.<......>.<<]>>>....<.>>>..........<<<.>>>>.<<<<<<+++++++[->>......<<]>>>....<.>>>..........<<<.>>>>.<<<<<<+++[->>.<.>.<..>.<....>.<..>.<<]>>>....<.>>>..........<<<.>>>>.<<<<<<+++++++[->>......<<]>>>....<............

Try it online!
The "readable" version :
+++++[>+++++++++>+++++++>++++++>++++++++>+++++++++>++<<<<<<-]>+>>++>++

<<
>...............>............>>.
<<<...............<....<....>.<.>>>>>.
<<<.............<.<..>...<.....>..<....>>>>>.
<<<.............<...<.......>......>..<<<++[->>>............<...<<]>>>>>>.
<<<................<<...........>>.....<<<++[->>>..........<.<...>.<<]>>>>>>.
<<<...............<..>>.<<.......>.......<<<++[->>>..........<.<.>.<.>.<<]>>>>>>.
<<<............<....>>.......<<......>...<<<++[->>>..........<.<.>.<.>.<<]>>>>>>.
<<<...........<<...>><.>>...<<<.>>>....<<<.>>>.<<...<....>>..........<.<.>.<.>.>..........<.<.>.<.>.>>>>.
<<<...........<<....>>>..........<<..<.....>>...........<...>............<...>>>>.
<<<...........<<....>>>....<....>.....<<<....>>>>>.
<<<.....<<<++[->>>........<....<<]>>>>>>.
<<<...<<<++[->>>........<......<<]>>>>>>.
<<<<<<+++++++[->>........<<]>>......>>>>.
<<<<<<+++[->>.<...>.<......>.<.>.<<]>>.>>>..................<<<.>>>>.
<<<<<<+++++++[->>......<<]>>.>>>..................<<<.>>>>.
<<<<<<+++[->>.<..>.<....>.<....>.<<]<+++++[->>>....<<<]>>>>>>>.
<<<<<<+++++++[->>......<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++[->>.<.....>.<......>.<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++++++[->>......<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++[->>.<.>.<..>.<....>.<..>.<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++++++[->>......<<]>>>....<............

That is nothing short of amazing. Did you design it yourself or use a programm to aid you?

Did it myself. Also i know there is probably a better and shorter way to do this, but tbh it was painful enouth to draw mario in brainfuck by hand.

On the plus-side, you know abso-f-ing-lutely nobody is going to try and come up with a competing shorter version :D

@Therandomguy "draw mario in brainfuck by hand" - What does this mean?

@CD001 is that a challenge?

@Evorlor Had an afternoon to waste on this instead of studying.

@Evorlor well there are brainfuck compilers, macros and scripts that can translate readable instructions into brainfuck. By "by hand" I meant whether he constructed the code entirely by himself which he acually did. Kudos for that.

Oh god... I know i'm not going to beat this and its pretty late, but here we go...

T-SQL, 322 298 288 bytes
SELECT CONCAT('',DECOMPRESS(CAST('H4sIAAAAAAACA6WRQYrEIBQF955CqJ0wdf/jjehM2rwOdofUQvIoHj9f65m2UMLRsYNng/4ZQU0NThjUtBFLDXwRBpWIWYfGpCaIRCy5cZswuFVX6U3bOAA73/+8nXYw2368uWwfj3r5MKzfq4W0UHhEQcUBsk0/b9yafllX9P/YpeDu7rVDTF6226WoPpy6bMUmPZ66UH4BHz4rVE8EAAA='as XML).value('.','varbinary(max)')))

Uses G-Zip compression built into SQL 2016 and later, along with Base64 encoding, see this tips post for details.
In SSMS, you'll either have to output as text after fiddling with SSMS character limits in settings, or just copy-and-paste the output to the code window:

EDITS: Saved 24 bytes with a better compressed string, thanks to @someone;  saved 10 bytes with an implicit conversion using CONCAT, thanks to @digscoop.

I think I have a shorter base64 gzip string, H4sIAAAAAAACA6WRQYrEIBQF955CqJ0wdf/jjehM2rwOdofUQvIoHj9f65m2UMLRsYNng/4ZQU0NThjUtBFLDXwRBpWIWYfGpCaIRCy5cZswuFVX6U3bOAA73/+8nXYw2368uWwfj3r5MKzfq4W0UHhEQcUBsk0/b9yafllX9P/YpeDu7rVDTF6226WoPpy6bMUmPZ66UH4BHz4rVE8EAAA=. I can't test this because I have no idea how, but you might or might not be able to omit the =.

@someone Thanks, that string does work (it does need the =), and saves 24 bytes; guess my encoding routine is far from ideal.

You could use a nameless variable and implicit conversion to shorten it a bit more. Try:
DECLARE @ XML='H4sIAAAAAAACA6WRQYrEIBQF955CqJ0wdf/jjehM2rwOdofUQvIoHj9f65m2UMLRsYNng/4ZQU0NThjUtBFLDXwRBpWIWYfGpCaIRCy5cZswuFVX6U3bOAA73/+8nXYw2368uWwfj3r5MKzfq4W0UHhEQcUBsk0/b9yafllX9P/YpeDu7rVDTF6226WoPpy6bMUmPZ66UH4BHz4rVE8EAAA='SELECT CONCAT('',DECOMPRESS(@.value('.','varbinary(max)')))

Thanks, @digscoop, saved me 10 bytes. I used the CONCAT trick, but not the XML variable, since that would have added back 3 bytes (it would be shorter, though, in situations I already had a variable)

MarioLANG, 3287 3286 3285  1771 Bytes
I had to do this for the theme.
+>+>.>.>.>.>.>.>.>)>(>.>.>.
+"+".".".".")")".")".".".".
+++........)..).....)......
+++.(.........)...)...(....
+++.......)...)...)).......
+++.(...)...((.......).....
+++.(.....)..(....(...)()..
+++.(.).....)(....((((.()..
+++.....).(.)(.............
+++..(..).....(.....)..))..
+)+)....).).(.(.........)..
+++)..(..(..(..............
+++)...((.(.(......)..(.(..
+++)...((..(.).......)..(..
+++....((.(..).....((.)(...
+++........(.........(..)..
+++..(.)......)......(.....
+++....)................(..
+++......(....(......)...(.
+++....(.(.).)(....).)..)(.
+++......(...)(..(.........
+++........).....(.(.)(..).
+++.....(............)..().
+++.)..)...................
+++..)).....)....(.)..).)).
+++....)..).)............).
+++..............)........(
+++.......)....(...(.......
+++.)))..).....(.(.........
+++(..)..)(.............(..
+++(.....)..)..)......(....
+++(..(...).)..)........).)
+++(..(....(.(.....)..)....
++++(.(...((.(.......(.....
++++.........()....(.(..(..
++++)....))......).........
++++...(..)..)......))...(.
++++)........)..)(..)...)(.
++)+...(..()...))..........
++++(.....(...(....)(.(.().
++++(...).(.....(...(......
++++(........)..().(.((.)..
++++.(.))..((..............
++++.(.....((...)..........
++++.(.)(..((....(.)....((
)+++......................
+)++.)..)..).....).(..).)(
++++.......))..((..(......
++++....((....)..(....(...
++)+.....(.(....)..)..(..)
++++..).((.(.......)......
++++.))...........(.....((
++++.....)).......()......
++++.....)).(.)....)....).
++++.(......(())..........
++++)....(.).....)........
++++.......)..(.(.......()
++++)....)(...(..(.....(..
++++.......(.)(.)......(.(
++++.....()(............).
++++().(..).....(.....))..
++++...()))......)....))()
+!+!.!.!.!.!.!.!.!.!.!.!.!
=#=#=#=#=#=#=#=#=#=#=#=#=#

Try it online!
I managed to save 1514 bytes by converting it from the simple straight code below to the 27x64 block above using elevators
+++++++++++++++++++++++++++++++++++++++++++++)++++++++++++++++++++++++++++++++)+++++++++++++++++++++++++++++++++++)++++++++++++++++++++++++++++++++++++++++++++++)++++++++++)++++++++++++++++++++++++++++++++++++++++++((((...............))))...........(.(((...............)....)....(.).).(((.............).)..(...).....(..)....).(((.............)...).......(......(..............)...(............)...)).(((................))...........((...............).)...(.(..........).)...(.)).(((...............)..))).(((.......(.................).).(.).(.(..........).).(.).(.)).(((............)....))).......(((......(.............).).(.).(.(..........).).(.).(.)).(((...........))...(.)))...((.))....((.)).(((...)....((..........).)...(.(..........).)...(.)).(((...........))....))..........(((..).....((...........)...(............)...)).(((...........))....))....((((....))))....((.....).(((.............)....(........)....)).(((...........)......(........)......)).((..............................................................)).((.)...(.)......(.).(..)...(.)......(.).(..)...(.)......(.).(..((..................)).)).((...........................................((..................)).)).((.)..(.)....(.)....(..)..(.)....(.)....(..)..(.)....(.)....(.....................)).((..........................................(....).((..........)).)).((.).....(.)......(..).....(.)......(..).....(.)......(.(....).((..........)).)).((..........................................(....).((..........)).)).((.).(.)..(.)....(.)..(..).(.)..(.)....(.)..(..).(.)..(.)....(.)..(.(....).((..........)).)).((..........................................(....)...........
=========================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================.

Try it online!
This is horrible and I'm very sorry. Loops can get really expensive (bytes wise) in MarioLANG if you're not smart about them and also I'd almost lost the will to live by the time I'd got this far so Mario literally just runs in a straight line, first setting 6 memory cells to the correct ASCII values, then switching between them to output in the right order. This can definitely be golfed down further and if you really hate yourself I highly suggest you give it a go.
(Saved one byte by deleting last equals (floor character) since Mario hits the last instruction as he falls even without it and another by realising that he could actually hit two instructions in the fall.)
5413 Bytes
+++++>)+++++++++)+++++++)++++++)++++++++)+++++++++)++((((((-[!)+))++)++(()...............)............)).(((...............(....(....).(.))))).(((.............(.(..)...(.....)..(....))))).(((.............(...(.......)......)..(((++>-)))............(...(([!)))))).(((................((...........)).....(((++>-)))..........(.(...).(([!)))))).(((...............(..)).((.......).......(((++>-)))..........(.(.).(.).(([!)))))).(((............(....)).......((......)...(((++>-)))..........(.(.).(.).(([!)))))).(((...........((...))(.))...(((.)))....(((.))).((...(....))..........(.(.).(.).)..........(.(.).(.).)))).(((...........((....)))..........((..(.....))...........(...)............(...)))).(((...........((....)))....(....).....(((....))))).(((.....(((++>-)))........(....(([!)))))).(((...(((++>-)))........(......(([!)))))).((((((+++++++>-))........(([!))......)))).((((((+++>-)).(...).(......).(.).(([!)).)))..................(((.)))).((((((+++++++>-))......(([!)).)))..................(((.)))).((((((+++>-)).(..).(....).(....).(([!(+++++>-)))....((([!))))))).((((((+++++++>-))......(([!)))....(.)))..........(((.)))).((((((+++>-)).(.....).(......).(([!)))....(.)))..........(((.)))).((((((+++++++>-))......(([!)))....(.)))..........(((.)))).((((((+++>-)).(.).(..).(....).(..).(([!)))....(.)))..........(((.)))).((((((+++++++>-))......(([!)))....(...........
====="=======================================================#========================================================================================================================================================================="=======================#==================================================="=========================#====================================================="===========================#====================================================="===========================#=================================================================================================================================================================================================================================================================="====================#=================="======================#===================="==============#======================"==========================#=============================================="============#=========================================="==========================#======"============#====================="============#========================================"========================#============================================"============#========================================"============================#============================================"============#==================.
     !                                                       <                                                                                !                       <                                                   !                         <                                                     !                           <                                                     !                           <                                                                                !                    <                  !                      <                    !              <                      !                          <                                              !            <                                          !                          <      !            <                     !            <                                        !                        <                                            !            <                                        !                            <                                            !            <
     #======================================================="                                                                                #======================="                                                   #========================="                                                     #==========================="                                                     #==========================="                                                                                #===================="                  #======================"                    #=============="                      #=========================="                                              #============"                                          #=========================="      #============"                     #============"                                        #========================"                                            #============"                                        #============================"                                            #============"

Try it online!
This is a port of The random guy's answer using Dennis's Brainfuck to MarioLANG converter making very minor changes to save a couple of bytes. While it's obviously much longer, it includes more features of the language and better shows how the language works so I thought I'd include it.

Wow. The amount of work you must have had to put in is insane.

PHP, 176 155 bytes
-21 bytes thanks to Ryan Moore's super compressed string.
This version uses raw output of gzdeflate and contains unprintable binary data, so the code itself and TIO link cannot be posted here, but here is a hex dump of it:
000000  3c 3f 3d 67 7a 69 6e 66 6c 61 74 65 28 27 a5 91
000010  81 06 04 21 00 44 01 e8 2b e2 01 71 ef ff 3f ef
000020  5c 91 76 f6 64 57 0f 31 c6 98 a6 ea 95 b6 50 c2
000030  03 50 c5 ab 83 0e 47 41 4d 1b 1c d0 a9 e9 86 2c
000040  35 70 62 38 a8 84 cc 38 34 06 35 41 24 64 c9 c5
000050  6d 40 e7 55 5c fd a5 6d fd 00 54 9f 5f 5e b5 4d
000060  40 d5 a7 2f 37 d3 f3 53 ef 1f b3 0e 22 e2 90 2e
000070  14 8e 28 a8 d8 41 b6 ea 73 e3 55 fb df b8 a2 3a
000080  8e ad 4a de 6d ef 0f 16 cd cb ba 9d ca e8 59 eb
000090  b2 8a 9d 3a 6d 5d f8 02 27 29 3b

Thanks to @dzaima, here is a TIO which uses bash to create and run this file: Try it online!
This basically reverses the deflate and prints the result. Save it as a binary file then execute it like this: php mario.php

PHP, 239 216 bytes
-23 bytes thanks to Ryan Moore's super compressed string.
<?=gzinflate(base64_decode('pZGBBgQhAEQB6CviAXHv/z/vXJF29mRXDzHGmKbqlbZQwgNQxauDDkdBTRsc0Knphiw1cGI4qITMODQGNUEkZMnFbUDnVVz9pW39AFSfX161TUDVpy830/NT7x+zDiLikC4Ujiio2EG26nPjVfvfuKI6jq1K3m3vDxbNy7qdyuhZ67KKnTptXfgC'));

Try it online!
Same as above version, but used base64_encode on output of gzdeflate, so the code is readable and TIO link is available too. This basically reverses the base64 and deflate and prints the result.

TIO link using bash to properly create the file

@dzaima Thanks a lot! Didn't know we could run other commands with bash in TIO.

Save 2 bytes for the pro version or 22 bytes for the semipro with pZGBBgQhAEQB6CviAXHv/z/vXJF29mRXDzHGmKbqlbZQwgNQxauDDkdBTRsc0Knphiw1cGI4qITMODQGNUEkZMnFbUDnVVz9pW39AFSfX161TUDVpy830/NT7x+zDiLikC4Ujiio2EG26nPjVfvfuKI6jq1K3m3vDxbNy7qdyuhZ67KKnTptXfgC

@Ryan Moore Thanks a lot! It actually saved 21 bytes on binary version and 23 bytes on readable version. How did you achieve such higher compression? Do you have any special tool and or settings?

@Night2 I use advdef from http://www.advancemame.it/ - it uses Zopfli to try a zillion different options and usually does better compression than regular gzip. The problem is that it only works on .gz content, so you have to gzip the original, advdef the .gz, and then strip off the .gz headers for PHP gzinflate to use it.

@RyanMoore Thanks! Looked at their documents and I like how libdeflate is their "normal" compressor, 2 levels below their "insane" zopfli compressor level. This will come handy in code golf challenges that require string compression.

LaTeX, 452 448 bytes
Created with bigram replacement (and one trigram) instead of programming a loop to replace multiple consecutive symbols.
\newlinechar`+\def~#1{\catcode`#1=13\lccode`~=`#1\lowercase{\def~}}~$#1#2{~#1{#2#2}}~l#1#2#3{~#1{#2#3}}\catcode`#=12$_*$[_$]{ }$^]$!^$<#$><$=>$&=$@.$:@$)-$()$?($/&lx#.$;xl'#@l"<#l`!^l|!]lv#+lc:@lw><lk#:lh`]lg'.lf.#lq#|ld<:lr<@lnfc~s{?)v}la/=li'klj^#l,js\typeout{h [[[+h >:x+` '":.d+` "c.wh"`"+!!:c.h gqgvh <*>"!! ;q;v`>[_*w` ;q;v| @f_*.[.*":|gqgv| :[[_d.| "`"+| :[^[*:+` >!>+| w!w+/&=w+g#cxrnxrnx<?sa"?sikrkkrkk&>va<,kndn<:n#,a<,xi'<.i'<.i'#,a<^=>}

LaTeX, 506 bytes
Most likely there will be a more efficient variant, but this is what I managed to get by hand (no built in compression tools in LaTeX...). I created a small loop to replace consecutive sequences.
\def\|{\catcode`}\def~#1{\|#1=13\lccode`~=`#1\lowercase{\def~}}\| =12~@#1#2{\ifnum#1>0#2@{\numexpr#1-1}{#2}\fi}\|#=12~){@3}~({@4}~?{(.}~/{( }~<{@9  }~>{< }~_{>)#}~[{<#).#}~]{<#.#.#}~^{#).#@6.#.#}~!{#@{18}-#}~={@{42}#}~'{?}~&{#..#?#?#}~;{/#@9--#}~:{#@5.#@6.#}~"{#.#..#?#..#}\newlinechar`+\typeout{>/@{12}{*}+>/(#?#.+>  #..)#@5.##?+>  )#@7.@6#) _ _+>@5 @{11}.@5 @2[+>/##*@7#@7 @2]+> (#@7*@6#) @2]+>).#)*.(*.*)#?@2[+>?@9**##@5._ _+>?(*/@5*?+>  (#@8 (#+>@6#@8 @6#+@{62}#+)^!+=!+)&@{20}#+=;+):;+=;+)";+=/@{12}#}

Terminal output (of both codes):
This is pdfTeX, Version 3.14159265-2.6-1.40.20 (TeX Live 2019) (preloaded format=pdf
latex)
 restricted \write18 enabled.
entering extended mode
(./mariocg.tex
LaTeX2e <2018-12-01>
               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############
)

Bubblegum, 138 bytes
00000000: a591 410a 0321 0003 efbe 6261 6e42 e7ff  ..A..!....banB..
00000010: cf2b b522 6e5a 6cc5 3908 2184 18bd eed4  .+."nZl.9.!.....
00000020: 8912 1e80 2ade 1db4 3b82 9a76 f794 c695  ....*...;..v....
00000030: 6ec8 7205 0e0c 0795 9019 874a 1677 1009  n.r........J.w..
00000040: 5972 717d 4363 2bae bed2 d676 00aa ff5f  Yrq}Cc+....v..._
00000050: 5eb5 0e40 d5df 2f17 e9f1 a99a 1f33 0f22  ^..@../......3."
00000060: e290 2e14 8e28 a8d8 4096 eaf1 c156 fbd7  .....(..@....V..
00000070: b8a2 f663 a992 bded edc1 a279 5ab7 5219  ...c.......yZ.R.
00000080: 3d6b 9d56 b152 a7ad 134f                 =k.V.R...O

Try it online!

For comparison, I tried outputting the entire image as a single Charcoal compressed string, which results in a 155-byte program. Trying to draw parts using Charcoal commands actually increases the length.

Interesting "language", it truly does kick a$$

Jelly, 235 213 bytes
“µ!æeıçȷ&#ð%ø&$dɓeñe÷Ɲ$Ƥ&ɓ'¤"' 'dd%dẎeȤdƤƬddƲdƝ‘s2⁴+Ɱ23¤żẎṣjƭƒ“Ç=ÇgƲ'€$fȤeƲ€fƈiÆf¿fÐɦÇ!×Çe2jÑþµþ¿g8i€þµþ½%4Ɲ5Ɲ2fƲ××½Ʋ;#½f¿f½Ʋ5¤6Ʋ€g¬g½i¬ⱮvØØØḳƁḳÞÞÞⱮpœßßßdœ⁾œŒŒŒdœ⁾¤o‘b50U+Ø0U‘Œṙṁ1xⱮ“&ðẏṪ¶ẏ×Ṙ⁷Ƈ⁾1Ẓṁn#’b64¤¤ị“ *#.-”Y

Try it online!
Uses a combination of run-length encoding and replacement of common length-2 sequences with a single digit. Does not use any standard compression library like gzip. Overall has 169 bytes of compressed data and 44 of code.
Explanation
Step 1: replace values in the data between 17 and 39 with prestored pairs of bytes
“µ...Ɲ‘                     | Base-250 integer list 9, 33, 22, 101, 25, 23, 26, 38, 35, 24, 37, 29, 38, 36, 100, 155, 101, 27, 101, 28, 150, 36, 151, 38, 155, 39, 3, 34, 39, 32, 39, 100, 100, 37, 100, 209, 101, 154, 100, 151, 152, 100, 100, 153, 100, 150
       s2                   | Split into twos
             ¤ż             | Zip the following as a nilad with this:
         ⁴                  | - 16
          +Ɱ23               | - Add this to implicit range from 1 to 23
             Ẏ              | Tighten (join outermost lists)
                   ƒ“Ç...o‘ | Reduce using the following, and starting with the base-250 integer list 14, 61, 14, 103, 153, 39, 12, 36, 102, 154, 101, 153, 12, 102, 156, 105, 13, 102, 11, 102, 15, 160, 14, 33, 17, 14, 101, 50, 106, 16, 31, 9, 31, 11, 103, 56, 105, 12, 31, 9, 31, 10, 37, 52, 150, 53, 150, 50, 102, 153, 17, 17, 10, 153, 59, 35, 10, 102, 11, 102, 10, 153, 53, 3, 54, 153, 12, 103, 7, 103, 10, 105, 7, 149, 118, 18, 18, 18, 217, 143, 217, 20, 20, 20, 149, 112, 30, 21, 21, 21, 100, 30, 142, 30, 19, 19, 19, 100, 30, 142, 3, 111
                  ƭ         | - Alternate between:
                ṣ           |   - Splitting
                 j          |   - And joining

Step 2: Run-length decode and convert to string
b50                                 | Convert to base 50
   U                                | Reverse order of bytes
    +Ø0                             | Add 0,0
       U                            | Reverse order again (effectively the last three links add in leading zeros where needed)
        ‘                           | Increment by 1
         Œṙ                         | Run length decode
           ṁ            ¤           | Mould like the following as a nilad:
            1xⱮ        ¤            | - 1 repeated each of the following as a nilad:
             “&...#’                |   - Base-250 integer 36418435425519061363927141799858777786
                    b64             |   - Convert to base 64
                         ị“ *#.-”   | Index into " *#.-"
                                 Y  | Join ith newlines

Bash + coreutils + xz, 243 242 240 bytes
base64 -d<<<4AROAJpdABBtAVsJZEAxAEVT46Z4yzQSDRh1V2s3yKKQ3CiFBCqNr55BVH/f7Qz/mkCIrVe+i4qcFSY5BEjUGbKH55TbsFibiXAoQ8LLpf0KeeR/Qj+UVG3Y3+Xx/Xt+0BI+rKPZCnr2NYt5PB4YsQBJeHbN+TCDB9VxVA5l2MZerD23kdk9GwTt9T7j2LGzPwyNGnq9XrJxWS3PWQOEtp8A|xz -qdFraw

The double quotes are not necessary.

@TheSola10 Thanks! Saved 2 bytes.

JavaScript (Node.js),  265  264 bytes
Saved 1 byte thanks to @Night2
Deflated.
_=>require('zlib').inflateRawSync(Buffer('pVJbDoAwCPvfKZb0b4nc/3jCRAWGOrN+qNiV8litDs2geKqCQQyQZ/inMnS8SpQRKSsYkoYw2la6ESuSpCEcq27IjPt5eDmCXFQ6jCTFl1yqYSW1/tAxzBcvp+9l6BCnJ3eqr6Wmi4H9LoHzLPNYQukd6k04bspjtA345Z7K1QDnPX2O0uKn0QcWnE13b9EoXXE1XeEtWnU12AE','base64'))+''

Try it online!

JavaScript (Node.js), 318 bytes
Consecutive string substitutions.
_=>[...`L=J00BP
FM1A46E.##3B
2G@;<9#7#:7#8.653*42-1.0 #`].reduce((s,c,i)=>s.split(Buffer([94-i])).join(c+`A= >9SOKQ< <N0#0H<> ?0C5;D3
13:498#653*42-1.0 #`[i]),`?T]=JT29#.\\A[O9\\[3.I?10#?0C779D.?TSYJT0*I#77 UBUJ2=8*I? UBUW3<8*.=.*[YYW9]8Z.K0#?0CK9=4=*9\\272WI7I
F;6I
AX3X3X@HV#@HA>>0L>0L>;2CVR>EZEZPRVRM^0<^0<^#RV462`)

Try it online!

JavaScript (ES7), 340 bytes
Crushed.
_=>[...'[{+SUPER~Mario!}]'+2**29].reduce((s,c)=>(l=s.split(c)).join(l.pop()),`U15555
U13#9#.~o#739}9~o397.28+S
18PP7.1ii
U13*2#18 a 335E28oa7}5.E.*39ii~P55E#9.8S~PEooE*P~o331+33~21+26r
#RRR00#6#00#
#[3[3[r#6]
9!9!9!]6]
#M3M3M#]6oor331o+9#P0{{{7..8U 6
2222r##E**]oo#0-#}.#!.97#+ iU#7}r2223a#}}U#}}~M}79#7~
8R7!.3E5*P77U11S3#8 3#+o {---[799`)

Try it online!
Or here:

console.log((

_=>[...'[{+SUPER~Mario!}]'+2**29].reduce((s,c)=>(l=s.split(c)).join(l.pop()),`U15555
U13#9#.~o#739}9~o397.28+S
18PP7.1ii
U13*2#18 a 335E28oa7}5.E.*39ii~P55E#9.8S~PEooE*P~o331+33~21+26r
#RRR00#6#00#
#[3[3[r#6]
9!9!9!]6]
#M3M3M#]6oor331o+9#P0{{{7..8U 6
2222r##E**]oo#0-#}.#!.97#+ iU#7}r2223a#}}U#}}~M}79#7~
8R7!.3E5*P77U11S3#8 3#+o {---[799`)

)())

Keg, 2204 1012 745 722 bytes
(35*| )(34*|\*)
(35*| )(4|\#)(4|\.)\#\.
(35*| )\#\.\.(3|\#)(5|\.)\#\#(4|\.)
(76+| )(3|\#)(7|\.)(6|\#)  (2|(34*| )(3|\#))
(82*| )(65+|\.)(5| )(2|(
| )\#(3|\.)\#)
(35*| )\#\#\*(7|\#)(7| )(2|(91+| )\#\.\#\.\#)
(34*| )(4|\#)(7|\*)(6|\#)   (2|(91+| )\#\.\#\.\#)
(65+| )(3|\.)\#(3|\*)\.(4|\*)\.\*(3|\#)(4|\.)(2|(91+| )\#(3|\.)\#)
(65+| )(4|\.)(91+|\*)\#\#(5|\.)(65+| )(3|\#)(34*| )(3|\#)
(65+| )(4|\.)(4|\*)    (5|\*)(4|\.)
     (2|(8| )(4|\#))
   (2|(8| )(6|\#))
(88*2-|\#)
(3|\#(3|\.)\#(6|\.)\#\.\#)\#(92*|\-)\#
(67*1+|\#)(92*|\-)\#
(3|\#\.\.\#(4|\.)\#(4|\.)\#)(54*|\#)
(67*|\#)    \#(91+|\-)\#
(3|\#(5|\.)\#(6|\.)\#)    \#(91+|\-)\#
(67*|\#)    \#(91+|\-)\#
(3|\#\.\#\.\.\#(4|\.)\#\.\.\#)    \#(91+|\-)\#
(67*|\#)    (34*|\#)

Try it online!
Saved 267 bytes thanks to @Sriotchilism O'Zaic, -23 thanks to a bug fix.
1012 byte program
(35*| )(34*|\*)\
(35*| )(4|\#)(4|\.)\#\.\
(35*| )\#(2|\.)(3|\#)(5|\.)(2|\#)(4|\.)\
(76+| )(3|\#)(7|\.)(6|\#)(72*| )(3|\#)(34*| )(3|\#)\
(82*| )(65+|\.)(35*| )\#(3|\.)\#(91+| )\#(3|\.)\#\
(35*| )(2|\#)\*(7|\#)(98+| )\#\.\#\.\#(91+| )\#\.\#\.\#\
(34*| )(4|\#)(7|\*)(6|\#)(76+| )\#\.\#\.\#(91+| )\#\.\#\.\#\
(65+| )(3|\.)\#(3|\*)\.(4|\*)\.\*(3|\#)(4|\.)(91+| )\#(3|\.)\#(91+| )\#(3|\.)\#\
(65+| )(4|\.)(91+|\*)(2|\#)(5|\.)(65+| )(3|\#)(34*| )(3|\#)\
(65+| )(4|\.)(4|\*)(4| )(5|\*)(4|\.)\
(67+| )(4|\#)(8| )(4|\#)\
(65+| )(6|\#)(8| )(6|\#)\
(88*2-|\#)\
\#(3|\.)\#(6|\.)\#\.(2|\#)(3|\.)\#(6|\.)\#\.(2|\#)(3|\.)\#(6|\.)\#\.(2|\#)(92*|\-)\#\
(67*1+|\#)(92*|\-)\#\
\#(2|\.)\#(4|\.)\#(4|\.)(2|\#)(2|\.)\#(4|\.)\#(4|\.)(2|\#)(2|\.)\#(4|\.)\#(4|\.)(37*|\#)\
(67*|\#)(4| )\#(91+|\-)\#\
\#(5|\.)\#(6|\.)(2|\#)(5|\.)\#(6|\.)(2|\#)(5|\.)\#(6|\.)\#(4| )\#(91+|\-)\#\
(67*|\#)(4| )\#(91+|\-)\#\
\#\.\#(2|\.)\#(4|\.)\#(2|\.)(2|\#)\.\#(2|\.)\#(4|\.)\#(2|\.)(2|\#)\.\#(2|\.)\#(4|\.)\#(2|\.)\#(4| )\#(91+|\-)\#\
(67*|\#)(4| )(34*|\#)

Try it online!
This is just a run-length encoding of the ascii picture but implemented in Keg
Old program
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \*\*\*\*\*\*\*\*\*\*\*\*\
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\#\.\.\.\.\#\.\
\ \ \ \ \ \ \ \ \ \ \ \ \ \#\.\.\#\#\#\.\.\.\.\.\#\#\.\.\.\.\
\ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\.\.\.\.\.\.\.\#\#\#\#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \.\.\.\.\.\.\.\.\.\.\.\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\.\.\.\#\ \ \ \ \ \ \ \ \ \ \#\.\.\.\#\
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\*\#\#\#\#\#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\.\#\.\#\ \ \ \ \ \ \ \ \ \ \#\.\#\.\#\
\ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\#\*\*\*\*\*\*\*\#\#\#\#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \ \#\.\#\.\#\ \ \ \ \ \ \ \ \ \ \#\.\#\.\#\
\ \ \ \ \ \ \ \ \ \ \ \.\.\.\#\*\*\*\.\*\*\*\*\.\*\#\#\#\.\.\.\.\ \ \ \ \ \ \ \ \ \ \#\.\.\.\#\ \ \ \ \ \ \ \ \ \ \#\.\.\.\#\
\ \ \ \ \ \ \ \ \ \ \ \.\.\.\.\*\*\*\*\*\*\*\*\*\*\#\#\.\.\.\.\.\ \ \ \ \ \ \ \ \ \ \ \#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\
\ \ \ \ \ \ \ \ \ \ \ \.\.\.\.\*\*\*\*\ \ \ \ \*\*\*\*\*\.\.\.\.\
\ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\#\ \ \ \ \ \ \ \ \#\#\#\#\
\ \ \ \ \ \ \ \ \ \ \ \#\#\#\#\#\#\ \ \ \ \ \ \ \ \#\#\#\#\#\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\
\#\.\.\.\#\.\.\.\.\.\.\#\.\#\#\.\.\.\#\.\.\.\.\.\.\#\.\#\#\.\.\.\#\.\.\.\.\.\.\#\.\#\#\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\#\
\#\.\.\#\.\.\.\.\#\.\.\.\.\#\#\.\.\#\.\.\.\.\#\.\.\.\.\#\#\.\.\#\.\.\.\.\#\.\.\.\.\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\ \ \ \ \#\-\-\-\-\-\-\-\-\-\-\#\
\#\.\.\.\.\.\#\.\.\.\.\.\.\#\#\.\.\.\.\.\#\.\.\.\.\.\.\#\#\.\.\.\.\.\#\.\.\.\.\.\.\#\ \ \ \ \#\-\-\-\-\-\-\-\-\-\-\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\ \ \ \ \#\-\-\-\-\-\-\-\-\-\-\#\
\#\.\#\.\.\#\.\.\.\.\#\.\.\#\#\.\#\.\.\#\.\.\.\.\#\.\.\#\#\.\#\.\.\#\.\.\.\.\#\.\.\#\ \ \ \ \#\-\-\-\-\-\-\-\-\-\-\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\ \ \ \ \#\#\#\#\#\#\#\#\#\#\#\#

Try it online!
I know this probably won't win any competitions, but hey, it looks nice.
Literally just escaping every character and printing it. I mean, it could be golfed, but don't you just love ascii art programs?

@A_, I originally tried that with the generator I used (i didn't write it by hand) but it didn't work

I don't know Keg but looks like this works and is 50 bytes shorter

And now that I understand how this works a bit more here is a much shorter version.

Pyth, 211 bytes
Xr9.HC.Z"xÚ]Á	Â@E%Q‚².NŠ[@‚^LI¦°Šñ¾$æ>A¼Ûƒx]Ð£cô 2Ìÿæ?&°sT	M3«DÊÇ‰bÝ/É¬}Ì ÏÞ‘L¦&›¡%®R$èW+…mö>3Ž`!Wr¢“ê0-ü
{*÷KšjÎÇËáÂÏÒm*üúYÓ^	. Õ¯ŽÎ´Ó,æ†]ó« –ÎRäP¨ïB#ª5Cø®Þš?ÇÇ¸z-vxË"<G6"
 .-*#

Try it online!
Compression method: Since there's only 6 characters, the space, newline as well as #.-*, replace each of these with a letter from a-f. Afterwards, run-length encode the whole thing (aaaaaccc -> 5a3c etc.), then compress using zlib.
Xr9.HC.Z"..."<G6"\n .-*#"  # Complete program (last " is implicit)
        "..."              # zlib-compressed string
      .Z                   # decompress
     C                     # read that as a base 256 integer
   .H                      # convert to hex string
 r9                        # run-length decode
X            <G6"\n .-*#"  # translate "abcdef" to "\n .-*#"

The compressed string is
      _0 _1 _2 _3  _4 _5 _6 _7  _8 _9 _a _b  _c _d _e _f

000_  78 da 5d 8d  c1 09 c2 40  10 45 0b 10  25 51 82 b2
001_  2e 4e 01 8a  5b 40 82 0b  5e 13 4c 01  49 07 a6 07
002_  0b b0 8a 05  f1 be 24 e6  3e 41 bc db  83 78 1f 5d
003_  d0 a3 63 f4  20 32 cc ff  1f e6 3f 26  b0 73 11 54
004_  0e 09 4d 08  33 9d ab 44  0c ca c7 89  62 dd 2f c9

005_  ac 7d cc 20  02 cf de 91  4c a6 26 9b  a1 25 ae 52
006_  07 24 8f e8  57 8f 2b 85  6d f6 3e 07  33 8e 60 21
007_  57 72 a2 93  16 ea 30 2d  fc 0a 7b 2a  f7 4b 9a 6a
008_  ce c7 cb e1  c2 cf d2 6d  2a fc fa 59  d3 5e 09 2e

009_  15 20 d5 af  8e ce b4 d3  2c e6 86 0e  5d f3 ab 20
00a_  96 ce 52 17  04 e4 50 a8  ef 42 0c 1e  23 aa 35 43
00b_  f8 ae de 9a  3f c7 0f c7  b8 7a 01 2d  76 78 cb

Python3, 921 916 752 751 539 534 476 bytes
And here's a mandatory fair version. I used a script to count the individual characters, should be identical:
w,s,d,r=' *.#'
m='--'
n=m*5
A=d*2
B=d*3
C=d*4
D=d*5
E=d*6
F=r*2
G=r*3
H=r*4
I=r*6
J=r*42
K=w*10
L=K+w
M=L+w
N=M+w
O=w*15
P=w*4
Q=w*8
R=d+r
S=r+R+R
T=B+r
U=r+T
V=r+A
W=r+d+F+T+E
X=r+C
Y=r+E+F+D
Z=R+A+X+V
a=r+P+r+n+r
b=J+P+r
c=F+A+X+X
e=b+n+r
f=s*12
g=d*7
h=s*3
j=s*4
k=r*62
l=m*9
o=r*11
p=r*21
z='\n'
for i in"OfzOHCrdzNVGDFCzNGgINwGMGzOwDEOUKUzOFsGHNPSKSzMHhjINSKSzLThdjdsGCKUKUzLCjhhFDLGMGzLCjPjsCzNHQHzLIQIzkzUEWWrdFlrzJrlrzVXXccpzezrDYYrEazezrZFZFZazboz":print(end=eval(i))

Try it online!
Courtesy of the awesome guys in the comments that are much better than me!
And here's the (python3) script for any others who might want to generate some code and are too lazy/efficient to count manually:
mario = '''
               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############
'''

curr_char = ""
count = 0
for i in mario:
    if i == curr_char:
        count += 1
    else:
        if curr_char != '\n':

            if curr_char == ' ':
                curr_char = 'w'
            elif curr_char == '#':
                curr_char = 'r'
            elif curr_char == ".":
                curr_char = "d"
            elif curr_char == "-":
                curr_char = "m"
            elif curr_char == '*':
                curr_char = 's'

            print(curr_char + '*' + str(count), end="+")
        else:
            print(",", end="")

        curr_char = i
        count = 1

Python3 loophole abused, 167 bytes
Since nothing was said about standard loopholes, I'll sneak this one in here while I can. TIO doesn't like urllib for some reason, if anyone knows a site to host the script on please tell me to.
Obviously a link shortener could save some bytes, but I didn't want to go down that rabbit-hole any further.
from urllib.request import *
import re
print(re.split("</?code>",str(urlopen("https://codegolf.stackexchange.com/q/192715/85978").read()))[1].replace("\\n","\n")[:-1])

I'm pretty sure the point about standard loopholes is that they apply even when not explicitly mentioned.

Yes, I agree; but since op said many people, including me and my friend, are interested about how to solve this problem within the fewest characters, I thought it might be worth a good laugh; which kind of fits the recreational programming theme of this post and parts of this site.

Then just take the text as input and use print(input())

Well, then I'd count the input towards the bytes used, since it'd defeat the entire challenge. I just wanted to play a bit with the 'programmers should never redo what is already out there' trope. Sorry if my mentality of just having fun in this environment bothers you, I didn't mean to at all!

@ar4093 there, added a fair version; you can upvote me now :P

I don't know python, but can you make m equal two dashes since every usage of dash is an even number?  If so, you can save about 5 characters.

Very observant! Nice!

-9 bytes if you combine the single characters into one string. w,s,d,r=' *.#'
m='--'

The last line is 3 bytes shorter as [*map(print,[...])]

You could keep repeating your manual RLE... ~ 544 B:
w,s,d,r=' .#';m='--';n=m5;A=d2;B=d3;C=d4;D=d5;E=d6;F=r2;G=r3;H=r4;I=r6;J=r42;K=w10;L=w11;M=w12;N=w13;O=w15;P=w4;Q=w8;R=d+r;S=r+R+R;T=B+r;U=r+T;V=r+A;W=r+d+F+T+E;X=r+C;Y=r+E+F+D;Z=R+A+X+V;a=r+P+r+n+r;b=J+P+r;c=F+A+X+X;e=b+n+r
for i in[O+s12,O+H+C+r+d,N+V+G+D+F+C,N+G+d7+I+w14+G+M+G,w16+d11+O+U+K+U,O+F+s+r7+w17+S+K+S,M+H+s7+I+N+S+K+S,L+T+s3+d+s4+d+s+G+C+K+U+K+U,L+C+s10+F+D+L+G+M+G,L+C+s4+P+s5+C,N+H+Q+H,L+I+Q+I,r62,U+E+W+W+r+d+F+m9+r,r43+m9+r,V+X+X+c+c+r21,e,r+D+Y+Y+r+E+a,e,r+Z+F+Z+F+Z+a,b+r11,]:print(i)

...and you can save another ~ 30 B if you then get rid of all the asterisk expressions (into vars) and remove the pluses making a single string, which you can then eval over

@AC what exactly do you mean? What whould I eval over?

-2 bytes

And another -3 bytes, continuing Veskah's work

@jaaq I meant something like this , saving another 58B (I might have split differently)

wow, nice! I didn't get that at all! Good catch!

@jaaq unfortunately, it's still longer than the boring old zip+mime approach, which comes in under 300 B (and has imports... ick!)

@AC well I guess that one's the winner. You should submit it as an additional answer though.

Bash + coreutils, 269 262 261 Bytes
base64 -d <<<H4sICLN9e10CA01BUklPAKVSWw6AMAj73ymW9G+J3P94wkQFhjqzfqjYlfJYrQ7NoHiqgkEMkGf4pzJ0vEqUESkrGJKGMNpWuhErkqQhHKtuyIz7eXg5glxUOowkxZdcqmEltf7QMcwXL6fvZegQpyd3qq+lpouB/S6B8yzzWELpHepNOG7KY7QN+OWeytUA5z19jtLip9EHFpxNd2/RKF1xNV3hLVp1tWPaAR8+K1RPBAAA|gunzip

A bit trivial - nothing clever happening here.  I'm not sure if I'm allowed to use gzip like this.  If I'm not I have no doubt someone will shout at me.
(better if I remove pointless spaces/quotes)
Thanks to @manatwork for saving a byte
Try it online!

Digital Trauma's tip may help you reduce it a bit more.

@manatwork Thanks, that helped me optimize a byte out of my answer.

You could drop the echo command and a pipe by making it base64 -d<<<...|gunzip

C (gcc), 322 320 318 316 bytes
-2 bytes thanks to ceilingcat.
f(i,c){for(i=0;c="/<q/TDQAq-QBSERDq-SGV.S,Sq/!K/QCQ*QCQq/R1W/\"QAQAQ*QAQAQq,T7V-QAQAQ*QAQAQq+CQ3A4A1SD*QCQ*QCQq+D:RE+S,Sq+D4$5Dq-T(Tq+V(Vq____RqQCQFQARCQFQARCQFQARocQq__]ocQqQBQDQDRBQDQDRBQDQD_Vq__\\$QjQqQEQFREQFREQFQ$QjQq__\\$QjQqQAQBQDQBRAQBQDQBRAQBQDQBQ$QjQq__\\$\\"[i++];)for(;c--%16;)printf(L" *.#-\n"+c/16-2);}

Try it online!

Bash, 486 bytes
a=#.#.#O#.#.#
b=#e#O#e#
c=I#w#
S="Tb
T3f#.
R#d2g1f
R2i5S2Q2
UmT$b
T1*6V$a
Q3]5R$a
Pe#Y.Z.*2fO$b
Pf\`1gP2Q2
PfZI[f
R3M3
P5M5
EEA
#e#h#.1e#h#.1e#h#.1wu#
EDwu#
#d#f#f1d#f#f1d#f#fD
EC$c
#g#h1g#h1g#h#$c
EC$c
#.#d#f#d1.#d#f#d1.#d#f#d#$c
ECI;"
p(){
for((i=$[d-$2];i>0;i--)){ printf "$1";}
}
IFS=
while read -r -d '' -n1 c;do
printf -vd %d "'$c"
[ $d -le 47 ]&&printf "$c"||[ $d -le 69 ]&&p '#' 47||[ $d -le 86 ]&&p ' ' 69||[ $d -le 98 ]&&p '*' 86||[ $d -le 109 ]&&p '.' 98||p '-' 109
done<<<$S

Try it online!
The Run-Length Encoded string $S generated by the non-golfed program here:
Try it online!
Then variables $a,$b,$c in $S were substituted by manual inspection, and a single back-tick had to be escaped in $S to allow variables to be used.

Perl, 422 396 370 366 365 characters
print"f c*
f 4#4.#.
d #..3#5.##4.
d 3#7.6#e 3#c 3#
10 b.f #3.#a #3.#
f ##*7#11 2<#.>#a 2<#.>#
c 4#7*6#d 2<#.>#a 2<#.>#
b 3.#3*.4*.*3#4.2<a #3.#>
b 4.a*##5.b 3#c 3#
b 4.4*4 5*4.
d 4#8 4#
b 6#8 6#
3e#
3<#3.#6.#.#>#12-#
2b#12-#
2<#..#4.#4.#>#.2<.#4>.15#
2a#4 #a-#
3<#5.#6.#>4 #a-#
2a#4 #a-#
3<#.#..#4.#..#>4 #a-#
2a#4 c#"=~s/.<(.+?)>/$1x$&/ger=~s/\w+(.)/$1x hex$&/ger;

Run-length encoded in 2 steps: consecutive characters and consecutive patterns of multiple characters.
Try it online!

PowerShell + tar, 265 = 9+256 bytes
This script works with Windows and Linux. The script extracts the output from the tar archive t (256 bytes). The t should be placed in the same directory as the script.
tar xOf t

Try it online!
The powershell script to create the tar archive t:
(@"
               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############
"@) | Set-Content f -Force
tar zcfo t f

Python 3, 551 bytes
[print(" *#.-\n"[ord(x[1])-35]*(ord(x[0])-35),end="")for x in ["2#/$$(2#'%'&$%$&$(0#$%%&&%(&%%'&$(0#&%*&)%1#&%/#&%$(3#.&2#$%&&$%-#$%&&$%$(2#%%$$*%4#$%$&$%$&$%-#$%$&$%$&$%$(/#'%*$)%0#$%$&$%$&$%-#$%$&$%$&$%$(.#&&$%&$$&'$$&$$&%'&-#$%&&$%-#$%&&$%$(.#'&-$%%(&.#&%/#&%$(.#'&'$'#($'&$(0#'%+#'%$(.#)%+#)%$(a%$($%&&$%)&$%$&%%&&$%)&$%$&%%&&$%)&$%$&%%5'$%$(N%5'$%$($%%&$%'&$%'&%%%&$%'&$%'&%%%&$%'&$%'&8%$(M%'#$%-'$%$($%(&$%)&%%(&$%)&%%(&$%)&$%'#$%-'$%$(M%'#$%-'$%$($%$&$%%&$%'&$%%&%%$&$%%&$%'&$%%&%%$&$%%&$%'&$%%&$%'#$%-'$%$(M%'#"[x:x+2]for x in range(0,454,2)]]

First code golf!
Try it online!

Good first code golf!

Pure JavaScript 419 bytes (no lib)
Compression (1 step: count each char in hex e.g. ********** gives *a, 2 step: convert two chars like *1 or #4 to single char witch free ascii code)

let d=`               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############`
c=d.replace(/(.)\1*/g,(m, g)=>g+m.length.toString(16)).replace(/(.)([1-6])/g,(m,g,e)=>  String.fromCharCode(' .#-*'.indexOf(g)*6- -(e-1)+58))

console.log(c.length,c);

Decompression

c=` f*c
 fICF@
 dFAHDGC
 dH.7K eH cH
:0.b fFBF aFBF
 fGR#7:1F@F@F aF@F@F
 cI*7K dF@F@F aF@F@F
 bBFT@U@RHC aFBF aFBF
 bC*aGD bH cH
 bCU=VC
 dI 8I
 bK 8K
He
FBFEF@GBFEF@GBFEF@GL2F
GbL2F
FAFCFCGAFCFCGAFCFCF5
Ga=F-aF
FDFEGDFEGDFEF=F-aF
Ga=F-aF
F@FAFCFAG@FAFCFAG@FAFCFAF=F-aF
Ga=#c`
console.log(c.replace(/[:-Z]/g,m=>(z=m.charCodeAt(0)-58,' .#-*'[z/6|0]+(1+z%6))).replace(/([ #.\-*])([0-9a-f]+)/g,(m,g,e)=>g.repeat('0x'+e)))

Python, 340 378 bytes
I messed up the encoding in the original answer, here's one based on LZW compression. Might revisit my original answer at some point.
n=0
for c in'"/AVHF`N.o,>D\\5:{/RD?{C._Q\\%r7,SUOXGh8<}nA^Qddb<=Vb7;L@QPi[XJ65W=p|@<fxMl2+C1gro(x%m"Iz0+B?9d</tYaj.!:6(T#_/5el1Hl{[W&g*A.Oc1*4zf#[{WfLr@Km_jgFkg#1D`&Ik9r\'{M]7c&# X1,U#]=>}JFwVexi7nzbKnS-@-y{IA=l#="EVj=8L`%"9w@zoc9!:q/rT\\OMd]/p^ksiT?P_yj,':n=n*94+ord(c)-32
d=[*' *\n#.-']
s=c=' '
while n:i=n%202;d+=[c+(i>=len(d)and c[0]or d[i][0])];c=d[i];s+=c;n//=202
print(s)

Try it online!

This one isn't correct, you're missing 16 characters in the last line of the output.

@Skillmon Thanks, updated with a working answer.

PHP, 608 565 557 bytes
Uses GMP, the 5kJvr... string was created by first using substitutions to convert the original to base 5 6, then GMP to convert to base 62.
<?=str_replace(range(0,5),str_split("\n-.#* "),gmp_strval(gmp_init('5kJvrGbxP8CrM96cfgUaH1i7H5NT19NW3eSlwbRNO6MzND4omDb8BkvVwnTb1bQtCr6pet0EVt9BQnTuRSwcrL1Gnzs6dMEKAPctFQDrnbXv3eIzlyPYhZpGTwostpxBRJa7bvJvVVgoVjErM9sLKVxa0YkOaOUgMAP6orzz4ZGzb5iQ4qGDDuUOEiKmrcGTHp58srEheAqQSRQE4dOMlauXH4i06DY6tY8gu4maD2BFa68FA7s9sQG9VplFHpecaduYnzLoZgz18xwunIlSkFyIFCUyVMgVxvN7wxtyFZZSAli6DRyV1EobXZtiRa60mYyIZTYL79x190EjhCRAlBM1Lk11FJCeOFkKpAYW8M1hzUpghKA07J31gHpvlkFFKA4dSXvoZwGPbcrGOsmcsi5GAbhB2MIJe9XJGrA7KcSeMfOdxany7HEcesx8oewhtlRHnwxmG8qu8WwA8fjm1S82LMGrq3t',62),6));

Run online.

C, 1142 1068 1044 bytes
It's not very good, but I made it. Basically, I went line by line and any place one function plus two or more function calls was shorter than the original text, I replaced the text with a function.
s=32;a=42;h=35;d=46;m=45;p(c,n){while(n--){putchar(c);}}n(){puts("");}c(){printf("#.#.#");}o(){printf("#...#");}z(){p(m,18);p(h,1);n();}x(char*c){printf("%s",c);}y(){p(h,42);x("    #----------#\n");}main(){p(s,15);p(a,12);n();p(s,15);x("####....#.\n");p(s,13);x("#..###.....##....\n");p(s,13);p(h,3);p(d,7);p(h,6);p(s,14);p(h,3);p(s,12);p(h,3);n();p(s,16);p(d,11);p(s,15);o();p(s,10);o();n();p(s,15);p(h,2);p(a,1);p(h,7);p(s,17);c();p(s,10);c();n();p(s,12);p(h,4);p(a,7);p(h,6);p(s,13);c();p(s,10);c();n();p(s,11);x("...#***.****.*###....");p(s,10);o();p(s,10);o();n();p(s,11);x("....**********##.....");p(s,11);p(h,3);p(s,12);p(h,3);n();p(s,11);x("....****    *****....\n");p(s,13);p(h,4);p(s,8);p(h,4);n();p(s,11);p(h,6);p(s,8);p(h,6);n();p(h,62);n();o();x("......#.##...#......#.##...#......#.##");z();p(h,43);z();x("#..#....#....##..#....#....##..#....#....");p(h,21);n();y();x("#.....#......##.....#......##.....#......#    #----------#\n");y();x("#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#\n");p(h,42);p(s,4);p(h,12);n();}

It saves 99 bytes over just using straight printf.
Saved 69 bytes by removing int and void specifiers, and the #include <stdio>. Saved another 2 bytes by declaring i as global instead of in the for loop. Saved another 3 bytes changing printf to putchar in two places. Removed another 21 bytes with changes suggested by @Christian Gibbons: Removed variable declarations at the beginning, changed the for loop to a decrementing while loop, changed '\n' to 10 in the n() function. Saved another 3 bytes changing putchar(10) to puts(""), courtesy of this answer.
1143 bytes
main(){printf("               ************\n               ####....#.\n             #..###.....##....\n             ###.......######              ###            ###\n                ...........               #...#          #...#\n               ##*#######                 #.#.#          #.#.#\n            ####*******######             #.#.#          #.#.#\n           ...#***.****.*###....          #...#          #...#\n           ....**********##.....           ###            ###\n           ....****    *****....\n             ####        ####\n           ######        ######\n##############################################################\n#...#......#.##...#......#.##...#......#.##------------------#\n###########################################------------------#\n#..#....#....##..#....#....##..#....#....#####################\n##########################################    #----------#\n#.....#......##.....#......##.....#......#    #----------#\n##########################################    #----------#\n#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#\n##########################################    ############\n");}

Try it online here.
Ungolfed (ish)
s=32;a=42;h=35;d=46;m=45; // ASCII indices of (space) * # . - symbols.
p(c,n){ // Prints c, n times.
    while(n--){
        putchar(c);}}
n(){ // Prints a newline.
    puts("");}
c(){ // Prints a piece of the coins. Used 4 times.
    printf("#.#.#");}
o(){ // Prints a piece of the coins, and the ground. Used 5 times.
    printf("#...#");}
z(){ // Prints a piece of the ground. Used twice.
    p(m,18);;p(h,1);n();}
x(char*c){ // Wrapper for printf. Used 10 times.
    printf("%s",c);}
y(){ // Prints a piece of the ground. Used twice.
    p(h,42);x("    #----------#\n");}
main(){
    p(s,15);p(a,12);n();
    p(s,15);x("####....#.\n");
    p(s,13);x("#..###.....##....\n");
    p(s,13);p(h,3);p(d,7);p(h,6);p(s,14);p(h,3);p(s,12);p(h,3);n();
    p(s,16);p(d,11);p(s,15);o();p(s,10);o();n();
    p(s,15);p(h,2);p(a,1);p(h,7);p(s,17);c();p(s,10);c();n();
    p(s,12);p(h,4);p(a,7);p(h,6);p(s,13);c();p(s,10);c();n();
    p(s,11);x("...#***.****.*###....");p(s,10);o();p(s,10);o();n();
    p(s,11);x("....**********##.....");p(s,11);p(h,3);p(s,12);p(h,3);n();
    p(s,11);x("....****    *****....\n");
    p(s,13);p(h,4);p(s,8);p(h,4);n();
    p(s,11);p(h,6);p(s,8);p(h,6);n();
    p(h,62);n();
    o();x("......#.##...#......#.##...#......#.##");z();
    p(h,43);z();
    x("#..#....#....##..#....#....##..#....#....");p(h,21);n();
    y();x("#.....#......##.....#......##.....#......#    #----------#\n");
    y();x("#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#\n");
    p(h,42);p(s,4);p(h,12);n();}

You can golf a bit more with some simple changes.  Remove s,a,h,d,m, from the beginning, those will be implicitly declared as ints when you initialize them immediately afterwards.  for(;i++>n;) will allow you to avoid writing i again within the loop.  putchar('\n') -> putchar(10) to shave a couple more bytes.  Also looks like you've got an extraneous ; in your z function.

actually, we can dump i altogether.  Instead of a for-loop, do while(n--)

@ChristianGibbons: Thanks. I think that saved 21 bytes. Too bad it's still over three times the size of that other C answer.

Moving x() to the top, you can have c() and  o() call it to save some bytes. x() itself can take int*, since all pointers tend to have the same size, and print using printf(c) to save a few more bytes. Two functions can be shortened somewhat: n(){p(10,1);} and p(c,n){while(n--)x(&c);} (assumes little endian). Any time you call a function without an argument, you can use the previous function call as an argument, like so: c();n(); --> n(c());.

Building on @gastropner 987 bytes

Python3, 557 bytes
Run length encoded, then a few repeated substrings (spaces then three "#", "-" surrounded by blocks, etc) manually extracted. Definitely room for improvement
u,v,w,x,y,z="*.-#\n "
t=z*4
s=x+w*18+x
r=t+x+w*10+x+y
q=x+v*3+x+v*6+x+v+x
p=x+v*2+x+v*4+x+v*4+x
o=x+v*5+x+v*6+x
n=x+v+x+v*2+x+v*4+x+v*2+x
m=z*10+x+v+x+v+x
l=z*10+x+v*3+x
print(t*4+u*12+y+z*15+x*4+v*4+x+v+y+z*13+x+v*2+x*3+v*5+x*2+v*4+y+z*13+x*3+v*7+x*6+z*14+x*3+t*3+x*3+y+t*4+v*11+z*5+l*2+y+z*15+x*2+u+x*7+z*7+m*2+y+t*3+x*4+u*7+x*6+z*3+m*2+y+z*11+v*3+x+u*3+v+u*4+v+u+x*3+v*4+l*2+y+z*11+v*4+u*10+x*2+v*5+z*11+x*3+t*3+x*3+y+z*11+v*4+u*4+t+u*5+v*4+y+z*13+x*4+t*2+x*4+y+z*11+x*6+t*2+x*6+y+x*62+y+q*3+s+y+x*42+s+y+p*3+x*20+y+x*42+r+o*3+r+x*42+r+n*3+r+x*42+t+x*11)

Python3, 789 bytes
Fun with random number generators. The image is run length encoded, then broken into chunks of 6. The first chunk (indices for the symbol to print) is generated from a pseudo-random number generator. The second is a base64 encoding of the 6 numbers.
from random import*
for a,b in zip([24743,129678,6328,31748,115,39591,43781,6080,105810,23721,53737,47694,64624,41381,26725,50462,13767,37213,119081,62980,29054,29054,29054,88178,27000,29054,29054,22423,17293,29054,53737,4887,17293,29054,29054,29054,53737,4887],[4366013200,2167672897,13976478019,12938928579,1328349251,1124376643,18371322817,10754461761,1090785345,1293447436,1241780289,11828203585,1141125187,3240640705,1091310209,11895611659,4479791875,13976490244,6627279364,1106776456,2164547651,2164547651,2164547651,1387008082,1141121089,1141121156,1141121156,1151866180,1157894218,2248429702,1141137477,1151864906,1090785354,2181316674,1141121089,1107562626,1141121092,11889283146]):
    seed(a)
    while b:
        b,i=divmod(b,64)
        print(" \n#-.*"[randrange(6)]*i,end="")

Instead of having newline stored in a variable you can use print(line1,line2,...,sep='\n')

SOGL V0.12, 971 bytes
I simply copied the whole string to the compressor. I realized that the string wasn't compressed a lot.
"ξ↔⁴‚σ╔↔æz½↓«ļ;¾⅝↑¶q$+ξρI#↔@≥Β⁄,;∆n2BΡ¾~«n▼og╤iCΘ⌠δZ░∑℮E3č─æ`⅓+↑žS]ķø 'αN²'Q-ω⅞±ž<e⁴Κ№6‼Dfθ∫⅞)i≠Ph╗8B‽`HΔ→┘↓d5∑∫h╤kΖΜY⅞|⌡Σχ¡GΥq«≡─ηe→°~⁹*░κRΝycč□±H⅔b¾℮╗↕Θ*ζΜ9⁵Dæqēυ¦Jn|¼▲ū-⁹¡╗;g²T℮F6u*ε¤3⅜v■└$}Q;▒MKηBqο⁰X╬/Lβ┌I╬č¤¾►'█p¹A0E∑QXγ9§čΡT▒ξ⁾n‚Υ∫æ¤3I-↕æA⁄gTq√šk3>‼μσ¤j:Zk►↓σ¾ņ*∑*╤ΚPn׀æS~3j‚~█fo╔Ε‼■¤υ ρ{¦Oτ◄μ`]ŗS▓κΜ4y║6AΨū0⁽:uMφ^υκ≤&/═;Ο≠№3→⁄Θ±ū<R°ω.cģ²⁴׀Kē~Θ60Εθ^Ε½rA┼═◄⅞║⁶jH²βX8ΓMOšι≤9#$XΚƨ]¶ļA¾⅛x▲Ε|F■¾ƨ(Υ5ΨB[↑√℮⅔α@↓ļ\TB⌠w⅝³βšīηo¤Ω¦∑CTΕņžAh′DαψH?¡ΙO‽HωΕ?○Æ¦Ζ`∙²u   ⁶¾╚iļ⁶Π7⁾ρ℮░;(Ο²9⅔v○⌡⁽¾‽↑┼ξjƧ¬h¼┌Y▲¹ēhμΞ*⁴ā≠cmeeW℮ADC═¬[9išE⅛~№k⅔№lķ¼⅛∆$qΒR┐Γ¦⅔}\Φ‼ΩxøG⁾ΓOŗ⅟zψ;¹]m║░↔═;↑τΩÆΘχW»G∞ΧQT_L  Δ   nē‼№>ζƧρΕ↔Λλ↑EīšÆ↑gWIμū█⁹└Ιf⌡EΘ⁶cυ═<⅜LjΤlτ⅞⅟ΟB╚@░⁽ič-|dΘž⁽Υ■tPp⁵θ╝│⅜v+M8³Τ╝ι░╬¶ū¾oī⅜o╥\VΨΖ6±≡∆hl?ΦģīX╚æ→#%C\aG‛Ι⌠?ΞJ⁄═⁴v°±∫⁸dy►īι׀ģ&χeģ ~xš/L»ψ(Ξ]δ‛ģæ─╗ƨ╚a*‰■Υ□L$.Λ└≈′9ν‚v░¦+ΛξƧΟļBKγ÷Π*IΝ‚ρTGΜ-^gΗ?Æ[ā╤⅓c&►δæ↓°√>R%┘⁵ī╥$J▲kψβ▲Χ╝0ψγαp¾‼~γ!ι⅔_γψ⁄⅝┼═ģÆ⁴A»┼Jλ∆≤š'ΣRΡΩd4¬hAVb¬zbH⁸ωθyV»⁹№ξ╤*°Kν-G[═ζ∙εY↔⁾Xp⁷χ<⁹≈≈┐>°(Æ#¼i┌γδ∫+ευļDET⌡∆═ν<xzΘ⁰⌡hS»ΚKļ⁰G*mε▲GΖλDΗ_Ηx╝⁴ΘλLσ╝ψB~χ[Ν#ΗhΡ\λ2Y∙ψ¤i⌠}λ▒│αξqzP⅜¶²‘

Try it Here!

Vyxal, 368 bytes
»æl⟨Ė"†ꜝ¯⅛±ʀ|⟩nǎ@•‛b⇧ǒḞŻḋ⟇P:₇bj⌊Ż↵⌐D:Jẏɖƒ)e⋏&ƈƈ⋎ĖXε4⟇ß„¹≤9=↲tẇ₀†°nẊF°q⋏~kƈxḟ√ẇjaK↔?÷∴4ɽġ⋎?ṅṅ…‹%⅛↵•«⌈0Ǎm ≬Ǎa≠‹E√℅λ'9ø!‟.7¨∴ṗpλ↔3ḋ~€¼↳Ǔ≬⌐p⋎Ȯβε ⁰A:M@ṙR√hŀ⟑$~y?ṫL∩¹W"⌈«½*;⟩↓!j₁½›ȯḢXṀ₆∪ʀ‹≈I∨⁽3Oǔ⟇⁽¬∧0ßṡ₃∵GB÷ɾ‡ḋ5<‛t½«s≬≠꘍‛#‡↑≬Kg`ZµƈÞḂV↑ɾ↑ȯẋ¯⊍CḞ(∵j⌈Ṁ⟇∷⁺ƈġ↓ u₌□⇩ḃ↑↲f⅛:¯J¾ƒl₈€FK≈ĊḢƈεC¹9ΠVG¶Ṡ‟~R∵ĠaBI∆ḃg2eṀ¡Ǒ8µEtṫy+¹₆C3g*/ė¬u
⁽ǐ≠MḊ•T⟇€•sṗSŻjJ₌∴¹Jƛǒ₃uṫż‹↔C∆%ẏ¶⟨⌈"(ṅ∑∆*$Ġ»`#.* -
`τ

Try it Online!
Losing to... A lot of stuff.

Perl with Filter:sh module, 672 bytes
It's long but it is also rather unreadable so I thought it qualifies as a golfing answer...
use Filter::sh 'sed "s/S/\" \"/g"';
use Filter::sh 'sed "s/\([0-9]\+\)/x\1 ./g"';
$e="....";$a="#...#$e..#.#";$b="#..#$e#$e#";$c="#$e.#$e..#";$d="#.#..#$e#..#";$f="###";$g="#...#";$h="#.#.#";
print S16"*"12"\n".S16'#'4'.'4"#.\n".S14"#..$f$e.##$e\n".S14$f."."7$f.$f.S13$f.S12"$f\n".S17"."11S14$g.S10"$g\n".S16"##*"."#"7S16$h.S10"$h\n".S13"$f#"."*"7"#"6S12$h.S10"$h\n".S12"...#***.****.*###$e".S9$g.S10"$g\n".S12$e."*"10"##$e.".S10$f.S12"$f\n".S12"$e****    ****$e\n".S14"$f#".S8"$f#\n".S12$f.$f.S8"$f$f\n"."#"62"\n$a$a$a#"."-"18"#\n"."#"43"-"18"#\n$b$b$b"."#"20"\n"."#"42S4"#"."-"10"#\n$c$c$c".S4"#"."-"10"#\n"."#"42S4"#"."-"10"#\n$d$d$d".S4"#"."-"10"#\n"."#"42S4"#"12"\n";

Explanation: the filter replaces S with " " and a number with x(num) ., so for example S14 becomes " "x14 . In Perl this means "print a space 14 times". Furthermore there is some manual compression for sequences that occur often using variables $a-$h.

Why use sed commands when perl supports s/regex/replace/g syntax natively?

@Score_Under that is because I didn't know about the e regex modifier that is needed here to execute the x operator after substitution - but now I do :D

TlanG 528 527 bytes
( *11\n)*11'*10>*11>*4\**12,<*13\#*4....\#.,<*12\#..\#*3.*5\#\#.*4#,>*12\#*3.*7\#*6 *13\#*3 *11\#*3#,>*15.*11 *14\#.*3\# *9\#.*3\##,>*14\#\#\*\#*7 *16\#*5<<.<*3.>*5 *7\#*5<<.<*3.#,>*11\#*4\**7\#*6 *12\#*5<<.<*3.>*5 *7\#*5<<.<*3.#,>*10...\#\**10<*7.>*4.>\#*3.*4 *9\#.*3\# *9\#.*3\##,>*10.*4\**10\#\#.*5 *10\#*3 *11\#*3#,>*10.*4\**4 *4\**5.*4#,>*12\#*4 *8\#*4\n>*10\#*20<*14 *8\n\#*62\n(\#.*3\#.*6\#.\#)*3\#\-*18\#\n\#*43\-*18\#\n(\#..\#.*4\#....\#)*3\#*20\n(\#*42 *4\#\-*10\#\n\n)*2'''(\#.*5\#.*6\#)*3 *4\#\-*10\##,,\#*58<*16 *4

yay own lang
This is how it works:
  <any char>
    - print
  <any char>*<number smaller than 512>
    - print multiple
  (<any string (can contain commands, but no other loops>)*<number smaller than 512>
    - print string multiple times
  \<any command>
    - print the command, dont execute it
  '
    - go up in terminal (must be compatible with terminal, any linux terminal works)
  ,
    - go down in terminal (must be compatible with terminal, any linux terminal works)
  <
    - go left in terminal (must be compatible with terminal, any linux terminal works)
  >
    - go right in terminal (must be compatible with terminal, any linux terminal works)
  #
    - go to start of line in terminal (must be compatible with terminal, any linux terminal works)
  -
    - delete everything behind the cursor (must be compatible with terminal, any linux terminal works)
  \n
    - line break (program line breaks are ignored)

Welcome to the site! I've edited your answer slightly so that it's closer to the standard answer format. As someone who tends to use their own languages, I'd highly recommend you edit in an explanation for how your code works, so that others are able to understand and verify your code. Furthermore, I'd suggest you check out some of the challenges linked here, which is a list of easy challenges to take new programming languages for a spin.

@cairdcoinheringaahing thanks! i will

///, 363 bytes
/~/\/\///J/  ~I/#3~H/#
~G/66~F/EE~E/JJ~D/##~C/55~B/
2~A/BJ~0/93~9/.#~8/D#~7/***~6/#.~5/8#~4/---------~3/...~2/FJ ~1/CCCCCD/2E7777AJ53.6A6.83.9I.A833.5D2J 82 8AJ 333..2EI#FJI#AJD*582EJG#FJG#B 577*5D2JG#FJG#B3#7.7*.*83.FJI#FJI#B3.777*D3..282 8B3.7*E7**3.A5F5B5DF5D
1CC5
II36D3I36D3I36D44H1#44H60096009600.CC5H1E#4-HI.03D3.03D3.03#E#4-H1E#4-HG0.69G0.69G0.69E#4-H1EC5

Try it online!
/// has great string compression capabilities.
/~/\/\// from Tips for golfing in ///.


text:
Permutations in Disguise
Given a \$n\$-dimensional vector \$v\$ with real entries, find a closest permutation \$p\$ of \$(1,2,...,n)\$ with respect to the \$l_1\$-distance.
Details

If it is more convenient, you can use permutations of \$(0,1,...,n-1)\$ instead. If there are multiple closest permutations, you can output any one or alternatively all of them.
The \$l_1\$ distance between two vectors \$u,v\$ is defined as $$d(u,v) = \sum_i \vert u_i-v_i\vert.$$
If you want, you can assume that the input solely consists of integers.

Examples
[0.5  1] -> [1 2], [2 1]
c*[1 1 ... 1] -> any permutation
[1 4 2 6 2] -> [1 4 3 5 2], [1 4 2 5 3]
[1 3 5 4 1] -> [2 3 5 4 1], [1 3 5 4 2]
[7 7 3 2 5 6 4 2] -> [8 7 3 2 5 6 4 1], [8 7 3 1 5 6 4 2], [7 8 3 2 5 6 4 1], [7 8 3 1 5 6 4 2]
[-2 4 5 7 -1 9 3] -> [1 4 5 6 2 7 3], [2 4 5 6 1 7 3], [1 4 5 7 2 6 3], [2 4 5 7 1 6 3]
[0 4 2 10 -1 10 5] -> [1 4 2 6 3 7 5], [1 4 3 6 2 7 5], [2 4 3 6 1 7 5], [3 4 2 6 1 7 5], [1 4 2 7 3 6 5], [1 4 3 7 2 6 5], [2 4 3 7 1 6 5], [3 4 2 7 1 6 5]

Octave script for generating more examples.

Are we guaranteed that all the elements of v, will be greater than 0? Or, at least, not 0?

No, the entries of v can be any integers. (Added some more examples.)

If they can be any real numbers then [1.6 2] is an important test case (greedy algorithm/lexicographic sort gives the wrong answer).

Dang! Could've saved a byte if they were all non-zero.

Duplicate in disguise? I'm not sure it should be closed as such, though, because it's not obvious that it is the same task (as now proved by xnor).

(In fact, it's not the same task, but all solutions of the linked challenge are solutions of this one.)

Python 2, 60 bytes
def f(l):z=zip(l,range(len(l)));print map(sorted(z).index,z)

Try it online!
Uses zero-indexing.
A fast algorithm with a simple idea. If we instead need to permute the input list to make it as close to \$(1,2,...,n)\$ as possible, we should just sort it, as proven below. Since we're instead permuting \$(1,2,...,n)\$, we choose the permutation that's ordered the same way as the input list, like in my challenge Imitate an ordering (except the input may have repeats). (Edit: miles pointed out this more identical challenge, where Dennis has this same answer.)

Claim: A permutation of the list \$l\$ that minimizes its distance to \$(1,2,...,n)\$ is \$l\$ sorted.
Proof: Consider some other permutation \$l'\$ of \$l\$. We'll prove it can't be better than \$l\$ sorted.
Pick two indices \$i,j\$ that \$l'\$ has out-of-order, that is where \$i<j\$ but  \$l'_i > l'_j\$. We show that swapping them can't increase the distance to \$(1,2,...,n)\$. We note that swap changes the contribution these two elements as follows:
  $$ |l'_i - i | + |l'_j - j | \to |l'_i - j | + |l'_j - i|.$$
Here's a neat way to show this can't be an increase. Consider two people walking on a number line, one going from \$l'_i\$ to \$i\$ and the other from \$l'_j\$ to \$j\$. The total distance they walk is the expression on the left. Since \$i<j\$ but \$l'_i > l'_j\$, they switch who is higher on the number line, which means they must cross at some point during their walks, call it \$p\$. But when they reach \$p\$, they could then swap their destinations and walk the same total distance. And then, it can't be worse for them to have walked to their swapped destinations from the start rather than using \$p\$ as a waypoint, which gives the total distance on the right-hand side.
So, sorting two out-of-order elements in \$l'\$ makes its distance to \$(1,2,...,n)\$ smaller or the same. Repeating this process will sort \$l\$ eventually. So, \$l\$ sorted is at least as good as \$l'\$ for any choice of \$l'\$, which means it as optimal or tied for optimal.

Note that the only property of \$(1,2,...,n)\$ that we used is that it's sorted, so the same algorithm would work to permute any given list to minimize its distance to any fixed list.
In the code, the only purpose of z=zip(l,range(len(l))) is to make the input elements distinct, that is to avoid ties, while keeping the same comparisons between unequal elements. If the input we guaranteed to have no repeats, we could remove this and just have lambda l:map(sorted(l).index,l).

brilliant insight

You've simplified this into finding the ordering.

@miles That's pretty funny, I completely forgot about that challenge even though I wrote an answer, and Dennis has this exact Python answer which I helped golf.

That "visual proof" is neat. I got the same idea but had to lay out each case of that formula to prove it. As a side remark, a few alternatives of obtaining ranks in Python using third-party libraries are shown in this post.

05AB1E, 7 bytes
āœΣαO}н

Try it online!

Explanation
ā              # get the numbers 1 to len(input) + 1
 œ             # Permutations of this
  Σ  }         # Sort by ...
   α           # Absolute difference
    O          # Sum these
      н        # And get the first one
               # implicitly print

Everytime i'm amazed by this, what 05AB1E can't do ?

@Therandomguy There aren't a lot of things which cannot be done in 05AB1E, but it's pretty bad at: regex-based challenges; matrix-based challenges (although this has been improved after some new builtins); lack of imaginary numbers; date/time related challenges; etc. However, although hard, it can still be done usually. To give two examples: The Work Day Countdown (go to next day, and get day of week are done manually); Quine outputs itself in binary (UTF-8 conversion is done manually).

@Grimy should be fixed now :)

Perl 6, 44 bytes
{permutations(+$_).min((*[]Z-$_)>>.abs.sum)}

Try it online!
Anonymous codeblock that returns the first minimum permutation with 0 indexing.
Explanation:
{                                          }   # Anonymous code block
 permutations(+$_)                             # From the permutations with the same length
                  .min(                   )    # Find the minimum by
                                      .sum       # The sum of
                                >>.abs           # The absolute values of
                       (*[]Z-$_)                 # The zip subtraction with the input

I think I might also be able to get rid of the .sum and sort by just the list of absolute values, but I'm not sure this is actually corret, though it passes my current test cases.

That was breaking my brain too (or the mostly-equivalent question of "does a greedy algorithm work for this?"). The simplest counterexample is [0.6 1] (assuming we're 0-indexed), where if you optimize for the first value you get [1,0] for a score of 1.4, but if you optimize for the whole vector the 1 is more valuable in the second position for a score of 0.6.

Ruby, 63 60 bytes
->v{[*1..v.size].permutation.max_by{|p|eval [p,0]*'*%p+'%v}}

Try it online!
There's a math trick here that could be helpful in other answers too--instead of minimizing the sum of the absolute values of the differences, we maximize the sum of the products. Why does that work?
Minimizing the sum of (x-y) squared isn't equivalent to minimizing the sum of |x-y|, but it will always give a valid answer, it just prioritizes reducing large differences over small ones whereas the actual challenge is indifferent between the two.
But (x-y)*(x-y) = x*x+y*y-2*x*y. Since the square terms will always show up somewhere in the sum for any permutation, they don't affect the result, so we can simplify to -2*x*y. The 2 factors out, so we can simplify to -x*y. Then if we change minimizing to maximizing, we can simplify to x*y.
Intuitively, this is similar to observing that if you're trying to maximize square footage using a set of horizontal walls and a set of vertical ones, you're best off pairing walls that are close in size to each other to create rooms that are as close to square as possible. 3*3 + 4*4 = 25, while 3*4 + 4*3 = 24.
Edit: Saved three bytes by generating and evaluating a format string instead of using zip and sum.

Minimizing the sum of (x-y) squared isn't equivalent to minimizing the sum of |x-y|, but it will always give a valid answer. Why is it the case? Is there no $y$ that minimizes $\sum |x-y|$ but not $\sum (x-y)^2$?

Jelly, 8 bytes
LŒ!ạS¥ÐṂ

Try it online!

Jelly, 5 bytes
Œ¿œ?J

A monadic Link accepting a list of numbers which yields a list of integers.
Try it online! Or see the test-suite.
How?
Œ¿œ?J - Link: list of numbers, X
Œ¿    - Index of X in a lexicographically sorted list of
         all permutations of X's items
    J - range of length of X
  œ?  - Permutation at the index given on the left of the
         items given on the right

N.B. L (length of) would work in place of J since œ? given an integer, n, on the right would implicitly make the range [1..n] to work with, but J is explicit.

Wolfram Language (Mathematica), 14 bytes
#@*#&@Ordering

Try it online!
Based on xnor's insight.

JavaScript (ES6), 61 bytes
Based on xnor's insight.
a=>[...a].map(g=n=>g[n]=a.sort((a,b)=>a-b).indexOf(n,g[n])+1)

Try it online!
Commented
a =>                    // a[] = input array
  [...a]                // create a copy of a[] (unsorted)
  .map(g = n =>         // let g be in a object; for each value n in the copy of a[]:
    g[n] =              //   update g[n]:
      a.sort(           //     sort a[] ...
        (a, b) => a - b //       ... in ascending order
      ).indexOf(        //     and find the position
        n,              //       of n in this sorted array,
        g[n]            //       starting at g[n] (interpreted as 0 if undefined)
      ) + 1             //     add 1
  )                     // end of map()

JavaScript (ES6),  130  128 bytes
There  must be  definitely is a more direct way...
0-indexed.
a=>(m=g=(k,p=[])=>1/a[k]?(h=i=>i>k||g(k+1,b=[...p],b.splice(i,0,k),h(-~i)))``:p.map((v,i)=>k+=(v-=a[i])*v)|k>m||(R=p,m=k))(0)&&R

Try it online! (with 1-indexed output)
How?
The helper function \$g\$ computes all permutations of \$(0,...,n-1)\$, where \$n\$ is the implicit length of the input array \$a[\;]\$.
For each permutation \$p\$, we compute:
$$k=n-1+\sum_{i=0}^{n-1}(p_i-a_i)^2$$
The only reason for the leading \$n-1\$ is that we re-use the internal counter of \$g\$ to save a few bytes, but it has no impact on the final result.
We eventually return the permutation that leads to the smallest \$k\$.

Python 2, 149 126 112 bytes
-23 bytes thanks to Mr. Xcoder
-14 bytes thanks to xnor
from itertools import*
f=lambda a:min(permutations(range(len(a))),key=lambda x:sum(abs(a-b)for a,b in zip(x,a)))

Try it online!
Uses permutations of (0 ... n-1).

You can switch to Python 2, so that you don't need functools anymore.

reduce is usually overkill, especially here where you're adding stuff. I think you can just do sum(abs(p-q)for p,q in zip(x,a)).

Gaia, 13 bytes
e:l┅f⟪D†Σ⟫∫ₔ(

Try it online!
e:		| eval and dup input
l┅f		| push permutations of [1..length(input)]
⟪   ⟫∫ₔ		| iterate over the permutations, sorting with minimum first
 D†Σ		| the sum of the absolute difference of the paired elements
       (	| and select the first (minimum)

J, 25 8 bytes
#\/:@/:]

Try it online!
Much shorter answer based xnor's brilliant idea.
original answer
J, 25 bytes
(0{]/:1#.|@-"1)i.@!@#A.#\

Try it online!

Japt -g, 12 bytes
Êõ á ñÈíaU x

Try it
For 0-indexed, replace the first 2 bytes with m, to map the array to its indices instead.
Êõ á ñÈíaU x     :Implicit input of array U
Ê                :Length
 õ               :Range [0,Ê]
   á             :Permutations
     ñÈ          :Sort by
       í U       :  Interleave with U
        a        :  Reduce each pair by absolute difference
           x     :  Reduce resulting array by addition
                 :Implicit output of first sub-array

w/o any permutation package
Python 3, 238 bytes
def p(a,r,l):
 if r==[]:l+=[a];return
 for i in range(len(r)):
  p(a+[r[i]],r[:i]+r[i+1:],l)
def m(l):
 s=(float("inf"),0);q=[];p([],list(range(len(l))),q)
 for t in q:D=sum(abs(e-f)for e,f in zip(l,t));s=(D,t)if D<s[0]else s
 return s[1]

Try it online!

Wolfram Language (Mathematica), 57 bytes
f@n_:=MinimalBy[Permutations@Range@Length@n,Tr@Abs[n-#]&]

Try it online!

source: Stack Exchange

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

sort: votes


text:
Olympic game scoring
The challenge is to write a golf-code program that, given n positive real numbers from 0 to 10 (format x.y, y only can be 0 or 5: 0, 0.5, 1, 1.5, 2, 2.5 … 9.5 and 10), discard the lowest and highest values (only one, even though they are repeated) and shows the average of the remaining, in x.y format (y can be 0 or 5, rounded to closest), similar to some Olympic Games scoring.
Examples:
Input -> Output
6 -> 6
6.5, 9 -> 8
9, 7, 8 -> 8
6, 5, 7, 8, 9 -> 7
5, 6.5, 9, 8, 7 -> 7
6.5, 6.5, 9.5, 8, 7 -> 7
5, 6.5, 7.5, 8.5, 9.5 -> 7.5
Notes: If the input is only two numbers, do not discard any, just average them. If the input is one number, the output is the same.
Clarifying the rounding rule (sorry, little confuse):
x.01 to x.25 round to x.0
x.26 to x.75 round to x.5
x.76 to x.99 round to x+1.0

How is the second example (6.5, 9 => 8) valid? If you throw out the high and the low, there are no values left to average?

Welcome to Code Golf SE!

Are we required to handle invalid test cases, and could we have a test case with non-integer output?

I'd suggest we do not handle invalid input, the Olympics will have a fixed number of judges greater than two for such an event. (Diving removes the four extremities from seven for example)

It's not required. and fixed. Thanks

Ah, we have to special case when given two judge's scores, that's a little odd.

If lowest or highest value appear more than once, do we discard all or only one?

@Night2 only 1 - but, yes, this should be clarified (I worked it out from 6.5, 6.5, 9.5, 8, 7 -> 7)

Are we to use round-half-up rounding - for example [5, 6, 6, 10, 11, 13] leads to an average of 8.25, should we output 8.0 or 8.5?

It seems like you're supposed to round half up

@Jonathan Allan in that case is 8.0

So the question is now, why - what is the rounding rule?

I realized it is a bit confuse, let's round them to the nearest, depending of the platform :)

Please make this clear in the question. Does x.99 round to x.50 then?

Tried to fix this, thanks :)

Your example 6.5, 9 disagrees with your spec which indicates that x.75 rounds to x.5.

Until the rounding is sorted I’ve voted to close.

Jelly, 12 bytes
ṢṖḊȯµÆmḤær0H

Try it online!
    µ           Take
Ṣ               the input sorted,
 Ṗ              without its last
  Ḋ             or first element,
   ȯ            or the unchanged input if that's empty,
     Æm         then calculate the mean,
       Ḥ        double it,
        ær      round it to the nearest multiple of
          0     10^-0 (= 1),
           H    and halve it.

A version which rounds halves down, in accordance with the spec at the expense of the second test case:
Jelly, 12 bytes
ṢṖḊȯµÆmḤ_.ĊH

Try it online!
The rounding method here is closer to Jonathan Allan's:
Ḥ        Double,
 _       subtract
  .      one half,
   Ċ     round up,
    H    and halve.

Just so happens to accidentally comply with the update to the spec

@NickKennedy If I don't round, that case produces 6.8, which should round up to 7 according to the spec since 6.75 < 6.8 ≤ 7.

sorry one two many 7s. I meant [1,10,6,7,7,7]

Oh, yeah, it does do that one wrong.

Retina, 86 bytes
\.5
__
\d+
*4*__
O`_+
_+ (.+) _+
$1
O`.
^ *
$.&*__:
(_+):(\1{4})*(\1\1)?_*
$#2$#3*$(.5

Try it online! Link includes test cases. Explanation:
\.5
__
\d+
*4*__

Since Retina can't readily handle fractional or zero numbers, each number is represented in unary as 1 more than 4 times the value. The .5 therefore expands to 2 _s, while the *4*_ applies to the whole number part, and a final _ is suffixed.
O`_+

Sort the numbers into order.
_+ (.+) _+
$1

If there are at least three numbers, discard the first (smallest) and last (largest).
O`.

Sort the spaces to the start, thus also summing the numbers.
^ *
$.&*__:

Count the number of spaces and add _ and a separator. This then represents the number we have to divide by.
(_+):(\1{4})*(\1\1)?_*
$#2$#3*$(.5

Divide the sum by the number of numbers, allowing for the fact that we're working in multiples of 4 times the original number, so that the integer and decimal portions can be directly extracted. This is a truncating division, but fortunately because we added an extra _ to each number, the result effectively includes an extra 0.25, thus giving us the rounding we want.

EDIT: This answer has since become invalid. It was valid for about half a minute after it was posted.
Jelly, 10 bytes
ṢḊṖȯƊÆmḤḞH

Try it online!

Ḟ seems to produce the wrong result for [6.5,9].

@UnrelatedString At the moment I posted this, it was the correct output. Looks like OP has changed the rule now.

Yes, I made a mess, sorry :(

As per my comment under Arnauld's post I basically had this algorithm too, so, after getting clarification on the rules, I've posted mine :)

@JonathanAllan Which is the same as Unrelated String's. :P

JavaScript (V8), 213 211 189 176 bytes
Edit: -2 bytes because I ended with ;\n} when I could just end with a }, silly mistake.
Edit 2: -22 more bytes by reading about general JS golfing tips. I managed to take out parentheses from my nested ternaries in the r rounding function, and used bitwise math operations to avoid using Math.floor and Math.ceil
Edit 3: -13 bytes because I was able to replace the a.length shortcut function with just direct calls to a.length to save 4 bytes. I also moved the g() function directly into the return statement, since it was only used once, which removed the rest of the bytes.
a=>{s=i=>a.splice(i,1)
e=_=>a.reduce((t,i)=>t+=i)/a.length
r=n=>(m=n%1,m<0.75?m>0.25?~~(n)+0.5:~~(n):n%1?-~n:n)
return a.length>2?r((a.sort((x,y)=>x-y),s(0),s(-1),e())):r(e())}

Try it online!
I'm sure it can be improved as I'm fairly new, but it was fun to solve this one. I believe the main things that could be improved are my rounding logic/methods, and the fact that the main function uses a function body ({ } and return).
There was one thing in the question that was inconsistent with the examples and I wasn't really sure how to handle it. I implemented it so that it's consistent with the examples, but it doesn't exactly reflect the specified rounding rules, here is the example I found to be inconsistent:
6.5, 9 -> 8
You say it should be 8, although the average is 7.75. In the rounding rules you say it has to be at least .76 to go +1. I chose to reflect the examples instead of your rounding rules, so >=0.75 to go +1, and <=0.25 to go -1, between 0.25 and 0.75 (exclusive) for .5. If the rounding specifications change, my code should be able to adapt without changing the number of bytes, by just changing the numbers in the rounding function r, and maybe the order of the ternary statement depending on the rules.
Slightly ungolfed with explanation (the math operations were changed to bitwise operations and g() is directly in the return statement)
a => { // a is the input array
    s = i=>a.splice(i, 1); // shortcut to remove index i for 1 element
    e = _=>a.reduce((t, i) => t += i) / a.length; // get array avg
    g = _=>(a.sort((x,y)=>x-y), s(0), s(-1), e()); // what to execute when > 2: sort, remove 1st/last, get avg
    t = n=>Math.floor(n); // Math.floor shortcut

    // apply olympic rounding to number by checking the value of n%1
    r = n=>(m=n%1,m < 0.75 ? (m > 0.25 ? t(n) + 0.5 : t(n)) : Math.ceil(n));

    // if arr length > 2: round g(), otherwise round e()
    return a.length > 2 ? r(g()) : r(e());
}

I’ve posted a comment on the question about the discrepancy between the example and spec.

why you do not use l=a.length and everytime you want a length simply call l, here I do not know why you arr using function here

@chaugiang That would save the value, not a reference to a.length, so since I'm using it before & after operations that modify the array, l would become invalid as soon as the array is changed. LMK if wrong. It turns out it would actually save me 3 bytes now to just replace this with direct a.length calls. When I initially wrote it, I didn't know JS allowed you to use negative numbers for splice, so initially my second splice was s(l()-1) instead of just s(-1), and when I had 3 length calls it saved bytes to have this shortcut. Now it's no longer worth it. Thanks, will update!

J, 36 35 bytes
[:(1r4<.@+&.+:+/%#)}:@}.^:(2<#)@/:~

Try it online!
Borrowed the double / floor / halve trick for rounding to 0.5 increments from Unrelated String.

Python 3, 62 bytes
def f(s):z=sorted(s)[1:-1]or s;return round(2*sum(z)/len(z))/2

Try it online!

Jelly, 12 bytes
ṢṖḊȯ⁸ÆmḤ+.ḞH

A monadic Link accepting a list of numbers which yields a number.
Try it online!
How?
ṢṖḊȯ⁸ÆmḤ+.ḞH - Link, list of numbers, X
Ṣ            - sort X
 Ṗ           - remove the right-most
  Ḋ          - remove the left-most
    ⁸        - chain's left argument, X
   ȯ         - logical OR (if we have nothing left use X instead)
     Æm      - arithmetic mean
       Ḥ     - double
         .   - literal half
        +    - add
          Ḟ  - floor
           H - halve

@NickKennedy 34/5>6.75

Sorry meant 1,10,7,7,7,6 where 27/4 = 6.75

This must be due to floating point limitations since that calculation is being done to yield 6.75 from Æm, doubling that gives 13.5 adding a half gives 14 and halving gives 7.0. Thus this (and the other submission with this issue) is valid, just some answers look wrong! EDIT: if we multiply up by 100 and use 50 instead of a half you can see that the method works in principle

No the issue is the slightly unconventional rounding in the spec. In fact your answer also gets [1,10,7,6,6,6] wrong (it should be 6 not 6.5), while @UnrelatedString’s original version gets that one right because Python rounds to even (so 12.5 rounds down to 12). As I’ve now pointed out in a comment on the question, one of the examples also violates the rounding spec. Also note that fractions of powers of 2 shouldn’t be an issue for floating point inaccuracy because they have an exact binary representation.

I feel like the spec is awkward and possibly unintentional. (What does x.251 round to, etc; are the boundaries inclusive, exclusive, or is it up to us?) ...and then there is the comment "I realized it is a bit confuse, let's round them to the nearest, depending of the platform". Maybe we should VTC as unclear?

yes agree VTC for now

Brachylog, 19 bytes
o{bṀk|}⟨+/l⟩×₄<÷₂/₂

Try it online!
And I thought the rounding was awkward in Jelly!

This is incorrect for [1,10,7,7,7,6]; 27/4 = 6.75 which should round to 6.5 according to spec.

Swift, 203 bytes
func a(b:[Double])->Void{var r=0.0,h=0.0,l=11.0
b.forEach{(c)in h=c>h ?c:h;l=c<l ?c:l;r+=c}
var d=Double(b.count)
r=d>2 ?(r-h-l)/(d-2.0):r/d
d=Double(Int(r))
r=r-d<=0.25 ?d:r-d<=0.75 ?d+0.5:d+1
print(r)}

Try it online!

PHP, 110 bytes
Seems like PHP has some good built-in functions for this. I just array_sum the whole thing, then if there's more than two elements, subtract the min() and max() values and divide by 2 less than the length of the array.
For the rounding, I use the round() function with the PHP_ROUND_HALF_DOWN flag (which = 2) on double the average, and then divide it by 2 so it goes in increments of 0.5
EDIT: for the case of [6.5, 9] I'm following the stated rule that 7.75 rounds to 7.5 and not 8 like in the original example given.
function s($s){$c=count($s);$t=array_sum($s);if($c>2){$c-=2;$t-=min($s)+max($s);}return round($t/$c*2,0,2)/2;}

Try it online!

Well done! I wanted to post a PHP answer but the rules had many flaws or changes that I just gave up! I tweaked your code a little and saved 10 bytes: Try it online!

Zsh --force_float, 141 136 109 96 bytes
Try it online!
 109bytes
 136bytes
 141bytes
n=$1;for x ((t+=x,m=x>m?x:m,n=x<n?x:n,s=2*(#>2?(t-m-n)/(#-2):t/#)))
<<<$[(s^0+(s-s^0>.5?1:0))/2]

Solution follows latest spec, except for the unclear second test case. Saved a few bytes using implicit ($@). Saved more by moving most calculations into the (( )) statement.
We implicitly iterate over the arguments with for x, and build a running total t, and also find maxima, minima m, n. If the number of arguments # is greater than 2, we discard m and n from the average. s is 2x the resulting average. If the mantissa of s is greater than 0.5, round s up, otherwise truncate with s^0. Finally, divide by 2 and output.

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


text:
"Know Thyself" Program
Challenge
Write a program that takes as input a text and output "That's me!" if the input is equal to the program own source code, and "That's not me!" otherwise.
Notes

This is codegolf, in each programming language the shortest program wins.
The input can be taken from program arguments or function argument, and the ouput can be printed or given as a return value.
Standard loopholes are forbidden.

I've also VTC as a duplicate, although it may not be that simple to port any answer from that challenge to this one. Grounds for keeping this variant?

@JonathanAllan The differences I can see aren't enough IMO, it's very unlikely that a solution from that challenge can't easily change its input source while its language is able to compete here, and the difference in the output strings is negligible. Also, there's a standard "template" for quines in most languages that's probably already used in the other challenge. I have a hammer too, though.

I've voted to reopen this challenge as I feel that, given that it's a [tag:quine] challenge, the difference between outputting true/anything and outputting 1 of 2 strings make this sufficiently different. Yes, there will be a few solutions to the dupe target that can be trivially modified to be competitive here but there will also be solutions that will need to take a different approach.

I don't see this as sufficiently different to merit being left open. Looking at the answers to the other challenges, the vast majority of them (at least those in languages I understand) are payload-capable quines to which one could add code to print specified strings, which is enough to make a duplicate. Additionally, this appears to be taking a pre-existing challenge with flexible IO and adding a cumbersome output format, which is a thing to avoid when writing challenges