Publicado desde aquí .

Este desafío está altamente "destilado" de esta pregunta. Un agradecimiento especial a @Akababa!

En esta tarea, debe insertar un signo de exclamación al comienzo de la cadena y después de cada carácter.

Reglas

• Siempre habrá una entrada de cadena no vacía. La entrada tampoco contendrá pestañas. Puede suponer que la entrada solo contiene caracteres imprimibles ASCII no extendidos y líneas nuevas.
• La entrada no contendrá nuevas líneas finales siempre que su idioma no pueda detectar una nueva línea.
• Este es un concurso de código de golf ; la respuesta más corta debería ganar.

Ejemplos

• 4 líneas nuevas dan como resultado 5 signos de exclamación delimitados por líneas nuevas. Es muy difícil poner esto como un texto de Markdown, por lo que se indica en su lugar.

1 2 3 4 5 6
129591 129012 129127 129582

0 0

Salidas

! 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

Salidas

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

Un caso de prueba base con un solo personaje:

una

Salidas

!¡una!

(¡Autocompletado! Es broma, no existe tal cosa). Contiene signos de exclamación:

!!
!!
!!
!!
!!

Salidas:

!!!!!
!!!!!
!!!!!
!!!!!
!!!!!

QuadR , 1 byte

¡Gracias a A__ por reducir a la mitad el recuento de bytes!

!

Pruébalo en línea!

No reemplaza nada con !

Python 3 , 27 bytes

lambda s:f"!{'!'.join(s)}!"

Pruébalo en línea!

Honestamente, espero que alguien pueda mostrarme una forma genial de hacer esto con un recuento de bytes más pequeño.

Python 3 , 26 bytes

lambda s:s.replace('','!')

Pruébalo en línea!

Retina 0.8.2 , 2 bytes

!

Pruébalo en línea! ¡Por fin, un desafío donde Retina tiene incorporado!

Haskell, 18 bytes

('!':).(>>=(:"!"))

-1 byte gracias a @nimi

Pruébalo en línea!

Python 2 , 27 bytes

lambda s:'!%s!'%'!'.join(s)

Pruébalo en línea!

JavaScript (ES6), 19 bytes

Toma la entrada como una matriz de caracteres.

s=>`!${s.join`!`}!`

Pruébalo en línea!

JavaScript (ES6),  23  20 bytes

Guardado 3 bytes gracias a @ShieruAsakoto

Toma la entrada como una cadena.

s=>[,...s,,].join`!`

Pruébalo en línea!

JavaScript (ES6), 22 bytes

Sugerido por @tjjfvi

Toma la entrada como una cadena.

s=>s.replace(/|/g,"!")

Pruébalo en línea!

R , 25 bytes

function(x)gsub("","!",x)

Pruébalo en línea!

Una función que acepta y devuelve un vector de caracteres.

Código de máquina 8086, formato .COM (MS-DOS 2+), 32 bytes

(-1 dependiendo del emulador: ver abajo)

Para obtener los mejores resultados, redirija la entrada estándar de un archivo, ya que escribir da una salida de aspecto extraño debido a que no hay almacenamiento en búfer; Además, las líneas nuevas se ven un poco raras porque están almacenadas como CR LF, yCR parte desordena la salida.

Este programa se comporta bien en una emulación real de MS-DOS (por ejemplo, PCjs), pero DOSBox parecía tener problemas con Ctrl + Z EOF (vea los comentarios en la lista de ensamblaje), por lo que NO intente ingresar la entrada usando la consola en DOSBox a menos que agregue el cheque extra!

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

Algunas partes interesantes:

• Ahorré algo de espacio de datos reutilizando la memoria que ya se había ejecutado (el 21Hin INT 21Hresulta ser !)

• Yo era casi capaz de utilizar un truco interesante que he encontrado en la página de "El poder oculto de Instrucciones de BCD" que habría permitido que la utilice AAAen lugar de un estándar TESTpara comparar ALa 0, el ahorro de un byte. Desafortunadamente, esto no está completamente documentado, por lo que no pude confiar en él: por ejemplo, PCjs no ajusta nada más que las banderas de transporte y transporte auxiliar. :-(

Código de ensamblaje (modo ideal TASM):

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

brainfuck , 24 22 bytes

-2 bytes gracias a JoKing.

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

Pruébalo en línea!

Pepe , 47 bytes

REREEeRErEErREeeEeeeeEREEeeREEeereeREEEEeeEReee

Pruébalo en línea!

Explicación:

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)

Laberinto ,  19 11 10  9 bytes

33
..
",@

Pruébalo en línea!

¿Cómo?

Entramos en el Laberinto en la esquina superior izquierda mirando hacia la derecha con una pila infinita de ceros ...

                         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

Afortunadamente, no necesitamos manejar elementos no imprimibles, de lo contrario, el primer byte cero nos daría la vuelta y causaría ,estragos.

sed , 12 bytes

s/\b\|\B/!/g

Pruébalo en línea!

-3 bytes gracias a Cows Quack

Zsh , 32 bytes

for c ('' ${(s::)1})echo -nE $c!

Pruébalo en línea!

(s::)se divide en caracteres, ''agrega un elemento vacío al inicio y luego echo -nE $c!hace eco de cada uno seguido de un !.

Perl 5 -p0, 17 6 bytes

s,,!,g

Pruébalo en línea!

Mi respuesta original fue -py $_='!'.s,.,$&!,gr. Gracias a @Nahuel Fouilleul por cortar 11 bytes y a @Grimy por la -p0sugerencia.

6502, 12 bytes (13 bytes si Apple II)

6502

El código de máquina supone que un par de ubicaciones de página cero están conectadas al hardware de entrada de caracteres ($ FE) y de salida (FF). Muchos sistemas basados ​​en 6502 facilitan la E / S de esta manera, aunque la dirección de E / S generalmente no está en la página cero.

Para simplificar, usé Py65 , un simulador de sistema de microordenador 6502 escrito en Python.

Aquí hay un volcado de memoria de Py65. Puede cargar el siguiente código en cualquier lugar de la página cero para que no se superponga $ FE y $ 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

Al ejecutarse en una ventana de comandos de Windows, puede pegar (Ctrl + V) cualquier texto que desee, o simplemente puede escribir. Si escribe, presione Ctrl + J para una nueva línea (mismo carácter ASCII). Presione Ctrl + C para interrumpir el procesador y volver al símbolo del sistema Py65.

Naturalmente, el código de ensamblaje es más fácil de leer.

       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

Para mayor claridad, aquí está el código de ensamblaje en formato CBA65 .

; 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

Manzana II

El código anterior supone que un valor nulo indica que no hay entrada, por lo que continúa sondeando hasta que se devuelve un valor no nulo.

A modo de comparación, Apple I y Apple II señalan la disponibilidad de un nuevo carácter al configurar el bit 7 de la dirección de E / S del teclado, que luego debe borrarse después de recuperar el carácter. En esos sistemas, la E / S de caracteres generalmente se realiza llamando a rutinas de monitoreo del sistema en lugar de acceder directamente al hardware.

Al llamar a RDKEY ($ FD0C) y COUT ($ FDED), el equivalente de Apple II de lo anterior se puede codificar en 13 bytes y se puede ejecutar en cualquier lugar de la RAM. Aquí está el código que ejecuté en un emulador Apple // e, a2ix en Android 9.

Presionar Retorno tiene el mismo efecto que una nueva línea.

*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

¿Notó que en lugar del valor ASCII normal # $ 21 para el signo de exclamación, en su lugar se usa # $ A1? Esto se debe a que enviar valores ASCII estándar a COUT hace que se muestren en "modo inverso", negro sobre blanco. Mostrar ASCII en blanco normal sobre negro requiere agregar # $ 80 al valor de caracteres en el acumulador antes de llamar a COUT. Debido a que RDKEY devuelve caracteres con el conjunto hi-bit, los programas de ensamblaje generalmente borran el bit del carácter para obtener su valor ASCII antes de usarlo.

Bash , 36 bytes

while read -n1 c;do printf \!$c;done

Pruébalo en línea!

¡Esto cuenta con que la nueva línea termine la entrada para el final! marca.

MarioLANG , 95 94 90 89 69 bytes

++++++
======< >)
>+++++++",+[
=======<.==<
>+++++++!(.-
========#===

Pruébalo en línea!

La primera vez que probé MarioLANG, ¡fue muy divertido!

Gracias a Jo King por -20 bytes

Explicación:

Entonces, como su nombre lo indica, MarioLANG está hecho para ejecutarse como un juego de Super Mario Bros. Funciona de manera similar a BF, con memoria dispuesta en una cinta de celdas. Hay operadores para incrementar, disminuir, imprimir (como ascii o numérico) y leer en la celda de memoria actual, y operadores para moverse hacia la izquierda o hacia la derecha a lo largo de la cinta.

Mario (el puntero de instrucciones) siempre comienza en la celda superior izquierda del programa, con su dirección de movimiento prevista establecida a la derecha. Si Mario no tiene un objeto similar a un piso debajo de él (=, "o #), caerá hasta llegar a un objeto similar a un piso. Si Mario deja el espacio del programa, el programa finaliza debido a Game Over :(

Este programa específico básicamente se puede dividir en dos mitades: la configuración y el bucle.

   Setup                          Loop
-----------------------------------------------
                       |
++++++                 |          
======<                |          >)
>+++++++               |          ",+[
=======<               |          .==<
>+++++++               |          !(.-
========               |          #===

En la sección Configuración, simplemente estamos incrementando la primera celda de memoria hasta llegar a 33, el valor ASCII para "!". Suficientemente fácil; Si esto se puede jugar al golf, es pura cuestión de forma. Mario comienza desde la esquina superior izquierda, recoge 10 monedas, comienza a caer al recoger el 11, cambia de dirección y luego repite. Recoge las últimas 11 monedas sin cambiar de dirección; finaliza la sección de configuración en la esquina inferior derecha "+".

En la sección de bucle, Mario comienza alcanzando un elevador. Los "!" El operador hace que deje de moverse para que permanezca en el elevador. En el camino hacia arriba, imprime el carácter ASCII correspondiente al valor de la celda de memoria actual (este siempre es 33, "!"), Luego cambia a la siguiente celda en la memoria. Mario llega a la cima y establece su dirección a la derecha. Se cae y lee un carácter de la entrada como su valor ASCII (o -1 si no hay ningún carácter). Incrementamos porque la única medida de control en MarioLANG es omitir una instrucción si la celda de memoria actual tiene un valor de 0. Si lo hace, omitimos cambiar la dirección de Mario, por lo que caminará directamente desde el siguiente piso hasta su destino. Si no es así, establecemos la dirección a la izquierda; caminar a la izquierda del piso inferior disminuye la celda actual a su valor anterior,

Versión anterior (89 bytes):

+++++++++++>,
==========@"+
+++++++++++)[
@==========.==<
+++++++++++!(.-
===========#===

Perl 6 , 16 11 bytes

{S:g/<(/!/}

Pruébalo en línea!

Reemplaza todas las coincidencias de ancho cero con signos de exclamación. No se permiten expresiones regulares nulas, por lo que utilizamos un marcador de captura para no capturar nada

C # (compilador interactivo de Visual C #) , 28 bytes

s=>$"!{String.Join("!",s)}!"

Pruébalo en línea!

05AB1E , 4 bytes

€'!Ć

E / S como una lista de caracteres.

Pruébalo en línea.

Explicación:

€'!  '# 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)

Befunge-98 (PyFunge) , 7 bytes

'!,#@~,

Pruébalo en línea!

Triangular , 15 13 bytes

B\3;#*~.,</@<

Pruébalo en línea!

-2 bytes después de recordar que Triangular tiene un operador de detención condicional.

Creo que esto es lo más breve posible. Hace triangular que los operadores de cambio de dirección condicionales, pero por desgracia funcionar de forma diferente que los otros condicionales. Mientras que todos los demás verifican si ToS <= 0, los condicionales de cambio de dirección verifican ToS! = 0. Si este no fuera el caso, tendríamos 10 bytes en forma de Bq3~#*/@<<.

Sin golf:

    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

Versión anterior (15 bytes):

B.3\.*#).(/?~@<

SimpleTemplate , 23 bytes

Este es un lenguaje que escribí, y se suponía que era para plantillas, pero bueno.

!{@eachargv.0}{@echo_}!

Debería ser casi autoexplicativo, una vez que vea el código no protegido:

!{@each argv.0 as char} {@echo char}!{@/}

Y una explicación:

• ! - Imprime el literal ! carácter
• {@each argv.0 as char}- Recorre cada carácter, con el valor establecido en la variable char( opcional , la variable predeterminada es _).
  argv.0es el primer parámetro pasado arender() método del compilador.
• {@echo char}!- genera la charvariable y un !carácter literal .
  Para la versión de golf, la variable predeterminada_ se usa la su lugar.
• {@/}- cierra el ciclo ( opcional )

Solución pura SimpleTemplate :

{@fn x}!{@eachargv.0}{@echo_}!{@/}{@/}

Crea una función x que genera el mismo resultado.

Puedes usarlo así:

{@call x "this is an example"}

Puedes probar todo esto en: http://sandbox.onlinephpfunctions.com/code/f6baff8d411fc8227ece81eccf05b6e7d3586bfa

En la línea 908, puede utilizar las variables $golfed, $ungolfedy $fnpara poner a prueba todas las versiones.

Sin embargo, si se le permite usar una matriz de caracteres, el código se simplifica (20 bytes):

!{@echoj"!" argv.0}!

Y sin golfos:

!{@echo separator "!" argv.0}!

Básicamente, genera todos los elementos en la matriz, unidos por "!", rodeados por literal !.
Debido a limitaciones en la clase del compilador, el espacio es obligatorio (en la versión golfizada).

Este código también es extremadamente difícil de usar en SimpleTemplate puro (usando la función como ejemplo):

{@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}

El @callpuede llamar a una función que existe en PHP, lo que significa que no es una pura SimpleTemplate solución.

Ruby , 17 16 bytes

->s{s.gsub'',?!}

Pruébalo en línea!

Gracias Value Ink por -1 byte

Gema , 11 personajes

\A=\!
?=?\!

Lamentablemente !comienza un comentario en Gema, por lo que debe ser escapado.

Ejecución de muestra:

bash-5.0$ echo -ne '1 2 3 4 5 6\n129591 129012 129127 129582\n\n0' | gema '\A=\!;?=?\!'
!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!

Pruébalo en línea!

Jalea , 5 bytes

Ż”!ṁż

Un programa completo que acepta una cadena, que imprime el resultado.

Pruébalo en línea!

¿Cómo?

Ż”!ṁż - 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!

Japt , 4 bytes

rP'!

Intentalo

r      Replace
 P     all empty strings "" with
  '!   An exclamation mark (If '!' wasn't a special character in Japt I could remove the quote)

Japt , 4 bytes

rP'!

Intentalo

Japt -P , 7 bytes

Lamentablemente !es un personaje reservado, que necesita las comillas.

ï'! i'!

Intentalo

No hay mucho que explicar: ïes producto cartesiano y iantecede.

Perl 5 + -p, 11 bytes

s/^|.\K/!/g

Pruébalo en línea!