[Question]
  [
Posted from [here](https://codegolf.meta.stackexchange.com/questions/2140/sandbox-for-proposed-challenges/17916#17916).
This challenge is highly "distilled" from [this](https://codegolf.stackexchange.com/questions/188863/print-function-for-linked-list) question. Special thanks to @Akababa!
In this task, you should insert an exclamation mark at the start of the string and after every character.
## Rules
* There will always be a non-empty-string input. The input will not contain tabs either. You can assume that the input only contain non-extended ASCII printable characters and newlines.
* The input will not contain trailing newlines as long as your language can't detect a newline.
* This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") contest; the shortest answer should win.
## Examples
* 4 newlines result in 5 newline-delimited exclamation marks. It is very hard to put this as a Markdown text, so this is stated instead.
```
1 2 3 4 5 6
129591 129012 129127 129582
0
```
Outputs
```
!1! !2! !3! !4! !5! !6!
!1!2!9!5!9!1! !1!2!9!0!1!2! !1!2!9!1!2!7! !1!2!9!5!8!2!
!
!0!
```
```
asd afjoK ak:e
kPrLd
    fOJOE;
    KFO
KFkepjgop sgpaoj   faj
```
Outputs
```
!a!s!d! !a!f!j!o!K! !a!k!:!e!
!k!P!r!L!d!
! ! ! ! !f!O!J!O!E!;!
! ! ! ! !K!F!O!
!K!F!k!e!p!j!g!o!p! !s!g!p!a!o!j! ! ! !f!a!j!
```
A base test case with only one character:
```
a
```
Outputs
```
!a!
```
(Auto-completion! Just kidding, there is no such thing.) Contains exclamation marks:
```
!!
!!
!!
!!
!!
```
Outputs:
```
!!!!!
!!!!!
!!!!!
!!!!!
!!!!!
```
  
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS), 1 byte
Thanks to A\_\_ for halving the byte count!
```
!
```
[Try it online!](https://tio.run/##KyxNTCn6/1/x/39DBSMFYwUTBVMFMy5DI0tTS0MFIGVgaASiDI3MQZSphREXlwEA "QuadR – Try It Online")
Replaces nothing with `!`
[Answer]
# [Python 3](https://docs.python.org/3/), 26 bytes
```
lambda s:s.replace('','!')
```
[Try it online!](https://tio.run/##TY5BT8MwDIXv/hVuLm3RQE1GgRXtyCQoUrkDB486Y@1IoiQS4teXprvMsvQ9PT0/2f3Fb2vWk95@TCf62feEoQk3nt2JvrjI81We5eUUOcSAW3wXzyawj7jn@MtsxAqEEBIVrvEWa7wDqTb1RuKMSqoEqe4T6gcFUM3h5YJCj6QH2yKNDcP45l97wHl099I9PS6y3XXQ7kZ2w8E6DAdHdkgJGs4tdK7KMrjY2YBPANDWY3oaj2ZhaJZO548mFuJaXKmqvHB0kUJlOf0D "Python 3 – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 2 bytes
```
!
```
[Try it online!](https://tio.run/##K0otycxL/P@fS/H/f0MFIwVjBRMFUwUzLkMjS1NLQwUgZWBoBKIMjcxBlKmFEReXAQA "Retina 0.8.2 – Try It Online") At last, a challenge where Retina has a built-in!
[Answer]
# [Python 3](https://docs.python.org/3/), 27 bytes
```
lambda s:f"!{'!'.join(s)}!"
```
[Try it online!](https://tio.run/##TY7BTsMwEETv@xXrvTRBgGK3AZqqRypBkNJ74eAqdolDbSu2hBDi20OcXrpa6Y1Gs6P1P/HT2eWot@/jlzwfW4mh0sR@F2xxb1xns5D/MRqjCjHgFg/0YoMaIh5V/FbK0i0QEUeBS1xhiQ/Axbpcc5xQcJHAxWNC@SQAiik8X8jQotTG1Sj7SkG/H95awGl089o8b2ZZ7xqod73y5uQ8hpOXzqSENJcWealiDK52MuADALQbMD2NnZ0ZqrnTD52NGd3RjSjyK0dnKZTn4z8 "Python 3 – Try It Online")
Honestly, I hope someone can show me a cool way to do this with a smaller byte count.
[Answer]
# [Python 2](https://docs.python.org/2/), 27 bytes
```
lambda s:'!%s!'%'!'.join(s)
```
**[Try it online!](https://tio.run/##HYwxEoIwEAD7e0VSMAeNhSUOpRTGmfgAmnNCkESSG47G18foVlvsLH@OV07n4oepvGl7OlLSo25EY4MaTyGvqZWuyICIE5A4RT5koyj2M8THfnegKt7e7PXyVzNaMGOcOSyZlSxMOfwKCnUBwPuajtbXaVe@ "Python 2 – Try It Online")**
[Answer]
# Haskell, 18 bytes
```
('!':).(>>=(:"!"))
```
-1 byte thanks to @nimi
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzX0NdUd1KU0/Dzs5Ww0pJUUlT839uYmaegq1CemqJc35eSWpeSbECUFahoLQkuKTIJ09BTyHtf1p@vkJSYhEQV3FlAM3K/5eclpOYXvxfN8I5IAAA "Haskell – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~24~~ 22 bytes
-2 bytes thanks to JoKing.
```
-[-[-<]>>+<],[>.<.,]>.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fNxoIbWLt7LRtYnWi7fRs9HRi7fT@//dUyMkvS1VwgqkEAA "brainfuck – Try It Online")
[Answer]
# [Labyrinth](https://github.com/m-ender/labyrinth), ~~19 11 10~~ 9 bytes
```
33
..
",@
```
**[Try it online!](https://tio.run/##y0lMqizKzCvJ@P/f2JhLT49LScfh///g/JyyVK6QjFQuH5i8IgA "Labyrinth – Try It Online")**
### How?
We enter the Labyrinth at the top-left facing right with an infinite stack of zeros...
```
                         I / O    stack
                                  0,0,0,...
3 - pop * 10 + 3                  3,0,0,0,...
  - 2 neighbours, forward
3 - pop * 10 + 3                  33,0,0,0,...
  - 2 neighbours, forward
. - pop & print chr          !    0,0,0,...
  - T junction from the side
  -   TOS==0, forward
, - read chr or -1       L        76,0,0,0,...   or   -1,0,0,0
  - T junction from the base
  -   if TOS > 0 right:
" -     no-op                     76,0,0,0,...
  -     2 neighbours, forward
. -     pop & print chr      L    0,0,0,...
  -     T junction from the side
  -       TOS==0, forward
3 -       ...back to the start
  -   elif TOS == -1 left:
@ -     exit                                          we're out!
  * right, but on the first occasion (from above) we hit the wall and turn
    around, so that's like a left
```
Luckily we don't need to handle un-printables, otherwise the first zero-byte would turn us around at `,` and play havoc.
[Answer]
# JavaScript (ES6), 19 bytes
Takes input as an array of characters.
```
s=>`!${s.join`!`}!`
```
[Try it online!](https://tio.run/##hYxNC4JAFEX371e8gUAlGpwpKwvb5SID21cwg184iiNOtIl@u2mrFoGXC@cuDlfJpzRJV7aPRaPTrM@D3gQHQWYvQ5UuG0HEm4g@0Y3RdUZrXdi5faWUCoYcl7hCD9fAuO/5DAe4jI9gfDPC23IAV9wdnKN1aywH4M@TNCnKXOkIZbXLoLp05xRwSB6f4uP@O6MwhiisslYVukVTtFKr0ZBq8n1KIAR@OthO/wE "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), ~~23~~ 20 bytes
*Saved 3 bytes thanks to @ShieruAsakoto*
Takes input as a string.
```
s=>[,...s,,].join`!`
```
[Try it online!](https://tio.run/##fYzBCoJAGITv/1P8nlSyxd2ysrBbHjKwewW76Cqu4oobvf6mnaJDw8A3MMMo8RKmGJvhuex1KW2VWJMcbwEhxATBgyjd9NzhttC90Z0kna69yuMUGa5wjRFugLI4iilOCCmbQdl2RrRjACH3cYHuvXd9gJ8TYUoUldIZinYvob2OlxJwUpWf89PhE7M0hyxt5aBqPaCpB6HVvBDq3/GfznHgy9z37Rs "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 22 bytes
*Suggested by [@tjjfvi](https://codegolf.stackexchange.com/users/87606/tjjfvi)*
Takes input as a string.
```
s=>s.replace(/|/g,"!")
```
[Try it online!](https://tio.run/##fYyxDoIwGIT3/yl@WKBRgVZR0eAmg5jgAzjQQCEWQhtqnHx3BCfjwOWS75K7nOQvbor@oZ@rTpViqOLBxCfj9UK3vBCu//brpW3ZZChUZ1QrvFbVbuXmFBmucYMhboGyKIwojggom0DZbkK4ZwBBTnCBzr1zCMDfCTcl8kqqFHlzENDc@msJOKrKLtn5@I1pkkGaNELLWmk0teZKTgsu545nOsuCH@eEDB8 "JavaScript (Node.js) – Try It Online")
[Answer]
# [Pepe](https://github.com/Soaku/Pepe), 47 bytes
```
REREEeRErEErREeeEeeeeEREEeeREEeereeREEEEeeEReee
```
[Try it online!](https://soaku.github.io/Pepe/#&T&E@!8j!l!l*DvH)
**Explanation:**
```
REREEeRE # Push 0,then input (str),then 0 -> (R)
         # The zeroes are pushed to correct the inserting
rEE # Begin loop labelled 0 -> (r)
  rREeeEeeeeE # Push "!" -> (R)
              # r flag inserts it instead of pushing
  REEeeREEee # Move pointer pos 2 steps forward -> (R)
ree # Loop while (R) != 0
REEEEeeE # Remove characters of (R) that are in stack of (r)
         # Removes the 0 in (R)
Reee # Output (R)
```
[Answer]
# [R](https://www.r-project.org/), 25 bytes
```
function(x)gsub("","!",x)
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jQjO9uDRJQ0lJR0lRSadC83@ahpJHak5OvkJ5flFOiqKS5n8A "R – Try It Online")
A function accepting and returning a character vector. 
[Answer]
# 8086 machine code, .COM format (MS-DOS 2+), 32 bytes
(-1 depending on emulator: see below)
For best results redirect standard input from a file, as typing gives odd-looking output due to no buffering; also, newlines look a little weird because they are stored as `CR LF`, and the `CR` part messes up the output.
This program behaves fine in an actual MS-DOS emulation (e.g. PCjs) but DOSBox seemed to have issues with Ctrl+Z EOF (see comments in the assembly listing), so *DON'T* try to enter input using the console in DOSBox unless you add the extra check!
```
BB 01 00 53 59 BA 0B 01 B4 40 CD 21 4A 4B B4 3F CD 21 85 C0 74 09 B4 40 43 41 CD 21 49 EB EE C3
```
Some interesting bits:
* I saved some data space by reusing memory that had already been executed (the `21H` in `INT 21H` happens to be `!`)
* I was *almost* able to use an interesting trick that I found on the page ["The Hidden Power of BCD Instructions"](http://www.hugi.scene.org/online/coding/hugi%2017%20-%20coaax.htm) which would have allowed me to use `AAA` instead of a standard `TEST` to compare `AL` to 0, saving one byte. Unfortunately, this is not fully documented so I couldn't rely on it: for example, PCjs doesn't adjust anything but the carry and auxiliary carry flags. :-(
Assembly code (TASM ideal mode):
```
IDEAL
MODEL   TINY
CODESEG
ORG 100H
;; DOSBox (tested with 0.74-2) didn't seem to handle Ctrl-Z as EOF
;; so uncomment the ";;" lines to run it there.
MAIN:
    MOV     BX,1
    PUSH    BX
    POP     CX
    MOV     DX,OFFSET MAIN_1+1  ; The 21H in INT 21H
    MOV     AH,40H
MAIN_1:
    INT     21H
    DEC     DX
    ;;PUSH  DX
    ;;POP   SI
IO_LOOP:
    DEC     BX
    MOV     AH,3FH
    INT     21H
    ;;; This should work on an non-emulated PC. 
    ;;;AAA      ; AL=0?
    TEST    AX,AX
    JZ      DONE
    ;;CMP   [BYTE PTR SI],1AH
    ;;JZ    DONE
    MOV     AH,40H
    INC     BX
    INC     CX
    INT     21H
    DEC     CX
    JMP     IO_LOOP
DONE:
    RET
ENDS
END MAIN
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ż”!ṁż
```
A full program accepting a string, which prints the result.
**[Try it online!](https://tio.run/##y0rNyan8///o7kcNcxUf7mw8uuf////q6uqJxSkKiWlZ@d4KidlWqVzZAUU@KVwKQJDm7@Xvag1merv5c3m7ZacWZKXnFygUpxck5meBVCRmAQ0AAA "Jelly – Try It Online")**
### How?
```
Ż”!ṁż - Main Link: list of characters, s   e.g. "abc"
 ”!   - character '!'                           '!'
   ṁ  - mould like:
Ż     -   s with a zero prepended              "!!!!"
    ż - zip together with s                    ["!a","!b","!c",'!']
      - implicit (smashing) print              !a!b!c!
```
[Answer]
# 6502, 12 bytes (13 bytes if Apple II)
**6502**
The machine code assumes that a pair of zero page locations are connected to character input ($FE) and output (FF) hardware. Many 6502-based systems facilitate I/O in this fashion, albeit I/O address are usually not in zero page.
For simplicity, I used [Py65](https://github.com/mnaberez/py65), a 6502 microcomputer system simulator written in Python.
Here is a memory dump from Py65. You can load the following code anywhere in zero page such that it does not overlap $FE and $FF. 
```
       PC  AC XR YR SP NV-BDIZC
6502: 0000 00 00 00 ff 00110010
.mem 0:b
0000:  a9  21  85  ff  a5  fe  f0  fc  85  ff  d0  f4
```
Running in a Windows command window, you can paste (Ctrl+V) any text you desire, or you can simply type. If typing, press Ctrl+J for a newline (same ASCII char). Press Ctrl+C to interrupt the processor and return to the Py65 command prompt.
Naturally, assembly code is easier to read.
```
       PC  AC XR YR SP NV-BDIZC
6502: 0000 00 00 00 ff 00110010
.d 00:0b
$0000  a9 21     LDA #$21
$0002  85 ff     STA $ff
$0004  a5 fe     LDA $fe
$0006  f0 fc     BEQ $0004
$0008  85 ff     STA $ff
$000a  d0 f4     BNE $0000
```
For clarity, here is the assembly code in [CBA65](http://www.crbond.com/tools.htm) format.
```
; ASSEMBLE:
; cba65 bangit
;
; LOAD/RUN
; python3 py65/monitor.py -i 00fe -o 00ff -l bangit.bin
; goto 0000
        .FILES  BIN=256
; I/O LOCATIONS
GETC    .EQU    $FE             ; (1) MOVING PY65'S GETC TO ZP SHAVES 1 BYTE
PUTC    .EQU    $FF             ; (1) MOVING PY65'S PUTC TO ZP SHAVES 2 BYTES
        .ORG    $0000
VROOM   LDA     #'!'
        STA     PUTC
VROOM2  LDA     GETC
        BEQ     VROOM2
        STA     PUTC
        BNE     VROOM
        .END
```
**Apple II**
The code above assumes a null indicates there is no input, so continues polling until a non-null value is returned.
For comparison, the Apple I and Apple II signals availability of a new character by setting bit 7 of the keyboard I/O address, which then needs to be cleared after fetching the character. On those systems, character I/O usually is performed by calling system monitor routines instead of accessing the hardware directly.
By calling RDKEY ($FD0C) and COUT ($FDED), the Apple II equivalent of the above can be coded in 13 bytes, and is runnable anywhere in RAM. Here is the code I ran in an Apple //e emulator, [a2ix](https://play.google.com/store/apps/details?id=org.deadc0de.apple2ix.basic&hl=en_US) on Android 9.
Pressing Return has the same effect as a newline.
```
*300L
0300-   A9 A1       LDA   #$A1
0302-   20 ED FD    JSR   $FDED
0305-   20 0C FD    JSR   $FD0C
0308-   20 ED FD    JSR   $FDED
030B-   F0 F3       BEQ   $0300
```
Did you notice that instead of the normal ASCII value #$21 for the exclamation point, #$A1 is used instead? That's because sending standard ASCII values to COUT causes them to be displayed in "inverse mode," black on white. Displaying ASCII in normal white on black requires adding #$80 to the character value in the accumulator before calling COUT. Because RDKEY returns characters with the hi-bit set, assembly programs generally cleared the bit of the character to obtain its ASCII value before using it.
[Answer]
# [sed](https://www.gnu.org/software/sed/), 12 bytes
```
s/\b\|\B/!/g
```
[Try it online!](https://tio.run/##K05N0U3PK/3/v1g/JimmJsZJX1E//f9/QwUjBWMFEwVTBTMuQyNLU0tDBSBlYGgEogyNzEGUqYURF5cBAA "sed – Try It Online")
*-3 bytes thanks to Cows Quack*
[Answer]
# [Befunge-98 (PyFunge)](https://pythonhosted.org/PyFunge/), 7 bytes
```
'!,#@~,
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//9XV9RRdqjT@f/fUMFIwVjBRMFUwYzL0MjS1NJQAUgZGBqBKEMjcxBlamHExWUAAA "Befunge-98 (PyFunge) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) -p0, ~~17~~ 6 bytes
```
s,,!,g
```
[Try it online!](https://tio.run/##HcxBDsIgFEXROat4rY0jbOAr1Zq4FtMBaTENkA9Ndy9SRyd3cqPl1ZRTYDc7P62YfNotY3d5wWdLGZf4j7BlKDhfW2GxbJ/o3q@2afske9mdGzlzSVJWS9EgXHGDwSA0jWbUqChNB5ruB@ZBQqhviNkFn0rd/gA "Perl 5 – Try It Online")
My original answer was `-p` and `$_='!'.s,.,$&!,gr`. Thanks to @Nahuel Fouilleul for cutting 11 bytes and to @Grimy for the `-p0` tip.
[Answer]
# [MarioLANG](https://github.com/tomsmeding/MarioLANG), ~~95~~ ~~94~~ ~~90~~ ~~89~~ 69 bytes
```
++++++
======< >)
>+++++++",+[
=======<.==<
>+++++++!(.-
========#===
```
[Try it online!](https://tio.run/##y00syszPScxL//9fGwy4bMHARsFOk8sOIqStpKMdDRW3tdEDYriMooaeLkzGVhmI//9PLE5RSEzLyvdWSMy2SuXKDijySeFSAII0fy9/V2sw09vNn8vbLTu1ICs9v0ChOL0gMT8LpCIxCwA "MarioLANG – Try It Online")
First time trying out MarioLANG, that was a lot of fun!
*Thanks to **Jo King** for -20 bytes*
**Explanation:**
So, as the name implies, MarioLANG is made to execute like a game of Super Mario Bros. It operates similarly to BF, with memory arranged in a tape of cells. There are operators to increment, decrement, print (as ascii or numeric) and read into the current memory cell, and operators to move left or right along the tape.
Mario (the instruction pointer) always begins in the top left cell of the program, with his intended direction of motion set to the right. If Mario does not have a floor-like object beneath him (=, ", or #), he will fall until he reaches a floor-like object. If Mario leaves the program space, the program ends due to Game Over :(
This specific program can basically be split into two halves: the setup, and the loop.
```
   Setup                          Loop
-----------------------------------------------
                       |
++++++                 |          
======<                |          >)
>+++++++               |          ",+[
=======<               |          .==<
>+++++++               |          !(.-
========               |          #===
```
In the Setup section, we're simply incrementing the first memory cell until we reach 33 - the ASCII value for "!". Easy enough; if this can be golfed, it's purely a matter of shape. Mario starts from the top left, picks up 10 coins, starts falling when picking up the 11th, switches directions, then repeats. He picks up the last 11 coins without switching directions; he ends the setup section at the bottom-rightmost "+".
In the loop section, Mario starts by reaching an elevator. The "!" operator makes him cease motion, so that he remains on the elevator. On the way up, it prints the corresponding ASCII character to the current memory cell's value (this one is always 33, "!"), then switches to the next cell in memory. Mario reaches the top and sets his direction to the right. He falls, and reads a character from input as its ASCII value (or -1 if no character). We increment because the only measure of control in MarioLANG is to skip an instruction if the current memory cell has a value of 0. If it does, we skip changing Mario's direction, so he will walk right off of the next floor to his doom. If it does not, we set direction to left; walking left off of the floor below decrements the current cell back to its previous value, that value is printed, and we move back to the first memory cell before getting back on the elevator.
---
**Previous version (89 bytes):**
```
+++++++++++>,
==========@"+
+++++++++++)[
@==========.==<
+++++++++++!(.-
===========#===
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~16~~ 11 bytes
```
{S:g/<(/!/}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/OtgqXd9GQ19Rv/Z/cWKlQppCcU5pUcF/QwUjBWMFEwVTBTMuQyNLU0tDBSBlYGgEogyNzEGUqYURF5cBAA "Perl 6 – Try It Online")
Replaces all zero width matches with exclamation marks. Null regexes are not allowed, so we use a capture marker to capture nothing instead
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 11 bytes
```
gsub(a,"!")
```
[Try it online!](https://tio.run/##SyzP/v8/vbg0SSNRR0lRSfP//8TiFIXEtKx8b4XEbKtUruyAIp8ULgUgSPP38ne1BjO93fy5vN2yUwuy0vMLFIrTCxLzs0AqErMA "AWK – Try It Online")
This is similar to some other entries. It changes a null string to `!` globally, using `$0` as the default target, then prints the result since no other action is defined. Using `a` works since it's an undefined variable and is shorter than using `""` (which would do the same thing).
[Answer]
# [Zsh](https://www.zsh.org/), ~~32~~ 23 bytes
```
<<<!${(j:!:)${(s::)1}}!
```
~~[Try it online!](https://tio.run/##TYvLCoJAGIX3/1McSVAXQTNlF6OlLTKwB2gz6ExeYkYcISh69klr08eB7yzOedrKPar6LhGG8GeIoj1K45TpUSAMAviv0CZJxN6RLCqDuU7hF56zVa0G6vpaDwrBVR9@XHVApdHSOQaOJVaIsSbGd/GOYdSC8UmMbybFW060ICdsCaEak0G0iaT20p9LwojKT3m6/9bsmFN2bGXX3EwHe@uEaaaFaMa/8zz6ywc "Zsh – Try It Online")~~
[Try it online!](https://tio.run/##TYvLDoIwFET39ytuIwmwo1VUCi5lISb4AW6alFcxtKEkJhq@vYJuPJnkzGLmZVv3bLtHhUGA3gbDMEWpXZZlxHsHihMeLrach3SeibNtV09gxm6YavTvw@nHffBB6qFyjiLDLe4wxj1QlsQJxUURZasoO6yKjwwgAiesRFErXaDoeQX9bbxKwIW6vJTn9FuLvIQi7yujGm3QNkZotS6EWv6OEPjLBw "Zsh – Try It Online")
`(s::)` splits into characters, `(j:!:)` joins on `!`s.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 11 bytes
```
(∊⊢⍪⍪¨)∘'!'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R2wSNRx1dj7oWPepdBUSHVmg@6pihrqgOlFM3VDBSMFYwUTBVBwA "APL (Dyalog Unicode) – Try It Online")
@Adám's golf to mine (see below).
```
{'!'⍪∊⍉↑⍵('!'⍴⍨≢⍵)}  ⍝ original
{'!'⍪∊⍵⍪¨('!'⍴⍨≢⍵)}  ⍝ concatenate each instead of transpose mix
{'!'⍪∊⍵⍪¨ '!'}       ⍝ each already handles many-to-one
{ ⍵ ⍪∊⍺⍪¨  ⍵ }∘'!'   ⍝ break out "!"
{∊⍵ ⍪ ⍺⍪¨  ⍵ }∘'!'   ⍝ defer flattening to later
(∊⊢ ⍪  ⍪¨    )∘'!'   ⍝ go tacit
(∊⊢⍪⍪¨)∘'!'          ⍝ remove spacing
```
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 19 bytes
```
{'!'⍪∊⍉↑⍵('!'⍴⍨≢⍵)}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RqdUX1R72rHnV0PertfNQ28VHvVg2w0JZHvSsedS4C8jVrgUoV1A0VjBSMFUwUTBXM1AE "APL (Dyalog Unicode) – Try It Online")
My first APL submission :P Loving this language. No idea why I need the parentheses after `⍵`.
```
{'!'⍪∊⍉↑⍵('!'⍴⍨≢⍵)}
{                   } ⍝ Boilerplate
              ⍴⍨      ⍝ Repeat
           '!'        ⍝ Exclamation point
                 ≢⍵  ⍝ len(input) times
         ⍵(        )  ⍝ Wrap ^ into an array with the input
       ↑              ⍝ Matrixify
      ⍉               ⍝ Transpose
     ∊                ⍝ Flatten
    ⍪                  ⍝ Prepend
 '!'                  ⍝ An exclamation point
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 28 bytes
```
s=>$"!{String.Join("!",s)}!"
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpds4@maV5qbWpSYlJNqk5yRWGSno4AhZJdm@7/Y1k5FSbE6uKQoMy9dzys/M09DSVFJp1izVlHpvzVXeFFmSapPZl6qRpqGUmZecWpRiUJSakl5amqekqam9X8A "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# Java 8, 20 bytes
A lambda function from `String` to `String`.
```
s->s.replace("","!")
```
[Try It Online](https://tio.run/##PU/LasMwEDwrX7ERBCxwRN@HtPGxt55yLKVsFTnIlR941ymh@NtdyXIDgpFGszOzFZ5xWx2/p2748s6A8UgEb@ga@F2JhSRGDnBu3RHq8JUduHfN6f0DsD@RikpRBSM9sPO6HBrDrm3063J5SfIcEhZQwn6ibUG6t51HYzMpc7mWahLiOVhd3Q2SJdhDY3/gSsYwIW/hDu7hAR7hSeYzs8DNgmyJQ/E4NDNjdC7bHpbys/kn7FJI2kEcLsS21u3Augsi9v@r6jBZI2dyE/oUsCGZJ4McSo1d5y/Z/FRKxZxxFc44/QE)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
€'!Ć
```
I/O as a list of characters.
[Try it online.](https://tio.run/##yy9OTMpM/f//UdMadcUjbf//RyslKukoKBWDiBQQoQAiwGJpICILROSDCG9U2WwQYQUiUkFETB5cMABEFIEIH7ipEGkFLATYFn8Q4QVnuYIIa/z6wM5xg2uBKEQIZsNdVgD3RjrcLwVwY4rhEgVwr@XDdWBzayJENhYA)
**Explanation:**
```
€'!  '# Prepend a "!"-item before each character in the (implicit) input-list
   Ć  # Enclose (append the first character of the list at the end of it)
      # (after which the result is output implicitly)
```
[Answer]
# [Triangular](https://github.com/aaronryank/triangular), ~~15~~ 13 bytes
```
B\3;#*~.,</@<
```
[Try it online!](https://tio.run/##KynKTMxLL81JLPr/3ynG2FpZq05Px0bfweb//8TiFIXEtKx8b4XEbKtUruyAIp8ULgUgSPP38ne1BjO93fy5vN2yUwuy0vMLFIrTCxLzs0AqErMA "Triangular – Try It Online")
*-2 bytes after remembering that Triangular has a conditional halt operator.*
I believe this is as short as it gets on this one. Triangular *does* have conditional direction-change operators, but they unfortunately work differently than the other conditionals. While all others check if ToS <= 0, the direction-changing conditionals check ToS != 0. If this weren't the case, we would have 10 bytes in the form of `Bq3~#*/@<<`.
Ungolfed:
```
    B
   \ 3
  ; # *
 ~ . , <
/ @ <
----------------------------------------------------
B3*              - Push 11 and 3, then pop both and push their product.
    <,<          - Change directions 3 times (to save 2 bytes on last line)
        @/       - Print Top of Stack value as a character, do not pop
          ~;\    - Push a character from input to ToS. Halt if ToS <= 0. Change Direction.
              #  - Print ToS as a character and pop
```
---
**Previous Version (15 bytes):**
```
B.3\.*#).(/?~@<
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~11~~ 6 bytes
```
"!"oio
```
[Try it online!](https://tio.run/##S8sszvj/X0lRKT8z//9/QwUjBWMFEwVTBTMA "><> – Try It Online")
Saved 5 bytes thanks to Jo King, suggesting exiting with an error. Previous version which does not exit with an error:
```
"!"oi:0(?;o
```
[Try it online!](https://tio.run/##S8sszvj/X0lRKT/TykDD3jr//39DBSMFYwUTBVMFMwA "><> – Try It Online")
[Answer]
# [SimpleTemplate](https://github.com/ismael-miguel/SimpleTemplate), 23 bytes
This is a language I wrote, and it was supposed to be for templates, but well.
```
!{@eachargv.0}{@echo_}!
```
Should be almost self-explanatory, once you see the ungolfed code:
```
!{@each argv.0 as char} {@echo char}!{@/}
```
And an explanation:
* `!` - Prints the literal `!` character
* `{@each argv.0 as char}` - Loops through every character, with the value set to the variable `char` (**optional**, the default variable is `_`).  
`argv.0` is the first parameter passed to the `render()` method of the compiler.
* `{@echo char}!` - outputs the `char` variable and a literal `!` character.  
For the golfed version, the default variable `_` is used instead.
* `{@/}` - closes the loop (**optional**)
---
Pure **SimpleTemplate** solution:
```
{@fn x}!{@eachargv.0}{@echo_}!{@/}{@/}
```
Creates a function `x` that outputs the same result.
You can use it like this:
```
{@call x "this is an example"}
```
You can try all of this on: <http://sandbox.onlinephpfunctions.com/code/f6baff8d411fc8227ece81eccf05b6e7d3586bfa>
On the line 908, you can use the variables `$golfed`, `$ungolfed` and `$fn` to test all the versions.
---
---
However, if it is allowed to use a character array, the code is simplified (20 bytes):
```
!{@echoj"!" argv.0}!
```
And ungolfed:
```
!{@echo separator "!" argv.0}!
```
Basically, outputs all items in the array, joined by `"!"`, surrounded by literal `!`.  
Due to limitations in the compiler class, the space is mandatory (in the golfed version).
This code is also extremelly harder to use in pure **SimpleTemplate** (using the function as example):
```
{@fn x}!{@echoj"!" argv.0}!{@/}
{@// alternative: @call str_split into a "a char array"}
{@set a "a", " ", "c", "h", "a", "r", " ", "a", "r", "r", "a", "y"}
{@call x a}
```
The `@call` can call a function that exists in PHP, which means that it isn't a pure **SimpleTemplate** solution.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 36 bytes
```
while read -n1 c;do printf \!$c;done
```
[Try it online!](https://tio.run/##S0oszvj/vzwjMydVoSg1MUVBN89QIdk6JV@hoCgzryRNIUZRBcTNS/3/PyQjs1gBiBIVSlKLSxQy8wpKS/S4AA "Bash – Try It Online")
This counts on the newline terminating the input for the last ! mark.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~17~~ 16 bytes
```
->s{s.gsub'',?!}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1664ulgvvbg0SV1dx16x9n9BaUmxQlq0kmdecWpRiUJSakl5amqeUiwXVMLGpqKiIpbLUMFIwVjBRMFUwYzL0MjS1NJQAUgZGBqBKEMjcxBlamHExWXABVT/HwA "Ruby – Try It Online")
Thanks Value Ink for -1 byte
]