[Question]
  [
*[Cross posted from my anagolf post (note: may contain spoilers, post mortem).](http://golf.shinh.org/p.rb?ASCII+Pylon)*
Output the following text exactly.
* You may have additional trailing whitespace on each line, and trailing newlines as well.
* Shortest code, in bytes, wins.
```
                                                
                                              !"!
                                             "#$#"
                                            #$%&%$#
                                           $%&'('&%$
                                          %&'()*)('&%
                                         &'()*+,+*)('&
                                        '()*+,-.-,+*)('
                                       ()*+,-./0/.-,+*)(
                                      )*+,-./01210/.-,+*)
                                     *+,-./012343210/.-,+*
                                    +,-./0123456543210/.-,+
                                   ,-./01234567876543210/.-,
                                  -./0123456789:9876543210/.-
                                 ./0123456789:;<;:9876543210/.
                                /0123456789:;<=>=<;:9876543210/
                               0123456789:;<=>?@?>=<;:9876543210
                              123456789:;<=>?@ABA@?>=<;:987654321
                             23456789:;<=>?@ABCDCBA@?>=<;:98765432
                            3456789:;<=>?@ABCDEFEDCBA@?>=<;:9876543
                           456789:;<=>?@ABCDEFGHGFEDCBA@?>=<;:987654
                          56789:;<=>?@ABCDEFGHIJIHGFEDCBA@?>=<;:98765
                         6789:;<=>?@ABCDEFGHIJKLKJIHGFEDCBA@?>=<;:9876
                        789:;<=>?@ABCDEFGHIJKLMNMLKJIHGFEDCBA@?>=<;:987
                       89:;<=>?@ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA@?>=<;:98
                      9:;<=>?@ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA@?>=<;:9
                     :;<=>?@ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA@?>=<;:
                    ;<=>?@ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA@?>=<;
                   <=>?@ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA@?>=<
                  =>?@ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA@?>=
                 >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>
                ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?
               @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@
              ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA
             BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCB
            CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDC
           DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFED
          EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFE
         FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGF
        GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHG
       HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIH
      IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJI
     JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJ
    KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLK
   LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONML
  MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONM
 NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPON
OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPO
```
  
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 73 bytes
```
' '*48;46..0|%{" "*$_+-join[char[]](($x=79-$_)..($y=$x+$j++)+(++$y)..$x)}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X11BXcvEwtrETE/PoEa1WklBSUslXls3Kz8zLzo5I7EoOjZWQ0OlwtbcUlclXlNPT0Ol0lalQlslS1tbU1tDW1ulEiioUqFZ@/8/AA "PowerShell – Try It Online")
Outputs the first whitespace-only line, then loops from `46` to `0`. Each iteration, outputs the corresponding number of spaces and then a `-join`ed together `char`-array of the appropriate symbols, via some calculations.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 13 bytes
```
Ｅ⁴⁸⮌✂γι⊕⊗ι‖Ｏ←
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUDDxEJHISi1LLWoOFUjOCczOVUjXUchU0fBMy@5KDU3Na8kNUXDJb80KQdIZ2qCgDVXUGpaTmpyiT9QVw7QCCuf1LQSTev////rluUAAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 ⁴⁸             Literal 48
Ｅ               Map over implicit range
      ι  ι      Current index
        ⊗       Doubled
       ⊕        Incremented
     γ          Printable ASCII
    ✂           Slice
   ⮌            Reverse
                Implicitly print each slice on separate lines
          ‖Ｏ←   Reflect with overlap
```
[Answer]
# [Python 2](https://docs.python.org/2/), 73 bytes
```
i=48
while i:i-=1;r=range(79-i,127-i*2);print' '*i+bytearray(r+r[-2::-1])
```
[Try it online!](https://tio.run/##BcFLCoAgEADQfadw56dmoQSW4kmihYHkQJgMQnh6e6/2lt9ixsCwbtOX8UkMHULQngLFcidhd8BFGwuojPSVsDTOuML56i1FotgFzXSAcQ70Kcf4AQ "Python 2 – Try It Online") Crossposted from anarchy golf (see [my submission](http://golf.shinh.org/reveal.rb?ASCII+Pylon/lynn_1523517333&py)).
Quick post-mortem analysis: xnor and dianne discovered the [exact](http://golf.shinh.org/reveal.rb?ASCII+Pylon/xnor_1523583184&py) same [solution](http://golf.shinh.org/reveal.rb?ASCII+Pylon/dianne_1523778547&py). ebicochneal submitted a [71 byte solution](http://golf.shinh.org/reveal.rb?ASCII+Pylon/ebicochineal_1523764377&py) which mitchs improved to [70 bytes](http://golf.shinh.org/reveal.rb?ASCII+Pylon/mitchs_1524714112&py). They avoid dealing with `bytearray` (which is long) or `''.join(map(chr,…))` (which is even longer) entirely, by keeping a "current line" variable and cleverly updating it.
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~15~~ 14 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
0ｃ［Ｃ²［ｊ｝¹ｍ］／││
```
[Try it here!](https://dzaima.github.io/Canvas/?u=MCV1RkY0MyV1RkYzQiV1RkYyMyVCMiV1RkYzQiV1RkY0QSV1RkY1RCVCOSV1RkY0RCV1RkYzRCV1RkYwRiV1MjUwMiV1MjUwMg__,v=2)
Note that while making this I added a couple built-ins (`ｃ` & `Ｃ`) as Canvas somehow didn't have any built-ins for ASCII/unicode before...
Explanation (some characters have been replaced to look monospace):
```
0c              push the charcode of "0" - 48
  {       ]     map over 1..48
   C              push the ASCII characters
    ²[ ]          repeat by the counter (0-indexed)
      j             remove the last character
        ¹m        mold to the length of the counter
           /    pad each line with spaces so it looks like a diagonal
            ││  palindromize the whole thing horizontally
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 17 bytes
```
48ḶḤr$z0ZUŒB+32ỌY
```
[Try it online!](https://tio.run/##y0rNyan8/9/E4uGObQ93LClSqTKICj06yUnb2Ojh7p7I//8B "Jelly – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 16 bytes
```
48FžQNÝûN+èJ}).C
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fxMLt6L5Av8NzD@/20z68wqtWU8/5/38A "05AB1E – Try It Online")
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), ~~16~~ 15 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
'½{ ~Δf⌡kFm}⁰¼╥
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JTI3JUJEJTdCJTIwJTdFJXUwMzk0ZiV1MjMyMWtGbSU3RCV1MjA3MCVCQyV1MjU2NQ__,v=0.12)
[Answer]
# VBA, 71 bytes
An anonymous VBE immediate window function that takes no input and outputs to the console.
```
For i=0To 47:?Spc(47-i);:For j=-i To i:?Chr(32-Abs(j)+2*i);:Next:?:Next
```
[Answer]
# [Common Lisp](http://www.clisp.org/), 110 bytes
```
(dotimes(i 48)(dotimes(j 96)(princ(if(>(abs(- j 48))i)" "(code-char(+(-(* i 2)(abs(- j 48)))32)))))(princ"
"))
```
[Try it online!](https://tio.run/##VYzNCkBAFEb3nuI2q@@j2SCx8S5jkCt/Ge8/klLO7tTp@EXDESP6/dJ1CFApa342S1MRx6mbh45o4boAK/MTUWnEwO/9YP3kTmSwSEUl5y9jkfPh3ZjEkDHe "Common Lisp – Try It Online")
### Explanation
```
(dotimes(i 48)                   ;; for i from 0 up to 47
    (dotimes(j 96)               ;; for j from 0 up to 95
        (princ                   ;; print
            (if(>(abs(- j 48))i) ;; if abs(j - 48) > i
                " "              ;; print " "
                (code-char(+(-(* i 2)(abs(- j 48)))32)) ;; else print appropriate character
            )
        )
    )(princ"
") ;; print newline
)
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 70 bytes
```
s=[*?\s..?~]*'';48.times{|i|puts s[i,i+1].rjust(48)+s.reverse[-2*i,i]}
```
[Try it online!](https://tio.run/##KypNqvz/v9g2Wss@plhPz74uVktd3drEQq8kMze1uLoms6agtKRYoTg6UydT2zBWryirtLhEw8RCU7tYryi1LLWoODVa10gLKBtb@/8/AA "Ruby – Try It Online")
Constructs the full printable ASCII string and then prints the required number of forward (padded with spaces) + backward slices of it.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 24 bytes
```
48RrḤ’$$ịØṖŒBṭ"48RU⁶ẋ$¤Y
```
[Try it online!](https://tio.run/##ATIAzf9qZWxsef//NDhScuG4pOKAmSQk4buLw5jhuZbFkkLhua0iNDhSVeKBtuG6iyTCpFn//w "Jelly – Try It Online")
[Answer]
# C (gcc), 117 bytes
```
c;i;main(){for(i=0;i<48;++i){for(c=2*i-15;c<32+2*i;++c)putchar(c>31+i?c:32);for(;c>31+i;--c)putchar(c);putchar(10);}}
```
[Try it online!](https://tio.run/##TYrbCsIwEAV/J2sINImCeJL2W8oBdR@8IPpU@u3blFLwbZgZhhtpRigeoz6dTNfXx2ntoOV4hve6GdZ00BBPYMnJN26J8v59eR9b7XP0OvCSk2DdsRmE8DcJdoydYJ7NFg "C (gcc) – Try It Online")
Ungolfed:
```
int ch;
int row;
int main(void) {
    for (row = 0; row < 48; ++row) {
        for (ch = 2*row-15; ch < 32 + 2*row; ++ch) {
            // The first character in the row is 2*row - 15 (row is zero-indexed)
            if (ch > 31+row)
                putchar(ch);
            else
                // If the current character is not in the pyramid, mask it with a space
                putchar(' ');
        }
        for (; ch > 31+row; --ch) {
            // Finish the other side of the pyramid
            putchar(ch);
        }
        putchar('\n');
    }
}
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~114~~ ~~113~~ 107 bytes
```
#define _(_)for(k=32;k<j;)putchar(j+_++);
f(j,k){for(j=31;++j<80;){printf("\n%*c",80-j,j);_(-31+k)_(j+~k)}}
```
[Try it online!](https://tio.run/##FcxBCsIwEADAu6@QirDrJtCaS2HbnwihxEazwVhCPZX49Vjvwzj9cK7W0332Ic1HCxb9O0MczZXjIIzLZ3XPKYOQJUI@eBAVcfsjGU3HRDL0LeO25JBWD80tnS@uUX2rRQmyBW06imj34RuxlPqaQoJ9AORSfw "C (gcc) – Try It Online")
*[101 bytes](https://tio.run/##Fc1BCsIwEADAvxSEXTeB1lwK29x8hhBCILUbjaWtpxKfbqwfmAl6DKHWCKIS7vG1gFjTMZEMfcu4z8uUtwjNLZ/OoVF9q0UJsgNtOkroQOiTsJT69FOGQwDkUr8hPvy4Vn21Dhz@2WTNhdMgjPN7C3d/ROSIkH8) are possible using a compiler flag.*
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~55~~ 53 bytes
```
say ' 'x 47-$_,chrs 32+2*$_ X-(-$_..$_)>>.abs for ^48
```
[Try it online!](https://tio.run/##K0gtyjH7/784sVJBXUG9QsHEXFclXic5o6hYwdhI20hLJV4hQlcDKKanpxKvaWenl5hUrJCWX6QQZ2Lx/z8A "Perl 6 – Try It Online")
[Answer]
# T-SQL, 153 bytes
```
DECLARE @ INT=33,@t CHAR(95)=''a:PRINT @t;
SET @t=LEFT(STUFF(STUFF(@t,63-@/2,2,''),46,0,CHAR(@-1)+CHAR(@)+CHAR(@+1)+CHAR(@)),33+@/2)
SET @+=2IF @<128GOTO a
```
Returns are for display only.
I tried several ideas, including a loop to preconstruct the full string (163 characters), and a nested loop to build it on the fly (168 characters), but this ended up being the shortest.
Basically, each loop I'm *cramming 4 new characters* into the center of the string, then trimming off the extras from both ends, using the [SQL `STUFF()` function](https://docs.microsoft.com/en-us/sql/t-sql/functions/stuff-transact-sql?view=sql-server-2017).
Formatted and explained:
```
DECLARE @ INT=33,                      --Using a single counter for both rows and CHAR
        @t CHAR(95)=''                 --a non-null CHAR field will pre-fill with spaces
a:                                     --GOTO loop, shorter than a WHILE
    PRINT @t                           --duh
    SET @t = LEFT(                     --lops off the character at the end
            STUFF(                     --crams 4 new characters in the middle
            STUFF(@t, 63-@/2, 2, '')   --snips out a space and the leading character
                 ,46, 0, CHAR(@-1) + CHAR(@) + CHAR(@+1) + CHAR(@))
                 ,33 + @/2)            --rest of the LEFT()
    SET @+=2
IF @<128 GOTO a
```
[Answer]
# [J](http://jsoftware.com/), 47 44 bytes
```
(,.~}:@|."1)(1+i.48)([|.@{.}.)"0 1 u:31+i.96
```
[Try it online!](https://tio.run/##y/pflFiuYGulYKAAwrp6Cs5BPm7/NXT06mqtHGr0lAw1NQy1M/VMLDQ1omv0HKr1avU0lQwUDBVKrYxBEpZm/zW5UpMz8hWU9IBG/QcA "J – Try It Online")
Thanks to Conor O'Brien for the template!
Thanks to FrownyFrog for indicating the invalid solution.
[Answer]
# Ruby, 59 bytes
```
48.times{|i|-47.upto(i){|c|putc~c<i ?32-c.abs+2*i:32};puts}
```
Cross-posted from my answer on anagol.
[Answer]
# Japt `-R`, ~~18~~ 15 bytes
[14 bytes](https://ethproductions.github.io/japt/?v=1.4.5&code=IzHHb2RIK1rJIKzqw/s=&input=LVI=) if an additional leading newline is allowed.
```
#0õ_odH+ZÉ ¬êÃû
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.5&code=IzD1X29kSCtaySCs6sP7&input=LVI=)
---
## Explanation
```
#0                  :48
  õ                 :Range [1,48]
   _         Ã      :Pass each Z through a function
    o               :  Range [0,Z)
      H+ZÉ          :    To each add 32+Z-1
     d              :    Get the character at that codepoint
           ¬        :  Join to a string
            ê       :  Palinrdomise
              û     :Centre pad each element to the length of the longest element
                    :Implicitly join with newlines and output
```
[Answer]
# [J](http://jsoftware.com/), ~~40 37~~32 bytes
40 expression `u:30+2>.(+:@i.@(2&+)(-*(>+:))"0 _|@i:)47` thanks to +Galen Ivanov & +Conor O'Brien for the ideas in their solutions
37 included **echo** `echo u:32+|.(~.(>:*+:@[-])"0 _])|i:47`
```
echo u:32+|.(~.(>:*[+-)"{])|i:47
```
incorporating @FrownyFrog tips from comments
[TIO](https://tio.run/##y/rv56SnkJdfopCYk6OQW6mQX56nUJ5flK2jkJmXnF9UkF@UWJJarFCSWVCskFaUn6vg4FYEVFMJJNP/pyZn5CuUWhkbadfoadTpadhZaUVr62oqVcdq1mRamZj//w8A "TIO")
[Answer]
# [Perl 5](https://www.perl.org/), ~~77~~ ~~75~~ 69 bytes
```
map{say$"x(47-$_),(@a=map chr$_+32,$_..$_*2),reverse@a[0..@a-2]}0..47
```
[Try it online!](https://tio.run/##K0gtyjH9/z83saC6OLFSRalCw8RcVyVeU0fDIdEWKKqQnFGkEq9tbKSjEq@npxKvZaSpU5RallpUnOqQGG2gp@eQqGsUWwtkmJj///8vv6AkMz@v@L@ur6megaEBAA "Perl 5 – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 95 bytes
```
f=(x=y=0)=>y<48?[`
`[x]]+Buffer([x<48-y|x>48+y?32:x<48?x+y*2-16:80-x+y*2])+f(++x%96?x:+!++y):''
```
[Try it online!](https://tio.run/##HcjdCoIwFADg@96ii3DrsDATmaM56DXGQLFNCnGiFedA775@7j6@e/fq1n65zQ8xxatPKWiGmnTOdUPnUhrbblqLzsHlGYJfmMXvCnpjU0ogcyrULwwC7QtxrJTMxd@OQ2AAuKsrgwq2AMRVlqU@Tmsc/WGMAwuM8/QB "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~98~~ 88 bytes
-1 byte thanks to @Mr.Xcoder
```
i=32
exec"print''.join(chr(i+i-32-abs(j))for j in range(32-i,i-31)).center(95);i+=1;"*48
```
[Try it online!](https://tio.run/##TYlNDoMgGAX3noKwEepPorZJG@NJGheIgB8mYAGT9vQUuuri5U1mjk/YrOljhGnoC/EWHB8OTCjLVlswhG@OQAXN0Dds8URTKq1DGoFBjhklSApQp95R2nJhgnDkcaMjVFM34sv1HuMTs4WvuEZYwO7y21NqPBcpvJwP2Zw7E5BBSmvtr6nNrzIt20QqTf6xwvMX "Python 2 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 78 bytes
```
s=*32;48.times{puts (s.map(&:chr)*'').center 95;c=*s[0]+1;s=c+s.map{|x|x+2}+c}
```
[Try it online!](https://tio.run/##KypNqvz/v9hWy9jI2sRCryQzN7W4uqC0pFhBo1gvN7FAQ80qOaNIU0tdXVMvOTWvJLVIwdLUOtlWqzjaIFbb0LrYNlkbrLC6pqKmQtuoVju59v9/AA "Ruby – Try It Online")
Full program. Ungolfed:
```
s=*32;                              # s is an array of integers
48.times{                           # Repeat 48 times:
  puts (s.map(&:chr)*'').center 95; # Turn each int to a char, join, center, and print
  c = *s[0] + 1;                    # c is a singleton array. It will bookend the next line
  s = c + s.map{|x|x+2} + c         # Add 2 to each element of s before adding the bookends
}
```
[Answer]
# [Yabasic](http://www.yabasic.de), 80 bytes
An anonymous [yabasic](/questions/tagged/yabasic "show questions tagged 'yabasic'") function that takes no input and outputs to the console
```
For i=0To 47
For j=i To 47?" ";Next
For j=-i To i?Chr$(32-Abs(j)+2*i);Next
?Next
```
[Try it online!](https://tio.run/##q0xMSizOTP7/3y2/SCHT1iAkX8HEnAvEybLNVADz7JUUlKz9UitKoMK6YPFMe@eMIhUNYyNdx6RijSxNbSOtTE2IMnsQ@f8/AA "Yabasic – Try It Online")
[Answer]
# [uBASIC](https://github.com/EtchedPixels/ubasic), 95 bytes
```
0ForI=0To47
1ForJ=ITo47:?" ";:NextJ
2ForK=-1*IToI:?Left$(Chr$(32-Abs(K)+2*I),1);:NextK
3?:NextI
```
[Try it online!](https://tio.run/##K01KLM5M/v/fwC2/yNPWICTfxJzLEMj2svUEsa3slRSUrK38UitKvLiMgOLetrqGWkApTyt7n9S0EhUN54wiFQ1jI13HpGINb01tIy1PTR1DTYgWby5jezDD8/9/AA "uBASIC – Try It Online")
[Answer]
# [MY-BASIC](https://github.com/paladin-t/my_basic), 97 bytes
An anonymous MY-BASIC response that takes no input and outputs to the Console
```
For i=0 To 47
For j=i To 47
Print" "
Next
For j=-i To i
Print Chr(32-Abs(j)+2*i)
Next
Print;
Next
```
[Try it online!](https://tio.run/##y63UTUoszkz@/98tv0gh09ZAISRfwcScC8TLss2E8gKKMvNKFJQUlLj8UitKoJK6YNlMqKRzRpGGsZGuY1KxRpamtpFWpiZELVjWGsz@/x8A "MY-BASIC – Try It Online")
-1 byte thanks to [Jonathan Frech](https://codegolf.stackexchange.com/users/73111/jonathan-frech)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 18 bytes
```
48:"@@Zv30++Xhc3Zu
```
[Try it online!](https://tio.run/##y00syfn/38TCSsnBIarM2EBbOyIj2Tiq9P9/AA "MATL – Try It Online")
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), 29 bytes
```
`0FaLssLF:P|LF:M|`/L-R` lRo|;
```
[Try it online!](https://tio.run/##S8/PScsszvj/P8HALdGnuNjHzSqgBkj41iTo@@gGJSjkBOXXWP//DwA "Gol><> – Try It Online")
### How it works
```
`0FaLssLF:P|LF:M|`/L-R` lRo|;
`0F                        |;  Repeat the following 48 times and halt...
   a                           Push 10 (\n)
    Lss                        Push L(loop counter) + 32
       LF:P|                   Repeat "Clone the top and increment" L times
            LF:M|              Repeat "Clone the top and decrement" L times
                 `/L-R`        Push 32 (space) 47-L times (space is significant)
                        lRo    Print everything as char, from the top,
                               until the stack is empty
```
[Answer]
# [Tcl](http://tcl.tk/), ~~129~~ ~~122~~ ~~118~~ 117 bytes
```
time {incr i;set j -48;set a {};time {set a $a[format %c [expr abs([incr j])>=$i?32:$i*2-abs($j)+30]]} 96;puts $a} 48
```
[Try it online!](https://tio.run/##K0nO@f@/JDM3VaE6My@5SCHTuji1RCFLQdfEAsxKVKiutYbIQ7gqidFp@UW5iSUKqskK0akVBUUKiUnFGtFg3Vmxmna2Kpn2xkZWKplaRrogGZUsTW1jg9jYWgVLM@uC0pJioBG1CiYW//8DAA "Tcl – Try It Online")
### Explanation
```
time { # for i from 0 up to 47
    incr i
    set j -48
    set a {}
    time { # for j from -48 up to 47
        # add next character to a
        set a $a[format %c [expr abs([incr j])>$i?32:$i*2-abs($j)+32]]
    } 96
    puts $a # print a
} 48
```
[Answer]
### C (gcc) 199 bytes
```
#include<stdio.h>
int i,j=32,k=32,l=49;int main(){while(k<127){for(i=0;i<l;++i)printf(" ");for(i=j;i<k;++i)printf("%c",i);printf("%c",k);for(i=k-1;i>=j;--i)printf("%c",i);printf("\n");j++;k+=2;l--;}}
```
[Try it online!](https://tio.run/##dYxBCsIwFET3nqJEhIQkYmtB5Cc9iRtJW/uTmEqtuCg9e0wRQRduBmbezBh5MSbGNQbjH3Wj7mON/barVhjGDIXV@0K4Rbwuj7CE1zMGyqZnh76hTuXFgU1tP1DUO0DlgXNktyE1W0oywuDNbGLuh20MEcjg27pP28kcsEojKf8OTiGdW87BcV2AlxLmOcYX)
Thanks to Picard and PunPun1000 for all of the help
]